unicode-input-toolconverter 0.2.0 → 0.2.3

package/browser_action/unicode/UnicodeConverter.js

@@ -1,19 +1,25 @@
 /* eslint-disable class-methods-use-this -- Todo: fix later */
+
+import camelCase from 'camelcase';
+
 import {getUnicodeDefaults} from '../preferences/prefDefaults.js';
 import {getHangulName, getHangulFromName} from './hangul.js';
 import charrefunicodeDb from './charrefunicodeDb.js';
 import unicodecharref from '../unicodecharref.js';
-import camelCase from '../../vendor/camelcase/index.js';
 
 /**
-* @typedef {"php"|"css"|"javascript"} UnicodeEscapeMode
-*/
+ * @typedef {"php"|"css"|"javascript"} UnicodeEscapeMode
+ */
+
+/**
+ * @typedef {number} Integer
+ */
 
 /**
  * @namespace Converts from one string form to another
  */
-const decim = /&#(\d*);/gu;
-const hexadec = /&#[xX]([\da-fA-F]*);/gu;
+const decim = /&#(\d*);/gv;
+const hexadec = /&#[xX]([\da-fA-F]*);/gv;
 
 const builtinEntities = new Set(['apos', 'quot', 'lt', 'gt', 'amp']);
 
@@ -22,9 +28,9 @@ const builtinEntities = new Set(['apos', 'quot', 'lt', 'gt', 'amp']);
 //   https://unicode.org/reports/tr31/ ;
 // Currently appears to be Tables 3, 3a, and 3b
 //   (besides \u0027 and \u2019 per XML)
-const xmlName = /[\p{ID_Start}_][\p{ID_Continue}\u0024\u005F\u002D\u002E\u003A\u00B7\u058A\u05F4\u0F0B\u200C\u2010\u2027\u30A0\u30FB\u05F3\u200D]*/gui;
+const xmlName = /[\p{ID_Start}_][\p{ID_Continue}\u{24}\u{5F}\u{2D}\u{2E}\u{3A}\u{B7}\u{58A}\u{5F4}\u{F0B}\u{200C}\u{2010}\u{2027}\u{30A0}\u{30FB}\u{5F3}\u{200D}]*/gvi;
 // const htmlOrXmlEnt = /&([a-z\d]+);/gui; // Works for basic HTML entitites
