@deffa5556/bail 1.0.6 → 1.0.9

package/cjs/lib/Discord/util/interactions/InteractionOptionsWrapper.cjs

@@ -0,0 +1,207 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Errors_1 = require("../Errors.cjs");
+const Constants_1 = require("../../Constants.cjs");
+/** A wrapper for interaction options. */
+class InteractionOptionsWrapper {
+    constructor(data, resolved) {
+        this.raw = data;
+        this.resolved = resolved;
+    }
+    _getOption(name, required = false, type) {
+        const opt = this.getOptions().find(o => o.name === name && o.type === type);
+        if (!opt && required) {
+            throw new Errors_1.WrapperError(`Missing required option: ${name}`);
+        }
+        else {
+            return opt;
+        }
+    }
+    getAttachment(name, required) {
+        if (this.resolved === null) {
+            throw new TypeError("Attempt to use getAttachment with null resolved. If this is on an autocomplete interaction, use getAttachmentOption instead.");
+        }
+        let val;
+        if (!(val = this.getAttachmentOption(name, required)?.value)) {
+            return undefined;
+        }
+        const a = this.resolved.attachments.get(val);
+        if (!a && required) {
+            throw new Errors_1.WrapperError(`Attachment not present for required option: ${name}`);
+        }
+        return a;
+    }
+    getAttachmentOption(name, required) {
+        return this._getOption(name, required, Constants_1.ApplicationCommandOptionTypes.ATTACHMENT);
+    }
+    getBoolean(name, required) {
+        return this.getBooleanOption(name, required)?.value;
+    }
+    getBooleanOption(name, required) {
+        return this._getOption(name, required, Constants_1.ApplicationCommandOptionTypes.BOOLEAN);
+    }
+    getChannel(name, required) {
+        if (this.resolved === null) {
+            throw new TypeError("Attempt to use getChannel with null resolved. If this is on an autocomplete interaction, use getChannelOption instead.");
+        }
+        let val;
+        if (!(val = this.getChannelOption(name, required)?.value)) {
+            return undefined;
+        }
+        const ch = this.resolved.channels.get(val);
+        if (!ch && required) {
+            throw new Errors_1.WrapperError(`Channel not present for required option: ${name}`);
+        }
+        return ch;
+    }
+    getChannelOption(name, required) {
+        return this._getOption(name, required, Constants_1.ApplicationCommandOptionTypes.CHANNEL);
+    }
+    getCompleteChannel(name, required) {
+        const resolved = this.getChannel(name, required);
+        if (!resolved) {
+            return undefined; // required will be handled in getChannel
+        }
+        const channel = resolved.completeChannel ?? (resolved.type === Constants_1.ChannelTypes.DM ? resolved : undefined);
+        if (!channel && required) {
+            throw new Errors_1.WrapperError(`Failed to resolve complete channel for required option: ${name}`);
+        }
+        return channel;
+    }
+    getFocused(required) {
+        const opt = this.getOptions().find(o => o.focused === true);
+        if (!opt && required) {
+            throw new Errors_1.WrapperError("Missing required focused option");
+        }
+        else {
+            return opt;
+        }
+    }
+    getInteger(name, required) {
+        return this.getIntegerOption(name, required)?.value;
+    }
+    getIntegerOption(name, required) {
+        return this._getOption(name, required, Constants_1.ApplicationCommandOptionTypes.INTEGER);
+    }
+    getMember(name, required) {
+        if (this.resolved === null) {
+            throw new TypeError("Attempt to use getMember with null resolved. If this is on an autocomplete interaction, use getUserOption instead.");
+        }
+        let val;
+        if (!(val = this.getUserOption(name, required)?.value)) {
+            return undefined;
+        }
+        const ch = this.resolved.members.get(val);
+        if (!ch && required) {
+            throw new Errors_1.WrapperError(`Member not present for required option: ${name}`);
+        }
+        return ch;
+    }
+    getMentionable(name, required) {
+        if (this.resolved === null) {
+            throw new TypeError("Attempt to use getMentionable with null resolved. If this is on an autocomplete interaction, use getAttachmentOption instead.");
+        }
+        let val;
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+        if (!(val = this._getOption(name, required, Constants_1.ApplicationCommandOptionTypes.MENTIONABLE)?.value)) {
+            return undefined;
+        }
+        const role = this.resolved.roles.get(val);
+        const user = this.resolved.users.get(val);
+        if ((!role && !user) && required) {
+            throw new Errors_1.WrapperError(`Value not present for required option: ${name}`);
+        }
+        return role ?? user;
+    }
+    getMentionableOption(name, required) {
+        return this._getOption(name, required, Constants_1.ApplicationCommandOptionTypes.MENTIONABLE);
+    }
+    getNumber(name, required) {
+        return this.getNumberOption(name, required)?.value;
+    }
+    getNumberOption(name, required) {
+        return this._getOption(name, required, Constants_1.ApplicationCommandOptionTypes.NUMBER);
+    }
+    /** Get the options received in this interaction, excluding subcommands and subcommand groups. */
+    getOptions() {
+        let baseOptions;
+        const sub = this.getSubCommand(false) ?? [];
+        switch (sub.length) {
+            case 0: {
+                baseOptions = this.raw;
+                break;
+            }
+            case 1: {
+                baseOptions = this.raw.find(o => o.name === sub[0] && o.type === Constants_1.ApplicationCommandOptionTypes.SUB_COMMAND)?.options;
+                break;
+            }
+            case 2: {
+                baseOptions = this.raw.find(o => o.name === sub[0] && o.type === Constants_1.ApplicationCommandOptionTypes.SUB_COMMAND_GROUP)?.options?.find(o2 => o2.name === sub[1] && o2.type === Constants_1.ApplicationCommandOptionTypes.SUB_COMMAND)?.options;
+                break;
+            }
+        }
+        return baseOptions ?? [];
+    }
+    getRole(name, required) {
+        if (this.resolved === null) {
+            throw new TypeError("Attempt to use getRole with null resolved. If this is on an autocomplete interaction, use getRoleOption instead.");
+        }
+        let val;
+        if (!(val = this.getRoleOption(name, required)?.value)) {
+            return undefined;
+        }
+        const ch = this.resolved.roles.get(val);
+        if (!ch && required) {
+            throw new Errors_1.WrapperError(`Role not present for required option: ${name}`);
+        }
+        return ch;
+    }
+    getRoleOption(name, required) {
+        return this._getOption(name, required, Constants_1.ApplicationCommandOptionTypes.ROLE);
+    }
+    getString(name, required) {
+        return this.getStringOption(name, required)?.value;
+    }
+    getStringOption(name, required) {
+        return this._getOption(name, required, Constants_1.ApplicationCommandOptionTypes.STRING);
+    }
+    getSubCommand(required) {
+        const opt = this.raw.find(o => o.type === Constants_1.ApplicationCommandOptionTypes.SUB_COMMAND || o.type === Constants_1.ApplicationCommandOptionTypes.SUB_COMMAND_GROUP);
+        if (opt?.options) {
+            // nested
+            if (opt.options.length === 1 && opt.type === Constants_1.ApplicationCommandOptionTypes.SUB_COMMAND_GROUP) {
+                const sub = opt.options.find(o => o.type === Constants_1.ApplicationCommandOptionTypes.SUB_COMMAND);
+                return sub?.options ? [opt.name, sub.name] : [opt.name];
+            }
+            else {
+                return [opt.name];
+            }
+        }
+        else {
+            if (required) {
+                throw new Errors_1.WrapperError("Missing required option: SubCommand/SubCommandGroup.");
+            }
+            else {
+                return undefined;
+            }
+        }
+    }
+    getUser(name, required) {
+        if (this.resolved === null) {
+            throw new TypeError("Attempt to use getUser with null resolved. If this is on an autocomplete interaction, use getUseOption instead.");
+        }
+        let val;
+        if (!(val = this.getUserOption(name, required)?.value)) {
+            return undefined;
+        }
+        const ch = this.resolved.users.get(val);
+        if (!ch && required) {
+            throw new Errors_1.WrapperError(`User not present for required option: ${name}`);
+        }
+        return ch;
+    }
+    getUserOption(name, required) {
+        return this._getOption(name, required, Constants_1.ApplicationCommandOptionTypes.USER);
+    }
+}
+exports.default = InteractionOptionsWrapper;

