text: /**
   * @license Hyphenopoly 4.10.0 - client side hyphenation for webbrowsers
   * ©2021  Mathias Nater, Güttingen (mathiasnater at gmail dot com)
   * https://github.com/mnater/Hyphenopoly
   *
   * Released under the MIT license
   * http://mnater.github.io/Hyphenopoly/LICENSE
   */
  
  /* globals Hyphenopoly:readonly */
  ((w, o) => {
      "use strict";
      const SOFTHYPHEN = "\u00AD";
  
      /**
       * Event
       */
      const event = ((H) => {
          const knownEvents = new Map([
              ["afterElementHyphenation", []],
              ["beforeElementHyphenation", []],
              ["engineReady", []],
              [
                  "error", [
                      (e) => {
                          if (e.runDefault) {
                              w.console.warn(e);
                          }
                      }
                  ]
              ],
              ["hyphenopolyEnd", []],
              ["hyphenopolyStart", []]
          ]);
          if (H.handleEvent) {
              const userEvents = new Map(o.entries(H.handleEvent));
              knownEvents.forEach((eventFuncs, eventName) => {
                  if (userEvents.has(eventName)) {
                      eventFuncs.unshift(userEvents.get(eventName));
                  }
              });
          }
          return {
              "fire": ((eventName, eventData) => {
                  eventData.runDefault = true;
                  eventData.preventDefault = () => {
                      eventData.runDefault = false;
                  };
                  knownEvents.get(eventName).forEach((eventFn) => {
                      eventFn(eventData);
                  });
              })
          };
      })(Hyphenopoly);
  
      /**
       * Register copy event on element
       * @param {Object} el The element
       * @returns {undefined}
       */
      function registerOnCopy(el) {
          el.addEventListener(
              "copy",
              (e) => {
                  e.preventDefault();
                  const sel = w.getSelection();
                  const div = document.createElement("div");
                  div.appendChild(sel.getRangeAt(0).cloneContents());
                  e.clipboardData.setData("text/plain", sel.toString().replace(RegExp(SOFTHYPHEN, "g"), ""));
                  e.clipboardData.setData("text/html", div.innerHTML.replace(RegExp(SOFTHYPHEN, "g"), ""));
              },
              true
          );
      }
  
      /**
       * Convert settings from H.setup-Object to Map
       * This is a IIFE to keep complexity low.
       */
      ((H) => {
          /**
           * Create a Map with a default Map behind the scenes. This mimics
           * kind of a prototype chain of an object, but without the object-
           * injection security risk.
           *
           * @param {Map} defaultsMap - A Map with default values
           * @returns {Proxy} - A Proxy for the Map (dot-notation or get/set)
           */
          function createMapWithDefaults(defaultsMap) {
              const userMap = new Map();
  
              /**
               * The get-trap: get the value from userMap or else from defaults
               * @param {Sring} key - The key to retrieve the value for
               * @returns {*}
               */
              function get(key) {
                  return (userMap.has(key))
                      ? userMap.get(key)
                      : defaultsMap.get(key);
              }
  
              /**
               * The set-trap: set the value to userMap and don't touch defaults
               * @param {Sring} key - The key for the value
               * @param {*} value - The value
               * @returns {*}
               */
              function set(key, value) {
                  userMap.set(key, value);
              }
              return new Proxy(defaultsMap, {
                  "get": (_target, prop) => {
                      if (prop === "set") {
                          return set;
                      }
                      if (prop === "get") {
                          return get;
                      }
                      return get(prop);
                  },
                  "ownKeys": () => {
                      return [
                          ...new Set(
                              [...defaultsMap.keys(), ...userMap.keys()]
                          )
                      ];
                  }
              });
          }
  
          const settings = createMapWithDefaults(new Map([
              ["defaultLanguage", "en-us"],
              [
                  "dontHyphenate", (() => {
                      const list = "abbr,acronym,audio,br,button,code,img,input,kbd,label,math,option,pre,samp,script,style,sub,sup,svg,textarea,var,video";
                      return createMapWithDefaults(
                          new Map(list.split(",").map((val) => {
                              return [val, true];
                          }))
                      );
                  })()
              ],
              ["dontHyphenateClass", "donthyphenate"],
              ["exceptions", new Map()],
              ["keepAlive", true],
              ["normalize", false],
              ["processShadows", false],
              ["safeCopy", true],
              ["substitute", new Map()],
              ["timeout", 1000]
          ]));
          o.entries(H.s).forEach(([key, value]) => {
              switch (key) {
              case "selectors":
                  // Set settings.selectors to array of selectors
                  settings.set("selectors", o.keys(value));
  
                  /*
                   * For each selector add a property to settings with
                   * selector specific settings
                   */
                  o.entries(value).forEach(([sel, selSettings]) => {
                      const selectorSettings = createMapWithDefaults(new Map([
                          ["compound", "hyphen"],
                          ["hyphen", SOFTHYPHEN],
                          ["leftmin", 0],
                          ["leftminPerLang", 0],
                          ["minWordLength", 6],
                          ["mixedCase", true],
                          ["orphanControl", 1],
                          ["rightmin", 0],
                          ["rightminPerLang", 0]
                      ]));
                      o.entries(selSettings).forEach(
                          ([selSetting, setVal]) => {
                              if (typeof setVal === "object") {
                                  selectorSettings.set(
                                      selSetting,
                                      new Map(o.entries(setVal))
                                  );
                              } else {
                                  selectorSettings.set(selSetting, setVal);
                              }
                          }
                      );
                      settings.set(sel, selectorSettings);
                  });
                  break;
              case "dontHyphenate":
              case "exceptions":
                  o.entries(value).forEach(([k, v]) => {
                      settings.get(key).set(k, v);
                  });
                  break;
              case "substitute":
                  o.entries(value).forEach(([lang, subst]) => {
                      settings.substitute.set(
                          lang,
                          new Map(o.entries(subst))
                      );
                  });
                  break;
              default:
                  settings.set(key, value);
              }
          });
          H.c = settings;
      })(Hyphenopoly);
  
      ((H) => {
          const C = H.c;
          let mainLanguage = null;
  
          event.fire(
              "hyphenopolyStart",
              {
                  "msg": "hyphenopolyStart"
              }
          );
  
          /**
           * Factory for elements
           * @returns {Object} elements-object
           */
          function makeElementCollection() {
              const list = new Map();
  
              /*
               * Counter counts the elements to be hyphenated.
               * Needs to be an object (Pass by reference)
               */
              const counter = [0];
  
              /**
               * Add element to elements
               * @param {object} el The element
               * @param {string} lang The language of the element
               * @param {string} sel The selector of the element
               * @returns {Object} An element-object
               */
              function add(el, lang, sel) {
                  const elo = {
                      "element": el,
                      "selector": sel
                  };
                  if (!list.has(lang)) {
                      list.set(lang, []);
                  }
                  list.get(lang).push(elo);
                  counter[0] += 1;
                  return elo;
              }
  
              /**
               * Removes elements from the list and updates the counter
               * @param {string} lang - The lang of the elements to remove
               */
              function rem(lang) {
                  let langCount = 0;
                  if (list.has(lang)) {
                      langCount = list.get(lang).length;
                      list.delete(lang);
                      counter[0] -= langCount;
                      if (counter[0] === 0) {
                          event.fire(
                              "hyphenopolyEnd",
                              {
                                  "msg": "hyphenopolyEnd"
                              }
                          );
                          if (!C.keepAlive) {
                              window.Hyphenopoly = null;
                          }
                      }
                  }
              }
  
              return {
                  add,
                  counter,
                  list,
                  rem
              };
          }
  
          /**
           * Get language of element by searching its parents or fallback
           * @param {Object} el The element
           * @param {string} parentLang Lang of parent if available
           * @param {boolean} fallback Will falback to mainlanguage
           * @returns {string|null} The language or null
           */
          function getLang(el, parentLang = "", fallback = true) {
              while (el) {
                  // Make sure lang is set and not empty string
                  if (el.getAttribute("lang")) {
                      return el.getAttribute("lang").toLowerCase();
                  }
                  if (parentLang) {
                      return parentLang;
                  }
                  el = el.parentElement;
              }
              return (fallback)
                  ? mainLanguage
                  : null;
          }
  
          /**
           * Collect elements that have a selector defined in C.selectors
           * and add them to elements.
           * @param {Object} [parent = null] The start point element
           * @param {string} [selector = null] The selector matching the parent
           * @returns {Object} elements-object
           */
          function collectElements(parent = null, selector = null) {
              const elements = makeElementCollection();
  
              const dontHyphenateSelector = (() => {
                  let s = "." + C.dontHyphenateClass;
                  o.getOwnPropertyNames(C.dontHyphenate).forEach((tag) => {
                      if (C.dontHyphenate.get(tag)) {
                          s += "," + tag;
                      }
                  });
                  return s;
              })();
              const matchingSelectors = C.selectors.join(",") + "," + dontHyphenateSelector;
  
              /**
               * Recursively walk all elements in el, lending lang and selName
               * add them to elements if necessary.
               * @param {Object} el The element to scan
               * @param {string} pLang The language of the parent element
               * @param {string} sel The selector of the parent element
               * @param {boolean} isChild If el is a child element
               * @returns {undefined}
               */
              function processElements(el, pLang, sel, isChild = false) {
                  const eLang = getLang(el, pLang);
                  const langDef = H.cf.langs.get(eLang);
                  if (langDef === "H9Y") {
                      elements.add(el, eLang, sel);
                      if (!isChild && C.safeCopy) {
                          registerOnCopy(el);
                      }
                  } else if (!langDef && eLang !== "zxx") {
                      event.fire(
                          "error",
                          Error(`Element with '${eLang}' found, but '${eLang}.wasm' not loaded. Check language tags!`)
                      );
                  }
                  el.childNodes.forEach((n) => {
                      if (n.nodeType === 1 && !n.matches(matchingSelectors)) {
                          processElements(n, eLang, sel, true);
                      }
                  });
              }
  
              /**
               * Searches the DOM for each sel
               * @param {object} root The DOM root
               * @returns {undefined}
               */
              function getElems(root) {
                  C.selectors.forEach((sel) => {
                      root.querySelectorAll(sel).forEach((n) => {
                          processElements(n, getLang(n), sel, false);
                      });
                  });
              }
  
              if (parent === null) {
                  if (C.processShadows) {
                      w.document.querySelectorAll("*").forEach((m) => {
                          if (m.shadowRoot) {
                              getElems(m.shadowRoot);
                          }
                      });
                  }
                  getElems(w.document);
              } else {
                  processElements(parent, getLang(parent), selector);
              }
              return elements;
          }
  
          const wordHyphenatorPool = new Map();
  
          /**
           * Factory for hyphenatorFunctions for a specific language and selector
           * @param {Object} lo Language-Object
           * @param {string} lang The language
           * @param {string} sel The selector
           * @returns {function} The hyphenate function
           */
          function createWordHyphenator(lo, lang, sel) {
              const poolKey = lang + "-" + sel;
              if (wordHyphenatorPool.has(poolKey)) {
                  return wordHyphenatorPool.get(poolKey);
              }
  
              const selSettings = C.get(sel);
              lo.cache.set(sel, new Map());
  
              /**
               * HyphenateFunction for non-compound words
               * @param {string} word The word
               * @returns {string} The hyphenated word
               */
              function hyphenateNormal(word) {
                  if (word.length > 61) {
                      event.fire(
                          "error",
                          Error("Found word longer than 61 characters")
                      );
                  } else if (!lo.reNotAlphabet.test(word)) {
                      return lo.hyphenate(
                          word,
                          selSettings.hyphen.charCodeAt(0),
                          selSettings.leftminPerLang.get(lang),
                          selSettings.rightminPerLang.get(lang)
                      );
                  }
                  return word;
              }
  
              /**
               * HyphenateFunction for compound words
               * @param {string} word The word
               * @returns {string} The hyphenated compound word
               */
              function hyphenateCompound(word) {
                  const zeroWidthSpace = "\u200B";
                  let parts = null;
                  let wordHyphenator = null;
                  if (selSettings.compound === "auto" ||
                      selSettings.compound === "all") {
                      wordHyphenator = createWordHyphenator(lo, lang, sel);
                      parts = word.split("-").map((p) => {
                          if (p.length >= selSettings.minWordLength) {
                              return wordHyphenator(p);
                          }
                          return p;
                      });
                      if (selSettings.compound === "auto") {
                          word = parts.join("-");
                      } else {
                          word = parts.join("-" + zeroWidthSpace);
                      }
                  } else {
                      word = word.replace("-", "-" + zeroWidthSpace);
                  }
                  return word;
              }
  
              /**
               * Checks if a string is mixed case
               * @param {string} s The string
               * @returns {boolean} true if s is mixed case
               */
              function isMixedCase(s) {
                  return [...s].map((c) => {
                      return (c === c.toLowerCase());
                  }).some((v, i, a) => {
                      return (v !== a[0]);
                  });
              }
  
              /**
               * HyphenateFunction for words (compound or not)
               * @param {string} word The word
               * @returns {string} The hyphenated word
               */
              function hyphenator(word) {
                  let hw = lo.cache.get(sel).get(word);
                  if (!hw) {
                      if (lo.exc.has(word)) {
                          hw = lo.exc.get(word).replace(
                              /-/g,
                              selSettings.hyphen
                          );
                      } else if (!selSettings.mixedCase && isMixedCase(word)) {
                          hw = word;
                      } else if (word.indexOf("-") === -1) {
                          hw = hyphenateNormal(word);
                      } else {
                          hw = hyphenateCompound(word);
                      }
                      lo.cache.get(sel).set(word, hw);
                  }
                  return hw;
              }
              wordHyphenatorPool.set(poolKey, hyphenator);
              return hyphenator;
          }
  
          const orphanControllerPool = new Map();
  
          /**
           * Factory for function that handles orphans
           * @param {string} sel The selector
           * @returns {function} The function created
           */
          function createOrphanController(sel) {
              if (orphanControllerPool.has(sel)) {
                  return orphanControllerPool.get(sel);
              }
              const selSettings = C.get(sel);
  
              /**
               * Function template
               * @param {string} ignore unused result of replace
               * @param {string} leadingWhiteSpace The leading whiteSpace
               * @param {string} lastWord The last word
               * @param {string} trailingWhiteSpace The trailing whiteSpace
               * @returns {string} Treated end of text
               */
              function controlOrphans(
                  ignore,
                  leadingWhiteSpace,
                  lastWord,
                  trailingWhiteSpace
              ) {
                  if (selSettings.orphanControl === 3 && leadingWhiteSpace === " ") {
                      // \u00A0 = no-break space (nbsp)
                      leadingWhiteSpace = "\u00A0";
                  }
                  return leadingWhiteSpace + lastWord.replace(RegExp(selSettings.hyphen, "g"), "") + trailingWhiteSpace;
              }
              orphanControllerPool.set(sel, controlOrphans);
              return controlOrphans;
          }
  
          /**
           * Hyphenate an entitiy (text string or Element-Object)
           * @param {string} lang - the language of the string
           * @param {string} sel - the selectorName of settings
           * @param {string} entity - the entity to be hyphenated
           * @returns {string | null} hyphenated str according to setting of sel
           */
          function hyphenate(lang, sel, entity) {
              const lo = H.languages.get(lang);
              const selSettings = C.get(sel);
              const minWordLength = selSettings.minWordLength;
  
              /*
               * Transpiled RegExp of
               * /[${alphabet}\p{Mn}Subset\p{Letter}\00AD-]{${minwordlength},}/gui
               */
              const reWord = RegExp(
                  `[${lo.alphabet}a-z\u0300-\u036F\u0483-\u0487\u00DF-\u00F6\u00F8-\u00FE\u0101\u0103\u0105\u0107\u0109\u010D\u010F\u0111\u0113\u0117\u0119\u011B\u011D\u011F\u0123\u0125\u012B\u012F\u0131\u0135\u0137\u013C\u013E\u0142\u0144\u0146\u0148\u014D\u0151\u0153\u0155\u0159\u015B\u015D\u015F\u0161\u0165\u016B\u016D\u016F\u0171\u0173\u017A\u017C\u017E\u017F\u01CE\u01D0\u01D2\u01D4\u01D6\u01D8\u01DA\u01DC\u0219\u021B\u02BC\u0390\u03AC-\u03CE\u03D0\u03E3\u03E5\u03E7\u03E9\u03EB\u03ED\u03EF\u03F2\u0430-\u044F\u0451-\u045C\u045E\u045F\u0491\u04AF\u04E9\u0561-\u0585\u0587\u0905-\u090C\u090F\u0910\u0913-\u0928\u092A-\u0930\u0932\u0933\u0935-\u0939\u093D\u0960\u0961\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A85-\u0A8B\u0A8F\u0A90\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AE0\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B60\u0B61\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB5\u0BB7-\u0BB9\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C33\u0C35-\u0C39\u0C60\u0C61\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D28\u0D2A-\u0D39\u0D60\u0D61\u0D7A-\u0D7F\u0E01-\u0E2E\u0E30\u0E32\u0E33\u0E40-\u0E45\u10D0-\u10F0\u1200-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u1E0D\u1E37\u1E41\u1E43\u1E45\u1E47\u1E6D\u1F00-\u1F07\u1F10-\u1F15\u1F20-\u1F27\u1F30-\u1F37\u1F40-\u1F45\u1F50-\u1F57\u1F60-\u1F67\u1F70-\u1F7D\u1F80-\u1F87\u1F90-\u1F97\u1FA0-\u1FA7\u1FB2-\u1FB4\u1FB6\u1FB7\u1FC2-\u1FC4\u1FC6\u1FC7\u1FD2\u1FD3\u1FD6\u1FD7\u1FE2-\u1FE7\u1FF2-\u1FF4\u1FF6\u1FF7\u2C81\u2C83\u2C85\u2C87\u2C89\u2C8D\u2C8F\u2C91\u2C93\u2C95\u2C97\u2C99\u2C9B\u2C9D\u2C9F\u2CA1\u2CA3\u2CA5\u2CA7\u2CA9\u2CAB\u2CAD\u2CAF\u2CB1\u2CC9\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\u00AD\u200B-\u200D-]{${minWordLength},}`, "gui"
              );
  
              /**
               * Hyphenate text according to setting in sel
               * @param {string} text - the strint to be hyphenated
               * @returns {string} hyphenated string according to setting of sel
               */
              function hyphenateText(text) {
                  if (C.normalize) {
                      text = text.normalize("NFC");
                  }
                  let tn = text.replace(
                      reWord,
                      createWordHyphenator(lo, lang, sel)
                  );
                  if (selSettings.orphanControl !== 1) {
                      tn = tn.replace(
                          /(\u0020*)(\S+)(\s*)$/,
                          createOrphanController(sel)
                      );
                  }
                  return tn;
              }
  
              /**
               * Hyphenate element according to setting in sel
               * @param {object} el - the HTMLElement to be hyphenated
               * @returns {undefined}
               */
              function hyphenateElement(el) {
                  event.fire(
                      "beforeElementHyphenation",
                      {
                          el,
                          lang
                      }
                  );
                  el.childNodes.forEach((n) => {
                      if (
                          n.nodeType === 3 &&
                          (/\S/).test(n.data) &&
                          n.data.length >= minWordLength
                      ) {
                          n.data = hyphenateText(n.data);
                      }
                  });
                  H.res.els.counter[0] -= 1;
                  event.fire(
                      "afterElementHyphenation",
                      {
                          el,
                          lang
                      }
                  );
              }
              let r = null;
              if (typeof entity === "string") {
                  r = hyphenateText(entity);
              } else if (entity instanceof HTMLElement) {
                  hyphenateElement(entity);
              }
              return r;
          }
  
          /**
           * Creates a language-specific string hyphenator
           * @param {String} lang - The language this hyphenator hyphenates
           */
          function createStringHyphenator(lang) {
              return ((entity, sel = ".hyphenate") => {
                  if (typeof entity !== "string") {
                      event.fire(
                          "error",
                          Error("This use of hyphenators is deprecated. See https://mnater.github.io/Hyphenopoly/Hyphenators.html")
                      );
                  }
                  return hyphenate(lang, sel, entity);
              });
          }
  
          /**
           * Creates a polyglot HTML hyphenator
           */
          function createDOMHyphenator() {
              return ((entity, sel = ".hyphenate") => {
                  collectElements(entity, sel).list.forEach((els, l) => {
                      els.forEach((elo) => {
                          hyphenate(l, elo.selector, elo.element);
                      });
                  });
                  return null;
              });
          }
  
          H.unhyphenate = () => {
              H.res.els.list.forEach((els) => {
                  els.forEach((elo) => {
                      const n = elo.element.firstChild;
                      n.data = n.data.replace(RegExp(C[elo.selector].hyphen, "g"), "");
                  });
              });
              return Promise.resolve(H.res.els);
          };
  
          /**
           * Hyphenate all elements with a given language
           * @param {string} lang The language
           * @param {Array} elArr Array of elements
           * @returns {undefined}
           */
          function hyphenateLangElements(lang, elements) {
              const elArr = elements.list.get(lang);
              if (elArr) {
                  elArr.forEach((elo) => {
                      hyphenate(lang, elo.selector, elo.element);
                  });
              } else {
                  event.fire(
                      "error",
                      Error(`Engine for language '${lang}' loaded, but no elements found.`)
                  );
              }
              if (elements.counter[0] === 0) {
                  w.clearTimeout(H.timeOutHandler);
                  if (C.hide !== -1) {
                      H.hide(0, null);
                  }
                  event.fire(
                      "hyphenopolyEnd",
                      {
                          "msg": "hyphenopolyEnd"
                      }
                  );
                  if (!C.keepAlive) {
                      window.Hyphenopoly = null;
                  }
              }
          }
  
          /**
           * Convert the exceptions from user input to Map
           * @param {string} lang – The language for which the Map is created
           * @return {Map}
           */
          function createExceptionMap(lang) {
              let exc = "";
              if (C.exceptions.has(lang)) {
                  exc = C.exceptions.get(lang);
              }
              if (C.exceptions.has("global")) {
                  if (exc === "") {
                      exc = C.exceptions.get("global");
                  } else {
                      exc += ", " + C.exceptions.get("global");
                  }
              }
              if (exc === "") {
                  return new Map();
              }
              return new Map(exc.split(", ").map((e) => {
                  return [e.replace(/-/g, ""), e];
              }));
          }
  
          /**
           * Setup lo
           * @param {string} lang The language
           * @param {function} hyphenateFunction The hyphenateFunction
           * @param {string} alphabet List of used characters
           * @param {number} leftmin leftmin
           * @param {number} rightmin rightmin
           * @returns {undefined}
           */
          function prepareLanguagesObj(
              lang,
              hyphenateFunction,
              alphabet,
              patternLeftmin,
              patternRightmin
          ) {
              C.selectors.forEach((sel) => {
                  const selSettings = C.get(sel);
                  if (selSettings.leftminPerLang === 0) {
                      selSettings.set("leftminPerLang", new Map());
                  }
                  if (selSettings.rightminPerLang === 0) {
                      selSettings.set("rightminPerLang", new Map());
                  }
                  selSettings.leftminPerLang.set(lang, Math.max(
                      patternLeftmin,
                      selSettings.leftmin,
                      Number(selSettings.leftminPerLang.get(lang)) || 0
                  ));
  
                  selSettings.rightminPerLang.set(lang, Math.max(
                      patternRightmin,
                      selSettings.rightmin,
                      Number(selSettings.rightminPerLang.get(lang)) || 0
                  ));
              });
              if (!H.languages) {
                  H.languages = new Map();
              }
              alphabet = alphabet.replace(/\\*-/g, "\\-");
              H.languages.set(lang, {
                  alphabet,
                  "cache": new Map(),
                  "exc": createExceptionMap(lang),
                  "hyphenate": hyphenateFunction,
                  "ready": true,
                  "reNotAlphabet": RegExp(`[^${alphabet}]`, "gi")
              });
              H.hy6ors.get(lang).resolve(createStringHyphenator(lang));
              event.fire(
                  "engineReady",
                  {
                      lang
                  }
              );
              if (H.res.els) {
                  hyphenateLangElements(lang, H.res.els);
              }
          }
  
          const decode = (() => {
              if (w.TextDecoder) {
                  const utf16ledecoder = new TextDecoder("utf-16le");
                  return ((ui16) => {
                      return utf16ledecoder.decode(ui16);
                  });
              }
              return ((ui16) => {
                  return String.fromCharCode.apply(null, ui16);
              });
          })();
  
          /**
           * Setup env for hyphenateFunction
           * @param {Object} baseData baseData
           * @param {function} hyphenateFunc hyphenateFunction
           * @returns {function} hyphenateFunction with closured environment
           */
          function encloseHyphenateFunction(baseData, hyphenateFunc) {
              const wordStore = new Uint16Array(baseData.buf, baseData.wo, 64);
              return ((word, hyphencc, leftmin, rightmin) => {
                  wordStore.set([95].concat(
                      [...word].map((c) => {
                          return c.charCodeAt(0);
                      }), 95, 0
                  ));
                  const len = hyphenateFunc(leftmin, rightmin, hyphencc);
                  if (len > 0) {
                      word = decode(
                          new Uint16Array(baseData.buf, baseData.hw, len)
                      );
                  }
                  return word;
              });
          }
  
          /**
           * Instantiate Wasm Engine
           * @param {string} lang The language
           * @returns {undefined}
           */
          function instantiateWasmEngine(heProm, lang) {
              const wa = window.WebAssembly;
  
              /**
               * Register character substitutions in the .wasm-hyphenEngine
               * @param {number} alphalen - The length of the alphabet
               * @param {object} exp - Export-object of the hyphenEngine
               */
              function registerSubstitutions(alphalen, exp) {
                  if (C.substitute.has(lang)) {
                      const subst = C.substitute.get(lang);
                      subst.forEach((substituer, substituted) => {
                          const substitutedU = substituted.toUpperCase();
                          const substitutedUcc = (substitutedU === substituted)
                              ? 0
                              : substitutedU.charCodeAt(0);
                          alphalen = exp.subst(
                              substituted.charCodeAt(0),
                              substitutedUcc,
                              substituer.charCodeAt(0)
                          );
                      });
                  }
                  return alphalen;
              }
  
              /**
               * Instantiate the hyphenEngine
               * @param {object} res - The fetched ressource
               */
              function handleWasm(res) {
                  const exp = res.instance.exports;
                  let alphalen = exp.conv();
                  alphalen = registerSubstitutions(alphalen, exp);
                  const baseData = {
                      /* eslint-disable multiline-ternary */
                      "buf": exp.mem.buffer,
                      "hw": (wa.Global) ? exp.hwo.value : exp.hwo,
                      "lm": (wa.Global) ? exp.lmi.value : exp.lmi,
                      "rm": (wa.Global) ? exp.rmi.value : exp.rmi,
                      "wo": (wa.Global) ? exp.uwo.value : exp.uwo
                      /* eslint-enable multiline-ternary */
                  };
                  prepareLanguagesObj(
                      lang,
                      encloseHyphenateFunction(
                          baseData,
                          exp.hyphenate
                      ),
                      decode(new Uint16Array(exp.mem.buffer, 1026, alphalen - 1)),
                      baseData.lm,
                      baseData.rm
                  );
              }
              heProm.w.then((response) => {
                  if (response.ok) {
                      let r2 = response;
                      if (heProm.c) {
                          r2 = response.clone();
                      }
                      if (
                          wa.instantiateStreaming &&
                          (response.headers.get("Content-Type") === "application/wasm")
                      ) {
                          return wa.instantiateStreaming(r2);
                      }
                      return r2.arrayBuffer().then((ab) => {
                          return wa.instantiate(ab);
                      });
                  }
                  return Promise.reject(Error(`File ${lang}.wasm can't be loaded from ${H.paths.patterndir}`));
              }).then(handleWasm, (e) => {
                  event.fire("error", e);
                  H.res.els.rem(lang);
              });
          }
  
          H.res.DOM.then(() => {
              mainLanguage = getLang(w.document.documentElement, "", false);
              if (!mainLanguage && C.defaultLanguage !== "") {
                  mainLanguage = C.defaultLanguage;
              }
              const elements = collectElements();
              H.res.els = elements;
              elements.list.forEach((ignore, lang) => {
                  if (H.languages &&
                      H.languages.has(lang) &&
                      H.languages.get(lang).ready
                  ) {
                      hyphenateLangElements(lang, elements);
                  }
              });
          });
  
          H.res.he.forEach((heProm, lang) => {
              instantiateWasmEngine(heProm, lang);
          });
  
          Promise.all(
              // Make sure all lang specific hyphenators and DOM are ready
              [...H.hy6ors.entries()].
                  reduce((accumulator, value) => {
                      if (value[0] !== "HTML") {
                          return accumulator.concat(value[1]);
                      }
                      return accumulator;
                  }, []).
                  concat(H.res.DOM)
          ).then(() => {
              H.hy6ors.get("HTML").resolve(createDOMHyphenator());
          }, (e) => {
              event.fire("error", e);
          });
      })(Hyphenopoly);
  })(window, Object);
  