@ejfdelgado/ejflab-common 1.0.0

package/src/IdGen.js

@@ -0,0 +1,211 @@
+const { MyConstants } = require("./MyConstants");
+
+class IdGen {
+  static RANDOM_SPACE = 3;
+  static MAX_LENGTH_ORD_TEXT = 11 + Math.ceil(IdGen.RANDOM_SPACE * 0.63);
+  static RANDOM_SPACE_MULT = Math.pow(10, IdGen.RANDOM_SPACE);
+  static URL_GET_DATE = "srv/date";
+
+  //Retorna un diferido con la fecha
+  static diferenciaFechaServidor = null;
+  static diferidoInvocacion = null;
+
+  static async ahora() {
+    return new Promise((resolve) => {
+      const sincronizar = async function () {
+        const response = await fetch(`${MyConstants.SRV_ROOT}${IdGen.URL_GET_DATE}`, {
+          method: "GET",
+        });
+        const rta = await response.json();
+        var temp = rta.unixtime;
+        IdGen.diferenciaFechaServidor = new Date().getTime() - temp;
+        resolve(temp);
+        return;
+      };
+
+      const usarDiferencia = function () {
+        var temp = new Date().getTime();
+        resolve(temp - IdGen.diferenciaFechaServidor);
+      };
+
+      if (IdGen.diferenciaFechaServidor == null) {
+        if (IdGen.diferidoInvocacion == null) {
+          IdGen.diferidoInvocacion = sincronizar();
+        } else {
+          IdGen.diferidoInvocacion.then(function () {
+            //Ya se puede usar la diferencia
+            usarDiferencia();
+          });
+        }
+      } else {
+        usarDiferencia();
+      }
+    });
+  }
+
+  static async edad(birthday) {
+    // birthday is a date
+    const fecha = await ahora();
+    var ageDifMs = fecha - birthday.getTime();
+    var ageDate = new Date(ageDifMs); // miliseconds from epoch
+    var ans = Math.abs(ageDate.getUTCFullYear() - 1970);
+    return ans;
+  }
+
+  static darInicioDia(epoch) {
+    var start = new Date(epoch);
+    start.setHours(0, 0, 0, 0);
+    return start.getTime();
+  }
+
+  static darFinDia(epoch) {
+    var end = new Date(epoch);
+    end.setHours(23, 59, 59, 999);
+    return end.getTime();
+  }
+
+  static darInicioMes(epoch) {
+    var start = new Date(epoch);
+    var firstDay = new Date(start.getFullYear(), start.getMonth(), 1);
+    return firstDay.getTime();
+  }
+
+  static darFinMes(epoch) {
+    var start = new Date(epoch);
+    var lastDay = new Date(start.getFullYear(), start.getMonth() + 1, 0);
+    lastDay.setHours(23, 59, 59, 999);
+    return lastDay.getTime();
+  }
+
+  //Solo año/mes/día
+  static epoch2Text(tiempo) {
+    if (typeof tiempo == "number") {
+      var fecha = new Date(tiempo);
+      return (
+        fecha.getFullYear() +
+        "/" +
+        (fecha.getMonth() + 1) +
+        "/" +
+        fecha.getDate()
+      );
+    } else {
+      return "";
+    }
+  }
+
+  static getDateParts(tiempo) {
+    var fecha = new Date(tiempo);
+    const remplazos = {
+      YYYY: fecha.getFullYear(),
+      MM: IdGen.addZero(fecha.getMonth() + 1),
+      DD: IdGen.addZero(fecha.getDate()),
+      HH: IdGen.addZero(fecha.getHours()),
+      mm: IdGen.addZero(fecha.getMinutes()),
+      ss: IdGen.addZero(fecha.getSeconds()),
+      zz: IdGen.addZero(fecha.getMilliseconds()),
+      EPOCH: fecha.getTime(),
+    };
+    remplazos.yyyy = remplazos.YYYY;
+    remplazos.dd = remplazos.DD;
+    return remplazos;
+  }
+
+  //Año/mes/día hora:mm:ss
+  static epoch2Text2(tiempo) {
+    if (typeof tiempo == "number") {
+      var partes = IdGen.getDateParts(tiempo);
+      return (
+        partes.YYYY +
+        "/" +
+        partes.MM +
+        "/" +
+        partes.DD +
+        " " +
+        partes.HH +
+        ":" +
+        partes.mm +
+        ":" +
+        partes.ss
+      );
+    } else {
+      return "";
+    }
+  }
+
+  static addZero(i) {
+    if (i < 10) {
+      i = "0" + i;
+    }
+    return i;
+  }
+
+  static async nuevo(epoch, useDayBounds) {
+    if (typeof epoch == "number") {
+      if (typeof useDayBounds == "boolean") {
+        if (useDayBounds === true) {
+          epoch = IdGen.darInicioDia(epoch);
+        } else {
+          epoch = IdGen.darFinDia(epoch);
+        }
+        return IdGen.num2ord(epoch, useDayBounds);
+      } else {
+        return IdGen.num2ord(epoch);
+      }
+    } else {
+      const fecha = await IdGen.ahora();
+      return IdGen.num2ord(fecha, useDayBounds);
+    }
+  }
+
+  static async nuevoIni(epoch = null) {
+    return await nuevo(epoch, true);
+  }
+
+  static async nuevoFin(epoch) {
+    return await nuevo(epoch, false);
+  }
+
+  static ord2num(id) {
+    var temp = parseInt(id, 36);
+    temp = temp / IdGen.RANDOM_SPACE_MULT;
+    return temp;
+  }
+
+  static num2ord(num, esInicio) {
+    if (typeof num == "number") {
+      let nuevo;
+      if (typeof esInicio == "boolean") {
+        if (esInicio === true) {
+          nuevo = num * IdGen.RANDOM_SPACE_MULT;
+        } else {
+          nuevo = num * IdGen.RANDOM_SPACE_MULT + (IdGen.RANDOM_SPACE_MULT - 1);
+        }
+      } else {
+        nuevo =
+          num * IdGen.RANDOM_SPACE_MULT +
+          Math.floor(Math.random() * IdGen.RANDOM_SPACE_MULT);
+      }
+      //console.log(num, nuevo);
+      let temp = nuevo.toString(36);
+      const diff = IdGen.MAX_LENGTH_ORD_TEXT - temp.length;
+      if (diff > 0) {
+        temp = new Array(diff).join("0") + temp;
+      }
+      //Intencionalmente, se cambia el último aleatorio por una 'a'
+      return temp.slice(0, -1) + "a";
+    }
+    return null;
+  }
+
+  static num2ordIni(num) {
+    return num2ord(num, true);
+  }
+
+  static num2ordFin(num) {
+    return num2ord(num, false);
+  }
+}
+
+module.exports = {
+  IdGen
+};

