From 11bb8b558b6048fa905be6991aad7df3e19a4aa3 Mon Sep 17 00:00:00 2001
From: KyMAN <0kyman0@gmail.com>
Date: Mon, 16 Dec 2024 17:51:17 +0100
Subject: [PATCH] feat(ecma): Moduled JavaScript to native ECAMScript
 importing.

---
 Public/ecma/ErrorsManager.ecma.js | 943 +++++++++++++++---------------
 Public/test.html                  |  27 +-
 version                           |   2 +-
 3 files changed, 501 insertions(+), 471 deletions(-)

diff --git a/Public/ecma/ErrorsManager.ecma.js b/Public/ecma/ErrorsManager.ecma.js
index fef9e97..7752079 100644
--- a/Public/ecma/ErrorsManager.ecma.js
+++ b/Public/ecma/ErrorsManager.ecma.js
@@ -1,489 +1,506 @@
+"use strict";
+
 /**
+ * @class
+ * @constructor
  * @param {string|Array.<string>} [alphabet]
  * @returns {void}
  * @access public
  */
-const ErrorsManager = function(alphabet){
-
-    /** @type {ErrorsManager} */
-    const self = this;
-    /** @type {number} */
-    let error = 0;
-    // /** @type {RegExp|null} */
-    // let re_hexa_error = null;
-
-    /**
-     * @returns {void}
-     * @access public
-     */
-    const constructor = () => {
-
-        self.set_alphabet(alphabet);
-
-    };
-
-    /**
-     * @param {!(string|Array.<string>)} new_alphabet 
-     * @returns {number}
-     * @access public
-     */
-    this.set_alphabet = new_alphabet => {
-
-        error = (
-            new_alphabet === undefined ? 0 : 
-            new_alphabet === null ? 0 : 
-            !ErrorsManager.prototype.is_string(new_alphabet) && !ErrorsManager.prototype.is_array(new_alphabet) ? 1 << 2 : 
-        0) << 1;
-
-        if(!error){
-            if(new_alphabet){
-
-                /** @type {number} */
-                const original_length = new_alphabet.length, 
-                      /** @type {number} */
-                      final_length = (new_alphabet = (new_alphabet instanceof Array ? new_alphabet : new_alphabet.split("")).filter((character, i) => (
-                          ErrorsManager.prototype.is_string(character) && character.length == 1 && new_alphabet.indexOf(character) == i
-                      ))).length;
-
-                error |= (
-                    original_length != final_length ? 1 << 0 : 
-                    final_length < 64 ? 1 << 1 : 
-                0) << 5;
-
-            };
-        };
-
-        alphabet = error || !new_alphabet ? (
-            alphabet && alphabet.length ? alphabet : 
-        ErrorsManager.prototype.BASE64) : new_alphabet;
-        // re_hexa_error = new RegExp("[^" + alphabet[0] + "]");
-
-        return error;
-    };
-
-    /**
-     * @param {!(string|number|Array.<number>)} code 
-     * @param {!number} [length = 0] 
-     * @returns {Array.<number>}
-     * @access public
-     */
-    this.to_array = (code, length = 0) => {
-
-        /** @type {Array.<number>} */
-        let array = [];
-
-        if(ErrorsManager.prototype.is_string(code))
-            array = code.split("").map(hexa => alphabet.indexOf(hexa));
-        else if(ErrorsManager.prototype.is_integer(code)){
-            while(code){
-                array.push(code & 0x3F);
-                code >>>= 6;
-            };
-        }else if(ErrorsManager.prototype.is_array(code))
-            array = [].concat(code);
-
-        while(array.length < length)
-            array.push(0);
-
-        return array && array.length ? array : [0];
-    };
-
-    /**
-     * @param {!(number|string|Array.<number>)} error 
-     * @param {!Array.<string|null>} messages 
-     * @returns {Array.<string>}
-     * @access public
-     */
-    this.process = (error, messages) => {
-
-        /** @type {Array.<string>} */
-        const response = [], 
-              /** @type {number} */
-              m = messages.length, 
-              /** @type {Array.<number>} */
-              array_error = self.to_array(error), 
-              /** @type {number} */
-              l = array_error.length;
-
-        for(let i = 0; i < l; i ++)
-            for(let j = 0; j < 6; j ++)
-                if(array_error[i] & (1 << j)){
-        
-                    /** @type {number} */
-                    const k = j + i * 6;
-
-                    response.push([k, k < m && messages[k] ? messages[k] : "error_message_" + k]);
-
-                };
-
-        return response;
-    };
-
-    /**
-     * @returns {Array.<string>}
-     * @access public
-     */
-    this.get_alphabet = () => alphabet.join("");
-
-    /**
-     * @param {!(string|number|Array.<number>)} code 
-     * @returns {number}
-     * @access public
-     */
-    this.bits = code => {
-        if(ErrorsManager.prototype.is_integer(code))
-            return code ? Math.log2(code) : 1;
-
-        ErrorsManager.prototype.is_string(code) && (code = self.to_array(code));
-
-        if(ErrorsManager.prototype.is_array(code))
-            return !(code = self.compact(code)).length || !code[code.length - 1] ? 1 : (code.length - 1) * 6 + (Math.log2(code[code.length - 1]) + 1 >> 0);
-        return null;
-    };
-
-    /**
-     * @param {!(string|number|Array.<number>)} code 
-     * @returns {Array.<string>}
-     * @access public
-     */
-    this.to_array_binary = code => (code = self.to_array(code)).map(hexa => ("000000" + hexa.toString(2)).slice(-6));
-
-    /**
-     * @param {!(string|number|Array.<number>)} code 
-     * @returns {number}
-     * @access public
-     */
-    this.to_integer = code => {
-        if(ErrorsManager.prototype.is_integer(code))
-            return code;
-        if(ErrorsManager.prototype.is_array(code))
-            return code.length ? code.length > 1 ? code.reduce((total, hexa, i) => total | (hexa << i * 6)) : code[0] : 0;
-        if(!ErrorsManager.prototype.is_string(code))
-            return 0;
-        return code ? code.length > 1 ? code.split("").reduce((total, hexa, i) => (i > 1 ? total : alphabet.indexOf(total)) | (alphabet.indexOf(hexa) << i * 6)) : alphabet.indexOf(code) : 0;
-    };
-
-    /**
-     * @param {!(string|number|Array.<number>)} code 
-     * @param {!number} [length = 0] 
-     * @returns {string}
-     * @access public
-     */
-    this.to_string = (code, length = 0) => {
-
-        /** @type {string} */
-        let string = "";
-
-        if(ErrorsManager.prototype.is_string(code))
-            string = code;
-        else{
-            if(ErrorsManager.prototype.is_integer(code)){
-                while(code){
-                    string += alphabet[code & 0x3F];
-                    code >>>= 6;
-                };
-            }else if(ErrorsManager.prototype.is_array(code))
-                string = code.length ? code.length > 1 ? code.reduce((total, hexa, i) => (i > 1 ? total : alphabet[total]) + alphabet[hexa]) : alphabet[code[0]] : alphabet[0];
-        };
-
-        while(string.length < length)
-            string += alphabet[0];
-
-        return string || alphabet[0];
-    };
-
-    /**
-     * @param {!(string|number|Array.<number>)} code 
-     * @param {!(number|Array.<number>)} [bits] 
-     * @returns {boolean|null}
-     * @access public
-     */
-    this.has = (code, bits) => {
-        if(!ErrorsManager.prototype.is_integer(bits) && !ErrorsManager.prototype.is_array(bits))
-            return (
-                ErrorsManager.prototype.is_string(code) ? code.split("").some(hexa => hexa != alphabet[0]) :
-                ErrorsManager.prototype.is_integer(code) ? !!code :
-                ErrorsManager.prototype.is_array(code) ? code.some(hexa => !!hexa) :
-            null);
-        
-        /** @type {Array.<number>} */
-        const error = self.to_array(code), 
-              /** @type {number} */
-              l = error.length * 6;
-
-        return l ? (
-            AnP.prototype.is_array(bits) ? bits : [bits]
-        ).some(bit => bit <= l && error[bit / 6 >> 0] & (1 << bit % 6)) : false;
-    };
-
-    /**
-     * @param {?any} code 
-     * @returns {any|null}
-     * @access public
-     */
-    this.to_unknown = code => code;
-
-    /**
-     * @param {!(string|number|Array.<number>)} code 
-     * @returns {string|number|Array.<number>}
-     * @access public
-     */
-    this.compact = code => {
-        if(ErrorsManager.prototype.is_string(code)){
-            while(code && code[code.length - 1] == alphabet[0])
-                code = code.substr(0, code.length - 1);
-            return code || alphabet[0];
-        };
-        if(ErrorsManager.prototype.is_array(code)){
-            code = [].concat(code);
-            while(code.length && !code[code.length - 1])
-                code.pop();
-            return code.length ? code : [0];
-        };
-        if(ErrorsManager.prototype.is_integer(code))
-            return code;
-        return 0;
-    };
-
-    /**
-     * @param {!(string|number|Array.<number>)} code 
-     * @param {!number} bits 
-     * @returns {string|number|Array.<number>}
-     * @access public
-     */
-    this.bitwise = (code, bits) => {
-
-        if(!bits || !self.has(code))
-            return code;
-
-
-        /** @type {boolean} */
-        const reverse = bits < 0, 
-              /** @type {number} */
-              start = (reverse ? bits *= -1 : bits) / 6 >> 0, 
-              /** @type {number} */
-              rest = bits % 6, 
-              /** @type {string} */
-              type_method = "to_" + ErrorsManager.prototype.type(code);
-
-        if(reverse){
-
-            code = self.to_string(code).substring(start);
-
-            if(rest){
-                if(code){
-
-                    /** @type {number} */
-                    const l = (code = self.to_array(code)).length - 1, 
-                          /** @type {number} */
-                          r = 6 - rest, 
-                          /** @type {number} */
-                          block = ~-(1 << rest);
-
-                    for(let i = 0; i < l; i ++)
-                        code[i] = (code[i] >> rest) | ((code[i + 1] & block) << r);
-                    code[l] >>= rest;
-
-                }else
-                    code = [0];
-            };
-
-        }else{
-
-            code = self.to_array(code);
-
-            if(rest){
-
-                /** @type {Array.<number>} */
-                const block = [~-(1 << (r = 6 - rest)), ~-(1 << rest) << r], 
-                      /** @type {number} */
-                      l = code.length - 1, 
-                      /** @type {number} */
-                      last = (code[l] & block[1]) >> r;
-
-                last && (code[l + 1] = last);
-                for(let i = l; i > 0; i --)
-                    code[i] = ((code[i] & block[0]) << rest) | (code[i - 1] >> r);
-                code[0] = (code[0] & block[0]) << rest;
-
-            };
-
-            for(let i = 0; i < start; i ++)
-                code.unshift(0);
-
-        };
-
-        return self[type_method](code);
-    };
-
-    /**
-     * @param {!(string|number|Array.<number>)} code 
-     * @param {!(string|number|Array.<number>)} error 
-     * @param {!number} [bit = 0] 
-     * @param {!number} [length = 0] 
-     * @returns {string}
-     * @access public
-     */
-    this.set = (code, error, bit = 0, length = 0) => {
-
-        code = self.to_array(code);
-        error = self.to_array(error);
-        bit && (error = self.bitwise(error, bit));
-
-        /** @type {number} */
-        let i = bit / 6 >> 0;
-
-        if(length){
-
-            /** @type {Array.<number>} */
-            const ampersand = [], 
-                  /** @type {number} */
-                  start = bit % 6, 
-                  /** @type {number} */
-                  m = (length + start) / 6 >> 0, 
-                  /** @type {number} */
-                  end = (start + length) % 6;
-
-            for(let j = 0; j < m; j ++)
-                ampersand.push(0);
-            ampersand[0] |= ~-(1 << start);
-            end && ampersand.push(~-(1 << (6 - end)) << end);
-
-            ampersand.forEach((hexa, j) => code[j + i] &= hexa);
-
-        };
-
-        if(has(error)){
-
-            /** @type {number} */
-            const l = error.length;
-
-            while(code.length <= i)
-                code.push(0);
-
-            for(; i < l; i ++)
-                code[i] = (code[i] || 0) | error[i];
-
-        };
-
-        return self.compact(self.to_string(code));
-    };
-
-    /**
-     * @param {!(string|number|Array.<number>)} code 
-     * @param {!(string|number|Array.<number>)} error 
-     * @param {!number} [bit = 0] 
-     * @param {!number} [length = 0] 
-     * @returns {string}
-     * @access public
-     */
-    this.join = (code, error, bit = 0, length = 0) => self.set(code, error, bit, length);
+export const ErrorsManager = (function(){
     
     /**
-     * @param {!(string|number|Array.<number>)} code 
-     * @param {!Array.<string|number|Array.<number>>} blocks 
-     * @param {!number} [bit = 0] 
-     * @param {!number} [length = 0] 
-     * @returns {string}
-     * @access public
+     * @constructs ErrorsManager
+     * @param {string|Array.<string>} [alphabet]
+     * @returns {void}
+     * @access private
      */
-    this.set_blocks = (code, blocks, bit = 0, length = 0) => {
+    const ErrorsManager = function(alphabet){
 
+        /** @type {ErrorsManager} */
+        const self = this;
         /** @type {number} */
-        const l = blocks.length;
+        let error = 0;
+        // /** @type {RegExp|null} */
+        // let re_hexa_error = null;
 
-        length && (code = self.set(code, 0, bit, length));
+        /**
+         * @returns {void}
+         * @access private
+         */
+        const constructor = () => {
 
-        for(let i = 0; i < l; i ++)
-            blocks[i] && (code = self.set(code, blocks[i], bit));
+            self.set_alphabet(alphabet);
+
+        };
+
+        /**
+         * @param {!(string|Array.<string>)} new_alphabet 
+         * @returns {number}
+         * @access public
+         */
+        this.set_alphabet = new_alphabet => {
+
+            error = (
+                new_alphabet === undefined ? 0 : 
+                new_alphabet === null ? 0 : 
+                !ErrorsManager.is_string(new_alphabet) && !ErrorsManager.is_array(new_alphabet) ? 1 << 2 : 
+            0) << 1;
+
+            if(!error){
+                if(new_alphabet){
+
+                    /** @type {number} */
+                    const original_length = new_alphabet.length, 
+                          /** @type {number} */
+                          final_length = (new_alphabet = (new_alphabet instanceof Array ? new_alphabet : new_alphabet.split("")).filter((character, i) => (
+                              ErrorsManager.is_string(character) && character.length == 1 && new_alphabet.indexOf(character) == i
+                          ))).length;
+
+                    error |= (
+                        original_length != final_length ? 1 << 0 : 
+                        final_length < 64 ? 1 << 1 : 
+                    0) << 5;
+
+                };
+            };
+
+            alphabet = error || !new_alphabet ? (
+                alphabet && alphabet.length ? alphabet : 
+            ErrorsManager.BASE64) : new_alphabet;
+            // re_hexa_error = new RegExp("[^" + alphabet[0] + "]");
+
+            return error;
+        };
+
+        /**
+         * @param {!(string|number|Array.<number>)} code 
+         * @param {!number} [length = 0] 
+         * @returns {Array.<number>}
+         * @access public
+         */
+        this.to_array = (code, length = 0) => {
+
+            /** @type {Array.<number>} */
+            let array = [];
+
+            if(ErrorsManager.is_string(code))
+                array = code.split("").map(hexa => alphabet.indexOf(hexa));
+            else if(ErrorsManager.is_integer(code)){
+                while(code){
+                    array.push(code & 0x3F);
+                    code >>>= 6;
+                };
+            }else if(ErrorsManager.is_array(code))
+                array = [].concat(code);
+
+            while(array.length < length)
+                array.push(0);
+
+            return array && array.length ? array : [0];
+        };
+
+        /**
+         * @param {!(number|string|Array.<number>)} error 
+         * @param {!Array.<string|null>} messages 
+         * @returns {Array.<string>}
+         * @access public
+         */
+        this.process = (error, messages) => {
+
+            /** @type {Array.<string>} */
+            const response = [], 
+                  /** @type {number} */
+                  m = messages.length, 
+                  /** @type {Array.<number>} */
+                  array_error = self.to_array(error), 
+                  /** @type {number} */
+                  l = array_error.length;
+
+            for(let i = 0; i < l; i ++)
+                for(let j = 0; j < 6; j ++)
+                    if(array_error[i] & (1 << j)){
+            
+                        /** @type {number} */
+                        const k = j + i * 6;
+
+                        response.push([k, k < m && messages[k] ? messages[k] : "error_message_" + k]);
+
+                    };
+
+            return response;
+        };
+
+        /**
+         * @returns {Array.<string>}
+         * @access public
+         */
+        this.get_alphabet = () => alphabet.join("");
+
+        /**
+         * @param {!(string|number|Array.<number>)} code 
+         * @returns {number}
+         * @access public
+         */
+        this.bits = code => {
+            if(ErrorsManager.is_integer(code))
+                return code ? Math.log2(code) : 1;
+
+            ErrorsManager.is_string(code) && (code = self.to_array(code));
+
+            if(ErrorsManager.is_array(code))
+                return !(code = self.compact(code)).length || !code[code.length - 1] ? 1 : (code.length - 1) * 6 + (Math.log2(code[code.length - 1]) + 1 >> 0);
+            return null;
+        };
+
+        /**
+         * @param {!(string|number|Array.<number>)} code 
+         * @returns {Array.<string>}
+         * @access public
+         */
+        this.to_array_binary = code => (code = self.to_array(code)).map(hexa => ("000000" + hexa.toString(2)).slice(-6));
+
+        /**
+         * @param {!(string|number|Array.<number>)} code 
+         * @returns {number}
+         * @access public
+         */
+        this.to_integer = code => {
+            if(ErrorsManager.is_integer(code))
+                return code;
+            if(ErrorsManager.is_array(code))
+                return code.length ? code.length > 1 ? code.reduce((total, hexa, i) => total | (hexa << i * 6)) : code[0] : 0;
+            if(!ErrorsManager.is_string(code))
+                return 0;
+            return code ? code.length > 1 ? code.split("").reduce((total, hexa, i) => (i > 1 ? total : alphabet.indexOf(total)) | (alphabet.indexOf(hexa) << i * 6)) : alphabet.indexOf(code) : 0;
+        };
+
+        /**
+         * @param {!(string|number|Array.<number>)} code 
+         * @param {!number} [length = 0] 
+         * @returns {string}
+         * @access public
+         */
+        this.to_string = (code, length = 0) => {
+
+            /** @type {string} */
+            let string = "";
+
+            if(ErrorsManager.is_string(code))
+                string = code;
+            else{
+                if(ErrorsManager.is_integer(code)){
+                    while(code){
+                        string += alphabet[code & 0x3F];
+                        code >>>= 6;
+                    };
+                }else if(ErrorsManager.is_array(code))
+                    string = code.length ? code.length > 1 ? code.reduce((total, hexa, i) => (i > 1 ? total : alphabet[total]) + alphabet[hexa]) : alphabet[code[0]] : alphabet[0];
+            };
+
+            while(string.length < length)
+                string += alphabet[0];
+
+            return string || alphabet[0];
+        };
+
+        /**
+         * @param {!(string|number|Array.<number>)} code 
+         * @param {!(number|Array.<number>)} [bits] 
+         * @returns {boolean|null}
+         * @access public
+         */
+        this.has = (code, bits) => {
+            if(!ErrorsManager.is_integer(bits) && !ErrorsManager.is_array(bits))
+                return (
+                    ErrorsManager.is_string(code) ? code.split("").some(hexa => hexa != alphabet[0]) :
+                    ErrorsManager.is_integer(code) ? !!code :
+                    ErrorsManager.is_array(code) ? code.some(hexa => !!hexa) :
+                null);
+            
+            /** @type {Array.<number>} */
+            const error = self.to_array(code), 
+                  /** @type {number} */
+                  l = error.length * 6;
+
+            return l ? (
+                AnP.is_array(bits) ? bits : [bits]
+            ).some(bit => bit <= l && error[bit / 6 >> 0] & (1 << bit % 6)) : false;
+        };
+
+        /**
+         * @param {?any} code 
+         * @returns {any|null}
+         * @access public
+         */
+        this.to_unknown = code => code;
+
+        /**
+         * @param {!(string|number|Array.<number>)} code 
+         * @returns {string|number|Array.<number>}
+         * @access public
+         */
+        this.compact = code => {
+            if(ErrorsManager.is_string(code)){
+                while(code && code[code.length - 1] == alphabet[0])
+                    code = code.substr(0, code.length - 1);
+                return code || alphabet[0];
+            };
+            if(ErrorsManager.is_array(code)){
+                code = [].concat(code);
+                while(code.length && !code[code.length - 1])
+                    code.pop();
+                return code.length ? code : [0];
+            };
+            if(ErrorsManager.is_integer(code))
+                return code;
+            return 0;
+        };
+
+        /**
+         * @param {!(string|number|Array.<number>)} code 
+         * @param {!number} bits 
+         * @returns {string|number|Array.<number>}
+         * @access public
+         */
+        this.bitwise = (code, bits) => {
+
+            if(!bits || !self.has(code))
+                return code;
+
+
+            /** @type {boolean} */
+            const reverse = bits < 0, 
+                  /** @type {number} */
+                  start = (reverse ? bits *= -1 : bits) / 6 >> 0, 
+                  /** @type {number} */
+                  rest = bits % 6, 
+                  /** @type {string} */
+                  type_method = "to_" + ErrorsManager.type(code);
+
+            if(reverse){
+
+                code = self.to_string(code).substring(start);
+
+                if(rest){
+                    if(code){
+
+                        /** @type {number} */
+                        const l = (code = self.to_array(code)).length - 1, 
+                              /** @type {number} */
+                              r = 6 - rest, 
+                              /** @type {number} */
+                              block = ~-(1 << rest);
+
+                        for(let i = 0; i < l; i ++)
+                            code[i] = (code[i] >> rest) | ((code[i + 1] & block) << r);
+                        code[l] >>= rest;
+
+                    }else
+                        code = [0];
+                };
+
+            }else{
+
+                code = self.to_array(code);
+
+                if(rest){
+
+                    /** @type {number} */
+                    const r = 6 - rest, 
+                          /** @type {Array.<number>} */
+                          block = [~-(1 << r), ~-(1 << rest) << r], 
+                          /** @type {number} */
+                          l = code.length - 1, 
+                          /** @type {number} */
+                          last = (code[l] & block[1]) >> r;
+
+                    last && (code[l + 1] = last);
+                    for(let i = l; i > 0; i --)
+                        code[i] = ((code[i] & block[0]) << rest) | (code[i - 1] >> r);
+                    code[0] = (code[0] & block[0]) << rest;
+
+                };
+
+                for(let i = 0; i < start; i ++)
+                    code.unshift(0);
+
+            };
+
+            return self[type_method](code);
+        };
+
+        /**
+         * @param {!(string|number|Array.<number>)} code 
+         * @param {!(string|number|Array.<number>)} error 
+         * @param {!number} [bit = 0] 
+         * @param {!number} [length = 0] 
+         * @returns {string}
+         * @access public
+         */
+        this.set = (code, error, bit = 0, length = 0) => {
+
+            code = self.to_array(code);
+            error = self.to_array(error);
+            bit && (error = self.bitwise(error, bit));
+
+            /** @type {number} */
+            let i = bit / 6 >> 0;
+
+            if(length){
+
+                /** @type {Array.<number>} */
+                const ampersand = [], 
+                      /** @type {number} */
+                      start = bit % 6, 
+                      /** @type {number} */
+                      m = (length + start) / 6 >> 0, 
+                      /** @type {number} */
+                      end = (start + length) % 6;
+
+                for(let j = 0; j < m; j ++)
+                    ampersand.push(0);
+                ampersand[0] |= ~-(1 << start);
+                end && ampersand.push(~-(1 << (6 - end)) << end);
+
+                ampersand.forEach((hexa, j) => code[j + i] &= hexa);
+
+            };
+
+            if(has(error)){
+
+                /** @type {number} */
+                const l = error.length;
+
+                while(code.length <= i)
+                    code.push(0);
+
+                for(; i < l; i ++)
+                    code[i] = (code[i] || 0) | error[i];
+
+            };
+
+            return self.compact(self.to_string(code));
+        };
+
+        /**
+         * @param {!(string|number|Array.<number>)} code 
+         * @param {!(string|number|Array.<number>)} error 
+         * @param {!number} [bit = 0] 
+         * @param {!number} [length = 0] 
+         * @returns {string}
+         * @access public
+         */
+        this.join = (code, error, bit = 0, length = 0) => self.set(code, error, bit, length);
+        
+        /**
+         * @param {!(string|number|Array.<number>)} code 
+         * @param {!Array.<string|number|Array.<number>>} blocks 
+         * @param {!number} [bit = 0] 
+         * @param {!number} [length = 0] 
+         * @returns {string}
+         * @access public
+         */
+        this.set_blocks = (code, blocks, bit = 0, length = 0) => {
+
+            /** @type {number} */
+            const l = blocks.length;
+
+            length && (code = self.set(code, 0, bit, length));
+
+            for(let i = 0; i < l; i ++)
+                blocks[i] && (code = self.set(code, blocks[i], bit));
+
+            return code || alphabet[0];
+        };
+
+        /**
+         * @param {!(string|number|Array.<number>)} code 
+         * @param {!number} _from 
+         * @param {!number} [_to = 0] 
+         * @returns {string|number|Array.<number>|null}
+         * @access public
+         */
+        this.slice = (code, _from, _to = 0) => {
+            if(!self.has(code))
+                return code;
+
+            /** @type {number} */
+            const bits = self.bits(code);
+            /** @type {number} */
+            let rest;
+
+            _from < 0 && (_from = bits + _from);
+            _to = (
+                _to > bits ? bits : 
+                _to < 0 ? bits - _to : 
+            _to) - _from;
+            rest = _to % 6;
+            code = self.bitwise(code, -_from);
+
+            return (
+                ErrorsManager.is_string(code) ? code.slice(0, _to / 6 >> 0) + (rest ? alphabet[alphabet.indexOf(code.slice(-1)) & ~-(1 << rest)] : "") : 
+                ErrorsManager.is_array(code) ? code.slice(0, _to / 6 >> 0).concat(rest ? [code[code.length - 1] & ~-(1 << rest)] : []) : 
+                ErrorsManager.is_integer(code) ? code & ~-(1 << _to) : 
+            null);
+        };
+
+        /**
+         * @param {!(string|number|Array.<number>)} code 
+         * @param {!number} _from 
+         * @param {!number} [_to = 0] 
+         * @returns {boolean}
+         * @access public
+         */
+        this.has_range = (code, _from, _to = 0) => self.has(self.slice(code, _from, _to));
+
+        constructor();
 
-        return code || alphabet[0];
     };
 
-    /**
-     * @param {!(string|number|Array.<number>)} code 
-     * @param {!number} _from 
-     * @param {!number} [_to = 0] 
-     * @returns {string|number|Array.<number>|null}
-     * @access public
-     */
-    this.slice = (code, _from, _to = 0) => {
-        if(!self.has(code))
-            return code;
-
-        /** @type {number} */
-        const bits = self.bits(code);
-        /** @type {number} */
-        let rest;
-
-        _from < 0 && (_from = bits + _from);
-        _to = (
-            _to > bits ? bits : 
-            _to < 0 ? bits - _to : 
-        _to) - _from;
-        rest = _to % 6;
-        code = self.bitwise(code, -_from);
-
-        return (
-            ErrorsManager.prototype.is_string(code) ? code.slice(0, _to / 6 >> 0) + (rest ? alphabet[alphabet.indexOf(code.slice(-1)) & ~-(1 << rest)] : "") : 
-            ErrorsManager.prototype.is_array(code) ? code.slice(0, _to / 6 >> 0).concat(rest ? [code[code.length - 1] & ~-(1 << rest)] : []) : 
-            ErrorsManager.prototype.is_integer(code) ? code & ~-(1 << _to) : 
-        null);
-    };
+    // /** @type {Array.<string>} */
+    // ErrorsManager.BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".split("");
 
     /**
-     * @param {!(string|number|Array.<number>)} code 
-     * @param {!number} _from 
-     * @param {!number} [_to = 0] 
+     * @param {?any} value 
      * @returns {boolean}
      * @access public
+     * @static
      */
-    this.has_range = (code, _from, _to = 0) => self.has(self.slice(code, _from, _to));
+    ErrorsManager.is_string = value => typeof value == "string";
 
-    constructor();
+    /**
+     * @param {?any} value 
+     * @returns {boolean}
+     * @access public
+     * @static
+     */
+    ErrorsManager.is_integer = value => typeof value == "number" && value == value >> 0;
 
-};
+    /**
+     * @param {?any} value 
+     * @returns {boolean}
+     * @access public
+     * @static
+     */
+    ErrorsManager.is_array = value => typeof value == "object" && value instanceof Array;
 
-/** @type {Array.<string>} */
-ErrorsManager.prototype.BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".split("");
+    /**
+     * @param {!(string|number|Array.<number>)} code 
+     * @returns {string}
+     * @access public
+     * @static
+     */
+    ErrorsManager.type = code => {
 
-/**
- * @param {?any} value 
- * @returns {boolean}
- * @access public
- * @static
- */
-ErrorsManager.prototype.is_string = value => typeof value == "string";
+        /** @type {Array.<string>} */
+        const types = ["string", "integer", "array"];
 
-/**
- * @param {?any} value 
- * @returns {boolean}
- * @access public
- * @static
- */
-ErrorsManager.prototype.is_integer = value => typeof value == "number" && value == value >> 0;
+        for(let i = 0; i < 3; i ++)
+            if(ErrorsManager["is_" + types[i]](code))
+                return types[i];
+        return "unknown";
+    };
 
-/**
- * @param {?any} value 
- * @returns {boolean}
- * @access public
- * @static
- */
-ErrorsManager.prototype.is_array = value => typeof value == "object" && value instanceof Array;
-
-/**
- * @param {!(string|number|Array.<number>)} code 
- * @returns {string}
- * @access public
- * @static
- */
-ErrorsManager.prototype.type = code => {
-
-    /** @type {Array.<string>} */
-    const types = ["string", "integer", "array"];
-
-    for(let i = 0; i < 3; i ++)
-        if(ErrorsManager.prototype["is_" + types[i]](code))
-            return types[i];
-    return "unknown";
-};
\ No newline at end of file
+    return ErrorsManager;
+})();
\ No newline at end of file
diff --git a/Public/test.html b/Public/test.html
index e5c838f..e5df401 100644
--- a/Public/test.html
+++ b/Public/test.html
@@ -1,7 +1,10 @@
-<script src="ecma/ErrorsManager.ecma.js"></script>
-<script>
+<script type="module" charset="utf-8">
+    "use strict";
 
-    errors_manager = new ErrorsManager();
+    import {ErrorsManager} from "./ecma/ErrorsManager.ecma.js";
+
+    /** @type {ErrorsManager} */
+    const errors_manager = new ErrorsManager();
 
     console.log(errors_manager.to_string(105));
     console.log(errors_manager.to_array(105));
@@ -13,19 +16,29 @@
     console.log(errors_manager.bits("pB"));
     console.log(errors_manager.bits([41, 1]));
 
-    options = [-10, -5, -3, -1, 0, 1, 3, 5, 10];
-    filler = "";
-    results = [];
+    /** @type {Array.<number>} */
+    const options = [-10, -5, -3, -1, 0, 1, 3, 5, 10], 
+          /** @type {Array.<number|string|Array.<number>} */
+          results = [];
+    /** @type {string} */
+    let filler = "";
 
     while(filler.length < 30)
         filler += " ";
 
-    format = (value, characters) => " " + (
+    /**
+     * @param {!string} value 
+     * @param {!number} character 
+     * @returns string
+     * @access public
+     */
+    const format = (value, characters) => " " + (
         JSON.stringify(value).replace(/,/g, ", ") + filler
     ).slice(0, characters) + " ";
 
     [105, "pB", [41, 1]].forEach((value, i) => options.forEach(bits => {
 
+        /** @type {string|number|Array.<number>} */
         const new_value = errors_manager.bitwise(value, bits);
 
         results.push([
diff --git a/version b/version
index da7a1d1..fb23388 100644
--- a/version
+++ b/version
@@ -1 +1 @@
-0.0.1.25
\ No newline at end of file
+0.0.1.27
\ No newline at end of file