{"version":3,"sources":["jsdelivr-header.js","/npm/hyphenopoly@6.0.0/hyphenopoly.module.js"],"names":[],"mappings":"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","file":"/npm/hyphenopoly@6.0.0/hyphenopoly.module.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.39.0.\n * Original file: /npm/hyphenopoly@6.0.0/hyphenopoly.module.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","/**\n * @license Hyphenopoly.module.js 6.0.0 - hyphenation for node\n * ©2024  Mathias Nater, Güttingen (mathiasnater at gmail dot com)\n * https://github.com/mnater/Hyphenopoly\n *\n * Released under the MIT license\n * http://mnater.github.io/Hyphenopoly/LICENSE\n */\n\n/* eslint-env node */\n\nconst decode = (() => {\n    const utf16ledecoder = new TextDecoder(\"utf-16le\");\n    return (ui16) => {\n        return utf16ledecoder.decode(ui16);\n    };\n})();\n\n/**\n * Create Object without standard Object-prototype\n * @returns {Object} empty object\n */\nconst empty = () => {\n    return Object.create(null);\n};\n\nconst H = empty();\n\nH.supportedLanguages = [\n    \"af\",\n    \"as\",\n    \"be\",\n    \"bg\",\n    \"bn\",\n    \"ca\",\n    \"cs\",\n    \"cy\",\n    \"da\",\n    \"de\",\n    \"de-x-syllable\",\n    \"el-monoton\",\n    \"el-polyton\",\n    \"en-gb\",\n    \"en-us\",\n    \"eo\",\n    \"es\",\n    \"et\",\n    \"eu\",\n    \"fi\",\n    \"fo\",\n    \"fr\",\n    \"fur\",\n    \"ga\",\n    \"gl\",\n    \"gu\",\n    \"hi\",\n    \"hr\",\n    \"hsb\",\n    \"hu\",\n    \"hy\",\n    \"ia\",\n    \"id\",\n    \"is\",\n    \"it\",\n    \"ka\",\n    \"kmr\",\n    \"kn\",\n    \"la\",\n    \"lt\",\n    \"lv\",\n    \"mk\",\n    \"ml\",\n    \"mn-cyrl\",\n    \"mr\",\n    \"nb\",\n    \"nl\",\n    \"nn\",\n    \"no\",\n    \"oc\",\n    \"or\",\n    \"pa\",\n    \"pi\",\n    \"pl\",\n    \"pms\",\n    \"pt\",\n    \"rm\",\n    \"ro\",\n    \"ru\",\n    \"sh-cyrl\",\n    \"sh-latn\",\n    \"sk\",\n    \"sl\",\n    \"sq\",\n    \"sr-cyrl\",\n    \"sv\",\n    \"ta\",\n    \"te\",\n    \"th\",\n    \"tk\",\n    \"tr\",\n    \"uk\",\n    \"zh-latn-pinyin\"\n];\n\nH.languages = new Map();\n\n/**\n * Create lang Object\n * @param {string} lang The language\n * @returns {Object} The newly created lang object\n */\nfunction createLangObj(lang) {\n    if (!H.languages.has(lang)) {\n        H.languages.set(lang, empty());\n    }\n    return H.languages.get(lang);\n}\n\n/**\n * Setup a language object (lo) and dispatch \"engineReady\"\n * @param {string} lang The language\n * @param {function} hyphenateFunction The hyphenateFunction\n * @param {string} alphabet List of used characters\n * @param {number} patternLeftmin leftmin as defined in patterns\n * @param {number} patternRightmin rightmin as defined in patterns\n * @returns {undefined}\n */\nfunction prepareLanguagesObj(\n    lang,\n    hyphenateFunction,\n    alphabet,\n    patternLeftmin,\n    patternRightmin\n) {\n    alphabet = alphabet.replace(/\\\\*-/g, \"\\\\-\");\n    const lo = createLangObj(lang);\n    if (!lo.engineReady) {\n        lo.cache = new Map();\n        const exc = [];\n        if (H.c.exceptions.has(lang)) {\n            exc.push(...H.c.exceptions.get(lang).split(\", \"));\n        }\n        if (H.c.exceptions.has(\"global\")) {\n            exc.push(...H.c.exceptions.get(\"global\").split(\", \"));\n        }\n        lo.exceptions = new Map(exc.map((e) => {\n            return [e.replace(/-/g, \"\"), e];\n        }));\n\n        lo.alphabet = alphabet;\n        lo.reNotAlphabet = RegExp(`[^${alphabet}]`, \"i\");\n        lo.lm = Math.max(\n            patternLeftmin,\n            H.c.leftmin,\n            H.c.leftminPerLang.get(lang) || 0\n        );\n        lo.rm = Math.max(\n            patternRightmin,\n            H.c.rightmin,\n            H.c.rightminPerLang.get(lang) || 0\n        );\n        lo.hyphenate = hyphenateFunction;\n        lo.engineReady = true;\n    }\n    H.events.dispatch(\"engineReady\", {\"msg\": lang});\n}\n\n/**\n * Setup env for hyphenateFunction\n * @param {Object} baseData baseData\n * @param {function} hyphenateFunc hyphenateFunction\n * @returns {function} hyphenateFunction with closured environment\n */\nfunction encloseHyphenateFunction(buf, hyphenateFunc) {\n    const wordStore = new Uint16Array(buf, 0, 64);\n\n    /**\n     * The hyphenateFunction that encloses the env above\n     * Copies the word to wasm-Memory, calls wasm.hyphenateFunc and reads\n     * the hyphenated word from wasm-Memory (eventually replacing hyphenchar)\n     * @param {String} word - the word that has to be hyphenated\n     * @param {String} hyphenchar - the hyphenate character\n     * @param {Number} leftmin - min number of chars to remain on line\n     * @param {Number} rightmin - min number of chars to go to new line\n     * @returns {String} the hyphenated word\n     */\n    return ((word, hyphencc, leftmin, rightmin) => {\n        wordStore.set([\n            ...[...word].map((c) => {\n                return c.charCodeAt(0);\n            }),\n            0\n        ]);\n        const len = hyphenateFunc(leftmin, rightmin, hyphencc);\n        if (len > 0) {\n            word = decode(new Uint16Array(buf, 0, len));\n        }\n        return word;\n    });\n}\n\n/**\n * Instantiate Wasm Engine\n * @param {string} lang The language\n * @returns {undefined}\n */\nfunction instantiateWasmEngine(lang, wasmdata) {\n    /**\n     * Register character substitutions in the .wasm-hyphenEngine\n     * @param {number} alphalen - The length of the alphabet\n     * @param {object} exp - Export-object of the hyphenEngine\n     */\n    function registerSubstitutions(alphalen, exp) {\n        if (H.c.substitute.has(lang)) {\n            const subst = H.c.substitute.get(lang);\n            subst.forEach((substituer, substituted) => {\n                const substitutedU = substituted.toUpperCase();\n                const substitutedUcc = (substitutedU === substituted)\n                    ? 0\n                    : substitutedU.charCodeAt(0);\n                alphalen = exp.subst(\n                    substituted.charCodeAt(0),\n                    substitutedUcc,\n                    substituer.charCodeAt(0)\n                );\n            });\n        }\n        return alphalen;\n    }\n\n    /**\n     * Instantiate the hyphenEngine\n     * @param {object} res - The fetched ressource\n     */\n    function handleWasm(inst) {\n        const exp = inst.exports;\n        let alphalen = exp.lct.value;\n        alphalen = registerSubstitutions(alphalen, exp);\n        prepareLanguagesObj(\n            lang,\n            encloseHyphenateFunction(\n                exp.mem.buffer,\n                exp.hyphenate\n            ),\n            decode(new Uint16Array(exp.mem.buffer, 1664, alphalen)),\n            exp.lmi.value,\n            exp.rmi.value\n        );\n    }\n    if (H.c.sync) {\n        const heInstance = new WebAssembly.Instance(\n            new WebAssembly.Module(wasmdata)\n        );\n        handleWasm(heInstance);\n    } else {\n        WebAssembly.instantiate(wasmdata).then((res) => {\n            handleWasm(res.instance);\n        });\n    }\n}\n\n/**\n * Read a .wasm file and call instantiateWasmEngine on success\n * @param {string} lang - The language\n * @returns {undefined}\n */\nfunction loadHyphenEngine(lang) {\n    const file = `${lang}.wasm`;\n    // eslint-disable-next-line require-jsdoc\n    const cb = (err, data) => {\n        if (err) {\n            H.events.dispatch(\"error\", {\n                \"key\": lang,\n                \"msg\": `${lang}.wasm not found.`\n            });\n        } else {\n            instantiateWasmEngine(lang, new Uint8Array(data).buffer);\n        }\n    };\n\n    if (typeof H.c.loader !== \"function\") {\n        H.events.dispatch(\"error\", {\n            \"msg\": \"Loader must be a function.\"\n        });\n        return;\n    }\n\n    if (H.c.sync) {\n        cb(null, H.c.loaderSync(file, new URL('./patterns/', import.meta.url)));\n    } else {\n        H.c.loader(file, new URL('./patterns/', import.meta.url)).then(\n            (res) => {\n                cb(null, res);\n            },\n            (err) => {\n                cb(err, null);\n            }\n        );\n    }\n}\n\nconst wordHyphenatorPool = new Map();\n\n/**\n * Factory for hyphenatorFunctions for a specific language and class\n * @param {Object} lo Language-Object\n * @param {string} lang The language\n * @returns {function} The hyphenate function\n */\nfunction createWordHyphenator(lo, lang) {\n    if (wordHyphenatorPool.has(lang)) {\n        return wordHyphenatorPool.get(lang);\n    }\n\n    /**\n     * HyphenateFunction for non-compound words\n     * @param {string} word The word\n     * @returns {string} The hyphenated word\n     */\n    function hyphenateNormal(word) {\n        if (word.length > 61) {\n            H.events.dispatch(\"error\", {\"msg\": \"found word longer than 61 characters\"});\n        } else if (!lo.reNotAlphabet.test(word)) {\n            return lo.hyphenate(\n                word,\n                H.c.hyphen.charCodeAt(0),\n                lo.lm,\n                lo.rm\n            );\n        }\n        return word;\n    }\n\n    /**\n     * HyphenateFunction for compound words\n     * @param {string} word The word\n     * @returns {string} The hyphenated compound word\n     */\n    function hyphenateCompound(word) {\n        let joiner = \"-\";\n        const parts = word.split(joiner).map((p) => {\n            if (H.c.compound !== \"hyphen\" &&\n                p.length >= H.c.minWordLength) {\n                return createWordHyphenator(lo, lang)(p);\n            }\n            return p;\n        });\n        if (H.c.compound !== \"auto\") {\n            // Add Zero Width Space\n            joiner += \"\\u200B\";\n        }\n        return parts.join(joiner);\n    }\n\n    /**\n     * Checks if a string is mixed case\n     * @param {string} s The string\n     * @returns {boolean} true if s is mixed case\n     */\n    function isMixedCase(s) {\n        return Array.prototype.map.call(s, (c) => {\n            return (c === c.toLowerCase());\n        }).some((v, i, a) => {\n            return (v !== a[0]);\n        });\n    }\n\n    /**\n     * HyphenateFunction for words (compound or not)\n     * @param {string} word The word\n     * @returns {string} The hyphenated word\n     */\n    function hyphenator(word) {\n        let hw = lo.cache.get(word);\n        if (!hw) {\n            if (lo.exceptions.has(word)) {\n                hw = lo.exceptions.get(word).replace(\n                    /-/g,\n                    H.c.hyphen\n                );\n            } else if (!H.c.mixedCase && isMixedCase(word)) {\n                hw = word;\n            } else if (word.includes(\"-\")) {\n                hw = hyphenateCompound(word);\n            } else {\n                hw = hyphenateNormal(word);\n            }\n            lo.cache.set(word, hw);\n        }\n        return hw;\n    }\n    wordHyphenatorPool.set(lang, hyphenator);\n    return hyphenator;\n}\n\nconst orphanController = (() => {\n    /**\n     * Function template\n     * @param {string} ignore unused result of replace\n     * @param {string} leadingWhiteSpace The leading whiteSpace\n     * @param {string} lastWord The last word\n     * @param {string} trailingWhiteSpace The trailing whiteSpace\n     * @returns {string} Treated end of text\n     */\n    function controlOrphans(\n        ignore,\n        leadingWhiteSpace,\n        lastWord,\n        trailingWhiteSpace\n    ) {\n        let h = H.c.hyphen;\n        if (\".\\\\+*?[^]$(){}=!<>|:-\".indexOf(H.c.hyphen) !== -1) {\n            h = `\\\\${H.c.hyphen}`;\n        }\n        if (H.c.orphanControl === 3 && leadingWhiteSpace === \" \") {\n            // \\u00A0 = no-break space (nbsp)\n            leadingWhiteSpace = \"\\u00A0\";\n        }\n        /* eslint-disable security/detect-non-literal-regexp */\n        return leadingWhiteSpace + lastWord.replace(new RegExp(h, \"g\"), \"\") + trailingWhiteSpace;\n        /* eslint-enable security/detect-non-literal-regexp */\n    }\n    return controlOrphans;\n})();\n\n/**\n * Encloses hyphenateTextFunction\n * @param {string} lang - The language\n * @return {function} The hyphenateText-function\n */\nfunction createTextHyphenator(lang) {\n    const lo = H.languages.get(lang);\n    const wordHyphenator = (wordHyphenatorPool.has(lang))\n        ? wordHyphenatorPool.get(lang)\n        : createWordHyphenator(lo, lang);\n\n    /*\n     * Transpiled RegExp of\n     * /[${alphabet}\\p{Letter}-]{${minwordlength},}/gui\n     */\n    const reWord = RegExp(\n        `[${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-]{${H.c.minWordLength},}`, \"gui\"\n    );\n\n    /**\n     * Hyphenate text\n     * @param {string} text The text\n     * @param {string} lang The language of the text\n     * @returns {string} Hyphenated text\n     */\n    return ((text) => {\n        if (H.c.normalize) {\n            text = text.normalize(\"NFC\");\n        }\n        let tn = text.replace(reWord, wordHyphenator);\n        if (H.c.orphanControl !== 1) {\n            tn = tn.replace(\n                /(\\u0020*)(\\S+)(\\s*)$/,\n                orphanController\n            );\n        }\n        return tn;\n    });\n}\n\n(() => {\n    // Events known to the system\n    const definedEvents = new Map();\n\n    /**\n     * Create Event Object\n     * @param {string} name The Name of the event\n     * @param {function|null} defFunc The default method of the event\n     * @param {boolean} cancellable Is the default cancellable\n     * @returns {undefined}\n     */\n    function define(name, defFunc, cancellable) {\n        definedEvents.set(name, {\n            cancellable,\n            \"default\": defFunc,\n            \"register\": []\n        });\n    }\n\n    define(\n        \"error\",\n        (e) => {\n            // eslint-disable-next-line no-console\n            console.error(e.msg);\n        },\n        true\n    );\n\n    define(\n        \"engineReady\",\n        null,\n        false\n    );\n\n    /**\n     * Dispatch event <name> with arguments <data>\n     * @param {string} name The name of the event\n     * @param {Object|undefined} data Data of the event\n     * @returns {undefined}\n     */\n    function dispatch(name, data) {\n        data.defaultPrevented = false;\n        data.preventDefault = (() => {\n            data.defaultPrevented = true;\n        });\n        definedEvents.get(name).register.forEach((currentHandler) => {\n            currentHandler(data);\n        });\n        if (!data.defaultPrevented && definedEvents.get(name).default) {\n            definedEvents.get(name).default(data);\n        }\n    }\n\n    /**\n     * Add EventListender <handler> to event <name>\n     * @param {string} name The name of the event\n     * @param {function} handler Function to register\n     * @returns {undefined}\n     */\n    function addListener(name, handler) {\n        if (definedEvents.has(name)) {\n            definedEvents.get(name).register.push(handler);\n        } else {\n            H.events.dispatch(\n                \"error\",\n                {\"msg\": `unknown Event \"${name}\" discarded`}\n            );\n        }\n    }\n\n    H.events = empty();\n    H.events.dispatch = dispatch;\n    H.events.addListener = addListener;\n})();\n\n/**\n * Create a Map with a default Map behind the scenes. This mimics\n * kind of a prototype chain of an object, but without the object-\n * injection security risk.\n *\n * @param {Map} defaultsMap - A Map with default values\n * @returns {Proxy} - A Proxy for the Map (dot-notation or get/set)\n */\nfunction createMapWithDefaults(defaultsMap) {\n    const userMap = new Map();\n\n    /**\n     * The get-trap: get the value from userMap or else from defaults\n     * @param {Sring} key - The key to retrieve the value for\n     * @returns {*}\n     */\n    function get(key) {\n        return (userMap.has(key))\n            ? userMap.get(key)\n            : defaultsMap.get(key);\n    }\n\n    /**\n     * The set-trap: set the value to userMap and don't touch defaults\n     * @param {Sring} key - The key for the value\n     * @param {*} value - The value\n     * @returns {*}\n     */\n    function set(key, value) {\n        userMap.set(key, value);\n    }\n    return new Proxy(defaultsMap, {\n        \"get\": (_target, prop) => {\n            if (prop === \"set\") {\n                return set;\n            }\n            if (prop === \"get\") {\n                return get;\n            }\n            return get(prop);\n        }\n    });\n}\n\n/**\n * Default loader emits error\n * @returns null\n */\nfunction defaultLoader() {\n    H.events.dispatch(\"error\", {\n        \"msg\": \"loader/loaderSync has not been configured.\"\n    });\n    return null;\n}\n\nH.config = ((userConfig) => {\n    const settings = createMapWithDefaults(new Map([\n        [\"compound\", \"hyphen\"],\n        [\"exceptions\", new Map()],\n        [\"hyphen\", \"\\u00AD\"],\n        [\"leftmin\", 0],\n        [\"leftminPerLang\", new Map()],\n        [\"loader\", defaultLoader],\n        [\"loaderSync\", defaultLoader],\n        [\"minWordLength\", 6],\n        [\"mixedCase\", true],\n        [\"normalize\", false],\n        [\"orphanControl\", 1],\n        [\"require\", []],\n        [\"rightmin\", 0],\n        [\"rightminPerLang\", new Map()],\n        [\"substitute\", new Map()],\n        [\"sync\", false]\n    ]));\n    Object.entries(userConfig).forEach(([key, value]) => {\n        switch (key) {\n        case \"exceptions\":\n        case \"leftminPerLang\":\n        case \"paths\":\n        case \"rightminPerLang\":\n            Object.entries(value).forEach(([k, v]) => {\n                settings.get(key).set(k, v);\n            });\n            break;\n        case \"substitute\":\n            Object.entries(value).forEach(([lang, subst]) => {\n                settings.substitute.set(\n                    lang,\n                    new Map(Object.entries(subst))\n                );\n            });\n            break;\n        default:\n            settings.set(key, value);\n        }\n    });\n    H.c = settings;\n    if (H.c.handleEvent) {\n        Object.entries(H.c.handleEvent).forEach(([name, fn]) => {\n            H.events.addListener(name, fn);\n        });\n    }\n    const result = new Map();\n    if (H.c.require.length === 0) {\n        H.events.dispatch(\n            \"error\",\n            {\"msg\": \"No language has been required. Setup config according to documenation.\"}\n        );\n    }\n    H.c.require.forEach((lang) => {\n        if (H.c.sync) {\n            H.events.addListener(\"engineReady\", (e) => {\n                if (e.msg === lang) {\n                    result.set(lang, createTextHyphenator(lang));\n                }\n            });\n        } else {\n            const prom = new Promise((resolve, reject) => {\n                H.events.addListener(\"engineReady\", (e) => {\n                    if (e.msg === lang) {\n                        resolve(createTextHyphenator(lang));\n                    }\n                });\n                H.events.addListener(\"error\", (e) => {\n                    if (e.key === lang) {\n                        reject(e.msg);\n                    }\n                });\n            });\n            result.set(lang, prom);\n        }\n        loadHyphenEngine(lang);\n    });\n    return result;\n});\n\nexport default H;\n"]}