package/cjs/lib/Discord/util/interactions/MessageInteractionResponse.cjs

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class MessageInteractionResponse {
+    constructor(interaction, message, type, callback) {
+        this.interaction = interaction;
+        this.message = message;
+        this.type = type;
+        this.callback = callback;
+    }
+    async deleteMessage() {
+        if (this.message !== null) {
+            return this.interaction.deleteFollowup(this.message.id);
+        }
+        return this.interaction.deleteOriginal();
+    }
+    async getMessage() {
+        if (this.message !== null) {
+            return this.message;
+        }
+        if (this.callback?.resource?.message) {
+            return this.callback.resource.message;
+        }
+        return this.interaction.getOriginal();
+    }
+}
+exports.default = MessageInteractionResponse;

package/cjs/lib/Discord/util/interactions/ModalSubmitInteractionComponentsWrapper.cjs

@@ -0,0 +1,98 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/** @module ModalSubmitInteractionComponentsWrapper */
+const shared_1 = require("./shared.cjs");
+const Errors_1 = require("../Errors.cjs");
+const Constants_1 = require("../../Constants.cjs");
+const Collection_1 = __importDefault(require("../Collection.cjs"));
+/** A wrapper for interaction components. */
+class ModalSubmitInteractionComponentsWrapper {
+    constructor(resolved, data) {
+        this.raw = data;
+        this.resolved = resolved;
+    }
+    _getComponent(customID, required = false, type) {
+        const opt = this.getComponents().find(o => o.customID === customID && o.type === type);
+        if (!opt && required) {
+            throw new Errors_1.WrapperError(`Missing required component: ${customID}`);
+        }
+        else {
+            return opt;
+        }
+    }
+    getChannelSelectComponent(name, required) {
+        return this._getComponent(name, required, Constants_1.ComponentTypes.CHANNEL_SELECT);
+    }
+    getChannelSelectValues(name, required) {
+        const component = this.getChannelSelectComponent(name, required);
+        return component?.values && (0, shared_1.mapRawToResolved)("channel", component.values, this.resolved.channels, false);
+    }
+    getCheckboxComponent(name, required) {
+        return this._getComponent(name, required, Constants_1.ComponentTypes.CHECKBOX);
+    }
+    getCheckboxGroupComponent(name, required) {
+        return this._getComponent(name, required, Constants_1.ComponentTypes.CHECKBOX_GROUP);
+    }
+    getCheckboxGroupValues(name, required) {
+        return this.getCheckboxGroupComponent(name, required)?.values;
+    }
+    getCheckboxValue(name, required) {
+        return this.getCheckboxComponent(name, required)?.value;
+    }
+    /** Get the components in this interaction. */
+    getComponents() {
+        return this.raw
+            .flatMap(r => r.type === Constants_1.ComponentTypes.ACTION_ROW ? r.components : r.component)
+            .filter(c => c !== undefined);
+    }
+    getFileUploadComponent(name, required) {
+        return this._getComponent(name, required, Constants_1.ComponentTypes.FILE_UPLOAD);
+    }
+    getFileUploadValues(name, required) {
+        const component = this.getFileUploadComponent(name, required);
+        return component?.values && (0, shared_1.mapRawToResolved)("attachment", component.values, this.resolved.attachments, false);
+    }
+    getMentionableSelectComponent(name, required) {
+        return this._getComponent(name, required, Constants_1.ComponentTypes.MENTIONABLE_SELECT);
+    }
+    getMentionableSelectValues(name, required) {
+        const component = this.getMentionableSelectComponent(name, required);
+        return component?.values && (0, shared_1.mapRawToResolved)("mentionable", component.values, new Collection_1.default([...this.resolved.users, ...this.resolved.roles]), false);
+    }
+    getRadioGroupComponent(name, required) {
+        return this._getComponent(name, required, Constants_1.ComponentTypes.RADIO_GROUP);
+    }
+    getRadioGroupValue(name, required) {
+        return this.getRadioGroupComponent(name, required)?.value;
+    }
+    getRoleSelectComponent(name, required) {
+        return this._getComponent(name, required, Constants_1.ComponentTypes.ROLE_SELECT);
+    }
+    getRoleSelectValues(name, required) {
+        const component = this.getRoleSelectComponent(name, required);
+        return component?.values && (0, shared_1.mapRawToResolved)("role", component.values, this.resolved.roles, false);
+    }
+    getStringSelectComponent(name, required) {
+        return this._getComponent(name, required, Constants_1.ComponentTypes.STRING_SELECT);
+    }
+    getStringSelectValues(name, required) {
+        return this.getStringSelectComponent(name, required)?.values;
+    }
+    getTextInput(name, required) {
+        return this.getTextInputComponent(name, required)?.value;
+    }
+    getTextInputComponent(name, required) {
+        return this._getComponent(name, required, Constants_1.ComponentTypes.TEXT_INPUT);
+    }
+    getUserSelectComponent(name, required) {
+        return this._getComponent(name, required, Constants_1.ComponentTypes.USER_SELECT);
+    }
+    getUserSelectValues(name, required) {
+        const component = this.getUserSelectComponent(name, required);
+        return component?.values && (0, shared_1.mapRawToResolved)("user", component.values, this.resolved.users, false);
+    }
+}
+exports.default = ModalSubmitInteractionComponentsWrapper;

