Intial Commit

nodered/rootfs/data/node_modules/libmime/lib/charset.js

@@ -0,0 +1,123 @@
+'use strict';
+
+const iconv = require('iconv-lite');
+const encodingJapanese = require('encoding-japanese');
+const charsets = require('./charsets');
+
+/**
+ * Character set encoding and decoding functions
+ */
+const charset = (module.exports = {
+    /**
+     * Encodes an unicode string into an Buffer object as UTF-8
+     *
+     * We force UTF-8 here, no strange encodings allowed.
+     *
+     * @param {String} str String to be encoded
+     * @return {Buffer} UTF-8 encoded typed array
+     */
+    encode(str) {
+        return Buffer.from(str, 'utf-8');
+    },
+
+    /**
+     * Decodes a string from Buffer to an unicode string using specified encoding
+     * NB! Throws if unknown charset is used
+     *
+     * @param {Buffer} buf Binary data to be decoded
+     * @param {String} [fromCharset='UTF-8'] Binary data is decoded into string using this charset
+     * @param {Function} [Iconv] node-iconv function
+     * @return {String} Decded string
+     */
+    decode(buf, fromCharset, Iconv) {
+        fromCharset = charset.normalizeCharset(fromCharset || 'UTF-8');
+
+        if (/^(us-)?ascii|utf-8|7bit$/i.test(fromCharset)) {
+            return buf.toString('utf-8');
+        }
+
+        try {
+            if (typeof Iconv === 'function') {
+                let decoder = new Iconv(fromCharset, 'UTF-8');
+                return decoder.convert(buf).toString();
+            }
+
+            if (/^jis|^iso-?2022-?jp|^EUCJP/i.test(fromCharset)) {
+                if (typeof buf === 'string') {
+                    buf = Buffer.from(buf);
+                }
+                try {
+                    let output = encodingJapanese.convert(buf, {
+                        to: 'UNICODE',
+                        from: fromCharset,
+                        type: 'string'
+                    });
+                    if (typeof output === 'string') {
+                        output = Buffer.from(output);
+                    }
+                    return output;
+                } catch (err) {
+                    // ignore, defaults to iconv-lite on error
+                }
+            }
+
+            return iconv.decode(buf, fromCharset);
+        } catch (err) {
+            // enforce utf-8, data loss might occur
+            return buf.toString();
+        }
+    },
+
+    /**
+     * Convert a string from specific encoding to UTF-8 Buffer
+     *
+     * @param {String|Buffer} str String to be encoded
+     * @param {String} [fromCharset='UTF-8'] Source encoding for the string
+     * @return {Buffer} UTF-8 encoded typed array
+     */
+    convert(data, fromCharset, Iconv) {
+        fromCharset = charset.normalizeCharset(fromCharset || 'UTF-8');
+
+        let bufString;
+
+        if (typeof data !== 'string') {
+            if (/^(us-)?ascii|utf-8|7bit$/i.test(fromCharset)) {
+                return data;
+            }
+
+            bufString = charset.decode(data, fromCharset, Iconv);
+            return charset.encode(bufString);
+        }
+        return charset.encode(data);
+    },
+
+    /**
+     * Converts well known invalid character set names to proper names.
+     * eg. win-1257 will be converted to WINDOWS-1257
+     *
+     * @param {String} charset Charset name to convert
+     * @return {String} Canoninicalized charset name
+     */
+    normalizeCharset(charset) {
+        charset = charset.toLowerCase().trim();
+
+        // first pass
+        if (charsets.hasOwnProperty(charset) && charsets[charset]) {
+            return charsets[charset];
+        }
+
+        charset = charset
+            .replace(/^utf[-_]?(\d+)/, 'utf-$1')
+            .replace(/^(?:us[-_]?)ascii/, 'windows-1252')
+            .replace(/^win(?:dows)?[-_]?(\d+)/, 'windows-$1')
+            .replace(/^(?:latin|iso[-_]?8859)?[-_]?(\d+)/, 'iso-8859-$1')
+            .replace(/^l[-_]?(\d+)/, 'iso-8859-$1');
+
+        // updated pass
+        if (charsets.hasOwnProperty(charset) && charsets[charset]) {
+            return charsets[charset];
+        }
+
+        return charset.toUpperCase();
+    }
+});