8 changed files with 1473 additions and 109697 deletions
@ -0,0 +1,13 @@ |
|||||
|
./command-line/.etherpump/ |
||||
|
./command-line/Unfolded* |
||||
|
./command-line/images* |
||||
|
./command-line/venv* |
||||
|
./command-line/multi* |
||||
|
./snapshots/*.pdf |
||||
|
.etherpump/ |
||||
|
__pycache__/ |
||||
|
web-interface/.etherpump/ |
||||
|
web-interface/__pycache__/ |
||||
|
web-interface/static/Unfolded* |
||||
|
web-interface/static/images* |
||||
|
web-interface/venv* |
||||
@ -0,0 +1,934 @@ |
|||||
|
/** |
||||
|
* @license Hyphenopoly 4.12.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) { |
||||
|
// Find closest el with lang attr not empty
|
||||
|
el = el.closest("[lang]:not([lang=''])"); |
||||
|
if (el && el.lang) { |
||||
|
return el.lang.toLowerCase(); |
||||
|
} |
||||
|
if (parentLang) { |
||||
|
return parentLang; |
||||
|
} |
||||
|
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}]`, "i") |
||||
|
}); |
||||
|
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, |
||||
|
...[...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); |
||||
@ -0,0 +1,349 @@ |
|||||
|
/** |
||||
|
* @license Hyphenopoly_Loader 4.12.0 - client side hyphenation |
||||
|
* ©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, d, H, o) => { |
||||
|
"use strict"; |
||||
|
|
||||
|
/** |
||||
|
* Shortcut for new Map |
||||
|
* @param {any} init - initialiser for new Map |
||||
|
* @returns {Map} |
||||
|
*/ |
||||
|
const mp = (init) => { |
||||
|
return new Map(init); |
||||
|
}; |
||||
|
|
||||
|
/** |
||||
|
* Sets default properties for an Object |
||||
|
* @param {object} obj - The object to set defaults to |
||||
|
* @param {object} defaults - The defaults to set |
||||
|
* @returns {object} |
||||
|
*/ |
||||
|
const setDefaults = (obj, defaults) => { |
||||
|
if (obj) { |
||||
|
o.entries(defaults).forEach(([k, v]) => { |
||||
|
// eslint-disable-next-line security/detect-object-injection
|
||||
|
obj[k] = obj[k] || v; |
||||
|
}); |
||||
|
return obj; |
||||
|
} |
||||
|
return defaults; |
||||
|
}; |
||||
|
|
||||
|
const store = sessionStorage; |
||||
|
const scriptName = "Hyphenopoly_Loader.js"; |
||||
|
const lcRequire = mp(); |
||||
|
|
||||
|
const shortcuts = { |
||||
|
"ac": "appendChild", |
||||
|
"ce": "createElement", |
||||
|
"ct": "createTextNode" |
||||
|
}; |
||||
|
|
||||
|
/** |
||||
|
* Set H.cf (Hyphenopoly.clientFeatures) either by reading out previously |
||||
|
* computed settings from sessionStorage or creating a template object. |
||||
|
* This is in an iife to keep complexity low. |
||||
|
*/ |
||||
|
(() => { |
||||
|
if (H.cacheFeatureTests && store.getItem(scriptName)) { |
||||
|
H.cf = JSON.parse(store.getItem(scriptName)); |
||||
|
H.cf.langs = mp(H.cf.langs); |
||||
|
} else { |
||||
|
H.cf = { |
||||
|
"langs": mp(), |
||||
|
"pf": false |
||||
|
}; |
||||
|
} |
||||
|
})(); |
||||
|
|
||||
|
/** |
||||
|
* Set H.paths and some H.s (setup) fields to defaults or |
||||
|
* overwrite with user settings. |
||||
|
* These is an iife to keep complexity low. |
||||
|
*/ |
||||
|
(() => { |
||||
|
const thisScript = d.currentScript.src; |
||||
|
const maindir = thisScript.slice(0, (thisScript.lastIndexOf("/") + 1)); |
||||
|
const patterndir = maindir + "patterns/"; |
||||
|
H.paths = setDefaults(H.paths, { |
||||
|
maindir, |
||||
|
patterndir |
||||
|
}); |
||||
|
|
||||
|
H.s = setDefaults(H.setup, { |
||||
|
"CORScredentials": "include", |
||||
|
"hide": "all", |
||||
|
"selectors": {".hyphenate": {}}, |
||||
|
"timeout": 1000 |
||||
|
}); |
||||
|
// Change mode string to mode int
|
||||
|
H.s.hide = ["all", "element", "text"].indexOf(H.s.hide); |
||||
|
})(); |
||||
|
|
||||
|
/** |
||||
|
* Copy required languages to local lcRequire (lowercaseRequire) and |
||||
|
* eventually fallbacks to local lcFallbacks (lowercaseFallbacks). |
||||
|
* This is in an iife to keep complexity low. |
||||
|
*/ |
||||
|
(() => { |
||||
|
const fallbacks = mp(o.entries(H.fallbacks || {})); |
||||
|
o.entries(H.require).forEach(([lang, wo]) => { |
||||
|
lcRequire.set(lang.toLowerCase(), { |
||||
|
"fn": fallbacks.get(lang) || lang, |
||||
|
wo |
||||
|
}); |
||||
|
}); |
||||
|
})(); |
||||
|
|
||||
|
/** |
||||
|
* Create deferred Promise |
||||
|
* |
||||
|
* Kudos to http://lea.verou.me/2016/12/resolve-promises-externally-with-
|
||||
|
* this-one-weird-trick/ |
||||
|
* @return {promise} |
||||
|
*/ |
||||
|
const defProm = () => { |
||||
|
let res = null; |
||||
|
let rej = null; |
||||
|
const promise = new Promise((resolve, reject) => { |
||||
|
res = resolve; |
||||
|
rej = reject; |
||||
|
}); |
||||
|
promise.resolve = res; |
||||
|
promise.reject = rej; |
||||
|
|
||||
|
return promise; |
||||
|
}; |
||||
|
|
||||
|
let stylesNode = null; |
||||
|
|
||||
|
/** |
||||
|
* Define function H.hide. |
||||
|
* This function hides (state = 1) or unhides (state = 0) |
||||
|
* the whole document (mode == 0) or |
||||
|
* each selected element (mode == 1) or |
||||
|
* text of each selected element (mode == 2) or |
||||
|
* nothing (mode == -1) |
||||
|
* @param {integer} state - State |
||||
|
* @param {integer} mode - Mode |
||||
|
*/ |
||||
|
H.hide = (state, mode) => { |
||||
|
if (state === 0) { |
||||
|
if (stylesNode) { |
||||
|
stylesNode.remove(); |
||||
|
} |
||||
|
} else { |
||||
|
const vis = "{visibility:hidden!important}"; |
||||
|
stylesNode = d[shortcuts.ce]("style"); |
||||
|
let myStyle = ""; |
||||
|
if (mode === 0) { |
||||
|
myStyle = "html" + vis; |
||||
|
} else { |
||||
|
o.keys(H.s.selectors).forEach((sel) => { |
||||
|
if (mode === 1) { |
||||
|
myStyle += sel + vis; |
||||
|
} else { |
||||
|
myStyle += sel + "{color:transparent!important}"; |
||||
|
} |
||||
|
}); |
||||
|
} |
||||
|
stylesNode[shortcuts.ac](d[shortcuts.ct](myStyle)); |
||||
|
d.head[shortcuts.ac](stylesNode); |
||||
|
} |
||||
|
}; |
||||
|
|
||||
|
const tester = (() => { |
||||
|
let fakeBody = null; |
||||
|
return { |
||||
|
|
||||
|
/** |
||||
|
* Append fakeBody with tests to document |
||||
|
* @returns {Object|null} The body element or null, if no tests |
||||
|
*/ |
||||
|
"ap": () => { |
||||
|
if (fakeBody) { |
||||
|
d.documentElement[shortcuts.ac](fakeBody); |
||||
|
return fakeBody; |
||||
|
} |
||||
|
return null; |
||||
|
}, |
||||
|
|
||||
|
/** |
||||
|
* Remove fakeBody |
||||
|
* @returns {undefined} |
||||
|
*/ |
||||
|
"cl": () => { |
||||
|
if (fakeBody) { |
||||
|
fakeBody.remove(); |
||||
|
} |
||||
|
}, |
||||
|
|
||||
|
/** |
||||
|
* Create and append div with CSS-hyphenated word |
||||
|
* @param {string} lang Language |
||||
|
* @returns {undefined} |
||||
|
*/ |
||||
|
"cr": (lang) => { |
||||
|
if (H.cf.langs.has(lang)) { |
||||
|
return; |
||||
|
} |
||||
|
fakeBody = fakeBody || d[shortcuts.ce]("body"); |
||||
|
const testDiv = d[shortcuts.ce]("div"); |
||||
|
const ha = "hyphens:auto"; |
||||
|
testDiv.lang = lang; |
||||
|
testDiv.style.cssText = `visibility:hidden;-webkit-${ha};-ms-${ha};${ha};width:48px;font-size:12px;line-height:12px;border:none;padding:0;word-wrap:normal`; |
||||
|
testDiv[shortcuts.ac]( |
||||
|
d[shortcuts.ct](lcRequire.get(lang).wo.toLowerCase()) |
||||
|
); |
||||
|
fakeBody[shortcuts.ac](testDiv); |
||||
|
} |
||||
|
}; |
||||
|
})(); |
||||
|
|
||||
|
/** |
||||
|
* Checks if hyphens (ev.prefixed) is set to auto for the element. |
||||
|
* @param {Object} elm - the element |
||||
|
* @returns {Boolean} result of the check |
||||
|
*/ |
||||
|
const checkCSSHyphensSupport = (elmStyle) => { |
||||
|
const h = elmStyle.hyphens || |
||||
|
elmStyle.webkitHyphens || |
||||
|
elmStyle.msHyphens; |
||||
|
return (h === "auto"); |
||||
|
}; |
||||
|
|
||||
|
H.res = { |
||||
|
"he": mp() |
||||
|
}; |
||||
|
const fw = mp(); |
||||
|
|
||||
|
/** |
||||
|
* Load hyphenEngines |
||||
|
* |
||||
|
* Make sure each .wasm is loaded exactly once, even for fallbacks |
||||
|
* fw: fetched wasm (maps filename to language) |
||||
|
* he: hyphenEngines (maps lang to wasm and counter) |
||||
|
* c (counter) is needed in Hyphenopoly.js to decide |
||||
|
* if wasm needs to be cloned |
||||
|
* @param {string} lang The language |
||||
|
* @returns {undefined} |
||||
|
*/ |
||||
|
const loadhyphenEngine = (lang) => { |
||||
|
const filename = lcRequire.get(lang).fn + ".wasm"; |
||||
|
H.cf.pf = true; |
||||
|
H.cf.langs.set(lang, "H9Y"); |
||||
|
if (fw.has(filename)) { |
||||
|
const hyphenEngineWrapper = H.res.he.get(fw.get(filename)); |
||||
|
hyphenEngineWrapper.c = true; |
||||
|
H.res.he.set(lang, hyphenEngineWrapper); |
||||
|
} else { |
||||
|
H.res.he.set( |
||||
|
lang, |
||||
|
{ |
||||
|
"w": w.fetch(H.paths.patterndir + filename, {"credentials": H.s.CORScredentials}) |
||||
|
} |
||||
|
); |
||||
|
fw.set(filename, lang); |
||||
|
} |
||||
|
}; |
||||
|
lcRequire.forEach((value, lang) => { |
||||
|
if (value.wo === "FORCEHYPHENOPOLY" || H.cf.langs.get(lang) === "H9Y") { |
||||
|
loadhyphenEngine(lang); |
||||
|
} else { |
||||
|
tester.cr(lang); |
||||
|
} |
||||
|
}); |
||||
|
const testContainer = tester.ap(); |
||||
|
if (testContainer) { |
||||
|
testContainer.querySelectorAll("div").forEach((n) => { |
||||
|
if (checkCSSHyphensSupport(n.style) && n.offsetHeight > 12) { |
||||
|
H.cf.langs.set(n.lang, "CSS"); |
||||
|
} else { |
||||
|
loadhyphenEngine(n.lang); |
||||
|
} |
||||
|
}); |
||||
|
tester.cl(); |
||||
|
} |
||||
|
const he = H.handleEvent; |
||||
|
if (H.cf.pf) { |
||||
|
H.res.DOM = new Promise((res) => { |
||||
|
if (d.readyState === "loading") { |
||||
|
d.addEventListener( |
||||
|
"DOMContentLoaded", |
||||
|
res, |
||||
|
{ |
||||
|
"once": true, |
||||
|
"passive": true |
||||
|
} |
||||
|
); |
||||
|
} else { |
||||
|
res(); |
||||
|
} |
||||
|
}); |
||||
|
const hide = H.s.hide; |
||||
|
if (hide === 0) { |
||||
|
H.hide(1, 0); |
||||
|
} |
||||
|
if (hide !== -1) { |
||||
|
H.timeOutHandler = w.setTimeout(() => { |
||||
|
H.hide(0, null); |
||||
|
// eslint-disable-next-line no-console
|
||||
|
console.info(scriptName + " timed out."); |
||||
|
}, H.s.timeout); |
||||
|
} |
||||
|
H.res.DOM.then(() => { |
||||
|
if (hide > 0) { |
||||
|
H.hide(1, hide); |
||||
|
} |
||||
|
}); |
||||
|
// Load main script
|
||||
|
const script = d[shortcuts.ce]("script"); |
||||
|
script.src = H.paths.maindir + "Hyphenopoly.js"; |
||||
|
d.head[shortcuts.ac](script); |
||||
|
H.hy6ors = mp(); |
||||
|
H.cf.langs.forEach((langDef, lang) => { |
||||
|
if (langDef === "H9Y") { |
||||
|
H.hy6ors.set(lang, defProm()); |
||||
|
} |
||||
|
}); |
||||
|
H.hy6ors.set("HTML", defProm()); |
||||
|
H.hyphenators = new Proxy(H.hy6ors, { |
||||
|
"get": (target, key) => { |
||||
|
return target.get(key); |
||||
|
}, |
||||
|
"set": () => { |
||||
|
// Inhibit setting of hyphenators
|
||||
|
return true; |
||||
|
} |
||||
|
}); |
||||
|
(() => { |
||||
|
if (he && he.polyfill) { |
||||
|
he.polyfill(); |
||||
|
} |
||||
|
})(); |
||||
|
} else { |
||||
|
(() => { |
||||
|
if (he && he.tearDown) { |
||||
|
he.tearDown(); |
||||
|
} |
||||
|
w.Hyphenopoly = null; |
||||
|
})(); |
||||
|
} |
||||
|
(() => { |
||||
|
if (H.cacheFeatureTests) { |
||||
|
store.setItem(scriptName, JSON.stringify( |
||||
|
{ |
||||
|
"langs": [...H.cf.langs.entries()], |
||||
|
"pf": H.cf.pf |
||||
|
} |
||||
|
)); |
||||
|
} |
||||
|
})(); |
||||
|
})(window, document, Hyphenopoly, Object); |
||||
Binary file not shown.
File diff suppressed because one or more lines are too long
@ -0,0 +1,22 @@ |
|||||
|
class hyphenopoly extends Paged.Handler { |
||||
|
constructor(chunker, polisher, caller) { |
||||
|
super(chunker, polisher, caller); |
||||
|
} |
||||
|
beforeParsed(content) { |
||||
|
|
||||
|
// add lang fr to all sections
|
||||
|
content.querySelectorAll("section").forEach(section => { |
||||
|
section.setAttribute("lang", "en-us") |
||||
|
}) |
||||
|
|
||||
|
Object.keys(Hyphenopoly.setup.selectors).forEach(sel => { |
||||
|
content.querySelectorAll(sel).forEach(elem => { |
||||
|
Hyphenopoly.hyphenators["HTML"].then((hyn) => { |
||||
|
hyn(elem, sel); |
||||
|
}); |
||||
|
}); |
||||
|
}); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
Paged.registerHandlers(hyphenopoly); |
||||
Loading…
Reference in new issue