matrix-react-sdk
Version:
SDK for matrix.org using React
323 lines (306 loc) • 39.3 kB
JavaScript
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.decryptMegolmKeyFile = decryptMegolmKeyFile;
exports.encryptMegolmKeyFile = encryptMegolmKeyFile;
var _logger = require("matrix-js-sdk/src/logger");
var _languageHandler = require("../languageHandler");
var _SdkConfig = _interopRequireDefault(require("../SdkConfig"));
/*
Copyright 2024 New Vector Ltd.
Copyright 2020 The Matrix.org Foundation C.I.C.
Copyright 2017 Vector Creations Ltd
SPDX-License-Identifier: AGPL-3.0-only OR GPL-3.0-only
Please see LICENSE files in the repository root for full details.
*/
const subtleCrypto = window.crypto.subtle;
/**
* Make an Error object which has a friendlyText property which is already
* translated and suitable for showing to the user.
*
* @param {string} message message for the exception
* @param {string} friendlyText
* @returns {{message: string, friendlyText: string}}
*/
function friendlyError(message, friendlyText) {
return {
message,
friendlyText
};
}
function cryptoFailMsg() {
return (0, _languageHandler._t)("encryption|export_unsupported");
}
/**
* Decrypt a megolm key file
*
* @param {ArrayBuffer} data file to decrypt
* @param {String} password
* @return {Promise<String>} promise for decrypted output
*
*
*/
async function decryptMegolmKeyFile(data, password) {
const body = unpackMegolmKeyFile(data);
const brand = _SdkConfig.default.get().brand;
// check we have a version byte
if (body.length < 1) {
throw friendlyError("Invalid file: too short", (0, _languageHandler._t)("encryption|import_invalid_keyfile", {
brand
}));
}
const version = body[0];
if (version !== 1) {
throw friendlyError("Unsupported version", (0, _languageHandler._t)("encryption|import_invalid_keyfile", {
brand
}));
}
const ciphertextLength = body.length - (1 + 16 + 16 + 4 + 32);
if (ciphertextLength < 0) {
throw friendlyError("Invalid file: too short", (0, _languageHandler._t)("encryption|import_invalid_keyfile", {
brand
}));
}
const salt = body.subarray(1, 1 + 16);
const iv = body.subarray(17, 17 + 16);
const iterations = body[33] << 24 | body[34] << 16 | body[35] << 8 | body[36];
const ciphertext = body.subarray(37, 37 + ciphertextLength);
const hmac = body.subarray(-32);
const [aesKey, hmacKey] = await deriveKeys(salt, iterations, password);
const toVerify = body.subarray(0, -32);
let isValid;
try {
isValid = await subtleCrypto.verify({
name: "HMAC"
}, hmacKey, hmac, toVerify);
} catch (e) {
throw friendlyError("subtleCrypto.verify failed: " + e, cryptoFailMsg());
}
if (!isValid) {
throw friendlyError("hmac mismatch", (0, _languageHandler._t)("encryption|import_invalid_passphrase"));
}
let plaintext;
try {
plaintext = await subtleCrypto.decrypt({
name: "AES-CTR",
counter: iv,
length: 64
}, aesKey, ciphertext);
} catch (e) {
throw friendlyError("subtleCrypto.decrypt failed: " + e, cryptoFailMsg());
}
return new TextDecoder().decode(new Uint8Array(plaintext));
}
/**
* Encrypt a megolm key file
*
* @param {String} data
* @param {String} password
* @param {Object=} options
* @param {Number=} options.kdf_rounds Number of iterations to perform of the
* key-derivation function.
* @return {Promise<ArrayBuffer>} promise for encrypted output
*/
async function encryptMegolmKeyFile(data, password, options // eslint-disable-line camelcase
) {
options = options || {};
const kdfRounds = options.kdf_rounds || 500000;
const salt = new Uint8Array(16);
window.crypto.getRandomValues(salt);
const iv = new Uint8Array(16);
window.crypto.getRandomValues(iv);
// clear bit 63 of the IV to stop us hitting the 64-bit counter boundary
// (which would mean we wouldn't be able to decrypt on Android). The loss
// of a single bit of iv is a price we have to pay.
iv[8] &= 0x7f;
const [aesKey, hmacKey] = await deriveKeys(salt, kdfRounds, password);
const encodedData = new TextEncoder().encode(data);
let ciphertext;
try {
ciphertext = await subtleCrypto.encrypt({
name: "AES-CTR",
counter: iv,
length: 64
}, aesKey, encodedData);
} catch (e) {
throw friendlyError("subtleCrypto.encrypt failed: " + e, cryptoFailMsg());
}
const cipherArray = new Uint8Array(ciphertext);
const bodyLength = 1 + salt.length + iv.length + 4 + cipherArray.length + 32;
const resultBuffer = new Uint8Array(bodyLength);
let idx = 0;
resultBuffer[idx++] = 1; // version
resultBuffer.set(salt, idx);
idx += salt.length;
resultBuffer.set(iv, idx);
idx += iv.length;
resultBuffer[idx++] = kdfRounds >> 24;
resultBuffer[idx++] = kdfRounds >> 16 & 0xff;
resultBuffer[idx++] = kdfRounds >> 8 & 0xff;
resultBuffer[idx++] = kdfRounds & 0xff;
resultBuffer.set(cipherArray, idx);
idx += cipherArray.length;
const toSign = resultBuffer.subarray(0, idx);
let hmac;
try {
hmac = await subtleCrypto.sign({
name: "HMAC"
}, hmacKey, toSign);
} catch (e) {
throw friendlyError("subtleCrypto.sign failed: " + e, cryptoFailMsg());
}
const hmacArray = new Uint8Array(hmac);
resultBuffer.set(hmacArray, idx);
return packMegolmKeyFile(resultBuffer);
}
/**
* Derive the AES and HMAC-SHA-256 keys for the file
*
* @param {Unit8Array} salt salt for pbkdf
* @param {Number} iterations number of pbkdf iterations
* @param {String} password password
* @return {Promise<[CryptoKey, CryptoKey]>} promise for [aes key, hmac key]
*/
async function deriveKeys(salt, iterations, password) {
const start = new Date();
let key;
try {
key = await subtleCrypto.importKey("raw", new TextEncoder().encode(password), {
name: "PBKDF2"
}, false, ["deriveBits"]);
} catch (e) {
throw friendlyError("subtleCrypto.importKey failed: " + e, cryptoFailMsg());
}
let keybits;
try {
keybits = await subtleCrypto.deriveBits({
name: "PBKDF2",
salt: salt,
iterations: iterations,
hash: "SHA-512"
}, key, 512);
} catch (e) {
throw friendlyError("subtleCrypto.deriveBits failed: " + e, cryptoFailMsg());
}
const now = new Date();
_logger.logger.log("E2e import/export: deriveKeys took " + (now.getTime() - start.getTime()) + "ms");
const aesKey = keybits.slice(0, 32);
const hmacKey = keybits.slice(32);
const aesProm = subtleCrypto.importKey("raw", aesKey, {
name: "AES-CTR"
}, false, ["encrypt", "decrypt"]).catch(e => {
throw friendlyError("subtleCrypto.importKey failed for AES key: " + e, cryptoFailMsg());
});
const hmacProm = subtleCrypto.importKey("raw", hmacKey, {
name: "HMAC",
hash: {
name: "SHA-256"
}
}, false, ["sign", "verify"]).catch(e => {
throw friendlyError("subtleCrypto.importKey failed for HMAC key: " + e, cryptoFailMsg());
});
return Promise.all([aesProm, hmacProm]);
}
const HEADER_LINE = "-----BEGIN MEGOLM SESSION DATA-----";
const TRAILER_LINE = "-----END MEGOLM SESSION DATA-----";
/**
* Unbase64 an ascii-armoured megolm key file
*
* Strips the header and trailer lines, and unbase64s the content
*
* @param {ArrayBuffer} data input file
* @return {Uint8Array} unbase64ed content
*/
function unpackMegolmKeyFile(data) {
// parse the file as a great big String. This should be safe, because there
// should be no non-ASCII characters, and it means that we can do string
// comparisons to find the header and footer, and feed it into window.atob.
const fileStr = new TextDecoder().decode(new Uint8Array(data));
// look for the start line
let lineStart = 0;
// eslint-disable-next-line no-constant-condition
while (1) {
const lineEnd = fileStr.indexOf("\n", lineStart);
if (lineEnd < 0) {
throw new Error("Header line not found");
}
const line = fileStr.slice(lineStart, lineEnd).trim();
// start the next line after the newline
lineStart = lineEnd + 1;
if (line === HEADER_LINE) {
break;
}
}
const dataStart = lineStart;
// look for the end line
// eslint-disable-next-line no-constant-condition
while (1) {
const lineEnd = fileStr.indexOf("\n", lineStart);
const line = fileStr.slice(lineStart, lineEnd < 0 ? undefined : lineEnd).trim();
if (line === TRAILER_LINE) {
break;
}
if (lineEnd < 0) {
throw new Error("Trailer line not found");
}
// start the next line after the newline
lineStart = lineEnd + 1;
}
const dataEnd = lineStart;
return decodeBase64(fileStr.slice(dataStart, dataEnd));
}
/**
* ascii-armour a megolm key file
*
* base64s the content, and adds header and trailer lines
*
* @param {Uint8Array} data raw data
* @return {ArrayBuffer} formatted file
*/
function packMegolmKeyFile(data) {
// we split into lines before base64ing, because encodeBase64 doesn't deal
// terribly well with large arrays.
const LINE_LENGTH = 72 * 4 / 3;
const nLines = Math.ceil(data.length / LINE_LENGTH);
const lines = new Array(nLines + 3);
lines[0] = HEADER_LINE;
let o = 0;
let i;
for (i = 1; i <= nLines; i++) {
lines[i] = encodeBase64(data.subarray(o, o + LINE_LENGTH));
o += LINE_LENGTH;
}
lines[i++] = TRAILER_LINE;
lines[i] = "";
return new TextEncoder().encode(lines.join("\n")).buffer;
}
/**
* Encode a typed array of uint8 as base64.
* @param {Uint8Array} uint8Array The data to encode.
* @return {string} The base64.
*/
function encodeBase64(uint8Array) {
// Misinterpt the Uint8Array as Latin-1.
// window.btoa expects a unicode string with codepoints in the range 0-255.
const latin1String = String.fromCharCode.apply(null, Array.from(uint8Array));
// Use the builtin base64 encoder.
return window.btoa(latin1String);
}
/**
* Decode a base64 string to a typed array of uint8.
* @param {string} base64 The base64 to decode.
* @return {Uint8Array} The decoded data.
*/
function decodeBase64(base64) {
// window.atob returns a unicode string with codepoints in the range 0-255.
const latin1String = window.atob(base64);
// Encode the string as a Uint8Array
const uint8Array = new Uint8Array(latin1String.length);
for (let i = 0; i < latin1String.length; i++) {
uint8Array[i] = latin1String.charCodeAt(i);
}
return uint8Array;
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_logger","require","_languageHandler","_SdkConfig","_interopRequireDefault","subtleCrypto","window","crypto","subtle","friendlyError","message","friendlyText","cryptoFailMsg","_t","decryptMegolmKeyFile","data","password","body","unpackMegolmKeyFile","brand","SdkConfig","get","length","version","ciphertextLength","salt","subarray","iv","iterations","ciphertext","hmac","aesKey","hmacKey","deriveKeys","toVerify","isValid","verify","name","e","plaintext","decrypt","counter","TextDecoder","decode","Uint8Array","encryptMegolmKeyFile","options","kdfRounds","kdf_rounds","getRandomValues","encodedData","TextEncoder","encode","encrypt","cipherArray","bodyLength","resultBuffer","idx","set","toSign","sign","hmacArray","packMegolmKeyFile","start","Date","key","importKey","keybits","deriveBits","hash","now","logger","log","getTime","slice","aesProm","catch","hmacProm","Promise","all","HEADER_LINE","TRAILER_LINE","fileStr","lineStart","lineEnd","indexOf","Error","line","trim","dataStart","undefined","dataEnd","decodeBase64","LINE_LENGTH","nLines","Math","ceil","lines","Array","o","i","encodeBase64","join","buffer","uint8Array","latin1String","String","fromCharCode","apply","from","btoa","base64","atob","charCodeAt"],"sources":["../../src/utils/MegolmExportEncryption.ts"],"sourcesContent":["/*\nCopyright 2024 New Vector Ltd.\nCopyright 2020 The Matrix.org Foundation C.I.C.\nCopyright 2017 Vector Creations Ltd\n\nSPDX-License-Identifier: AGPL-3.0-only OR GPL-3.0-only\nPlease see LICENSE files in the repository root for full details.\n*/\n\nimport { logger } from \"matrix-js-sdk/src/logger\";\n\nimport { _t } from \"../languageHandler\";\nimport SdkConfig from \"../SdkConfig\";\n\nconst subtleCrypto = window.crypto.subtle;\n\n/**\n * Make an Error object which has a friendlyText property which is already\n * translated and suitable for showing to the user.\n *\n * @param {string} message message for the exception\n * @param {string} friendlyText\n * @returns {{message: string, friendlyText: string}}\n */\nfunction friendlyError(message: string, friendlyText: string): { message: string; friendlyText: string } {\n    return { message, friendlyText };\n}\n\nfunction cryptoFailMsg(): string {\n    return _t(\"encryption|export_unsupported\");\n}\n\n/**\n * Decrypt a megolm key file\n *\n * @param {ArrayBuffer} data file to decrypt\n * @param {String} password\n * @return {Promise<String>} promise for decrypted output\n *\n *\n */\nexport async function decryptMegolmKeyFile(data: ArrayBuffer, password: string): Promise<string> {\n    const body = unpackMegolmKeyFile(data);\n    const brand = SdkConfig.get().brand;\n\n    // check we have a version byte\n    if (body.length < 1) {\n        throw friendlyError(\"Invalid file: too short\", _t(\"encryption|import_invalid_keyfile\", { brand }));\n    }\n\n    const version = body[0];\n    if (version !== 1) {\n        throw friendlyError(\"Unsupported version\", _t(\"encryption|import_invalid_keyfile\", { brand }));\n    }\n\n    const ciphertextLength = body.length - (1 + 16 + 16 + 4 + 32);\n    if (ciphertextLength < 0) {\n        throw friendlyError(\"Invalid file: too short\", _t(\"encryption|import_invalid_keyfile\", { brand }));\n    }\n\n    const salt = body.subarray(1, 1 + 16);\n    const iv = body.subarray(17, 17 + 16);\n    const iterations = (body[33] << 24) | (body[34] << 16) | (body[35] << 8) | body[36];\n    const ciphertext = body.subarray(37, 37 + ciphertextLength);\n    const hmac = body.subarray(-32);\n\n    const [aesKey, hmacKey] = await deriveKeys(salt, iterations, password);\n    const toVerify = body.subarray(0, -32);\n\n    let isValid;\n    try {\n        isValid = await subtleCrypto.verify({ name: \"HMAC\" }, hmacKey, hmac, toVerify);\n    } catch (e) {\n        throw friendlyError(\"subtleCrypto.verify failed: \" + e, cryptoFailMsg());\n    }\n    if (!isValid) {\n        throw friendlyError(\"hmac mismatch\", _t(\"encryption|import_invalid_passphrase\"));\n    }\n\n    let plaintext;\n    try {\n        plaintext = await subtleCrypto.decrypt(\n            {\n                name: \"AES-CTR\",\n                counter: iv,\n                length: 64,\n            },\n            aesKey,\n            ciphertext,\n        );\n    } catch (e) {\n        throw friendlyError(\"subtleCrypto.decrypt failed: \" + e, cryptoFailMsg());\n    }\n\n    return new TextDecoder().decode(new Uint8Array(plaintext));\n}\n\n/**\n * Encrypt a megolm key file\n *\n * @param {String} data\n * @param {String} password\n * @param {Object=} options\n * @param {Number=} options.kdf_rounds Number of iterations to perform of the\n *    key-derivation function.\n * @return {Promise<ArrayBuffer>} promise for encrypted output\n */\nexport async function encryptMegolmKeyFile(\n    data: string,\n    password: string,\n    options?: { kdf_rounds?: number }, // eslint-disable-line camelcase\n): Promise<ArrayBuffer> {\n    options = options || {};\n    const kdfRounds = options.kdf_rounds || 500000;\n\n    const salt = new Uint8Array(16);\n    window.crypto.getRandomValues(salt);\n\n    const iv = new Uint8Array(16);\n    window.crypto.getRandomValues(iv);\n\n    // clear bit 63 of the IV to stop us hitting the 64-bit counter boundary\n    // (which would mean we wouldn't be able to decrypt on Android). The loss\n    // of a single bit of iv is a price we have to pay.\n    iv[8] &= 0x7f;\n\n    const [aesKey, hmacKey] = await deriveKeys(salt, kdfRounds, password);\n    const encodedData = new TextEncoder().encode(data);\n\n    let ciphertext;\n    try {\n        ciphertext = await subtleCrypto.encrypt(\n            {\n                name: \"AES-CTR\",\n                counter: iv,\n                length: 64,\n            },\n            aesKey,\n            encodedData,\n        );\n    } catch (e) {\n        throw friendlyError(\"subtleCrypto.encrypt failed: \" + e, cryptoFailMsg());\n    }\n\n    const cipherArray = new Uint8Array(ciphertext);\n    const bodyLength = 1 + salt.length + iv.length + 4 + cipherArray.length + 32;\n    const resultBuffer = new Uint8Array(bodyLength);\n    let idx = 0;\n    resultBuffer[idx++] = 1; // version\n    resultBuffer.set(salt, idx);\n    idx += salt.length;\n    resultBuffer.set(iv, idx);\n    idx += iv.length;\n    resultBuffer[idx++] = kdfRounds >> 24;\n    resultBuffer[idx++] = (kdfRounds >> 16) & 0xff;\n    resultBuffer[idx++] = (kdfRounds >> 8) & 0xff;\n    resultBuffer[idx++] = kdfRounds & 0xff;\n    resultBuffer.set(cipherArray, idx);\n    idx += cipherArray.length;\n\n    const toSign = resultBuffer.subarray(0, idx);\n\n    let hmac;\n    try {\n        hmac = await subtleCrypto.sign({ name: \"HMAC\" }, hmacKey, toSign);\n    } catch (e) {\n        throw friendlyError(\"subtleCrypto.sign failed: \" + e, cryptoFailMsg());\n    }\n\n    const hmacArray = new Uint8Array(hmac);\n    resultBuffer.set(hmacArray, idx);\n    return packMegolmKeyFile(resultBuffer);\n}\n\n/**\n * Derive the AES and HMAC-SHA-256 keys for the file\n *\n * @param {Unit8Array} salt  salt for pbkdf\n * @param {Number} iterations number of pbkdf iterations\n * @param {String} password  password\n * @return {Promise<[CryptoKey, CryptoKey]>} promise for [aes key, hmac key]\n */\nasync function deriveKeys(salt: Uint8Array, iterations: number, password: string): Promise<[CryptoKey, CryptoKey]> {\n    const start = new Date();\n\n    let key;\n    try {\n        key = await subtleCrypto.importKey(\"raw\", new TextEncoder().encode(password), { name: \"PBKDF2\" }, false, [\n            \"deriveBits\",\n        ]);\n    } catch (e) {\n        throw friendlyError(\"subtleCrypto.importKey failed: \" + e, cryptoFailMsg());\n    }\n\n    let keybits;\n    try {\n        keybits = await subtleCrypto.deriveBits(\n            {\n                name: \"PBKDF2\",\n                salt: salt,\n                iterations: iterations,\n                hash: \"SHA-512\",\n            },\n            key,\n            512,\n        );\n    } catch (e) {\n        throw friendlyError(\"subtleCrypto.deriveBits failed: \" + e, cryptoFailMsg());\n    }\n\n    const now = new Date();\n    logger.log(\"E2e import/export: deriveKeys took \" + (now.getTime() - start.getTime()) + \"ms\");\n\n    const aesKey = keybits.slice(0, 32);\n    const hmacKey = keybits.slice(32);\n\n    const aesProm = subtleCrypto\n        .importKey(\"raw\", aesKey, { name: \"AES-CTR\" }, false, [\"encrypt\", \"decrypt\"])\n        .catch((e) => {\n            throw friendlyError(\"subtleCrypto.importKey failed for AES key: \" + e, cryptoFailMsg());\n        });\n\n    const hmacProm = subtleCrypto\n        .importKey(\n            \"raw\",\n            hmacKey,\n            {\n                name: \"HMAC\",\n                hash: { name: \"SHA-256\" },\n            },\n            false,\n            [\"sign\", \"verify\"],\n        )\n        .catch((e) => {\n            throw friendlyError(\"subtleCrypto.importKey failed for HMAC key: \" + e, cryptoFailMsg());\n        });\n\n    return Promise.all([aesProm, hmacProm]);\n}\n\nconst HEADER_LINE = \"-----BEGIN MEGOLM SESSION DATA-----\";\nconst TRAILER_LINE = \"-----END MEGOLM SESSION DATA-----\";\n\n/**\n * Unbase64 an ascii-armoured megolm key file\n *\n * Strips the header and trailer lines, and unbase64s the content\n *\n * @param {ArrayBuffer} data  input file\n * @return {Uint8Array} unbase64ed content\n */\nfunction unpackMegolmKeyFile(data: ArrayBuffer): Uint8Array {\n    // parse the file as a great big String. This should be safe, because there\n    // should be no non-ASCII characters, and it means that we can do string\n    // comparisons to find the header and footer, and feed it into window.atob.\n    const fileStr = new TextDecoder().decode(new Uint8Array(data));\n\n    // look for the start line\n    let lineStart = 0;\n    // eslint-disable-next-line no-constant-condition\n    while (1) {\n        const lineEnd = fileStr.indexOf(\"\\n\", lineStart);\n        if (lineEnd < 0) {\n            throw new Error(\"Header line not found\");\n        }\n        const line = fileStr.slice(lineStart, lineEnd).trim();\n\n        // start the next line after the newline\n        lineStart = lineEnd + 1;\n\n        if (line === HEADER_LINE) {\n            break;\n        }\n    }\n\n    const dataStart = lineStart;\n\n    // look for the end line\n    // eslint-disable-next-line no-constant-condition\n    while (1) {\n        const lineEnd = fileStr.indexOf(\"\\n\", lineStart);\n        const line = fileStr.slice(lineStart, lineEnd < 0 ? undefined : lineEnd).trim();\n        if (line === TRAILER_LINE) {\n            break;\n        }\n\n        if (lineEnd < 0) {\n            throw new Error(\"Trailer line not found\");\n        }\n\n        // start the next line after the newline\n        lineStart = lineEnd + 1;\n    }\n\n    const dataEnd = lineStart;\n    return decodeBase64(fileStr.slice(dataStart, dataEnd));\n}\n\n/**\n * ascii-armour a  megolm key file\n *\n * base64s the content, and adds header and trailer lines\n *\n * @param {Uint8Array} data  raw data\n * @return {ArrayBuffer} formatted file\n */\nfunction packMegolmKeyFile(data: Uint8Array): ArrayBuffer {\n    // we split into lines before base64ing, because encodeBase64 doesn't deal\n    // terribly well with large arrays.\n    const LINE_LENGTH = (72 * 4) / 3;\n    const nLines = Math.ceil(data.length / LINE_LENGTH);\n    const lines = new Array(nLines + 3);\n    lines[0] = HEADER_LINE;\n    let o = 0;\n    let i;\n    for (i = 1; i <= nLines; i++) {\n        lines[i] = encodeBase64(data.subarray(o, o + LINE_LENGTH));\n        o += LINE_LENGTH;\n    }\n    lines[i++] = TRAILER_LINE;\n    lines[i] = \"\";\n    return new TextEncoder().encode(lines.join(\"\\n\")).buffer;\n}\n\n/**\n * Encode a typed array of uint8 as base64.\n * @param {Uint8Array} uint8Array The data to encode.\n * @return {string} The base64.\n */\nfunction encodeBase64(uint8Array: Uint8Array): string {\n    // Misinterpt the Uint8Array as Latin-1.\n    // window.btoa expects a unicode string with codepoints in the range 0-255.\n    const latin1String = String.fromCharCode.apply(null, Array.from(uint8Array));\n    // Use the builtin base64 encoder.\n    return window.btoa(latin1String);\n}\n\n/**\n * Decode a base64 string to a typed array of uint8.\n * @param {string} base64 The base64 to decode.\n * @return {Uint8Array} The decoded data.\n */\nfunction decodeBase64(base64: string): Uint8Array {\n    // window.atob returns a unicode string with codepoints in the range 0-255.\n    const latin1String = window.atob(base64);\n    // Encode the string as a Uint8Array\n    const uint8Array = new Uint8Array(latin1String.length);\n    for (let i = 0; i < latin1String.length; i++) {\n        uint8Array[i] = latin1String.charCodeAt(i);\n    }\n    return uint8Array;\n}\n"],"mappings":"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","ignoreList":[]}