package/src/ModuloDatoSeguro.js

@@ -0,0 +1,142 @@
+
+// ¿Cómo generar las llaves públicas y privadas?
+
+//1. Se genera el par:
+//openssl genrsa -out local_par.pem 256
+//2. Se genera la llave pública:
+//openssl rsa -in local_par.pem -pubout -out local_publica.crt
+//3. Se genera la llave privada:
+//openssl pkcs8 -topk8 -inform PEM -outform PEM -nocrypt -in local_par.pem -out local_privada.key
+
+//openssl genrsa -out local_par.pem 256 && openssl rsa -in local_par.pem -pubout -out local_publica.crt && openssl pkcs8 -topk8 -inform PEM -outform PEM -nocrypt -in local_par.pem -out local_privada.key
+//openssl genrsa -out local_par.pem 2048 && openssl rsa -in local_par.pem -pubout -out local_publica.crt && openssl pkcs8 -topk8 -inform PEM -outform PEM -nocrypt -in local_par.pem -out local_privada.key
+//openssl req -new -x509 -key local_privada.key -out local_publica.cer
+//openssl x509 -in local_publica.crt -out local_publica.pem -outform PEM
+
+//const AES = require("crypto-js/aes");
+//const Utf8 = require("crypto-js/enc-utf8");
+
+class ModuloDatoSeguro {
+  // create a key for symmetric encryption
+  // pass in the desired length of your key
+  static generateKey(keyLength = 10) {
+    // define the characters to pick from
+    const chars =
+      "0123456789ABCDEFGHIJKLMNOPQRSTUVWXTZabcdefghiklmnopqrstuvwxyz*&-%/!?*+=()";
+    let randomstring = "";
+    for (let i = 0; i < keyLength; i++) {
+      const rnum = Math.floor(Math.random() * chars.length);
+      randomstring += chars.substring(rnum, rnum + 1);
+    }
+    return randomstring;
+  };
+
+  static cifrarSimple(objeto, llave, AES) {
+    const texto = JSON.stringify(objeto);
+    const encriptado = AES.encrypt(texto, llave);
+    return encriptado.toString();
+  }
+  static decifrarSimple(texto, llave, AES, Utf8) {
+    const desencriptado = AES.decrypt(texto, llave).toString(Utf8);
+    return JSON.parse(desencriptado);
+  }
+  static decifrarConListaDeLlavesInterno(texto, llaves, AES, Utf8) {
+    for (let i = 0; i < llaves.length; i++) {
+      try {
+        const llave = llaves[i];
+        const temp = ModuloDatoSeguro.decifrarSimple(texto, llave, AES, Utf8);
+        return temp;
+      } catch (err) { }
+    }
+    return undefined;
+  }
+  static ofuscarTexto(txt, switchOrder = true, switchLettersWithNumbers = true, useSpace = " ") {
+    let salida = "";
+    const REMAPPING = {
+      "i": "1",
+      "I": "1",
+      "a": "4",
+      "A": "4",
+      "e": "3",
+      "E": "3",
+      "s": "5",
+      "S": "5",
+      "t": "7",
+      "T": "7",
+      "o": "0",
+      "O": "0",
+    };
+    const remapLet = (some) => {
+      if (!switchLettersWithNumbers) {
+        return some;
+      }
+      const nueva = REMAPPING[some];
+      if (!nueva) {
+        return some;
+      }
+      return nueva;
+    };
+    const remapArray = (some) => {
+      let nuevo = "";
+      for (let j = 0; j < some.length; j++) {
+        nuevo += remapLet(some[j]);
+      }
+      return nuevo;
+    };
+    const REGEX = /[a-zA-ZáéíóúüÁÉÍÓÚñÑ]/;
+    let pal = [];
+    let copy = null;
+    const mapFun = (character, i) => {
+      let aleatorio = Math.floor(Math.random() * (copy.length - 1));
+      if (aleatorio == i && copy.length > 1) {
+        aleatorio += 1;
+      }
+      const actual = copy.splice(aleatorio, 1)[0];
+      return actual;
+
+    };
+    const procesarPalabra = () => {
+      if (pal.length > 0) {
+        if (pal.length <= 3) {
+          salida += remapArray(pal.join(''));
+        } else {
+          const ini = remapLet(pal.splice(0, 1)[0]);
+          const fin = remapLet(pal.splice(pal.length - 1, 1)[0]);
+          salida += ini;
+
+          if (switchOrder) {
+            copy = [].concat(pal);
+            pal = pal.map(mapFun);
+            salida += remapArray(pal.join(''));
+          } else {
+            salida += remapArray(pal.join(''));
+          }
+          salida += fin;
+        }
+        pal = [];
+      }
+    };
+    for (let i = 0; i < txt.length; i++) {
+      const act = txt[i];
+      if (REGEX.test(act)) {
+        // Busco la palabra completa
+        pal.push(act);
+      } else {
+        // Se revisa si hay una palabra antes
+        procesarPalabra();
+        // Pasa derecho
+        if (act == " ") {
+          salida += useSpace;
+        } else {
+          salida += act;
+        }
+      }
+    }
+    procesarPalabra();
+    return salida;
+  }
+}
+
+module.exports = {
+  ModuloDatoSeguro
+};