-const htmlOrXmlEnt = new RegExp('&(' + xmlName.source + ');', 'gui');
+const htmlOrXmlEnt = new RegExp('&(' + xmlName.source + ');', 'gvi');
 
 export const getUnicodeConverter = () => {
   const {getPref} = getUnicodeDefaults();
@@ -34,14 +40,21 @@ export const getUnicodeConverter = () => {
    */
   return class UnicodeConverter {
     /**
-     * @param {IntlDom} _
+     * @param {{_: import('intl-dom').I18NCallback<string>}} cfg
      */
     constructor ({_}) {
       this._ = _;
+
+      /** @type {string[]} */
       this.newents = [];
+
+      /** @type {(string|number)[]} */
       this.newcharrefs = [];
 
+      /** @type {string[]} */
       this.entities = [];
+
+      /** @type {number[]} */
       this.numericCharacterReferences = [];
     }
 
@@ -75,7 +88,7 @@ export const getUnicodeConverter = () => {
 
     /**
      * @param {string} out
-     * @returns {string}
+     * @returns {Promise<string>}
      */
     async charref2htmlentsval (out) {
       // If true, should allow conversion to &apos;
@@ -83,11 +96,11 @@ export const getUnicodeConverter = () => {
 
       out = out.replaceAll(decim, (match, match1) => {
         const matched = this.numericCharacterReferences.indexOf(
-          Number.parseInt(match1)
+          Number.parseInt(match1, 10)
         );
         if (
           matched !== -1 &&
-          (matched !== this.getAposPos() || xhtmlentmode)
+          (xhtmlentmode || matched !== this.getAposPos())
         ) {
           return '&' + this.entities[matched] + ';';
         }
@@ -98,7 +111,7 @@ export const getUnicodeConverter = () => {
         );
         if (
           matched !== -1 && (
-            matched !== this.getAposPos() || xhtmlentmode
+            xhtmlentmode || matched !== this.getAposPos()
           )
         ) {
           return '&' + this.entities[matched] + ';';
@@ -110,8 +123,8 @@ export const getUnicodeConverter = () => {
 
     /**
      * @param {string} unicodeToConvert
-     * @param {boolean} leaveSurrogates
-     * @returns {string}
+     * @param {boolean} [leaveSurrogates]
+     * @returns {Promise<string>}
      */
     async unicode2charrefDecval (unicodeToConvert, leaveSurrogates) {
       let out = '';
@@ -129,7 +142,7 @@ export const getUnicodeConverter = () => {
 
         // Replace this 'if' condition and remove the 'else' if also
         //  want ascii
-        } else if (temp >= 128 || asciiLt128) {
+        } else if (asciiLt128 || temp >= 128) {
           out += '&#' + temp + ';';
         } else {
           out += unicodeToConvert.charAt(i);
@@ -140,9 +153,9 @@ export const getUnicodeConverter = () => {
 
     /**
      * @param {string} unicodeToConvert
-     * @param {boolean} leaveSurrogates
-     * @param {UnicodeEscapeMode} type
-     * @returns {string}
+     * @param {boolean} [leaveSurrogates]
+     * @param {UnicodeEscapeMode} [type]
+     * @returns {Promise<string>}
      */
     async unicode2charrefHexval (unicodeToConvert, leaveSurrogates, type) {
       // alert(unicodeToConvert + '::' + leaveSurrogates + '::' + type);
@@ -192,7 +205,7 @@ export const getUnicodeConverter = () => {
           }
           out += beginEscape + xstyle + hexletters + endEscape;
         // Replace this 'if' condition and remove the 'else' if also want ascii
-        } else if (temp >= 128 || asciiLt128) {
+        } else if (asciiLt128 || temp >= 128) {
           hexletters = temp.toString(16);
           if (hexLettersUpper) {
             hexletters = hexletters.toUpperCase();
@@ -215,12 +228,14 @@ export const getUnicodeConverter = () => {
 
     /**
      * @param {string} unicodeToConvert
-     * @returns {string}
+     * @returns {Promise<string>}
      */
     async unicode2htmlentsval (unicodeToConvert) {
       for (let i = 0; i < this.newents.length; i++) {
         unicodeToConvert = unicodeToConvert.replaceAll(
-          this.newcharrefs[i], '&' + this.newents[i] + ';'
+          // eslint-disable-next-line @stylistic/max-len -- Long
+          // eslint-disable-next-line unicorn/no-unsafe-string-replacement -- Safe here
+          String(this.newcharrefs[i]), '&' + this.newents[i] + ';'
         );
       }
 
@@ -231,9 +246,9 @@ export const getUnicodeConverter = () => {
       const ampkeep = await getPref('ampkeep');
 
       for (const ch of unicodeToConvert) {
-        const codePoint = ch.codePointAt();
+        const codePoint = ch.codePointAt(0);
         const tempcharref = this.numericCharacterReferences.indexOf(
-          codePoint
+          /** @type {number} */ (codePoint)
         );
 
         out += tempcharref !== -1 &&
@@ -247,7 +262,7 @@ export const getUnicodeConverter = () => {
 
     /**
      * @param {string} out
-     * @returns {string}
+     * @returns {Promise<string>}
      */
     async htmlents2charrefDecval (out) {
       // If true, don't convert &apos;, &quot;, &lt;, &gt;, and &amp;
@@ -256,7 +271,7 @@ export const getUnicodeConverter = () => {
         if (!xmlentkeep || !builtinEntities.has(match1)) {
           // If recognized multiple char ent. (won't convert these to decimal)
           if (this.newents.includes(match1)) {
-            return this.newcharrefs[this.newents.indexOf(match1)];
+            return String(this.newcharrefs[this.newents.indexOf(match1)]);
           }
           // If recognized single char. ent.
           if (this.entities.includes(match1)) {
@@ -274,7 +289,7 @@ export const getUnicodeConverter = () => {
 
     /**
      * @param {string} out
-     * @returns {string}
+     * @returns {Promise<string>}
      */
     async htmlents2charrefHexval (out) {
       const xstyle = 'x';
@@ -296,7 +311,7 @@ export const getUnicodeConverter = () => {
           // If recognized multiple char. ent. (won't convert these to
           //   hexadecimal)
           if (c !== -1) {
-            return this.newcharrefs[c];
+            return String(this.newcharrefs[c]);
           }
 
           // If recognized single char. ent.
@@ -316,7 +331,7 @@ export const getUnicodeConverter = () => {
 
     /**
      * @param {string} out
-     * @returns {string}
+     * @returns {Promise<string>}
      */
     async htmlents2unicodeval (out) {
       // If true, don't convert &apos;, &quot;, &lt;, &gt;, and &amp;
@@ -329,7 +344,7 @@ export const getUnicodeConverter = () => {
 
           // If recognized multiple char ent.
           if (this.newents.includes(match1)) {
-            return this.newcharrefs[this.newents.indexOf(match1)];
+            return String(this.newcharrefs[this.newents.indexOf(match1)]);
           }
           // If recognized single char. ent.
           if (this.entities.includes(match1)) {
@@ -355,7 +370,7 @@ export const getUnicodeConverter = () => {
 
     /**
      * @param {string} out
-     * @returns {string}
+     * @returns {Promise<string>}
      */
     async dec2hexval (out) {
       const xstyle = 'x';
@@ -405,7 +420,7 @@ export const getUnicodeConverter = () => {
           unicode += s + next;
           break;
         default: {
-          const hexEsc = toconvert.slice(i + 1).match(/^([A-Fa-f\d]{1,5})(?:([A-Fa-f\d])|(\r\n|[ \t\r\n\f])?)/u); // 1-5 hex and WS, or 6 hex
+          const hexEsc = toconvert.slice(i + 1).match(/^([A-Fa-f\d]{1,5})(?:([A-Fa-f\d])|(\r\n|[ \t\r\n\f])?)/v); // 1-5 hex and WS, or 6 hex
           if (hexEsc) {
             i += hexEsc[0].length - 1; // We want to skip the whole structure
             const hex = hexEsc[1] + (hexEsc[2] || ''); // [2] only if is 6-digit
@@ -414,9 +429,9 @@ export const getUnicodeConverter = () => {
             // \u000 is disallowed in CSS 2.1 (behavior undefined) and above
             //  0x10FFFF is beyond valid Unicode; fix: disallow non-characters
             //  too?
-            if (dec > 0x10FFFF || dec === 0) {
+            if (dec === 0 || dec > 0x10FFFF) {
               // Replacement character since not valid Unicode
-              unicode += '\uFFFD';
+              unicode += '\u{FFFD}';
               break;
             }
 
@@ -425,7 +440,7 @@ export const getUnicodeConverter = () => {
             // Too low ASCII to be converted (not a letter, digit,
             //  underscore, or hyphen)
             // eslint-disable-next-line unicorn/prefer-ternary -- Structure
-            if (dec < 0xA1 && (/[^\w-]/u).test(hexStr)) {
+            if (dec < 0xA1 && (/[^\w\-]/v).test(hexStr)) {
               // Don't convert since won't be valid if unescaped
               // Although https://www.w3.org/TR/CSS21/grammar.html#scanner
               //  (under "nonascii" which is a possible (indirect) component
@@ -462,7 +477,7 @@ export const getUnicodeConverter = () => {
 
     /**
      * @param {string} toconvert
-     * @param {UnicodeEscapeMode} mode
+     * @param {UnicodeEscapeMode} [mode]
      * @returns {string}
      */
     jsescape2unicodeval (toconvert, mode) {
@@ -479,7 +494,8 @@ export const getUnicodeConverter = () => {
               unicode += s;
               break;
             case 'u':
-              hexChrs = (/^[a-fA-F\d]{6}|[a-fA-F\d]{4}/u).exec(toconvert.slice(i + 2));
+              // eslint-disable-next-line sonarjs/anchor-precedence -- Intended
+              hexChrs = (/^[a-fA-F\d]{6}|[a-fA-F\d]{4}/v).exec(toconvert.slice(i + 2));
               if (hexChrs) {
                 unicode += String.fromCodePoint(
                   Number.parseInt(hexChrs[0], 16)
@@ -498,7 +514,7 @@ export const getUnicodeConverter = () => {
               unicode += s;
               break;
             case 'r':
-              unicode += '\u000D';
+              unicode += '\u{D}';
               break;
             case 'n':
               unicode += '\n';
@@ -516,7 +532,7 @@ export const getUnicodeConverter = () => {
               unicode += '\b';
               break;
             case 'u':
-              hexChrs = (/^[a-fA-F\d]{4}/u).exec(toconvert.slice(i + 2));
+              hexChrs = (/^[a-fA-F\d]{4}/v).exec(toconvert.slice(i + 2));
               if (hexChrs) {
                 unicode += String.fromCharCode(Number.parseInt(hexChrs[0], 16));
                 i += hexChrs[0].length; // 4
@@ -536,7 +552,7 @@ export const getUnicodeConverter = () => {
 
     /**
      * @param {string} toconvert
-     * @returns {string}
+     * @returns {Promise<string>}
      */
     async unicode2jsescapeval (toconvert) {
       return await this.unicode2charrefHexval(toconvert, true, 'javascript');
@@ -544,7 +560,7 @@ export const getUnicodeConverter = () => {
 
     /**
      * @param {string} toconvert
-     * @returns {string}
+     * @returns {Promise<string>}
      */
     async unicodeTo6DigitVal (toconvert) {
       return await this.unicode2charrefHexval(toconvert, false, 'php');
@@ -552,7 +568,7 @@ export const getUnicodeConverter = () => {
 
     /**
      * @param {string} toconvert
-     * @returns {string}
+     * @returns {Promise<string>}
      */
     async unicode2cssescapeval (toconvert) {
       return await this.unicode2charrefHexval(toconvert, false, 'css');
@@ -570,13 +586,13 @@ export const getUnicodeConverter = () => {
 
     /**
      * @param {string} toconvert
-     * @returns {string}
+     * @returns {Promise<string>}
      */
     async unicode2CharDescVal (toconvert) {
       const asciiLt128 = await getPref('asciiLt128');
       return (await Promise.all([...toconvert].map(async (ch) => {
-        const codePoint = ch.codePointAt();
-        if (codePoint >= 128 || asciiLt128) {
+        const codePoint = /** @type {number} */ (ch.codePointAt(0));
+        if (asciiLt128 || codePoint >= 128) {
           const charDesc = await this.getCharDescForCodePoint(codePoint);
           if (charDesc) { // Skip if no description in database
             return String.raw`\C{` + charDesc + '}';
@@ -591,19 +607,21 @@ export const getUnicodeConverter = () => {
      * @returns {Promise<string>}
      */
     async charDesc2UnicodeVal (toconvert) {
+      /** @type {Promise<number|false|void>[]} */
       const promises = [];
-      toconvert.replaceAll(/\\C\{([^}]*)\}/gu, (n, n1) => {
+      toconvert.replaceAll(/\\C\{([^\}]*)\}/gv, (n, n1) => {
         promises.push(this.lookupUnicodeValueByCharName(n1));
+        return ''; // No-op
       });
 
       const unicodeVals = await Promise.all(promises);
 
       let i = -1;
-      return toconvert.replaceAll(/\\C\{([^}]*)\}/gu, () => {
+      return toconvert.replaceAll(/\\C\{([^\}]*)\}/gv, () => {
         ++i;
-        return unicodeVals[i]
-          ? String.fromCodePoint(unicodeVals[i])
-          : '\uFFFD'; // Replacement character if not found?
+        return Object.hasOwn(unicodeVals, i)
+          ? String.fromCodePoint(/** @type {number} */ (unicodeVals[i]))
+          : '\u{FFFD}'; // Replacement character if not found?
       });
     }
 
@@ -611,7 +629,7 @@ export const getUnicodeConverter = () => {
      * Obtain a Unicode character description for a given decimal-expressed
      * code point.
      * @param {Integer} dec The code point of the description to obtain
-     * @returns {string} The Unicode character description
+     * @returns {Promise<string|void>} The Unicode character description
      */
     async getCharDescForCodePoint (dec) {
       // Todo: This should support CJK and those which are only marked by
@@ -651,7 +669,7 @@ export const getUnicodeConverter = () => {
     /**
      * Search for a Unicode character value matching a given description.
      * @param {string} value
-     * @returns {Integer}
+     * @returns {Promise<Integer|false|void>}
      */
     async lookupUnicodeValueByCharName (value) {
       // todo: Character names for Unihan
@@ -665,23 +683,23 @@ export const getUnicodeConverter = () => {
         /* istanbul ignore next -- Known todo */
         : 'searchkDefinition';
       await this.searchUnicode(
-        {id, value}, table, 'noChart=true', 'strict=true'
+        {id, value}, table, true, true
       );
-      if (!this.descripts[0] && value.length <= 7) {
+      if (!this.descripts?.[0] && value.length <= 7) {
         // Try Hangul (if possible size for Hangul)
         // Fix: Is Hangul allowed in PHP 6 Unicode escape names?
         const ret = getHangulFromName(value);
         return ret ? ret.charCodeAt(0) : false;
       }
-      return this.descripts[0];
+      return this.descripts?.[0];
     }
 
     // Used for conversions, so included here (also used externally)
     /**
      * @param {{id: string, value: string}} obj E.g., an input element
-     * @param {string} table
-     * @param {boolean} nochart
-     * @param {boolean} strict
+     * @param {string} [table]
+     * @param {boolean} [nochart]
+     * @param {boolean} [strict]
      * @returns {Promise<void>}
      */
     async searchUnicode (obj, table, nochart, strict) { // Fix: allow Jamo!
@@ -694,26 +712,34 @@ export const getUnicodeConverter = () => {
       /* istanbul ignore next -- Just a guard */
       if (
         // Don't query the other databases here
-        (obj.id.startsWith('searchk') && table === 'UnicodeData') ||
-        ((/^search[^k]/u).test(obj.id) && table === 'Unihan')
+        (table === 'UnicodeData' && obj.id.startsWith('searchk')) ||
+        (table === 'Unihan' && (/^search[^k]/v).test(obj.id))
       ) {
         return;
       }
-      const nameDesc = obj.id.replace(/^search/u, '');
-
-      // const nameDesc = (table === 'Unihan') ? 'kDefinition'
-      // : 'Name'; // Fix: let Unihan search Mandarin, etc.
-
-      const conn = table === 'Unihan'
-        ? unicodecharref.unihanDatabase
-        : charrefunicodeDb;
-
       if (table === 'Unihan' && !nochart && !unicodecharref.unihanDb_exists) {
         alert(this._('need_download_unihan'));
         return;
       }
 
+      const nameDesc = obj.id.replace(/^search/v, '');
+
+      // const nameDesc = (table === 'Unihan') ? 'kDefinition'
+      // : 'Name'; // Fix: let Unihan search Mandarin, etc.
+
+      const conn =
+        /**
+         * @type {import('./charrefunicodeDb.js').UnicodeDatabase|
+         * import('./charrefunicodeDb.js').UnihanDatabase}
+         */ (
+          table === 'Unihan'
+            ? unicodecharref.unihanDatabase
+            : charrefunicodeDb
+        );
+
       await conn.connect();
+
+      /** @type {number[]} */
       this.descripts = [];
 
       try {
@@ -753,18 +779,18 @@ export const getUnicodeConverter = () => {
           ? chars.filter((chr) => {
             const cell = table === 'Unihan'
               /* istanbul ignore next -- Not yet using strict checking */
-              ? chr.columns[
+              ? /** @type {{columns: string[]}} */ (chr).columns[
                 unicodecharref.Unihan.indexOf(field)
               ]
-              : chr[camelizedField];
+              : /** @type {Record<string, string>}} */ (chr)[camelizedField];
             return cell.toLowerCase() === nameDescVal.toLowerCase();
           })
           : chars.filter((chr) => {
             const cell = table === 'Unihan'
-              ? chr.columns[
+              ? /** @type {{columns: string[]}} */ (chr).columns[
                 unicodecharref.Unihan.indexOf(field)
               ]
-              : chr[camelizedField];
+              : /** @type {Record<string, string>}} */ (chr)[camelizedField];
             return cell.toLowerCase().includes(
               nameDescVal.toLowerCase()
             );
@@ -779,7 +805,7 @@ export const getUnicodeConverter = () => {
             return;
           }
           // Fix: inefficient, but fits more easily into current pattern
-          this.descripts.push(hex);
+          this.descripts?.push(hex);
         });
       /* istanbul ignore next -- Debugging */
       } catch (e) {