Merge branch 'JustStudio7:main' into main

Author: SubhrajitSain

_just/dangerously-insert-files/[email protected]

@@ -169,11 +169,17 @@ const characterMap = [
   'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
   '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-', '_', '(', ')', '.', '~'
 ];
+const cc = characterMap.length;
 
 const errorprefix = 'Encoder.js Error: ';
+const encddecdpfx = (insertmode) => {return `The text cannot be ${insertmode} for the following reason: `};
+const docsurllink = 'https://encoder.js.is-a.dev/en/docs';
 const errors = [
   `${errorprefix}The string to be decoded is not correctly encoded.`,
-  `${errorprefix}Something went wrong.`
+  `${errorprefix}Something went wrong.`,
+  (mode_, param, paramtype) => {return `${errorprefix}${encddecdpfx(mode_)}${param} must be a ${paramtype}. ${docsurllink}`},
+  (mode_, param) => {return `${errorprefix}${encddecdpfx(mode_)}${param} is required. ${docsurllink}`},
+  (mode_, param, info) => {return `${errorprefix}${encddecdpfx(mode_)}${param} cannot be ${info}. ${docsurllink}`}
 ]
 const knownErrors = [
   "InvalidCharacterError: Failed to execute 'atob' on 'Window': The string to be decoded is not correctly encoded.",
@@ -596,7 +602,8 @@ function throwNewError(catchedError, id_) {
   }
 }
 