package/src/ModuloDatoSeguro.test.js

@@ -0,0 +1,29 @@
+const { ModuloDatoSeguro } = require('./ModuloDatoSeguro.js');
+const NodeRSA = require('node-rsa');
+const fs = require('fs');
+const { ModuloDatoSeguroFront } = require('./ModuloDatoSeguroFront.js');
+
+const test = () => {
+    //https://stackoverflow.com/questions/12524994/encrypt-decrypt-using-pycrypto-aes-256
+    const dato = "edgar jose fernando";
+    const clave = ModuloDatoSeguroFront.generateKey(4);
+    const encriptado = ModuloDatoSeguroFront.cifrarSimple(dato, clave);
+    console.log(encriptado);
+    const desencriptado = ModuloDatoSeguroFront.decifrarSimple(encriptado, clave);
+    console.log(dato + "=>" + encriptado + '=>' + desencriptado);
+}
+
+const test2 = () => {
+    const par = ModuloDatoSeguroFront.generateKeyPair();
+    const prueba = { valor: "LaPdRu17bzZxOaguGU1Q" };
+    const cifrado = ModuloDatoSeguroFront.cifrar(prueba, par.public);
+    console.log(cifrado);
+    const decifrado = ModuloDatoSeguroFront.decifrar(cifrado, par.private);
+    console.log(decifrado);
+}
+
+// 
+
+//test();
+
+test2();

