taler-xotp

parserScript.js (7373B)

---

 /**
  *  Parsing module in JS using the baseX-Converter C library
  */
 
 let base32, base8, Module;
 const outSize = 128;
 
 const baseX_retValues = {
     1: "Argument Error",
     2: "Buffer Overflow",
     3: "Source Error",
     4: "Unexpected Error"
 }
 const placeholders = {
     base8_encode: "Enter text to base8 encoding",
     base8_decode: "Base-8 String (1-8)",
     base32_encode: "Enter text to base32 encoding",
     base32_decode: "Enter Base32-String"
 };
 
 const parserSelect = document.getElementById("baseX_parser");
 const inputField = document.getElementById("inputText");
 const outputField = document.getElementById("baseX-output");
 const copyButton = document.querySelector(".copy-button");
 
 // Load modules 
 Promise.all([
     Base32Module().then(mod => {
         base32 = {
             module: mod,
             encode: mod.cwrap('base32_encodeBytes', 'number', ['number', 'number', 'number', 'number']),
             decode: mod.cwrap('base32_decodeString', 'number', ['number', 'number', 'number', 'number', 'number']),
         }
     }),
 
     Base8Module().then(mod => {
         base8 = {
             module: mod,
             encode: mod.cwrap('base8_encodeBytes', 'number', ['number', 'number', 'number', 'number']),
             decode: mod.cwrap('base8_decodeNum', 'number', ['number', 'number', 'number', 'number', 'number']),
             stringToNum: mod.cwrap('base8_stringToNum', 'number', ['number', 'number'])
         };
     })
 ])
 
 function base8_encodeBytes(bytes) {
     const inputLength = bytes.length;
     const inputPtr = base8.module._malloc(inputLength);
     base8.module.HEAPU8.set(bytes, inputPtr);
     const outputPtr = base8.module._malloc(outSize); // 
     retVal = base8.encode(outputPtr, outSize, inputPtr, inputLength);
     if (0 != retVal) {
         throw new Error(`Encoding error with ${baseX_retValues[retVal]}`);
     }
     else {
         output = base8.module.UTF8ToString(outputPtr);
     }
     base8.module._free(inputPtr);
     base8.module._free(outputPtr);
     return output;
 }
 
 function base8_decodeString(input) {
     const inputLength = input.length;
     if (0 == inputLength) {
         return null;
     }
     const inputStrPtr = base8.module.allocateUTF8(input);
     const inputAsNumPtr = base8.module._malloc(inputLength);
     retVal = base8.stringToNum(inputAsNumPtr, inputStrPtr);
     if (retVal != 0) {
         throw new Error(`Parsing input to integer fails with: ${baseX_retValues[retVal]}`);
     }
     const outputPtr = base8.module._malloc(outSize);
     const outLengthPtr = base8.module._malloc(4); // 4 Bytes für int32
     retVal = base8.decode(outputPtr, outLengthPtr, outSize, inputAsNumPtr, inputLength);
 
     const outLength = base8.module.HEAP32[outLengthPtr >> 2];
 
     if (0 != retVal) {
         base8.module._free(inputAsNumPtr);
         base8.module._free(outputPtr);
         base8.module._free(outLengthPtr);
         base8.module._free(inputStrPtr);
         throw new Error(`Decoding error with: ${baseX_retValues[retVal]}`);
     }
     else {
         output = new Uint8Array(base8.module.HEAPU8.buffer, outputPtr, outLength);
     }
     base8.module._free(inputAsNumPtr);
     base8.module._free(outputPtr);
     base8.module._free(outLengthPtr);
     base8.module._free(inputStrPtr);
     return output;
 }
 
 
 function base32_encodeBytes(inputBytes) {
     const inputLength = inputBytes.length;
     const inputPtr = base32.module._malloc(inputLength);
     base32.module.HEAPU8.set(inputBytes, inputPtr);
     const outputPtr = base32.module._malloc(outSize); // 
     retVal = base32.encode(outputPtr, outSize, inputPtr, inputLength);
 
     output = base32.module.UTF8ToString(outputPtr);
     base32.module._free(inputPtr);
     base32.module._free(outputPtr);
     if (0 != retVal) {
         throw new Error(`Encoding error with ${baseX_retValues[retVal]}`);
     }
     else {
         return output;
     }
 }
 
 function base32_decodeString(inputString) {
     const inputLength = inputString.length;
     if (0 == inputLength) {
         return null;
     }
     const inputStrPtr = base32.module.allocateUTF8(inputString);
     const outputPtr = base32.module._malloc(outSize);
     const outLengthPtr = base32.module._malloc(4); // 4 Bytes für int32
     retVal = base32.decode(outputPtr, outLengthPtr, outSize, inputStrPtr);
     const outLength = base32.module.HEAP32[outLengthPtr >> 2];
     const decoded = new Uint8Array(base32.module.HEAPU8.buffer, outputPtr, outLength);
     // Free up memory
     base32.module._free(outLengthPtr);
     base32.module._free(inputStrPtr);
     base32.module._free(outputPtr);
     if (0 != retVal) {
         throw new Error(`Decoding base32 results in ${baseX_retValues[retVal]}`);
     }
     else {
         return decoded;
     }
 }
 
 function parseInput() {
     let output = "";
     let inputBytes;
 
     try {
         switch (baseX_parser.value) {
             case "base8_encode":
                 inputBytes = new TextEncoder().encode(inputField.value);
                 output = base8_encodeBytes(inputBytes);
                 break;
             case "base8_decode":
                 const decodedBase8 = base8_decodeString(inputField.value)
                 if (null != decodedBase8) {
                     const hexString = Array.from(decodedBase8)
                         .map(byte => byte.toString(16).padStart(2, '0')).join(', ');
                     const asciiString = new TextDecoder("utf-8").decode(decodedBase8);
                     output = hexString + '\n' + asciiString;
                 }
                 break;
             case "base32_encode":
                 inputBytes = new TextEncoder().encode(inputField.value);
                 output = base32_encodeBytes(inputBytes);
                 break;
             case "base32_decode":
                 const decodedBase32 = base32_decodeString(inputField.value);
                 if (null != decodedBase32) {
                     const hexString = Array.from(decodedBase32)
                         .map(byte => byte.toString(16).padStart(2, '0')).join(', ');
                     const asciiString = new TextDecoder("utf-8").decode(decodedBase32);
                     output = hexString + '\n' + asciiString;
                 }
                 break;
             case "base32_to_base8":
                 const base32Bytes = base32_decodeString(inputField.value);
                 if (null != base32Bytes) {
                     output = base8_encodeBytes(base32Bytes);
                 }
                 break;
             case "base8_to_base32":
                 const base8Bytes = base8_decodeString(inputField.value);
                 if (null != base8Bytes) {
                     output = base32_encodeBytes(base8Bytes);
                 }
                 break;
             default:
                 output = "Selection unknown";
         }
     } catch (e) {
         output = "Error at parsing: " + e.message;
     }
 
 
 
     if (output.trim() !== "") {
         copyButton.style.display = "block";
     } else {
         copyButton.style.display = "none";
     }
     outputField.textContent = output;
 }
 
 function updatePlaceholder() {
     const selected = parserSelect.value;
     inputField.placeholder = placeholders[selected] || "Input...";
 }
 
 parserSelect.addEventListener("change", () => {
     updatePlaceholder();
     parseInput();
 });
 
 document.getElementById("inputText").addEventListener("input", parseInput);
 
 // Set initial
 updatePlaceholder();