package/cjs/lib/Discord/util/interactions/SelectMenuValuesWrapper.cjs

@@ -0,0 +1,77 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/** @module SelectMenuValuesWrapper */
+const shared_1 = require("./shared.cjs");
+const Constants_1 = require("../../Constants.cjs");
+const Collection_1 = __importDefault(require("../Collection.cjs"));
+/** A wrapper for select menu data. */
+class SelectMenuValuesWrapper {
+    constructor(resolved, values) {
+        this.resolved = resolved;
+        this.raw = values;
+    }
+    /**
+     * Get the selected channels.
+     *
+     * If `ensurePresent` is false, channels that aren't in resolved will be ignored.
+     * @param ensurePresent If true, an error will be thrown if any value cannot be mapped to a channel.
+     */
+    getChannels(ensurePresent) {
+        return (0, shared_1.mapRawToResolved)("channel", this.raw, this.resolved.channels, ensurePresent);
+    }
+    /**
+     * Get the complete version of the selected channels. This will only succeed if the channel is cached. If the channel is private and isn't cached, an `InteractionResolvedChannel` instance will still be returned.
+     *
+     * If `ensurePresent` is false, channels that aren't in resolved will be ignored.
+     * @param ensurePresent If true, an error will be thrown if any value cannot be mapped to a channel.
+     */
+    getCompleteChannels(ensurePresent) {
+        return this.getChannels(ensurePresent).map(ch => ch.type === Constants_1.ChannelTypes.DM ? ch.completeChannel ?? ch : ch);
+    }
+    /**
+     * Get the selected members.
+     *
+     * If `ensurePresent` is false, members that aren't in resolved will be ignored.
+     * @param ensurePresent If true, an error will be thrown if any value cannot be mapped to a member.
+     */
+    getMembers(ensurePresent) {
+        return (0, shared_1.mapRawToResolved)("member", this.raw, this.resolved.members, ensurePresent);
+    }
+    /**
+     * Get the selected mentionables. (users, roles)
+     *
+     * If `ensurePresent` is false, mentionables that aren't in resolved will be ignored.
+     * @param ensurePresent If true, an error will be thrown if any value cannot be mapped to a user, or role.
+     */
+    getMentionables(ensurePresent) {
+        return (0, shared_1.mapRawToResolved)("mentionable", this.raw, new Collection_1.default([...this.resolved.users, ...this.resolved.roles]), ensurePresent);
+    }
+    /**
+     * Get the selected roles.
+     *
+     * If `ensurePresent` is false, roles that aren't in resolved will be ignored.
+     * @param ensurePresent If true, an error will be thrown if any value cannot be mapped to a role.
+     */
+    getRoles(ensurePresent) {
+        return (0, shared_1.mapRawToResolved)("role", this.raw, this.resolved.roles, ensurePresent);
+    }
+    /**
+     * Get the selected string values. This cannot fail.
+     */
+    getStrings() {
+        return this.raw;
+    }
+    /**
+     * Get the selected users.
+     *
+     * If `ensurePresent` is false, users that aren't in resolved will be ignored.
+     * @param ensurePresent If true, an error will be thrown if any value cannot be mapped to a user.
+     */
+    getUsers(ensurePresent) {
+        return (0, shared_1.mapRawToResolved)("user", this.raw, this.resolved.users, ensurePresent);
+    }
+}
+exports.default = SelectMenuValuesWrapper;