package/src/ModuloDatoSeguro.test.mjs

@@ -0,0 +1,45 @@
+//const { ModuloDatoSeguro } = require('./ModuloDatoSeguro.js');
+//const NodeRSA = require('node-rsa');
+//const fs = require('fs');
+
+import { ModuloDatoSeguroBack } from "./ModuloDatoSeguroBack.mjs";
+
+//const { ModuloDatoSeguroBack } = require('./ModuloDatoSeguroBack');
+
+const test = () => {
+    //https://stackoverflow.com/questions/12524994/encrypt-decrypt-using-pycrypto-aes-256
+    const rand = ModuloDatoSeguroBack.generateKey(4);
+    const dato = `LaPdRu17bzZxOaguGU1Q_${rand}`;
+    const clave = ModuloDatoSeguroBack.generateKey(4);
+    const encriptado = ModuloDatoSeguroBack.cifrarSimple(dato, clave);
+    console.log(encriptado);
+    const desencriptado = ModuloDatoSeguroBack.decifrarSimple(encriptado, clave);
+    console.log(dato + " => " + ` ${clave} ` + encriptado + ' => ' + desencriptado);
+}
+
+const test2 = () => {
+    const par = ModuloDatoSeguroBack.generateKeyPair();
+    const prueba = { valor: "LaPdRu17bzZxOaguGU1Q" };
+    const cifrado = ModuloDatoSeguroBack.cifrar(prueba, par.public);
+    console.log(cifrado);
+    const decifrado = ModuloDatoSeguroBack.decifrar(cifrado, par.private);
+    console.log(decifrado);
+}
+
+test();
+//test2();
+
+/*
+const texto = "Una calurosa mañana, se encontraba Tío Conejo recolectando zanahorias para el almuerzo. De repente, escuchó un rugido aterrador: ¡era Tío Tigre! \
+—¡Ajá, Tío Conejo! —dijo el felino—. No tienes escapatoria, pronto te convertirás en un delicioso bocadillo. \
+En ese instante, Tío Conejo notó unas piedras muy grandes en lo alto de la colina e ideó un plan. \
+—Puede que yo sea un delicioso bocadillo, pero estoy muy flaquito —dijo Tío Conejo—. Mira hacia la cima de la colina, ahí tengo mis vacas y te puedo traer una. ¿Por qué conformarte con un pequeño bocadillo, cuando puedes darte un gran banquete? \
+Como Tío Tigre se encontraba de cara al sol, no podía ver con claridad y aceptó la propuesta. Entonces le permitió a Tío Conejo ir colina arriba mientras él esperaba abajo. \
+Al llegar a la cima de la colina, Tío Conejo gritó: \
+—Abre bien los brazos Tío Tigre, estoy arreando la vaca más gordita. \
+Entonces, Tío Conejo se acercó a la piedra más grande y la empujó con todas sus fuerzas. La piedra rodó rápidamente. \
+Tío Tigre estaba tan emocionado que no vio la enorme piedra que lo aplastó, dejándolo adolorido por meses. \
+Tío Conejo huyó saltando de alegría.";
+console.log(ModuloDatoSeguroBack.ofuscarTexto(texto, true, true, "/"));
+console.log(ModuloDatoSeguroBack.ofuscarTexto("Un computador no puede procesar una imagen que tenga esto", true, true, "/")):
+*/

