FRE-709: Document duplicate recovery wake - FRE-635 already recovered via FRE-708
This commit is contained in:
257
node_modules/postal-mime/dist/decode-strings.cjs
generated
vendored
Normal file
257
node_modules/postal-mime/dist/decode-strings.cjs
generated
vendored
Normal file
@@ -0,0 +1,257 @@
|
||||
"use strict";
|
||||
var __defProp = Object.defineProperty;
|
||||
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
||||
var __getOwnPropNames = Object.getOwnPropertyNames;
|
||||
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
||||
var __export = (target, all) => {
|
||||
for (var name in all)
|
||||
__defProp(target, name, { get: all[name], enumerable: true });
|
||||
};
|
||||
var __copyProps = (to, from, except, desc) => {
|
||||
if (from && typeof from === "object" || typeof from === "function") {
|
||||
for (let key of __getOwnPropNames(from))
|
||||
if (!__hasOwnProp.call(to, key) && key !== except)
|
||||
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
||||
}
|
||||
return to;
|
||||
};
|
||||
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
||||
var decode_strings_exports = {};
|
||||
__export(decode_strings_exports, {
|
||||
blobToArrayBuffer: () => blobToArrayBuffer,
|
||||
decodeBase64: () => decodeBase64,
|
||||
decodeParameterValueContinuations: () => decodeParameterValueContinuations,
|
||||
decodeURIComponentWithCharset: () => decodeURIComponentWithCharset,
|
||||
decodeWord: () => decodeWord,
|
||||
decodeWords: () => decodeWords,
|
||||
getDecoder: () => getDecoder,
|
||||
getHex: () => getHex,
|
||||
textEncoder: () => textEncoder
|
||||
});
|
||||
module.exports = __toCommonJS(decode_strings_exports);
|
||||
const textEncoder = new TextEncoder();
|
||||
const base64Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
||||
const base64Lookup = new Uint8Array(256);
|
||||
for (let i = 0; i < base64Chars.length; i++) {
|
||||
base64Lookup[base64Chars.charCodeAt(i)] = i;
|
||||
}
|
||||
function decodeBase64(base64) {
|
||||
let bufferLength = Math.ceil(base64.length / 4) * 3;
|
||||
const len = base64.length;
|
||||
let p = 0;
|
||||
if (base64.length % 4 === 3) {
|
||||
bufferLength--;
|
||||
} else if (base64.length % 4 === 2) {
|
||||
bufferLength -= 2;
|
||||
} else if (base64[base64.length - 1] === "=") {
|
||||
bufferLength--;
|
||||
if (base64[base64.length - 2] === "=") {
|
||||
bufferLength--;
|
||||
}
|
||||
}
|
||||
const arrayBuffer = new ArrayBuffer(bufferLength);
|
||||
const bytes = new Uint8Array(arrayBuffer);
|
||||
for (let i = 0; i < len; i += 4) {
|
||||
let encoded1 = base64Lookup[base64.charCodeAt(i)];
|
||||
let encoded2 = base64Lookup[base64.charCodeAt(i + 1)];
|
||||
let encoded3 = base64Lookup[base64.charCodeAt(i + 2)];
|
||||
let encoded4 = base64Lookup[base64.charCodeAt(i + 3)];
|
||||
bytes[p++] = encoded1 << 2 | encoded2 >> 4;
|
||||
bytes[p++] = (encoded2 & 15) << 4 | encoded3 >> 2;
|
||||
bytes[p++] = (encoded3 & 3) << 6 | encoded4 & 63;
|
||||
}
|
||||
return arrayBuffer;
|
||||
}
|
||||
function getDecoder(charset) {
|
||||
charset = charset || "utf8";
|
||||
let decoder;
|
||||
try {
|
||||
decoder = new TextDecoder(charset);
|
||||
} catch (err) {
|
||||
decoder = new TextDecoder("windows-1252");
|
||||
}
|
||||
return decoder;
|
||||
}
|
||||
async function blobToArrayBuffer(blob) {
|
||||
if ("arrayBuffer" in blob) {
|
||||
return await blob.arrayBuffer();
|
||||
}
|
||||
const fr = new FileReader();
|
||||
return new Promise((resolve, reject) => {
|
||||
fr.onload = function(e) {
|
||||
resolve(e.target.result);
|
||||
};
|
||||
fr.onerror = function(e) {
|
||||
reject(fr.error);
|
||||
};
|
||||
fr.readAsArrayBuffer(blob);
|
||||
});
|
||||
}
|
||||
function getHex(c) {
|
||||
if (c >= 48 && c <= 57 || c >= 97 && c <= 102 || c >= 65 && c <= 70) {
|
||||
return String.fromCharCode(c);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
function decodeWord(charset, encoding, str) {
|
||||
let splitPos = charset.indexOf("*");
|
||||
if (splitPos >= 0) {
|
||||
charset = charset.substr(0, splitPos);
|
||||
}
|
||||
encoding = encoding.toUpperCase();
|
||||
let byteStr;
|
||||
if (encoding === "Q") {
|
||||
str = str.replace(/=\s+([0-9a-fA-F])/g, "=$1").replace(/[_\s]/g, " ");
|
||||
let buf = textEncoder.encode(str);
|
||||
let encodedBytes = [];
|
||||
for (let i = 0, len = buf.length; i < len; i++) {
|
||||
let c = buf[i];
|
||||
if (i <= len - 2 && c === 61) {
|
||||
let c1 = getHex(buf[i + 1]);
|
||||
let c2 = getHex(buf[i + 2]);
|
||||
if (c1 && c2) {
|
||||
let c3 = parseInt(c1 + c2, 16);
|
||||
encodedBytes.push(c3);
|
||||
i += 2;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
encodedBytes.push(c);
|
||||
}
|
||||
byteStr = new ArrayBuffer(encodedBytes.length);
|
||||
let dataView = new DataView(byteStr);
|
||||
for (let i = 0, len = encodedBytes.length; i < len; i++) {
|
||||
dataView.setUint8(i, encodedBytes[i]);
|
||||
}
|
||||
} else if (encoding === "B") {
|
||||
byteStr = decodeBase64(str.replace(/[^a-zA-Z0-9\+\/=]+/g, ""));
|
||||
} else {
|
||||
byteStr = textEncoder.encode(str);
|
||||
}
|
||||
return getDecoder(charset).decode(byteStr);
|
||||
}
|
||||
function decodeWords(str) {
|
||||
let joinString = true;
|
||||
let done = false;
|
||||
while (!done) {
|
||||
let result = (str || "").toString().replace(
|
||||
/(=\?([^?]+)\?[Bb]\?([^?]*)\?=)\s*(?==\?([^?]+)\?[Bb]\?[^?]*\?=)/g,
|
||||
(match, left, chLeft, encodedLeftStr, chRight) => {
|
||||
if (!joinString) {
|
||||
return match;
|
||||
}
|
||||
if (chLeft === chRight && encodedLeftStr.length % 4 === 0 && !/=$/.test(encodedLeftStr)) {
|
||||
return left + "__\0JOIN\0__";
|
||||
}
|
||||
return match;
|
||||
}
|
||||
).replace(
|
||||
/(=\?([^?]+)\?[Qq]\?[^?]*\?=)\s*(?==\?([^?]+)\?[Qq]\?[^?]*\?=)/g,
|
||||
(match, left, chLeft, chRight) => {
|
||||
if (!joinString) {
|
||||
return match;
|
||||
}
|
||||
if (chLeft === chRight) {
|
||||
return left + "__\0JOIN\0__";
|
||||
}
|
||||
return match;
|
||||
}
|
||||
).replace(/(\?=)?__\x00JOIN\x00__(=\?([^?]+)\?[QqBb]\?)?/g, "").replace(/(=\?[^?]+\?[QqBb]\?[^?]*\?=)\s+(?==\?[^?]+\?[QqBb]\?[^?]*\?=)/g, "$1").replace(
|
||||
/=\?([\w_\-*]+)\?([QqBb])\?([^?]*)\?=/g,
|
||||
(m, charset, encoding, text) => decodeWord(charset, encoding, text)
|
||||
);
|
||||
if (joinString && result.indexOf("\uFFFD") >= 0) {
|
||||
joinString = false;
|
||||
} else {
|
||||
return result;
|
||||
}
|
||||
}
|
||||
}
|
||||
function decodeURIComponentWithCharset(encodedStr, charset) {
|
||||
charset = charset || "utf-8";
|
||||
let encodedBytes = [];
|
||||
for (let i = 0; i < encodedStr.length; i++) {
|
||||
let c = encodedStr.charAt(i);
|
||||
if (c === "%" && /^[a-f0-9]{2}/i.test(encodedStr.substr(i + 1, 2))) {
|
||||
let byte = encodedStr.substr(i + 1, 2);
|
||||
i += 2;
|
||||
encodedBytes.push(parseInt(byte, 16));
|
||||
} else if (c.charCodeAt(0) > 126) {
|
||||
c = textEncoder.encode(c);
|
||||
for (let j = 0; j < c.length; j++) {
|
||||
encodedBytes.push(c[j]);
|
||||
}
|
||||
} else {
|
||||
encodedBytes.push(c.charCodeAt(0));
|
||||
}
|
||||
}
|
||||
const byteStr = new ArrayBuffer(encodedBytes.length);
|
||||
const dataView = new DataView(byteStr);
|
||||
for (let i = 0, len = encodedBytes.length; i < len; i++) {
|
||||
dataView.setUint8(i, encodedBytes[i]);
|
||||
}
|
||||
return getDecoder(charset).decode(byteStr);
|
||||
}
|
||||
function decodeParameterValueContinuations(header) {
|
||||
let paramKeys = /* @__PURE__ */ new Map();
|
||||
Object.keys(header.params).forEach((key) => {
|
||||
let match = key.match(/\*((\d+)\*?)?$/);
|
||||
if (!match) {
|
||||
return;
|
||||
}
|
||||
let actualKey = key.substr(0, match.index).toLowerCase();
|
||||
let nr = Number(match[2]) || 0;
|
||||
let paramVal;
|
||||
if (!paramKeys.has(actualKey)) {
|
||||
paramVal = {
|
||||
charset: false,
|
||||
values: []
|
||||
};
|
||||
paramKeys.set(actualKey, paramVal);
|
||||
} else {
|
||||
paramVal = paramKeys.get(actualKey);
|
||||
}
|
||||
let value = header.params[key];
|
||||
if (nr === 0 && match[0].charAt(match[0].length - 1) === "*" && (match = value.match(/^([^']*)'[^']*'(.*)$/))) {
|
||||
paramVal.charset = match[1] || "utf-8";
|
||||
value = match[2];
|
||||
}
|
||||
paramVal.values.push({ nr, value });
|
||||
delete header.params[key];
|
||||
});
|
||||
paramKeys.forEach((paramVal, key) => {
|
||||
header.params[key] = decodeURIComponentWithCharset(
|
||||
paramVal.values.sort((a, b) => a.nr - b.nr).map((a) => a.value).join(""),
|
||||
paramVal.charset
|
||||
);
|
||||
});
|
||||
}
|
||||
// Annotate the CommonJS export names for ESM import in node:
|
||||
0 && (module.exports = {
|
||||
blobToArrayBuffer,
|
||||
decodeBase64,
|
||||
decodeParameterValueContinuations,
|
||||
decodeURIComponentWithCharset,
|
||||
decodeWord,
|
||||
decodeWords,
|
||||
getDecoder,
|
||||
getHex,
|
||||
textEncoder
|
||||
});
|
||||
|
||||
// Make default export work naturally with require()
|
||||
if (module.exports.default) {
|
||||
var defaultExport = module.exports.default;
|
||||
var namedExports = {};
|
||||
for (var key in module.exports) {
|
||||
if (key !== 'default' && key !== '__esModule') {
|
||||
namedExports[key] = module.exports[key];
|
||||
}
|
||||
}
|
||||
module.exports = defaultExport;
|
||||
Object.assign(module.exports, namedExports);
|
||||
// Preserve __esModule and .default for bundler/transpiler interop
|
||||
Object.defineProperty(module.exports, '__esModule', { value: true });
|
||||
module.exports.default = defaultExport;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user