-export const encode = (text, key, compress) => {
+const useShit = false;
+function encode4(text, key, compress) {
   let encd;
   let inputText = text;
   if (key && typeof key == 'string' && key != '') {
@@ -614,7 +621,7 @@ export const encode = (text, key, compress) => {
       encd = `${datachar}${enc2.slice(1)}`;
     }
   }
-  if (compress && /^\d+$/.test(inputText) && inputText.length < 11) {
+  if (useShit && compress && /^\d+$/.test(inputText) && inputText.length < 11) {
     try {
       const base62num = intToBase62(parseInt(inputText));
       if (base62num === base62ToInt(base62num)) {
@@ -624,12 +631,12 @@ export const encode = (text, key, compress) => {
   } else encde();
   return encode3(encd);
 };
-export const decode = (text, key) => {
+function decode4(text, key) {
   let inputText = decode3(text);
   let datachar = inputText.slice(0,1);
   let decd;
   let encd = inputText.slice(1);
-  if (datachar == 'U') {
+  if (datachar == 'U' && useShit) {
     decd = base62ToInt(encd);
   } else {
     if (!used.test(datachar)) {
@@ -664,3 +671,130 @@ export const decode = (text, key) => {
   }
   return decd;
 };
+
+function check(text, key) {
+  if (!/^[A-Za-z0-9_().~-]+$/.test(text)) throw new Error(errors[0]);
+  if (text.length > 2 && text !== 'V' && (key === undefined || key === null)) throw new Error(errors[0]);
+}
+function even_or_odd(number) {
+  return number % 2 === 0 ? false : true;
+}
+
+const numEncode = (text, key) => {
+  let num = '';
+  for (let i = 0; i < text.length; i++) {
+    num += key ? `${(parseInt(text.charAt(i), 10) + key.charCodeAt(i % key.length)) % 10}` : text.charAt(i);
+  }
+  let number = parseInt(num, 10);
+  number = key ? number % parseInt(text, 10) : number;
+  if (`${number}`.replaceAll('e','found') !== `${number}`) return false;
+  let output_ = false;
+  if (number < cc) {
+    output_ = 'U' + characterMap[number];
+  } else if (number < 4624) {
+    number -= cc;
+    output_ = 'u' + characterMap[Math.floor(number / cc)] + characterMap[number % cc];
+  } else if (number < 314432) {
+    number -= 4624;
+    output_ = 'Q' + characterMap[Math.floor(number / (cc * cc))] + characterMap[Math.floor((number % (cc * cc)) / cc)] + characterMap[number % cc];
+  } else if (number < 21381376) {
+    number -= 314432;
+    output_ = 'q' + characterMap[Math.floor(number / (cc * cc * cc))] + characterMap[Math.floor((number % (cc * cc * cc)) / (cc * cc))] + characterMap[Math.floor((number % (cc * cc)) / cc)] + characterMap[number % cc];
+  } else if (useShit) {
+    let result = '';
+    while (number >= 0) {
+      result = characterMap[number % cc] + result;
+      number = Math.floor(number / cc) - 1;
+    }
+    output_ = result;
+  } else {
+    return false;
+  }
+  return encode3(output_);
+}
+const numDecode = (text, key) => {
+  const encoded = decode3(text);
+  const prefix = encoded.charAt(0);
+  let number = 0;
+  let output_;
+  if (prefix === 'U') {
+    output_ = (characterMap.indexOf(encoded.charAt(1))).toString();
+  } else if (prefix === 'u') {
+    number += cc;
+    number += characterMap.indexOf(encoded.charAt(1)) * cc + characterMap.indexOf(encoded.charAt(2));
+    output_ = number.toString();
+  } else if (prefix === 'Q') {
+    number += 4624;
+    number += characterMap.indexOf(encoded.charAt(1)) * (cc * cc) + characterMap.indexOf(encoded.charAt(2)) * cc + characterMap.indexOf(encoded.charAt(3));
+    output_ = number.toString();
+  } else if (prefix === 'q') {
+    number += 314432;
+    number += characterMap.indexOf(encoded.charAt(1)) * (cc * cc * cc) + characterMap.indexOf(encoded.charAt(2)) * (cc * cc) + characterMap.indexOf(encoded.charAt(3)) * cc + characterMap.indexOf(encoded.charAt(4));
+    output_ = number.toString();
+  } else {
+    let base = 0;
+    for (let i = 0; i < encoded.length; i++) {
+      base = base * cc + characterMap.indexOf(encoded.charAt(i));
+    }
+    output_ = base.toString();
+  }
+  let num = '';
+  for (let i = 0; i < output_.length; i++) {
+    num += key ? `${(parseInt(output_.charAt(i), 10) - key.charCodeAt(i % key.length) + 10) % 10}` : output_.charAt(i);
+  }
+  return num;
+}
+
+function encode5 (text, key, compress) {
+  if (text === undefined || text === null) throw new Error(errors[3]('encoded', 'Text'));
+  if (typeof text !== 'string') throw new Error(errors[2]('encoded', 'Text', 'string'));
+  if (key !== undefined && key !== null && typeof key !== 'string') throw new Error(errors[2]('encoded', 'Key', 'string'));
+  if (compress !== undefined && compress !== null && typeof compress !== 'boolean') throw new Error(errors[2]('encoded', 'Compress', 'boolean'));
+  if (text === '') throw new Error(errors[4]('encoded', 'Text', text));
+  const encoded_ = encode4(text, key, compress);
+  let output_ = encoded_;
+  if (compress) {
+    const doubleEncoded = encode4(encoded_, key, compress);
+    const numEncoded = numEncode(text);
+    const customDecode5 = (text) => {
+      try {
+        return decode5(text);
+      } catch {
+        return false;
+      }
+    }
+    if (doubleEncoded.length < encoded_.length) {
+      output_ = `J${doubleEncoded}`;
+    }
+    if (/^[0-9]+$/.test(text) && (key === undefined || key === null || key === '') && customDecode5(numEncoded) === text) {output_ = numEncoded}
+  }
+  if (even_or_odd(output_.length)) output_ = output_.split('').reverse().join('');
+  return output_;
+}
+function decode5 (text, key) {
+  let input_ = text;
+  if (even_or_odd(input_.length)) input_ = input_.split('').reverse().join('');
+  if (input_ === undefined || input_ === null) throw new Error(errors[3]('decoded', 'Text'));
+  if (typeof input_ !== 'string') throw new Error(errors[2]('decoded', 'Text', 'string'));
+  if (key !== undefined && key !== null && typeof key !== 'string') throw new Error(errors[2]('decoded', 'Key', 'string'));
+  check(input_, key);
+  const datachar = input_.slice(0,1);
+  const nodatachar = input_.slice(1);
+  let output_;
+  if (datachar == 'J') {
+    output_ = decode4(decode4(nodatachar, key), key);
+  } else if (datachar == 'U' || datachar == 'u' || datachar == 'Q' || datachar == 'q') {
+    output_ = numDecode(text);
+  } else {
+    output_ = decode4(input_, key);
+  }
+  return output_;
+}
+
+export const encode = (text, key, compress) => {
+  return encode5(text, key, compress);
+};
+export const decode = (text, key) => {
+  return decode5(text, key);
+};
+