package/src/ModuloDatoSeguroBack.mjs

@@ -0,0 +1,55 @@
+import NodeRSA from "node-rsa";
+import pkgCriptoJs from 'crypto-js';
+const { AES } = pkgCriptoJs;
+import Utf8 from "crypto-js/enc-utf8.js";
+import { ModuloDatoSeguro } from "./ModuloDatoSeguro.js";
+
+export class ModuloDatoSeguroBack extends ModuloDatoSeguro {
+    static SCHEMES = ["pkcs1", "pkcs8", "openssh"];
+    static KEY_TYPES = ["public", "private"];
+    static scheme_default = ModuloDatoSeguroBack.SCHEMES[0];
+
+    static cifrarSimple(objeto, llave) {
+        return super.cifrarSimple(objeto, llave, AES)
+    }
+
+    static decifrarSimple(texto, llave) {
+        return super.decifrarSimple(texto, llave, AES, Utf8);
+    }
+
+    static generateKeyPair = (tamanio = 512) => {
+        const key = new NodeRSA({ b: tamanio });
+        key.setOptions({ encryptionScheme: ModuloDatoSeguroBack.scheme_default });
+        const respose = {
+            public: key.exportKey(`${ModuloDatoSeguroBack.SCHEMES[0]}-${ModuloDatoSeguroBack.KEY_TYPES[0]}-pem`),
+            private: key.exportKey(`${ModuloDatoSeguroBack.SCHEMES[0]}-${ModuloDatoSeguroBack.KEY_TYPES[1]}-pem`),
+        };
+        return respose;
+    };
+    static cifrar(objeto, llavePublica) {
+        llavePublica = llavePublica.replace('\n', '');
+        const miniKey = ModuloDatoSeguro.generateKey(10);
+        const format = `${ModuloDatoSeguroBack.scheme_default}-${ModuloDatoSeguroBack.KEY_TYPES[0]}-pem`;
+        const key = new NodeRSA(llavePublica, format);
+        const encryptedKey = key.encrypt(miniKey, 'base64');
+        const texto = JSON.stringify(objeto);
+        const aesEncrypted = AES.encrypt(texto, miniKey);
+        const encryptedMessage = aesEncrypted.toString();
+        return Buffer.from(JSON.stringify({
+            llave: encryptedKey,
+            mensaje: encryptedMessage,
+        })).toString("base64");
+
+    }
+    static decifrar(texto, llavePrivada) {
+        llavePrivada = llavePrivada.replace('\n', '');
+        const parametroSinBase64 = JSON.parse(Buffer.from(texto, "base64"));
+        const key = new NodeRSA(llavePrivada, `${ModuloDatoSeguroBack.scheme_default}-${ModuloDatoSeguroBack.KEY_TYPES[1]}-pem`);
+        const llaveDesencriptada = key.decrypt(parametroSinBase64["llave"], 'utf8');
+        var desencriptado = AES.decrypt(
+            parametroSinBase64["mensaje"],
+            llaveDesencriptada
+        ).toString(Utf8);
+        return JSON.parse(desencriptado);
+    }
+}