package/cjs/lib/Discord/util/interactions/shared.cjs

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapRawToResolved = mapRawToResolved;
+const Errors_1 = require("../Errors.cjs");
+/**
+ * Maps raw select menu values to resolved objects.
+ *
+ * If `ensurePresent` is false, values that aren't in `resolved` will be ignored.
+ */
+function mapRawToResolved(type, raw, resolved, ensurePresent = false) {
+    return raw
+        .map(id => {
+        const value = resolved.get(id);
+        if (!value && ensurePresent) {
+            throw new Errors_1.WrapperError(`Failed to find ${type} in resolved data: ${id}`);
+        }
+        return value;
+    })
+        .filter(Boolean);
+}

package/cjs/lib/Discord/util/warning.cjs

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WarningCodes = void 0;
+exports.warning = warning;
+var WarningCodes;
+(function (WarningCodes) {
+    WarningCodes["OCEANIC_CACHE_DISABLED"] = "OCEANIC_CACHE_DISABLED";
+    WarningCodes["OCEANIC_COLLECTIONS_LIMIT_WITH_CACHE_DISABLED"] = "OCEANIC_COLLECTIONS_LIMIT_WITH_CACHE_DISABLED";
+    WarningCodes["OCEANIC_AUTH_AND_TOKEN_PROVIDED"] = "OCEANIC_AUTH_AND_TOKEN_PROVIDED";
+})(WarningCodes || (exports.WarningCodes = WarningCodes = {}));
+const WarningOptions = {
+    [WarningCodes.OCEANIC_CACHE_DISABLED]: {
+        detail: "Set the disableCache option to the literal string \"no-warning\" to disable this warning.",
+        message: "Enabling the disableCache option is not recommended. This will break many aspects of the library, as it is not designed to function without cache."
+    },
+    [WarningCodes.OCEANIC_COLLECTIONS_LIMIT_WITH_CACHE_DISABLED]: {
+        detail: "Remove the collectionsLimit option, or zero out all of the possible options to disable this warning.",
+        message: "Providing the collectionsLimit option when the disableCache option has been enabled is redundant. Any provided values will be ignored."
+    },
+    [WarningCodes.OCEANIC_AUTH_AND_TOKEN_PROVIDED]: {
+        detail: "Remove either the auth or token option to disable this warning.",
+        message: "Providing both the token and auth options is redundant. The auth option will be used over token."
+    }
+};
+const warnedCodes = new Set();
+function warning(code) {
+    if (warnedCodes.has(code))
+        return;
+    const options = WarningOptions[code];
+    process.emitWarning(options.message, {
+        code,
+        detail: options.detail
+    });
+}

