Tools for generating the Volumetric Regimes book https://volumetricregimes.xyz/ (wiki-to-print, using Paged.js)
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
935 lines
35 KiB
935 lines
35 KiB
3 years ago
|
/**
|
||
|
|
* @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);
|