package/src/ModuloDatoSeguroFront.js

@@ -0,0 +1,73 @@
+
+// ¿Cómo generar las llaves públicas y privadas?
+
+//1. Se genera el par:
+//openssl genrsa -out local_par.pem 256
+//2. Se genera la llave pública:
+//openssl rsa -in local_par.pem -pubout -out local_publica.crt
+//3. Se genera la llave privada:
+//openssl pkcs8 -topk8 -inform PEM -outform PEM -nocrypt -in local_par.pem -out local_privada.key
+
+//openssl genrsa -out local_par.pem 256 && openssl rsa -in local_par.pem -pubout -out local_publica.crt && openssl pkcs8 -topk8 -inform PEM -outform PEM -nocrypt -in local_par.pem -out local_privada.key
+//openssl genrsa -out local_par.pem 2048 && openssl rsa -in local_par.pem -pubout -out local_publica.crt && openssl pkcs8 -topk8 -inform PEM -outform PEM -nocrypt -in local_par.pem -out local_privada.key
+//openssl req -new -x509 -key local_privada.key -out local_publica.cer
+//openssl x509 -in local_publica.crt -out local_publica.pem -outform PEM
+const { Buffer } = require('buffer');
+const { JSEncrypt } = require("jsencrypt");
+const AES = require("crypto-js/aes");
+const Utf8 = require("crypto-js/enc-utf8");
+const { ModuloDatoSeguro } = require("./ModuloDatoSeguro.js");
+
+class ModuloDatoSeguroFront extends ModuloDatoSeguro {
+    // create a key for symmetric encryption
+    // pass in the desired length of your key
+
+    static cifrarSimple(objeto, llave) {
+        return super.cifrarSimple(objeto, llave, AES)
+    }
+
+    static decifrarSimple(texto, llave) {
+        return super.decifrarSimple(texto, llave, AES, Utf8);
+    }
+
+    static decifrarConListaDeLlaves(texto, llaves) {
+        return super.decifrarConListaDeLlavesInterno(texto, llaves, AES, Utf8);
+    }
+
+    static cifrar = function (objeto, llavePublica) {
+        llavePublica = llavePublica.replace('\n', '');
+        const key = ModuloDatoSeguro.generateKey(10);
+        const texto = JSON.stringify(objeto); //JSON
+        const aesEncrypted = AES.encrypt(texto, key);
+        const encryptedMessage = aesEncrypted.toString();
+        // we create a new JSEncrypt object for rsa encryption
+        const rsaEncrypt = new JSEncrypt();
+        // we set the public key (which we passed into the function)
+        rsaEncrypt.setPublicKey(llavePublica);
+        // now we encrypt the key & iv with our public key
+        const encryptedKey = rsaEncrypt.encrypt(key);
+        //Se codifica en base 64 para que pueda viajar en la url
+
+        return Buffer.from(JSON.stringify({
+            llave: encryptedKey,
+            mensaje: encryptedMessage,
+        })).toString("base64");
+    };
+
+    static decifrar = function (texto, llavePrivada) {
+        llavePrivada = llavePrivada.replace('\n', '');
+        const decrypt = new JSEncrypt();
+        decrypt.setPrivateKey(llavePrivada);
+        const parametroSinBase64 = JSON.parse(Buffer.from(texto, "base64"));
+        const llaveDesencriptada = decrypt.decrypt(parametroSinBase64["llave"]);
+        var desencriptado = AES.decrypt(
+            parametroSinBase64["mensaje"],
+            llaveDesencriptada
+        ).toString(Utf8);
+        return JSON.parse(desencriptado);
+    };
+}
+
+module.exports = {
+    ModuloDatoSeguroFront
+};

package/src/ModuloSonido.js