package/cjs/lib/Signal/Group/ciphertext-message.cjs

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CiphertextMessage = void 0;
+class CiphertextMessage {
+    constructor() {
+        this.UNSUPPORTED_VERSION = 1;
+        this.CURRENT_VERSION = 3;
+        this.WHISPER_TYPE = 2;
+        this.PREKEY_TYPE = 3;
+        this.SENDERKEY_TYPE = 4;
+        this.SENDERKEY_DISTRIBUTION_TYPE = 5;
+        this.ENCRYPTED_MESSAGE_OVERHEAD = 53;
+    }
+}
+exports.CiphertextMessage = CiphertextMessage;
+//# sourceMappingURL=ciphertext-message.js.map

package/cjs/lib/Signal/Group/group-session-builder.cjs

@@ -0,0 +1,67 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupSessionBuilder = void 0;
+const keyhelper = __importStar(require("./keyhelper.cjs"));
+const sender_key_distribution_message_js_1 = require("./sender-key-distribution-message.cjs");
+const sender_key_name_js_1 = require("./sender-key-name.cjs");
+const sender_key_record_js_1 = require("./sender-key-record.cjs");
+class GroupSessionBuilder {
+    constructor(senderKeyStore) {
+        this.senderKeyStore = senderKeyStore;
+    }
+    async process(senderKeyName, senderKeyDistributionMessage) {
+        const senderKeyRecord = await this.senderKeyStore.loadSenderKey(senderKeyName);
+        senderKeyRecord.addSenderKeyState(senderKeyDistributionMessage.getId(), senderKeyDistributionMessage.getIteration(), senderKeyDistributionMessage.getChainKey(), senderKeyDistributionMessage.getSignatureKey());
+        await this.senderKeyStore.storeSenderKey(senderKeyName, senderKeyRecord);
+    }
+    async create(senderKeyName) {
+        const senderKeyRecord = await this.senderKeyStore.loadSenderKey(senderKeyName);
+        if (senderKeyRecord.isEmpty()) {
+            const keyId = keyhelper.generateSenderKeyId();
+            const senderKey = keyhelper.generateSenderKey();
+            const signingKey = keyhelper.generateSenderSigningKey();
+            senderKeyRecord.setSenderKeyState(keyId, 0, senderKey, signingKey);
+            await this.senderKeyStore.storeSenderKey(senderKeyName, senderKeyRecord);
+        }
+        const state = senderKeyRecord.getSenderKeyState();
+        if (!state) {
+            throw new Error('No session state available');
+        }
+        return new sender_key_distribution_message_js_1.SenderKeyDistributionMessage(state.getKeyId(), state.getSenderChainKey().getIteration(), state.getSenderChainKey().getSeed(), state.getSigningKeyPublic());
+    }
+}
+exports.GroupSessionBuilder = GroupSessionBuilder;
+//# sourceMappingURL=group-session-builder.js.map

