Reservationer/application/assets/cx-libtranslate.debug.js

var cx_libtranslate = (() => {
  var __getOwnPropNames = Object.getOwnPropertyNames;
  var __commonJS = (cb, mod) => function __require() {
    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
  };

  // source/translation.js
  var require_translation = __commonJS({
    "source/translation.js"(exports) {
      var translation = class {
        /**
         * @var {string}
         * This is translated content.
         */
        #content;
        /**
         * @var {bool}
         * This is true, when content is translated from dict, and false
         * when could not being found.
         */
        #translated;
        /**
         * This create new translation. Translation store content of the 
         * translation, make avairable to format translated phrase and also
         * store that translation was found in the phrasebook.
         * 
         * @param {string} content - Content of the translation.
         * @param {bool} translated - True when translation could be found.
         */
        constructor(content, translated = true) {
          if (typeof content !== "string") {
            throw new TypeError("Translated content must be string.");
          }
          if (typeof translated !== "boolean") {
            throw new TypeError("Result of translation must be boolean.");
          }
          this.#content = content;
          this.#translated = translated;
          Object.freeze(this);
        }
        /**
         * This convert transiation to string.
         * 
         * @returns {string} - Content of the translation.
         */
        toString() {
          return this.#content;
        }
        /**
         * @returns {string} - Content of the translation.
         */
        get text() {
          return this.#content;
        }
        /**
         * @returns {bool} - True when translation was found, false when not.
         */
        get valid() {
          return this.translated;
        }
        /**
         * This would format ready translation, with numbers, dats, and 
         * other content, which could not being statically places into
         * translation. To use it, place name of content object key into
         * "#{}" in translation. 
         * 
         * @example ```
         *  Translation: "I have more than #{how_many} apples!"
         *  Object: { how_many: 10 }
         *  Result: "I have more than 10 apples!"
         * ```
         * 
         * @param {string} content 
         * @returns {string}
         */
        format(content) {
          if (typeof content !== "object") {
            throw new TypeError("Content to format from must be object.");
          }
          if (!this.#translated) {
            return this.#content;
          }
          return this.#parse_format(content);
        }
        /**
         * This infill prepared translation with data from content 
         * object.
         * 
         * @see format
         * 
         * @param {object} content - Content to load data from. 
         * @returns {string} - Formater translation.
         */
        #parse_format(content) {
          let parts = this.#content.split("#{");
          let result = parts[0];
          for (let count = 1; count < parts.length; ++count) {
            const part = parts[count];
            const splited = part.split("}");
            if (splited.length === 1) {
              return result + splited[0];
            }
            const name = splited.splice(0, 1)[0].trim();
            const rest = splited.join("}");
            if (!(name in content)) {
              DEBUG: throw new RangeError(
                'Could not find "' + name + '".'
              );
              result += rest;
              continue;
            }
            result += content[name] + rest;
          }
          return result;
        }
      };
      exports.translation = translation;
    }
  });

  // source/phrasebook.js
  var require_phrasebook = __commonJS({
    "source/phrasebook.js"(exports) {
      var translation = require_translation().translation;
      var phrasebook = class _phrasebook {
        /**
         * @var {Map}
         * This store phrases in flat notation.
         */
        #phrases;
        /**
         * @var {?object}
         * This store object for nested object notation.
         */
        #objects;
        /**
         * This create new phrasebook from phrases map, and optional object
         * for phrases in object notation.
         * 
         * @param {Map} phrases - This contain phrases in flat notation.
         * @param {?object} objects - This contain phrases in object notation. 
         */
        constructor(phrases, objects = null) {
          if (!(phrases instanceof Map)) {
            throw new TypeError("Phrases must an map.");
          }
          if (objects !== null && typeof objects !== "object") {
            throw new TypeError("Objects must be null or object.");
          }
          this.#phrases = phrases;
          this.#objects = objects;
        }
        /**
         * This translate given phrase. When phrase is in the nested object 
         * notation, then try to find phrase in objects. When not, try to find
         * phrase in the flat phrases. When could not find phrase, then return 
         * not translated phrase. Content always is returned as translation
         * object, which could be also formated wich numbers, dates and
         * much more.
         * 
         * @param {string} phrase - Phrase to translate. 
         * @returns {translation} - Translated phrase.
         */
        translate(phrase) {
          if (typeof phrase !== "string") {
            throw new TypeError("Phrase to translate must be an string.");
          }
          if (this.#is_nested(phrase)) {
            return this.#translate_nested(phrase);
          }
          return this.#translate_flat(phrase);
        }
        /**
         * This translate given phrase. When phrase is in the nested object 
         * notation, then try to find phrase in objects. When not, try to find
         * phrase in the flat phrases. When could not find phrase, then return 
         * not translated phrase. Content always is returned as translation
         * object, which could be also formated wich numbers, dates and
         * much more.
         * 
         * @param {string} phrase - Phrase to translate. 
         * @returns {translation} - Translated phrase.
         */
        get(phrase) {
          return this.translate(phrase);
        }
        /**
         * Check that phrase is nested or not.
         * 
         * @param {string} phrase - Phrase to check that is nested
         * @returns {bool} - True when nested, false when not 
         */
        #is_nested(phrase) {
          return phrase.indexOf(".") !== -1;
        }
        /**
         * This translate object notated phrase.
         * 
         * @param {string} phrase - Phrase to translate.
         * @returns {translation} - Translated phrase. 
         */
        #translate_nested(phrase) {
          if (this.#objects === null) {
            return this.#translate_flat(phrase);
          }
          const parts = phrase.trim().split(".");
          let current = this.#objects;
          for (const count in parts) {
            const part = parts[count];
            if (!(part in current)) {
              return new translation(phrase, false);
            }
            current = current[part];
          }
          if (typeof current !== "string") {
            return new translation(phrase, false);
          }
          return new translation(current, true);
        }
        /**
         * This set phrasebook as default. That mean, it would add own translate
         * function to global scope, and create _({string}) function in the global
         * scope. It is useable to minify code with translations. It is not 
         * avairable in the NodeJS, only in the browser.
         * 
         * @returns {phrasebook} - Object itself to chain loading.
         */
        set_as_default() {
          const translate = (content) => {
            return this.translate(content);
          };
          window._ = translate;
          window.translate = translate;
        }
        /**
         * This translate flat phrase.
         * 
         * @param {string} phrase - Phrase to translate. 
         * @returns {translation} - Translated phrase.
         */
        #translate_flat(phrase) {
          const prepared = _phrasebook.prepare(phrase);
          const found = this.#phrases.has(prepared);
          const translated = found ? this.#phrases.get(prepared) : phrase;
          return new translation(translated, found);
        }
        /**
         * This prepars phrase, that mean replece all spaces with "_", trim 
         * and also replace all big letters with lowwer. 
         * 
         * @param {string} content - Phrase to preapre.
         * @return {string} - Prepared phrase.
         */
        static prepare(content) {
          if (typeof content !== "string") {
            throw new TypeError("Content to prepare must be an string.");
          }
          return content.trim().replaceAll(" ", "_").replaceAll(".", "_").toLowerCase();
        }
      };
      exports.phrasebook = phrasebook;
    }
  });

  // source/loader.js
  var require_loader = __commonJS({
    "source/loader.js"(exports) {
      var phrasebook = require_phrasebook().phrasebook;
      var loader = class {
        /**
         * @var {string}
         * This is location of the phrasebook on the server.
         */
        #path;
        /**
         * @var {bool}
         * This is true, when must load local file, or false when fetch.
         */
        #local;
        /**
         * This create new loader of the phrasebook.
         * 
         * @param {string} path - Location of the phrasebook to fetch.
         * @param {bool} local - False when must fetch from remote.
         */
        constructor(path, local = false) {
          if (typeof path !== "string") {
            throw new TypeError("Path of the file must be string.");
          }
          if (typeof local !== "boolean") {
            throw new TypeError("Local must be bool variable.");
          }
          this.#path = path;
          this.#local = local;
        }
        /**
         * This load file from path given in the constructor, parse and return it.
         * 
         * @returns {phrasebook} - New phrasebook with content from JSON file.
         */
        async #load_remote() {
          const request = await fetch(this.#path);
          const response = await request.json();
          return this.#parse(response);
        }
        /**
         * This load file from path given in the constructor, parse and return it.
         * 
         * @returns {phrasebook} - New phrasebook with content from JSON file.
         */
        async #load_local() {
          let fs = null;
          if (fs === null) {
            throw new Error("Could not use ndoe:fs in browser.");
          }
          const content = await fs.readFile(this.#path, { encoding: "utf8" });
          const response = JSON.parse(content);
          return this.#parse(response);
        }
        /**
         * This load file from path given in the constructor, parse and return it.
         * 
         * @returns {phrasebook} - New phrasebook with content from JSON file.
         */
        load() {
          if (this.#local) {
            return this.#load_local();
          }
          return this.#load_remote();
        }
        /**
         * This parse phrasebook. When phrasebook contain "phrases" or "objects" 
         * keys, and also "objects" is not string, then parse it as nested file,
         * in the other way parse it as flat.
         * 
         * @param {object} content - Fetched object with translations. 
         * @returns {phrasebook} - Loaded phrasebook.
         */
        #parse(content) {
          const has_objects = "objects" in content && typeof content["objects"] === "object";
          const has_phrases = "phrases" in content && typeof content["phrases"] === "object";
          const is_nested = has_objects || has_phrases;
          if (is_nested) {
            const phrases = has_phrases ? content["phrases"] : {};
            const objects = has_objects ? content["objects"] : {};
            return new phrasebook(
              this.#parse_phrases(phrases),
              objects
            );
          }
          return new phrasebook(this.#parse_phrases(content));
        }
        /**
         * This parse flat phrases object to map.
         * 
         * @param {object} content - Flat phrases object to pase.
         * @returns {Map} - Phrases parsed as Map.
         */
        #parse_phrases(content) {
          const phrases = /* @__PURE__ */ new Map();
          Object.keys(content).forEach((phrase) => {
            const name = phrasebook.prepare(phrase);
            const translation = content[phrase];
            phrases.set(name, translation);
          });
          return phrases;
        }
      };
      exports.loader = loader;
    }
  });

  // source/languages.js
  var require_languages = __commonJS({
    "source/languages.js"(exports) {
      var loader = require_loader().loader;
      var phrasebook = require_phrasebook().phrasebook;
      var languages = class {
        /**
         * @var {string}  
         * This represents path to directory where phrasebooks had been stored.
         */
        #path;
        /**
         * @var {Map}
         * This store languages and its files on server. 
         */
        #libs;
        /**
         * @var {bool}
         * This store that directory is in the local file system, or remote
         * server. When true, resources would be loaded by node:fs. When 
         * false, resources would be fetched.
         */
        #local;
        /**
         * This create new languages library. Next, languages could be added to
         * the library by command, or by loading index file.
         * 
         * @throws {TypeError} - When parameters is not in correct format.
         * 
         * @param {string} path - Path to phrasebooks on the server or filesystem.
         * @param {bool} local - True when phrasebooks dirs would be loaded by 
         *                       node:fs module. False when would be fetch.
         */
        constructor(path, local = false) {
          if (typeof path !== "string") {
            throw new TypeError("Path to the phrasebooks must be string.");
          }
          if (typeof local !== "boolean") {
            throw new TypeError("Local must be bool variable.");
          }
          this.#local = local;
          this.#path = path;
          this.#libs = /* @__PURE__ */ new Map();
        }
        /**
         * This add new language to the library by name. Name must be in form
         * like POSIX locale, like en_US, or pl_PL. That mean first two letter
         * mest be ISO 639-1 and second two letters mst be in ISO 3166-1 alpha-2
         * 2 letter country code format.
         * 
         * @see https://www.loc.gov/standards/iso639-2/php/code_list.php
         * @see https://en.wikipedia.org/wiki/List_of_ISO_639_language_codes
         * @see https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2
         * @see https://en.wikipedia.org/wiki/Locale_(computer_software)
         * 
         * @throws {TypeError} - When tpes of the parameters is not correct.
         * 
         * @param {string} name - Name of the language, like "en_US".
         * @param {string} file - Name of the file in the directory.
         * @return {languages} - Instnace of this class to chain.
         */
        add(name, file) {
          if (typeof name !== "string") {
            throw new TypeError("Name of the language must be sting.");
          }
          if (typeof file !== "string") {
            throw new TypeError("File on in the directory must be string.");
          }
          if (this.#libs.has(name)) {
            console.error('Language "' + name + '" already loaded.');
            console.error("It could not being loaded twice.");
            return this;
          }
          if (!this.#valid_locale(name)) {
            console.error('Language name "' + name + '" invalid formated.');
            console.error("It could not being loaded.");
            return this;
          }
          this.#libs.set(name, file);
          return this;
        }
        /**
         * This load all phrasebook given in the index file. Index must be
         * JSON file, which contain one object. That object properties must be
         * languages names in the notation like in add function. Valus of that
         * properties musts being strings which contains names of the phrasebook
         * files in the path directory.
         * 
         * @example ``` { "pl_PL": "polish.json", "en_US": "english.json" } ```
         * 
         * @see add
         * 
         * @param {string} index - Index file in the phrasebook directory.
         * @return {languages} - New languages instance with loaded index.
         */
        async load(index) {
          if (typeof index !== "string") {
            throw new TypeError("Name of index file is not string.");
          }
          const response = await this.#load_index(index);
          this.#libs.clear();
          Object.keys(response).forEach((name) => {
            if (typeof name !== "string") {
              console.error("Name of the language must be string.");
              console.error("Check languages index.");
              console.error("Skipping it.");
              return;
            }
            if (typeof response[name] !== "string") {
              console.error("Name of phrasebook file must be string.");
              console.error("Check languages index.");
              console.error("Skipping it.");
              return;
            }
            this.add(name, response[name]);
          });
          return this;
        }
        /**
         * This load index object. That check, and when content must be loaded
         * from local filesystem, it use node:fs, or when it must be fetched from
         * remote, then use fetch API.
         * 
         * @param {string} index - Name of the index file in library. 
         * @returns {object} - Loaded index file content. 
         */
        async #load_index(index) {
          const path = this.#full_path(index);
          if (this.#local) {
            let fs = null;
            if (fs === null) {
              throw new Error("Could not use ndoe:fs in browser.");
            }
            return JSON.parse(
              await fs.readFile(path, { encoding: "utf-8" })
            );
          }
          const request = await fetch(path);
          return await request.json();
        }
        /**
         * This check that language exists in languages library.
         * 
         * @param {string} name - Name of the language to check.
         * @return {bool} - True when language exists, false when not
         */
        has(name) {
          return this.#libs.has(name);
        }
        /**
         * This return all avairable languages.
         * 
         * @return {Array} - List of all avairable languages.
         */
        get avairable() {
          const alls = new Array();
          this.#libs.keys().forEach((name) => {
            alls.push(name);
          });
          return alls;
        }
        /**
         * @returns {string} - Default 
         */
        get default() {
          const avairable = this.avairable;
          if (avairable.length === 0) {
            throw new Error("Languages list is empty. Can not load default.");
          }
          return avairable[0];
        }
        /**
         * This load phrasebook with give name.
         * 
         * @throws {TypeError} - Param type is not correct.
         * @throws {RangeError} - Language not exists in libs.
         * 
         * @param {string} name - Name of the language to load. 
         * @returns {phrasebook} - Phrasebook loaded from the file.
         */
        select(name) {
          if (typeof name !== "string") {
            throw new TypeError("Name of the language must be string.");
          }
          if (!this.has(name)) {
            DEBUG: throw new RangeError(
              'Not found language "' + name + '".'
            );
            return new phrasebook(/* @__PURE__ */ new Map());
          }
          const file = this.#libs.get(name);
          const path = this.#full_path(file);
          return new loader(path, this.#local).load();
        }
        /**
         * This return full path to the file.
         * 
         * @param {string} name - Name of the file to get its path
         * @return {string} - Full path of the file
         */
        #full_path(name) {
          let glue = "/";
          if (this.#path[this.#path.length - 1] === glue) {
            glue = "";
          }
          return this.#path + glue + name;
        }
        /**
         * This check that format is valid POSIX like locale.
         * 
         * @param {string} name - Name to check format of.
         * @return {bool} - True when format is valid, false when not.
         */
        #valid_locale(name) {
          const splited = name.split("_");
          if (splited.length !== 2) {
            return false;
          }
          const first = splited[0];
          const second = splited[1];
          if (first.toLowerCase() !== first || first.length !== 2) {
            return false;
          }
          if (second.toUpperCase() !== second || second.length !== 2) {
            return false;
          }
          return true;
        }
      };
      exports.languages = languages;
    }
  });

  // source/selector.js
  var require_selector = __commonJS({
    "source/selector.js"(exports) {
      var languages = require_languages().languages;
      var selector = class {
        /**
         * @var {languages}
         * This store languages container.
         */
        #languages;
        /**
         * @var {?HTMLElement}
         * This store selector HTML container, or null when not created.
         */
        #container;
        /**
         * @var {HTMLElement}
         * This store languages HTML selector object.
         */
        #selector;
        /**
         * @var {Array}
         * This is array of callbacks which must being called after change.
         */
        #callbacks;
        /**
         * This create new selector object, from languages container.
         * 
         * @param {languages} languages - Languages container to work on.
         */
        constructor(languages2) {
          this.#container = null;
          this.#languages = languages2;
          this.#callbacks = new Array();
          this.#selector = this.#create_selector();
        }
        /**
         * This check that selector is currently inserted anywhere.
         * 
         * @returns {bool} - True when selector is inserted anywhere.
         */
        get is_inserted() {
          return this.#container !== null;
        }
        /**
         * This inserts selector into given HTML element, or directly into
         * document body, when any element is not specified. It returns 
         * itselt, to call more functions inline.
         * 
         * @param {?HTMLElement} where - Place to insert selector, or null.
         * @returns {selector} - This object to chain loading.
         */
        insert(where = null) {
          if (this.is_inserted) {
            return this;
          }
          if (where === null) {
            where = document.querySelector("body");
          }
          this.#container = this.#create_container();
          where.appendChild(this.#container);
          return this;
        }
        /**
         * This run all functions which was registered as onChange callback.
         */
        #on_change() {
          this.#callbacks.forEach((count) => {
            count(this.current);
          });
        }
        /**
         * This function remove selector from HTML element, if it is already
         * inserted anywhere.
         * 
         * @returns {selector} - This object to chain loading.
         */
        remove() {
          if (!this.is_inserted) {
            return this;
          }
          this.#container.remove();
          this.#container = null;
          return this;
        }
        /**
         * This create new container with selector inside.
         * 
         * @returns {HTMLElement} - New container with selector.
         */
        #create_container() {
          const container = document.createElement("div");
          container.classList.add(this.class_name);
          container.appendChild(this.#selector);
          return container;
        }
        /**
         * This add new callback to selector. All callbacks would be called
         * after language change. Callback would get one parameter, which is
         * name of the location.
         * 
         * @param {CallableFunction} callback - Function to call on change.
         * @returns 
         */
        add_listener(callback) {
          this.#callbacks.push(callback);
          return this;
        }
        /**
         * This return HTML class name of selector container.
         * 
         * @returns {string} - HTML class name of selector container.
         */
        get class_name() {
          return "cx-libtranslate-language-selector";
        }
        /**
         * This create HTML option element from language name.
         * 
         * @param {string} location - Name of single language. 
         * @returns {HTMLElement} - New option element.
         */
        #create_option(location) {
          const name = location.split("_").pop();
          const option = document.createElement("option");
          option.innerText = name;
          option.value = location;
          return option;
        }
        /**
         * This return current selected language name.
         * 
         * @returns {string} - Current selected language.
         */
        get current() {
          return this.#selector.value;
        }
        /**
         * This set current selected language for the selector.
         * 
         * @param {string} name - Name of the language to set.
         * @returns {selector} - This to chain loading.
         */
        set_selection(name) {
          if (!this.#languages.has(name)) {
            DEBUG: throw new Error(
              'Selector has not "' + name + '" language in the container.'
            );
          }
          this.#selector.value = name;
          return this;
        }
        /**
         * This reload languages list in the selector. It could be used
         * after change in the languages container.
         * 
         * @returns {selector} - Itself to chain loading.
         */
        reload() {
          while (this.#selector.lastChild) {
            this.#selector.lastChild.remove();
          }
          this.#languages.avairable.forEach((count) => {
            this.#selector.appendChild(this.#create_option(count));
          });
          return this;
        }
        /**
         * This create new HTML selector object, witch all languages
         * from container inserted as options.
         * 
         * @returns {HTMLElement} - New selector object.
         */
        #create_selector() {
          const selector2 = document.createElement("select");
          selector2.addEventListener("change", () => {
            this.#on_change();
          });
          this.#languages.avairable.forEach((count) => {
            selector2.appendChild(this.#create_option(count));
          });
          return selector2;
        }
      };
      exports.selector = selector;
    }
  });

  // source/autotranslate.js
  var require_autotranslate = __commonJS({
    "source/autotranslate.js"(exports) {
      var { phrasebook } = require_phrasebook();
      var autotranslate = class _autotranslate {
        /**
         * @var {?phrasebook}
         * This store phrasebook to get translates from, or store null, to get
         * translate content from global translate function.
         */
        #phrasebook;
        /**
         * @var {?MutationObserver}
         * This store observer object, when it is connecter and waiting for 
         * changaes, or store null, when observer currently not working.
         */
        #observer;
        /**
         * This create new autotranslator. It require phrasebook, to loads 
         * translations for phrases from. When null had been given, the it 
         * use global translate function.
         * 
         * @throws {Error} - When trying to use it in the NodeJS.
         * 
         * @param {?phrasebook} phrasebook 
         */
        constructor(phrasebook2 = null) {
          this.#observer = null;
          this.#phrasebook = phrasebook2;
        }
        /**
         * It return class name for elements, which would be translated by 
         * autotranslator.
         * 
         * @returns {string} - Class name for autotranslating elements.
         */
        static get_class_name() {
          return "translate";
        }
        /**
         * This return selector for choose elements which must be autotranslated.
         * 
         * @returns {string} - Selector of the elements to translate.
         */
        get #class_selector() {
          return "." + _autotranslate.get_class_name();
        }
        /**
         * This return name of attribute which store phrase to translate.
         * 
         * @returns {string} - Name of attribute which store phrase.
         */
        static get_attribute_name() {
          return "phrase";
        }
        /**
         * This check that autotranslator is connected and waiting to changes.
         * 
         * @returns {bool} - True when observer is connected, fakse when not.
         */
        get is_connected() {
          return this.#observer !== null;
        }
        /**
         * This search elements which could be translated in the element given
         * in the parameter. When null given, then it search elements in the 
         * all document.
         * 
         * @param {?HTMLElement} where - Item to load items from or null.
         * @returns {Array} - Array of elements to translate.
         */
        #get_all_items(where = null) {
          if (where === null) {
            where = document;
          }
          return Array.from(
            where.querySelectorAll(this.#class_selector)
          );
        }
        /**
         * It translate given phrase, baseed on loaded phrasebook, or when not
         * loaded any, then use global translate function. When it also not 
         * exists, then throws error in debug mode, or return not translated
         * phrase on production.
         * 
         * @throws {Error} - When any option to translate not exists.
         * 
         * @param {string} content - Phrase to translate.
         * @returns {string} - Translated content.
         */
        #translate(content) {
          if (this.#phrasebook !== null) {
            return this.#phrasebook.translate(content);
          }
          if (_ === void 0) {
            DEBUG: throw new Error("All translate options are unavairable.");
            return content;
          }
          return _(content);
        }
        /**
         * This add mutable observer to the body. It wait for DOM modifications,
         * and when any new node had been adder, or any phrase attribute had 
         * been changed, then it trying to translate it.
         * 
         * @returns {autotranslate} - This object to chain load.
         */
        connect() {
          if (this.is_connected) {
            return this;
          }
          const body = document.querySelector("body");
          const callback = (targets) => {
            this.#process(targets);
          };
          const options = {
            childList: true,
            attributes: true,
            characterData: false,
            subtree: true,
            attributeFilter: [_autotranslate.get_attribute_name()],
            attributeOldValue: false,
            characterDataOldValue: false
          };
          this.#observer = new MutationObserver(callback);
          this.#observer.observe(body, options);
          return this;
        }
        /**
         * This prcoess all given in the array mutable records. 
         * 
         * @param {Array} targets - Array with mutable records. 
         */
        #process(targets) {
          targets.forEach((count) => {
            if (count.type === "attributes") {
              this.#update_single(count.target);
              return;
            }
            this.#get_all_items(count.target).forEach((count2) => {
              this.#update_single(count2);
            });
          });
        }
        /**
         * This disconnect observer, and remove it.
         * 
         * @returns {autotranslate} - This object to chain loading.
         */
        disconnect() {
          if (!this.is_connected) {
            return this;
          }
          this.#observer.disconnect();
          this.#observer = null;
          return this;
        }
        /**
         * This update single element, based on phrase attribute. When element 
         * is standard HTMLElement, then it place translated content into 
         * innerText, but when element is input, like HTMLInputElement or
         * HTMLTextAreaElement, then it place result into placeholder. When
         * input is button, or submit, then it put content into value.
         * 
         * @param {HTMLElement} target - Element to translate 
         */
        #update_single(target) {
          const attrobute_name = _autotranslate.get_attribute_name();
          const phrase = target.getAttribute(attrobute_name);
          const result = this.#translate(phrase);
          if (target instanceof HTMLInputElement) {
            if (target.type === "button" || target.type === "submit") {
              target.value = result;
              return;
            }
            target.placeholder = result;
            return;
          }
          if (target instanceof HTMLTextAreaElement) {
            target.placeholder = result;
            return;
          }
          target.innerText = result;
        }
        /**
         * This update translation of all elements in the document. It is useable
         * when new autotranslator is created. 
         * 
         * @returns {autotranslate} - Instance of object to chain loading.
         */
        update() {
          this.#get_all_items().forEach((count) => {
            this.#update_single(count);
          });
          return this;
        }
      };
      exports.autotranslate = autotranslate;
    }
  });

  // source/preferences.js
  var require_preferences = __commonJS({
    "source/preferences.js"(exports) {
      var languages = require_languages().languages;
      var phrasebook = require_phrasebook().phrasebook;
      var selector = require_selector().selector;
      var autotranslate = require_autotranslate().autotranslate;
      var preferences = class {
        /**
         * @var {languages}
         * This store loaded languages object.
         */
        #languages;
        /**
         * @var {?selector}
         * This store selector for preferences.
         */
        #selector;
        /**
         * @var {?autotranslate}
         * This store autotranslator, or null.
         */
        #autotranslate;
        /**
         * This create new language preferences manager from loaded languages
         * object.
         *
         * @throws {Error} - When trying to use it in NodeJS.
         * 
         * @param {languages} target - loaded languages object.
         */
        constructor(target) {
          this.#selector = null;
          this.#autotranslate = null;
          this.#languages = target;
        }
        /**
         * This return name of language key in localStorage.
         * 
         * @returns {string} - Name of key in localStorage.
         */
        get #setting_name() {
          return "cx_libtranslate_lang";
        }
        /**
         * This return current saved language name, or null if any language
         * is not selected yet.
         * 
         * @returns {?string} - Saved language or null.
         */
        get #state() {
          return localStorage.getItem(this.#setting_name);
        }
        /**
         * This return selector, which could being used in the ui.
         * 
         * @returns {selector} - New UI selector of the languages.
         */
        get selector() {
          if (this.#selector !== null) {
            return this.#selector;
          }
          this.#selector = new selector(this.#languages).set_selection(this.current).add_listener((target) => {
            this.update(target);
          }).add_listener(async (target) => {
            if (this.#autotranslate === null) {
              return;
            }
            this.#reload_autotranslate();
          });
          return this.#selector;
        }
        async #reload_autotranslate() {
          const connected = this.#autotranslate.is_connected;
          if (connected) {
            this.#autotranslate.disconnect();
          }
          this.#autotranslate = null;
          const created = await this.get_autotranslate();
          if (connected) {
            created.connect();
          }
        }
        /**
         * This load phrasebook for selected language, create autotranslate
         * for it, and returns it. Autotranslate is cached in this object.
         * 
         * @returns {autotranslate} - Autotranslate for phrasebook.
         */
        async get_autotranslate() {
          if (this.#autotranslate !== null) {
            return this.#autotranslate;
          }
          const phrasebook2 = await this.load_choosen_phrasebook();
          this.#autotranslate = new autotranslate(phrasebook2);
          this.#autotranslate.update();
          return this.#autotranslate;
        }
        /**
         * This save new selected language name to localStorage, or remove it 
         * from there if null given.
         * 
         * @param {?string} content - Name of selected language or null.
         */
        set #state(content) {
          if (content === null) {
            localStorage.removeItem(this.#setting_name);
            return;
          }
          localStorage.setItem(this.#setting_name, content);
        }
        /**
         * This return current language from localStorage. When any language is
         * not loaded yet, then return default language. It also check that value
         * value from localStorage, and if it not avairable in languages storage,
         * then also return default language.
         * 
         * @return {string} - Name of the current language.
         */
        get current() {
          const saved = this.#state;
          if (saved === null) {
            return this.#languages.default;
          }
          if (this.#languages.has(saved)) {
            return saved;
          }
          return this.#languages.default;
        }
        /**
         * This load phrasebook for current selected language.
         * 
         * @returns {phrasebook} - Phrasebook for current language.
         */
        async load_choosen_phrasebook() {
          return await this.#languages.select(this.current);
        }
        /**
         * This return loaded languages container.
         * 
         * @returns {languages} - Languages container.
         */
        get languages() {
          return this.#languages;
        }
        /**
         * This set new language for user. It also check that language exists 
         * in the language container. When not exists, throws error.
         * 
         * @throws {Error} - When language not exists in container.
         * 
         * @param {string} name - New language to select.
         * @returns {preferences} - This object to chain.
         */
        update(name) {
          DEBUG: if (!this.#languages.has(name)) {
            let error = 'Can not set language "' + name + '" ';
            error += "because not exists in languages container.";
            throw new Error(error);
          }
          this.#state = name;
          return this;
        }
      };
      exports.preferences = preferences;
    }
  });

  // source/core.js
  var require_core = __commonJS({
    "source/core.js"(exports, module) {
      if (typeof module !== "undefined" && module.exports) {
        module.exports.phrasebook = require_phrasebook().phrasebook;
        module.exports.loader = require_loader().loader;
        module.exports.languages = require_languages().languages;
        module.exports.loader = require_loader().loader;
        module.exports.preferences = require_preferences().preferences;
        module.exports.selector = require_selector().selector;
        module.exports.autotranslate = require_autotranslate().autotranslate;
      } else {
        window.cx_libtranslate = {
          phrasebook: require_phrasebook().phrasebook,
          loader: require_loader().loader,
          languages: require_languages().languages,
          translation: require_translation().translation,
          preferences: require_preferences().preferences,
          selector: require_selector().selector,
          autotranslate: require_autotranslate().autotranslate
        };
      }
    }
  });
  return require_core();
})();
//# sourceMappingURL=cx-libtranslate.debug.js.map