@@ -0,0 +1,83 @@
+"use strict";
+
+/*
+const response = await ModuloSonido.preload([
+'/assets/sounds/finish.mp3',
+]);
+await ModuloSonido.play('/assets/sounds/finish.mp3');
+*/
+
+class ModuloSonido {
+	static sonidos = {};
+	static createAudio({ source, volume = 100, loop = false }) {
+		return new Promise((resolve, reject) => {
+			const audio = new Audio();
+			audio.volume = volume / 100;
+			audio.loop = loop;
+			audio.addEventListener("error", (err) => {
+				reject(new Error(`Error leyendo el audio ${source}`));
+			});
+			audio.addEventListener("loadeddata", () => {
+				let duration = audio.duration;
+				console.log(`duration:${duration}`);
+				resolve(audio);
+			});
+			audio.src = source;
+		});
+	}
+
+	static async preload(lista = []) {
+		const promesas = [];
+		lista.forEach((llave) => {
+			if (llave in ModuloSonido.sonidos) {
+				promesas.push(Promise.resolve(ModuloSonido.sonidos[llave]));
+			} else {
+				const promesa = ModuloSonido.createAudio({ source: llave });
+				promesa.then((audio) => {
+					ModuloSonido.sonidos[llave] = audio;
+				});
+				promesas.push(promesa);
+			}
+		});
+		return await Promise.all(promesas);
+	};
+
+
+	static async play(llave, loop = false, volume = 1) {
+		let ref = null;
+		if (llave in ModuloSonido.sonidos) {
+			ref = ModuloSonido.sonidos[llave];
+		} else {
+			ref = (await ModuloSonido.preload([llave]))[0];
+		}
+		ref.volume = volume;
+		let isPlaying = ref.currentTime > 0 && !ref.paused && !ref.ended
+			&& ref.readyState > 2;
+		if (!isPlaying) {
+			ref.loop = loop;
+			ref.play();
+		}
+	};
+
+	static stop(llave) {
+		const sonido = ModuloSonido.sonidos[llave];
+		if (sonido) {
+			sonido.pause();
+			sonido.currentTime = 0;
+		}
+	}
+
+	static stopAll() {
+		const llaves = Object.keys(ModuloSonido.sonidos);
+		for (let i = 0; i < llaves.length; i++) {
+			const llave = llaves[i];
+			const sonido = ModuloSonido.sonidos[llave];
+			sonido.pause();
+			sonido.currentTime = 0;
+		}
+	}
+}
+
+module.exports = {
+	ModuloSonido
+};

package/src/ModuloVideos.js

@@ -0,0 +1,51 @@
+
+class ModuloVideos {
+	static videos = {};
+	static createVideo({ source }) {
+		return new Promise((resolve, reject) => {
+			const video = document.createElement("video");
+			video.addEventListener("error", (err) => {
+				reject(new Error(`Error leyendo el video ${source}`));
+			});
+			video.addEventListener("loadeddata", () => {
+				const width = video.videoWidth;
+				const height = video.videoHeight;
+				console.log(`Loaded video ${width} x ${height}!`);
+				resolve(video);
+			});
+			video.setAttribute("src", source);
+			video.load();
+		});
+	}
+
+	static destroyVideo(llave) {
+		if (llave in ModuloVideos.videos) {
+			const video = ModuloVideos.videos[llave];
+			video.pause();
+			video.removeAttribute('src');
+			video.load();
+			video.removeAllListeners('seeked');
+			delete ModuloVideos.videos[llave];
+		}
+	}
+
+	static async preload(lista = []) {
+		const promesas = [];
+		lista.forEach((llave) => {
+			if (llave in ModuloVideos.videos) {
+				promesas.push(Promise.resolve(ModuloVideos.videos[llave]));
+			} else {
+				const promesa = ModuloVideos.createVideo({ source: llave });
+				promesa.then((video) => {
+					ModuloVideos.videos[llave] = video;
+				});
+				promesas.push(promesa);
+			}
+		});
+		return await Promise.all(promesas);
+	};
+}
+
+module.exports = {
+	ModuloVideos
+};