package/cjs/lib/Signal/Group/group_cipher.cjs

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupCipher = void 0;
+const crypto_js_1 = require("libsignal/src/crypto.js");
+const sender_key_message_js_1 = require("./sender-key-message.cjs");
+const sender_key_name_js_1 = require("./sender-key-name.cjs");
+const sender_key_record_js_1 = require("./sender-key-record.cjs");
+const sender_key_state_js_1 = require("./sender-key-state.cjs");
+class GroupCipher {
+    constructor(senderKeyStore, senderKeyName) {
+        this.senderKeyStore = senderKeyStore;
+        this.senderKeyName = senderKeyName;
+    }
+    async encrypt(paddedPlaintext) {
+        const record = await this.senderKeyStore.loadSenderKey(this.senderKeyName);
+        if (!record) {
+            throw new Error('No SenderKeyRecord found for encryption');
+        }
+        const senderKeyState = record.getSenderKeyState();
+        if (!senderKeyState) {
+            throw new Error('No session to encrypt message');
+        }
+        const iteration = senderKeyState.getSenderChainKey().getIteration();
+        const senderKey = this.getSenderKey(senderKeyState, iteration === 0 ? 0 : iteration + 1);
+        const ciphertext = await this.getCipherText(senderKey.getIv(), senderKey.getCipherKey(), paddedPlaintext);
+        const senderKeyMessage = new sender_key_message_js_1.SenderKeyMessage(senderKeyState.getKeyId(), senderKey.getIteration(), ciphertext, senderKeyState.getSigningKeyPrivate());
+        await this.senderKeyStore.storeSenderKey(this.senderKeyName, record);
+        return senderKeyMessage.serialize();
+    }
+    async decrypt(senderKeyMessageBytes) {
+        const record = await this.senderKeyStore.loadSenderKey(this.senderKeyName);
+        if (!record) {
+            throw new Error('No SenderKeyRecord found for decryption');
+        }
+        const senderKeyMessage = new sender_key_message_js_1.SenderKeyMessage(null, null, null, null, senderKeyMessageBytes);
+        const senderKeyState = record.getSenderKeyState(senderKeyMessage.getKeyId());
+        if (!senderKeyState) {
+            throw new Error('No session found to decrypt message');
+        }
+        senderKeyMessage.verifySignature(senderKeyState.getSigningKeyPublic());
+        const senderKey = this.getSenderKey(senderKeyState, senderKeyMessage.getIteration());
+        const plaintext = await this.getPlainText(senderKey.getIv(), senderKey.getCipherKey(), senderKeyMessage.getCipherText());
+        await this.senderKeyStore.storeSenderKey(this.senderKeyName, record);
+        return plaintext;
+    }
+    getSenderKey(senderKeyState, iteration) {
+        let senderChainKey = senderKeyState.getSenderChainKey();
+        if (senderChainKey.getIteration() > iteration) {
+            if (senderKeyState.hasSenderMessageKey(iteration)) {
+                const messageKey = senderKeyState.removeSenderMessageKey(iteration);
+                if (!messageKey) {
+                    throw new Error('No sender message key found for iteration');
+                }
+                return messageKey;
+            }
+            throw new Error(`Received message with old counter: ${senderChainKey.getIteration()}, ${iteration}`);
+        }
+        if (iteration - senderChainKey.getIteration() > 2000) {
+            throw new Error('Over 2000 messages into the future!');
+        }
+        while (senderChainKey.getIteration() < iteration) {
+            senderKeyState.addSenderMessageKey(senderChainKey.getSenderMessageKey());
+            senderChainKey = senderChainKey.getNext();
+        }
+        senderKeyState.setSenderChainKey(senderChainKey.getNext());
+        return senderChainKey.getSenderMessageKey();
+    }
+    async getPlainText(iv, key, ciphertext) {
+        try {
+            return (0, crypto_js_1.decrypt)(key, ciphertext, iv);
+        }
+        catch (e) {
+            throw new Error('InvalidMessageException');
+        }
+    }
+    async getCipherText(iv, key, plaintext) {
+        try {
+            return (0, crypto_js_1.encrypt)(key, plaintext, iv);
+        }
+        catch (e) {
+            throw new Error('InvalidMessageException');
+        }
+    }
+}
+exports.GroupCipher = GroupCipher;
+//# sourceMappingURL=group_cipher.js.map