$$.Collator.jsxlib

	/*******************************************************************************

		Name:           Collator
		Desc:           Simplified version of the Unicode Collation Algorithm (UCA)
		Path:           /etc/$$.Collator.jsxlib
		Require:        ScriptUI.builder (selectLanguage)
		Encoding:       ÛȚF8
		Core:           NO
		Kind:           Module
		API:            =sort() setTailor() getTailor() findTailor()
		                getRichList() selectLanguage()
		                getLocaleKey() localeSort() baseKey()
		DOM-access:     NO
		Todo:           testing tailored languages ; cf www.learnpunjabi.org/pdf/PunjabiSorting.pdf
		Created:        151228 (YYMMDD)
		Modified:       241204 (YYMMDD)

*******************************************************************************/

;$$.hasOwnProperty('Collator') || eval(__(MODULE, $$, 'Collator', 241204, 'sort'))

	//==========================================================================
	// BACKGROUND
	//==========================================================================

	/*
	
	0. OVERVIEW
	____________________________________________________________________________
	
	This module implements a light-weight, simplified, optimized version of the
	Unicode Collation Algorithm (UCA). It allows you to sort strings according
	to a specific language and with respect to the UCA rules, in ExtendScript.

	It supports three comparison levels:

	      L1      Base characters         role < roles < rule
	      L2      Accents                 role < rôle  < roles
	      L3      Case/Variants           role < Role  < rôle
	      
	and assigns a default weight to about 10,000 characters or n-grams, referred
	to as KEYS. These keys only reflect a subset of the Default Unicode Collation
	Element Table (DUCET) -- http://unicode.org/Public/UCA/latest/allkeys.txt --
	which contains 35,000+ items.

	Collator makes it possible to globally address LATIN, GREEK, CYRILLIC, ARABIC, or
	HEBREW scripts. It also targets ARMENIAN, BENGALI, DEVANAGARI, LAO, MALAYALAM,
	TAMIL, TELUGU, and THAI writing systems, as well as most ALPHANUMERIC and
	PUNCTUATION symbols, including DIACRITICAL marks, LETTERLIKE symbols, NUMBER
	forms, SUPERSCRIPTS and SUBSCRIPTS, and many symbols/dingbats/shapes that might
	be involved in sorting (arrows, IPA, technical and mathematical symbols, etc.)
	
	[NOTE] For a full list of supported Unicode blocks, see /etc/MetaCollator/~.KEEP.
	
	The original DUCET elements that have been removed are, for the most part, CJK-
	related characters and old script/language components. A distinct implementation
	should be designed to handle these characters. *If you need to sort CJK strings,
	do not use the present module.*


	1. BASICS
	____________________________________________________________________________

	To any supported key (character or n-gram, including surrogate pairs such as
	`\uD82F\uDCA0`), Collator assigns a Weight Sequence (WS). A WS is a string in
	the form S1,S2,... where each S_i represents a Weight Code in base 36:
	
	      WeightCode_i = parseInt(S_i, 36).

	This specific encoding allows to reduce the size of the literal map. Weights are
	ordered as specified in the DUCET but they use a smaller range of (L1,L2,L3)
	values, so the actual weight code of any element is coerced into a single
	uint32 that JavaScript can digest and manipulate through bitwise operators.
	
	[NOTE] The KEY-to-WS map is stored in /etc/Collator/$$.WMAP.jsxres.
	It can be rebuilt from scratch using the MetaCollator module.

	Each Weight Code (uint32) encodes inner weights as follows:

	      1111 1111 1111 1xxx 2222 222y 3333 3zzV
	      └─────────────────┘ └───────┘ └──────┘╰──Variable-Bit
	              L1             L2        L3
	           13+3 bits      7+1 bits  4+2 bits
	
	where
	      L1 (16bits)     reflects a level-1 weight (BASE)
	      L2 (8bits)      reflects a level-2 weight (DIACRITICS)
	      L3 (6bits)      reflects a level-3 weight (CASE)
	      V  (1bit flag)  tells whether the code concerns a 'variable' element
	                      (see below.)

	`xxx`, `y` and `zz` are reserved bits (set to zero in WMAP) used in TAILORED
	languages which need specific reordering. The subfolder /etc/Collation/tailoring
	contains 50+ resource files that extend the default rules to specific languages
	or language sets.
	
	For example, the European Ordering Rules (EOR) are defined in the file
	
	      `/etc/Collation/tailoring/$$.EOR.jsxres`

	which adds L1 and/or L2 extra bits for addressing keys like
	`Æ`, `æ`, `IJ`, `ij`, `Œ`, `œ`, `ß`, etc.
	
	[NOTE] The Minimal Weight Code (assigned to the TAB character in ~.WMAP)
	is `b8y1` in base 36, i.e 524809 (decimal), that is b10000000001000001001:

	      0000 0000 0000 1000 0000 0010 0000 1001
	      └─────────────────┘ └───────┘ └──────┘╰──Variable-Bit
	              L1             L2        L3

	This number determines:
	- the minimal L1 16-bit value as b1000 (8)
	- the minimal L2  8-bit value as b10   (2)
	- the minimal L3  7-bit value as b100  (4)


	3. VARIABLE WEIGHTING
	____________________________________________________________________________

	"Variable collation elements, which typically include punctuation characters
	and which may or may not include a subset of symbol characters, require
	special handling in the UCA."

	[REF] http://unicode.org/reports/tr10/#Variable_Weighting

	The present implementation provides two variable-weighting options:
	
	(a) NON-IGNORABLE: Variable collation elements are "not reset to be quaternary
        collation elements", that is, their weight values just behave as specified
        in the map like any other regular collation element.

        For example, it comes
        
	           'a b'  <<<  'a B'  <  'a-b'  <<<  'a-B'  <  'ab'

	    since*
	    
	    [.1E89.0020.0002],[*0209.0020.0002],[.1EA3.0020.0002]     ; 'a b'
	    <<<                                             ^^^^
	    [.1E89.0020.0002],[*0209.0020.0002],[.1EA3.0020.0008]     ; 'a B'
	    <                   ^^^^
	    [.1E89.0020.0002],[*020D.0020.0002],[.1EA3.0020.0002]     ; 'a-b'
	    <<<                                             ^^^^
	    [.1E89.0020.0002],[*020D.0020.0002],[.1EA3.0020.0008]     ; 'a-B'
	    <                   ^^^^
	    [.1E89.0020.0002],[.1EA3.0020.0002]                       ; 'ab'

	    * As specified in UCA's Main Algorithm -- unicode.org/reports/tr10/
	    tr10-41.html#Main_Algorithm -- the actual sort keys to be compared are
	    in fact <L1_Weights>\0<L2_Weights>\0<L3_Weights>, that is
	    
	            [1E89,0209,1EA3]\0[0020,0020,0020]\0[0002,0002,0002] for 'a b'
	            [1E89,0209,1EA3]\0[0020,0020,0020]\0[0002,0002,0008] for 'a B'
	            etc

	    "The UCA uses the value zero (0000) for the level separator, to guarantee
	    that the level separator has a lower value than any of the actual
	    collation weights appended to the sort key from the collation element
	    array. Implementations can, however, use a non-zero value, as long as
	    that value is lower than the minimum weight at that level."


    (b) BLANKED: "Variable collation elements and any subsequent ignorable
        collation elements are reset so that all weights (...) are zero."

        For example, it comes
        
		       'a b'  ===  'a-b'  ===  'ab'  <<<  'a B'  ===  'a-B'

		since*

	    [.1E89.0020.0002]<0>[.1EA3.0020.0002]                         ; 'a b'
	    ===
	    [.1E89.0020.0002]<0>[.1EA3.0020.0002]                         ; 'a-b'
	    ===
	    [.1E89.0020.0002]<0>[.1EA3.0020.0002]                         ; 'ab'
        <<<                             ^^^^
	    [.1E89.0020.0002]<0>[.1EA3.0020.0008]                         ; 'a B'
	    ===
	    [.1E89.0020.0002]<0>[.1EA3.0020.0008]                         ; 'a-B'
	    
	    * See (a) note.

	[NOTE] The SHIFTED and SHIFT-TRIMMED options are not implemented in Collator.


	4. AVOIDING NORMALIZATION
	____________________________________________________________________________

	A conformant implementation of the UCA should, as a first step, convert the
	input string into Normalization Form D (NFD), as detailed in
	https://unicode.org/reports/tr15/
	
	However,
	
	"Conformant implementations must get the same results as the UCA, but such
	implementations may use different techniques to get those results, usually
	with the goal of achieving better performance. For example, an implementation
	may be able to avoid normalizing most, if not all, of an input string in
	[NFD conversion] of the algorithm.

	In a straightforward implementation of the algorithm, canonically decomposable
	characters do not require mappings to collation elements because [NFD
	conversion] decomposes them, so they do not occur in any of the following
	algorithm steps and thus are irrelevant for the collation elements lookup.
	For example, there need not be a mapping for “ü” because it is always
	decomposed to the sequence “u + ◌̈”.

	In an optimized implementation, a canonically decomposable character like
	“ü” may map directly to the sequence of collation elements for the
	decomposition (“ü” → CE(u)CE(◌̈), unless there is a contraction defined for
	that sequence). For most input strings, these mappings can be used directly
	for correct results, rather than first having to normalize the text.

	While such an approach can lead to significantly improved performance, there
	are various issues that need to be handled, including but not limited to the
	following:

    -  Typically, the easiest way to manage the data is to add mappings for each
       of the canonically equivalent strings, the so-called “canonical closure”.
       Thus, each of {ǭ, ǫ + ̄ , ō + ̨ , o+ ̄ + ̨ , o+ ̨, +  ̄ } can map to the
       same collation elements.
    
    -  These collation elements must be in the same order as if the characters
       were decomposed using Normalization Form D.
    
    -  The easiest approach is to detect sequences that are in the format known
       as “Fast C or D form” (FCD*), and to directly look up collation elements
       for characters in such FCD sequences, without normalizing them.
       
       * Canonical Equivalence in Applications: http://unicode.org/notes/tn5/
    
    -  In any difficult cases, such as if a sequence is not in FCD form, or when
       there are contractions that cross sequence boundaries, the algorithm can
       fall back to doing a full NFD normalization."
	
	In the present implementation, input strings are *assumed* to be supplied in
	FCD form and canonical equivalences are treated straight in `WMAP`. For
	example, the grapheme “ü” is registered as:
	
	      "\u00FC"    => "x8gmiw,4qw",  // 3833.1.1  0.12.1
	
	which also matches the values found in the canonical decomposition:
	
	      "\u0075"    => "x8gmiw",      // 3833.1.1
	      "\u0308"    => "4qw",         // 0.12.1

	Thus, the result of processing the weight sequence is equivalent as far as
	no tailoring is involved for the grapheme “ü”.
	
	Now, should the grapheme “ü” require tailoring (as in Danish: `Y << ü`),
	special rules have to be specified for both the composed key (\u00FC) and
	its decomposed form "\u0075\u0308". Technically, the default weight sequences
	of the individual keys "\u0075" and "\u0308" won't change, but
	
	      i. The key "\u00FC" has to be overridden:     "\u00FC" => <new_WS>
	
	     ii. A new key "\u0075\u0308" has to be added:  "\u0075\u0308" => <new_WS>

	Those tailoring rules are treated and encoded from MetaCollator and made
	available to Collator from the ~.TLRM resource. (See next section for detail.)
	Usual decompositions are automatically added by MetaCollator while parsing the
	tailoring rules.


	5. TAILORING
	____________________________________________________________________________

	"Tailoring consists of any well-defined change in the Collation Element Table
	and/or any well-defined change in the behavior of the algorithm. Typically,
	a tailoring is expressed by means of a formal syntax which allows detailed
	manipulation of values in a Collation Element Table (...) A tailoring can
	be used to provide linguistically-accurate collation, if desired."
	
	[REF] http://unicode.org/reports/tr35/tr35-collation.html#Rules

	Collator implements the main tailoring procedure, that is,

	    "Reordering any character or contraction with respect
	     to others in the default ordering."
	    
	  The reordering can represent a L1 difference ( A < B ),  L2 difference
	  ( A << À ), or L3 difference ( a <<< A ).
	  
	  E.g in Breton:    C < ch <<< Ch <<< CH
	                      < c'h <<< C'h <<< C'H

	  The map ~.TLRM provides, for particular language keys like `br_BR` or `es_ES`,
	  a sequence of RULES that specify such reordering. In Collator's syntax the
	  usual operators <, <<, and <<< are changed into `>1`, `>2`, `>3`. Then the
	  above rules will be encoded

	      br_BR:
	      {
	         . . .
	         "ch" : ">1C",   "Ch" : ">3ch",   "CH" : ">3Ch",
	         "c'h" : ">1CH", "C'h" : ">3c'h", "C'H" : ">3C'h",
	         . . .
	      }

	  The first key asserts that ch > C, in other words, the digram “ch” must have a
	  L1-weight greater than that of “C”. Technically, when `µ.setTailor()` is
	  invoked for selecting particular tailoring rules, Collator consumes the extra
	  bits `xxx`, `y` and/or `zz` allowed in weight encoding:

	      1111 1111 1111 1xxx 2222 222y 3333 3zzV
	      └─────────────────┘ └───────┘ └──────┘╰──Var
	              L1             L2        L3

	  The rule "ch"=>">1C", for example, increments the `xxx` part of the L1 area to
	  make room for the bigram “ch”. It is therefore possible to insert up to seven L1
	  additional weights at any point of the default collation map.
	  
	  When a L1 weight is inserted for tailoring purpose, the L2_L3_V bits are reset
	  to zero. So the result of tailoring the “ch” bigram looks like
	  
	      <default_C_bits>001 0000 0000 0000 0000
	      └─────────────────┘ └───────┘ └──────┘╰──Var
	              L1             L2        L3
	  
	  On the other hand, *native* L2 weights only offer a single extra bit (`y`) of
	  differenciation. This is justified by the fact that adding several L2 weights
	  between the default values is unfrequent, so it is assumed in the present
	  implementation that such event rarely occurs and can be treated by simply
	  increasing L2 as a whole when the `y` bit is already set. That `y` extra bit
	  is useful though. For example, the Estonian key (et_EE) has a rule
	  
	      V << w <<< W
	  
	  which specifies that “w” is ordered as V/v at the primary level (L1) while
	  introducing a L2 difference, then w <<< W is maintained at the third level.
	  In Collator's syntax,
	  
	      "w" => ">2V"     //  V <<  w
	      "W" => ">3w"     //  w <<< W

	  It comes that the extra L2 bit is consumed:

	    w :: <default_V_bits>000 <def_L2>1 0000 0000
	         └─────────────────┘ └───────┘ └──────┘╰──Var
	                 L1             L2        L3
	  and

	    W :: <default_V_bits>000 <def_L2>1 0000 0010
	         └─────────────────┘ └───────┘ └──────┘╰──Var
	                 L1             L2        L3
	  
	  Note that since the rule "w"=>">2V" comes first and redefines w's weights,
	  the next rule "W" => ">3w" resets W's weight with respect to the new value
	  assigned to w. So order matters when encoding tailoring resources.
	  (See /etc/MetaCollator/tailoring.)

	[NOTE] Collator does not support fine-tuned operations like "Setting the
	secondary level to be backwards or forwards" or "Customizing the exact list
	of variable collation elements". Also, when a `[beforeN]` operation is
	required, it has to be rephrased to fit our `>N...` syntax.


	6. MAIN ALPHABETS
	____________________________________________________________________________

	By default (ROOT), Latin, Greek, and Cyrillic alphabets are ordered as
	specified in the DUCET:

	      LATIN
	      Aa, Bb, Cc, Dd, Ee, Əə, Ff, Gg, Hh, Ii, ı, Jj, Kk, Ll, Mm, Nn,
	      Ŋŋ, Oo, Pp, Qq, ĸ, Rr, Ss, Tt, Ŧŧ, Uu, Vv, Ww, Xx, Yy, Zz, Þþ

	      GREEK
	      Αα, Ββ, Γγ, Δδ, Εε, Ζζ, Ηη, Θθ, Ιι, Κκ, Λλ, Μμ, Νν, Ξξ, Οο, Ππ,
	      Ρρ, Σσς, Ττ, Υυ, Φφ, Χχ, Ψψ, Ωω
	
	      CYRILLIC
	      Аа, Әә, Бб, Вв, Гг, Ғғ, Дд, Ђђ, Ѓѓ, Ее, Єє, Жж, Җҗ, Зз, Ѕѕ, Ии,
	      Іі, Її, Йй, Јј, Кк, Ққ, Ҝҝ, Лл, Љљ, Мм, Нн, Ңң, Њњ, Оо, Өө, Пп,
	      Рр, Сс, Тт, Ћћ, Ќќ, Уу, Ўў, Үү, Ұұ, Фф, Хх, Ҳҳ, Һһ, Цц, Чч, Ҹҹ,
	      Џџ, Шш, Щщ, Ъъ, Ыы, Ьь, Ээ, Юю, Яя

	Other writing systems are included (ARABIC, HEBREW, ARMENIAN, BENGALI,
	DEVANAGARI, LAO, MALAYALAM, TAMIL, TELUGU, and THAI) but they likely
	require serious tailoring refinements to deal with the many underlying
	languages they support. This is also the case for some CYRILLIC- or
	even LATIN-based languages. Collator should gradually evolve to provide
	such refinements...
	

	7. EUROPEAN ORDERING RULES (EOR)
	____________________________________________________________________________
	
	[REF] en.wikipedia.org/wiki/European_ordering_rules

	"The European ordering rules (EOR/EN 13710), define an ordering for strings
	written in languages that are written with the Latin, Greek and Cyrillic
	alphabets. The standard covers languages used by the European Union, the
	European Free Trade Association, and parts of the former Soviet Union. It is
	a tailoring of the Common Tailorable Template of ISO/IEC 14651. EOR can
	in turn be tailored for different (European) languages. But in inter-
	European contexts, EOR can be used without further tailoring."


	REFERENCES
	____________________________________________________________________________

	Unicode Collation Algorithm:    unicode.org/reports/tr10/
	Language-Territory Information: unicode.org/cldr/charts/latest/supplemental/language_territory_information.html
	Collation Charts per language:  www.unicode.org/cldr/charts/28/collation/
	Alphabetical Order (WP):        en.wikipedia.org/wiki/Alphabetical_order
	List of Latin-script letters    en.wikipedia.org/wiki/List_of_Latin-script_letters
	Common Locale Data Repository:  cldr.unicode.org
	Collation Customization:        userguide.icu-project.org/collation/customization
	Languages:                      101languages.net/
	Online Tool (ICU):              demo.icu-project.org/icu-bin/collation.html
	J. Tauber's Python Collator:    github.com/jtauber/pyuca
	Linguistic Collation (SAS)      support.sas.com/resources/papers/linguistic_collation.pdf
	Comparing with JS Collators     dev.to/aumayeung/comparing-non-english-strings-with-javascript-collators-57bf
	ISKO: Alphabetization           www.isko.org/cyclo/alphabetization

	*/

	//==========================================================================
	// NOTICE
	//==========================================================================

	/*

	[ADD220405] The internal map `W1BA` has been added to provide easy access
	to fondamental characters ('base keys') from level1 weights. This map
	is not involved in sorting. Given a non-variable key whose level1 weight
	(`1111 1111 1111 1xxx`) is represented by the character W="\uHHHH",
	W1BA[W] returns the first* WMAP key associated to that level1 weight.
	This information can be used to extract the alphabetical group of a
	key, e.g. to link 'à' or 'Æ' to the base key 'A' in Latin, or 'ΰ'
	to 'Υ', etc.
	
	* By construction, the first WMAP key associated to a weight is usually
	  the uppercase form of a letter, so is the W1BA value in most cases.
	  However, the client code shouldn't assume that W1BA[W] is the upper-
	  case form in every Unicode area that provide alphabetic characters.
	  Better is to apply .toLowerCase() [resp. toUpperCase()] depending on
	  your requirements.

	*/

	//==========================================================================
	// DATA
	//==========================================================================

	[PRIVATE]

	({
		YALT : $$.Yalt &&
		(
		$$.Yalt.addPackage
		(
		#include 'Collator/$$.yalt.jsxres'
		)
		,
		$$.Yalt.addPackage
		(
		#include 'Collator/$$.LING.yalt.jsxres'
		)
		),

		// Root key-to-weight map. Each weight is a string in "w1,w2,w3..." form,
		// where each `wi` is the base 36 representation of a uint32 weight.
		// ---
		WMAP:
		#include 'Collator/$$.WMAP.jsxres'
		,

		// Level1-to-BaseKey map. Each level1 weight (\uHHHH) is
		// associated to a 'base key', typically the uppercase form of
		// a fundamental alphabetic letter.
		// ---
		W1BA:
		#include 'Collator/$$.W1BA.jsxres'
		,

		// Attractors (used to extract better baseKeys when possible.)
		// An attractor can be supplied as 2nd arg to `baseKey()`.
		// [REM] The last character must provide a codepoint that is
		// just beyond the last letter.
		// ---
		ATTR:
		{
			// LATIN:
			// Aa Bb Cc Dd Ee[Əə] Ff Gg Hh Ii[ı] Jj Kk Ll Mm Nn[Ŋŋ]
			// Oo Pp Qq (ĸ) Rr Ss Tt[Ŧŧ] Uu Vv Ww Xx Yy Zz (Þþ)
			// ---
			// ATTRACTOR:
			// A[Ⱥ…ꭤ] B[ʙ…Ƃ] C[Ȼ…Ꜿ] D[Ɖ…ẟ] E[ꬲ…ɤ] F[ꜰ…ꟻ] G[ɡ…Ƣ] H[ʜ…ɧ] ʻ[ʼ] I[ı…Ɩ]
			// J[ȷ…ʄ] K[Ƙ…ʞ] L[ʟ…ʎ] M[ᴍ…ꝳ] N[ɴ…ꬼ] O[ꬽ…Ȣ] P[Ᵽ…ⱷ] Q[Ꝗ…Ɋ] ĸ R[ꭅ…Ꝝ] S[ꜱ…ʆ] T[Ŧ…ʇ]
			// U[ꭎ…Ʊ] V[Ꝟ…Ʌ] W[Ⱳ…ʍ] X[ꭖ…ꭕ] Y[ʏ…Ȝ] Z[Ƶ…ʓ] Þ[Ꝥ…Ꝧ]   \u01BF
			// ---
			// Absorbs: Əə, ı, Ŋŋ, ĸ, Ŧŧ
			// Keeps:   ĸ U+0138 and Þ U+00DE (THORN) as individual letters.
			LATIN: "ABCDEFGHIJKLMNOPQĸRSTUVWXYZÞ" + "\u01BF",

			// GREEK (U+0391...U+03A9)
			// Αα Ββ Γγ Δδ Εε Ζζ Ηη Θθ Ιι Κκ Λλ Μμ Νν Ξξ Οο Ππ Ρρ Σσς Ττ Υυ Φφ Χχ Ψψ Ωω
			// ---
			// ATTRACTOR:
			// Α Β Γ Δ Ε (Ϝ[Ͷ]) (Ϛ) Ζ (Ͱ) Η Θ Ι (Ϳ) Κ Λ Μ Ν
			// Ξ Ο Π (Ϻ) (Ϟ[Ϙ]) Ρ[ϼ] Σ[ͼͻͽ] Τ Υ Φ Χ Ψ Ω[ꭥ]   \u03E0
			// ---
			// Absorbs: Ͷ (PAMPHYLIAN DIGAMMA), Ϙ (ARCHAIC KOPPA), ϼ, ͼͻͽ [SIGMAs] and ꭥ
			// Keeps    Ϝ (DIGAMMA), Ϛ (STIGMA), Ͱ (HETA), Ϳ (YOT),
			//          Ϻ (SAN), Ϟ (KOPPA) as individual letters.
			GREEK: "ΑΒΓΔΕϜϚΖͰΗΘΙͿΚΛΜΝΞΟΠϺϞΡΣΤΥΦΧΨΩ" + "\u03E0",

			// CYRILLIC ATTRACTOR:
			// Аа[Әә] Бб Вв Гг[Ғғ,Ѓѓ] Дд (Ђђ) (Ҙ) Ее[Єє] Жж[Җҗ] Зз (Ѕѕ)
			// Ии[Іі] Йй (Јј) Кк[Ққ,Ҝҝ] (Ԛ) Лл[Љљ] Мм Нн[Ңң,Њњ] Оо[Өө] Пп (Ҁ)
			// Рр Сс Тт (Ћћ) Уу[Ўў,Үү,Ұұ] Фф Хх[Ҳҳ] (Һһ) (Ѡ) Цц
			// Чч[Ҹҹ] (Ҽ) (Ҿ) (Џџ) Шш Щщ (\uA64E) Ъъ Ыы Ьь Ээ Юю (\uA656) Яя
			// ---
			// - А absorbs Ә (SCHWA) since it's often assimilated to Ӓ
			//   https://en.wikipedia.org/wiki/Schwa_(Cyrillic)
			// - Г (GHE) absorbs Ғ (GHE WITH STROKE) and variants like Ӷ;
			//   it also absorbs Ѓ \u0403 (GJE) analyzed as a diactrical variant
			// - Д (DE) absorbs \u0500 (KOMI DE), \uA680 (DWE)
			// - Ђ (DJE) absorbs \uA662 (SOFT DE), \u0502 (KOMI DJE)
			// - Ҙ \u0498 (ZE WITH DESCENDER, or DHE) is unique to the Bashkir language;
			//   in UCA it has a specific weight < Е, hence before З (ZE, \u0417)
			//      . . .
			//      "\u0498" //  4118.1.6  Ҙ (ZE WITH DESCENDER)
			//      "\u0415" //  4119.1.6  Е (IE)
			//      . . .
			//   so we had to introduce this exception before Е to prevent wrong grouping.
			//   https://en.wikipedia.org/wiki/Bashkir_language
			// - Е (IE) absorbs Є (UKRAINIAN IE)
			// - Ж (ZHE) absorbs \u052A (DZZHE), \uA684 (ZHWE) and Җ (ZHE WITH DESCENDER)
			// - З (ZE) absorbs \uA640 (ZEMLYA), \u0504 (KOMI ZJE), \u0510 (REVERSED ZE)
			//   and \uA642 (DZELO)
			// - Ѕ (DZE) absorbs \uA644 (REVERSED DZE), \u04E0 (ABKHASIAN DZE),
			//   \uA688 (DZZE), \u0506 (KOMI DZJE) and uA682 (DZWE)
			// - И (I) absorbs \u048A (SHORT I WITH TAIL), \u0406 (BYELORUSSIAN-UKRAINIAN I)
			//   \uA646 (IOTA) -- Note: \u048A SHORT I WITH TAIL is an exception, used only
			//   in Kildin Sami language (https://en.wikipedia.org/wiki/Short_I_with_tail)
			// - Й (SHORT I or YOT) is a separate letter, although made of И with a breve.
			//   It has a distinct position in alphabet depending on the language:
			//      Belarusian 11th ("non-syllabic I")
			//      Bulgarian  10th ("short I")
			//      Russian    11th ("short I")
			//      Ukrainian  14th
			//      Kazakh     13th
			//   Cf. https://en.wikipedia.org/wiki/Short_I
			// - К (KA) absorbs many diacritical variants like Қ (KA WITH DESCENDER),
			//   Ӄ (KA WITH HOOK) etc.
			// - Ԛ (QA) is unusual but has dedicated level1 weight between К and Л.
			// - Л (EL) absorbs many diacritical variants like Ӆ, Ԯ, etc, as well as
			//   Љ (LJE) which is a ligature used in Macedonian and Itelmen,
			//   and Ԕ (LHA) analyzed as a cross-digraph of Л (EL) and Х (KHA).
			// - М (EM) absorbs Ӎ (EM WITH TAIL) and \uA666 (SOFT EM).
			// - Н (EN) absorbs many diactrical variants (with hooks, tail, descender...)
			//   and  \u04A4 (LIGATURE EN GHE), \u040A Њ (NJE, Macedonian), \u050A Ԋ (KOMI NJE).
			// - О (\u041E) absorbs \u04E8 (BARRED O).
			// - П (PE) absorbs Ԥ (PE WITH DESCENDER), Ҧ (PE WITH MIDDLE HOOK).
			// - Ҁ \u0480 (KOPPA) is an archaical letter: "certain modern textbooks and
			//   dictionaries of Old Church Slavonic language insert this character (...)
			//   either between П and Р (to reproduce the Greek alphabetical order) or at
			//   the very end of the list." П < Ҁ < Р is adopted in the UCA.
			//   https://en.wikipedia.org/wiki/Koppa_(Cyrillic)
			// - Р (ER) absorbs Ҏ (ER WITH TICK) and Ԗ (RHA) analyzed as a cross-digraph
			//   of Р and Х (was used in the Moksha language.)
			// - С (ES) absorbs \u050C Ԍ (KOMI SJE) and Ҫ (ES WITH DESCENDER).
			// - Т (TE) absorbs \uA68C Ꚍ (TWE), \u050E Ԏ (KOMI TJE), \u04AC Ҭ (TE WITH
			//   DESCENDER), \uA68A Ꚋ (TE WITH MIDDLE HOOK)
			// - Ћ \u040B (TSHE) has its own level1 weight and is a separated base key
			//   it is used in the Serbian Cyrillic alphabet, https://en.wikipedia.org/wiki/Tshe
			// - У (U) absorbs \u04AE Ү (STRAIGHT U), \u04B0 Ұ and the special UK element
			//   \u1C88 (SMALL LETTER UNBLENDED UK) and \u0478 (UK).
			// - Х (HA) absorbs diacritical variants \u04FC Ӽ, \u04FE Ӿ and \u04B2 Ҳ
			// - Һ (SHHA, or HE) has its form derived from the Latin letter H, "but the capital
			//   forms are more similar to a rotated Cyrillic letter Che (Ч) or a stroke-less Tshe (Ћ).
			//   Most of the languages using the letter call it ha - the name shha was created when
			//   the letter was encoded in Unicode." https://en.wikipedia.org/wiki/Shha
			//   It absorbs Ԧ (SHHA WITH DESCENDER) and \uA694 Ꚕ (HWE)
			// - Ѡ (CYRILLIC OMEGA) was adopted into the early Cyrillic alphabet, it absorbs
			//   \u047E Ѿ (OT), \uA64C Ꙍ (BROAD OMEGA), \u047C Ѽ (OMEGA WITH TITLO : "beautiful omega")
			//   and \u047A Ѻ (ROUND OMEGA)
			// - Ц (TSE) absorbs \uA660 (REVERSED TSE), \uA68E (TSWE), \u04B4 Ҵ (LIGATURE TE TSE)
			//   and \uA690 Ꚑ (TSSE) whose shape originated as a ligature of TE and ES (it is used in
			//   the Abkhaz language.)
			// - Ч (CHE) absorbs \u052C Ԭ (DCHE), \uA692 Ꚓ (TCHE), \u04B6 Ҷ (CHE WITH DESCENDER),
			//   \u04CB Ӌ (KHAKASSIAN CHE), \u04B8 Ҹ (CHE WITH VERTICAL STROKE) and \uA686 Ꚇ (CCHE).
			// - Ҽ (ABKHASIAN CHE) and its descender form \u04BE Ҿ (ABKHASIAN CHE WITH DESCENDER)
			//   are inserted as two separate base keys, although used only in the Abkhaz language.
			//   In this alphabet, Џ < Ҽ < Ҿ -- cf https://en.wikipedia.org/wiki/Abkhazian_Che --
			//   which violates default UCA ordering...
			// - Џ (DZHE) should collate before Ҽ in Abkhaz alphabet!
			// - Ш (SHA) absorbs \uA696 (SHWE)
			// - Щ (SHCHA) in Russian and Ukrainian corresponds to ШЧ in related words in Belarusian.
			// - \uA64E Ꙏ (NEUTRAL YER) is used "in transcribing documents when it is hard to tell
			//   the difference between a Ь and a Ъ. It was common in Late Medieval Russian archival
			//   materials and scripts." This special base key must be explicit as it collates before
			//   \u042A Ъ (HARD SIGN) at level 1. It then absorbs \u2E2F (VERTICAL TILDE) and
			//   \uA67F (PAYEROK=omitted yer)
			// - Ъ (HARD SIGN) absorbs \uA650 Ꙑ (YERU WITH BACK YER)
			// - Ы (YERU) is distinct from \uA650 (YERU WITH BACK YER)
			// - Ь (SOFT SIGN) absorbs Ҍ (SEMISOFT SIGN) and the old-Cyrillic letter \u0462 Ѣ (YAT),
			//   as well as \uA652 (IOTIFIED YAT)
			// - Ю (YU) absorbs \uA654 (REVERSED YU)
			// - \uA656 (IOTIFIED or 'Iotated' A) Ꙗ is an archaic letter used today only in Church Slavonic.
			//   It is introduced w.r.t UCA between YU and YA.
			// ---
			CYRILLIC: "АБВГДЂҘЕЖЗЅИЙЈКԚЛМНОПҀРСТЋУФХҺѠЦЧҼҾЏШЩ\uA64EЪЫЬЭЮ\uA656Я" + "\u0464",
		},

		// Regex that retrieve all weighted keys from a string.
		// ---
		MTCH:
		#include 'Collator/$$.MTCH.jsxres'
		,
		
		// String that contains all zero-weighted keys.
		// ---
		ZROS:
		#include 'Collator/$$.ZROS.jsxres'
		,
		
		// Tailoring map. (Contains tailoring rules for 50+ languages.)
		// Keys are ISO639 identifiers (cf etc/Linguist/languages) or
		// specialized `zz_xyz` subkeys like `de_phone`. The unique
		// exception is `EOR` (addressing European Ordering Rules.)
		// ---
		TLRM:
		#include 'Collator/$$.TLRM.jsxres'
		,

		// Suffix map. Any tailor key of the form `zz_xyz` has a suffix
		// `_xyz` which must be a key of ~.SUFX. The suffix map provides
		// a display pattern `ptn` for that suffix (in default EN) so `zz`
		// can be parsed independently as an ISO639 identifier. Also, the
		// SUFX map provides a `def` property that tells (0|1) whether
		// `zz_xyz` is the default tailoring key for the match `zz`.
		// For example, `es_modern` is the default tailor for `es`,
		// since `~.SUFX['_modern'].def` is 1.
		// ---
		SUFX:
		#include 'Collator/$$.SUFX.jsxres'
		,
		
		// Language map. Subset (200+ items) of Linguist/LISO.
		// zz => { name:str, dft:'EOR'|'ROOT', natv:str }
		// When `zz` is not visible among TLRM keys, the `dft` property
		// tells whether the EOR rules might be applied instead of ROOT.
		// [REM] As a default mechanism EOR is automatically associated
		// to Latn/Grek/Cyrl writing systems.
		// ---
		LING:
		#include 'Collator/$$.LING.jsxres'
		,

	})

	//==========================================================================
	// KEYS/WEIGHT TOOLS
	//==========================================================================

	[PRIVATE]
	
	({
		SPLT: function(/*str*/s,/*bool=0*/UPD_LENGTH,/*bool=0*/SPLIT_BY_FFFD,  F,a,i,ks,n)
		//----------------------------------
		// (Split-Into-Keys.) Split `s` into an array of measurable keys, based
		// on `callee.CUR_MTCH`.
		// [FIX210519] If `s` is empty, skips the process and makes ret.SIZE==0.
		// [FIX200617] [CHG200618] Removes any `\0...` suffix from `s` before
		// extracting keys. This both prevents `string.replace(...)` bugs and
		// satisfies the rule (1) specified in `µ.sort()`.
		// [CHG200616] If `SPLIT_BY_FFFD` is set, non-measurable characters are
		// replaced by `\uFFFD`, remaining as a special separator having the max
		// weight. But *this is no longer the default approach* as it seems more
		// relevant to purely ignore non-measurable elements (in order to prevent
		// issues with line terminators, ill-formed strings, etc.)
		// Each elem of the returned array is a key having 1, 2, or more characters.
		// (n-grams with n>2 usually appear in tailoring, cf ~.TLRM AND ~.TMAP.)
		// [REM] `callee.CUR_MTCH` is either a tailored regex, or the default ~.MTCH.
		// The caller is responsible to set `CUR_MTCH` as expected.
		// ---
		// For saving performance, the returned array is volatile and its `length`
		// property *is not updated* ; use `<ret>.SIZE` instead when needed. You
		// can set `UPD_LENGTH` to 1 to force the update of `<ret>.length` when
		// absolutely necessary (that's more time-consuming.)
		// ---
		// this :: ~
		// => str[]&  [VOLATILE]  + .SIZE 
		{
			// Init.
			// ---
			F = callee[ SPLIT_BY_FFFD ? 'REPL' : 'REPL_FFFD' ]; // [CHG200616]
			SPLIT_BY_FFFD && (F.OFS=0);
			(a=F.RET).SIZE = 0;

			// [FIX210519] Needed to support empty imput. In that case,
			// skip the replace routine (would kill CS4 otherwise.)
			// ---
			if( s.length )
			{
				// [CHG200618] Removes any '\0...' suffix before extracting keys.
				// ---
				0 <= (i=s.indexOf('\0')) && (s=s.slice(0,i));
				
				// Preprocessing routines (keys specified in callee.PREP.)
				// ---
				for( i=-1, n=(ks=callee.PREP).SIZE ; ++i < n ; s=this[ks[i]](s) );

				// Trick: we use a 'fake' replacement function, its actual job is
				// to digest the successive matches captured by the regex and to
				// update accordingly its internal array `F.RET`. (See callee.REPL.)
				// [FIX210519] Make sure `s` is *still nonempty* before replacement.
				// ---
				s.length && s.replace(callee.CUR_MTCH, F);
			}
			
			// Time-consuming in ExtendScript but sometimes needed.
			// ---
			UPD_LENGTH && a.length != a.SIZE && (a.length=a.SIZE);
			return a;
		}
		.setup
		({
			REPL: function($match,$offset,_,q,z)
			//----------------------------------
			// Replace callback that always returns '' (important!)
			// `$match`  :: Current match found in the input.
			// `$offset` :: Index of $match in the input, noting that the
			//              input is dynamically reduced, from left to right,
			//              as every incoming match <M> is replaced by ''
			// ---
			// => ''
			{
				return (q=callee.RET), (q[z=q.SIZE]=$match), (q.SIZE=1+z), '';
			}
			.setup({ RET:[] }),

			REPL_FFFD: function($match,$offset,_,q,z)
			//----------------------------------
			// [REM200616] Old version -- no longer used by default.
			// ---
			// Replace callback that always returns '' (important!)
			// `$match`  :: Current match found in the input.
			// `$offset` :: Index of $match in the input, noting that the
			//              input is dynamically reduced, from left to right,
			//              as every incoming match <M> is replaced by ''
			// 
			// At each step `callee.OFS` indicates the *previous* offset
			// (init=0.) If $offset > OFS, the OUT symbol \uFFFD is added
			// in the RET array whose SIZE is incremented. Then $match is
			// added, RET.SIZE is incremented, and OFS is updated to
			// $offset. In the below schema `•` represents the OUT symbol.
			//
			//      OFS     0                      3                  4
			//      input   XXX<M>Y<M><M>…  ->  XXXY<M><M>…  ->  XXXY<M>…
			//      offset      3                    4                4
			//      RET [] => [•,M1]        =>  [•,M1,•,M2]  => [•,M1,•,M2,M3]
			//      SIZE 0 =>      2        =>            4  =>              5
			// ---
			// => ''
			{
				z = (q=callee.RET).SIZE;
				
				callee.OFS < $offset && ( q[z++]=callee.OUT, callee.OFS=$offset );
				
				return (q[z++]=$match), (q.SIZE=z), '';
			}
			.setup({ RET:[], OFS:0, OUT:String.fromCharCode(0xFFFD) }),
			
			CUR_MTCH: µ['~'].MTCH,
			
			// Array of preprocessing routines (~ keys.)
			// ---
			PREP: [].setup({ SIZE:0 }),
		}),
		
		SPLT_EXT: function(/*str*/s,/*bool=0*/UPD_LENGTH)
		//----------------------------------
		// (Split-External.) [ADD220328] Alias of `~.SPLT` made available to
		// external context. (Could be used by callback functions.)
		// ---
		// this :: any
		// => str[]&  [VOLATILE]  + .SIZE 
		{
			return callee.µ['~'].SPLT(s, UPD_LENGTH);
		},

		TMAP: function(/*{key=>rule}|false*/TL,  WRN,TM,TB,k,keys,op,rf,m,i,t,w,b,w1,WZ)
		//----------------------------------
		// (Tailor-Map.) Set the tailor map with respect to incoming rules.
		// This function also updates `~.SPLT.CUR_MTCH` accordingly.
		// Supply a falsy TL to restore the default map (= no tailoring.)
		// ---
		// [REM] `TMAP.DATA` and `~.WMAP` share the same k=>WS structure.
		// TMAP.DATA is used to partially supersede WMAP assignments: if
		// a KEY is found in TMAP.DATA its associated Weight String will
		// be used. While TMAP.DATA is built, SPLT.CUR_MTCH is updated
		// to make sure that any new key can be detected by the regex (the
		// whole key must be capturable as such, taking precedence over
		// substrings that ~.MTCH could detect.) Also, given a set of new
		// keys k1, k2, k3..., it's important to prepend regex patterns
		// from longest to shortest keys, in case `k_i` would be part of
		// `k_j` (j>i). Keys are therefore reordered to guarantee that
		// longest strings will be captured first while splitting an input.
		// ---
		// [ADD220405] `TMAP.BASE` and `~.W1BA` share the same W=>BaseKey
		// structure. TMAP.BASE is used to augment or partially supersede
		// W1BA assignments: if a WEIGHT is found in TMAP.BASE its asso-
		// ciated Base Key will be used.
		// ---
		// rule   ::  ( `==` | `>1` | `>2` | `>3` ) + refString
		// `this` ::  ~
		// ---
		// => undef [OK]  |  ERR_MSG [KO]
		{
			// Clean up the tailor-map and restore the default (ROOT) config.
			// ---
			TM = callee.DATA;
			for( k in TM ) delete TM[k];
			this.SPLT.CUR_MTCH = this.MTCH;  // So far, activate the default regex.

			TB = callee.BASE;                // [ADD220405] Tailored Weight1-to-BaseKey
			for( k in TB ) delete TB[k];

			if( !TL ) return;                // Nothing to do: goes back to default.

			// Init.
			// ---
			(WRN = callee.WARNS).length = 0;
			const WM = this.WMAP;
			const WB = this.W1BA;
			const MAX1 = parseInt(WM['\uFFFD'],36)>>>16; // Maximal L1 weight
			const CHR = String.fromCharCode;
			this.SPLT.PREP.SIZE = 0;

			keys = [];

			for( k in TL )
			{
				if( !TL.hasOwnProperty(k) ) continue;

				// Keys require descending sort by length.
				// [REM] In principle we could optimize the final regex by ignoring
				// keys that are already captured in full by ~.MTCH, but in practice
				// we will prepend *every* tailoring key, even being already detected,
				// as this does not dramatically increase the whole regex and likely
				// speeds up the detection of initial, relevant keys.
				// ---
				keys.push( CHR(~k.length)+k );

				// Get the operator and the reference.
				// ---
				op = (rf=TL[k]).slice(0,2);  // `==` | `>1` | `>2` | `>3`
				rf = rf.slice(2);            // Any string (character, bigram or more.)

				// [REM] The TM map has been initialized to `{}`. It is intended to
				// provide `k => WeightString` mapping for every TL's key. When a
				// rule `k •rf` is parsed (• referring to any operator), we may find
				// that `rf` has been previously involved as a key: TM[rf]==WS.
				// In such event, WS should take precedence over SPLT(rf) and be used
				// as the reference Weight String for applying •. For example,
				//     `k ==rf`   implies   TM[k]=WS
				//     `k >1rf`   implies   TM[k]=incrementL1(WS)
				// On the other hand, if TM[rf] is undefined, then rf is splitted into
				// subkeys through SPLT(rf). But some of these subkeys could in turn
				// already exist in TM, and their dedicated Weight Strings should then
				// be used rather than the default ones.
				// ---
				m = TM.hasOwnProperty(rf) ? [rf] : this.SPLT(rf,1);                           // m :: [ "k1", "k2", ... ]
				for( i=m.length ; i-- ; m[i] = TM.hasOwnProperty(t=m[i]) ? TM[t] : WM[t] );   // m :: [ "w11,w12...", "w21,w22...", ... ]

				// EQUAL -> strict weight equivalence (just concatenate.)
				// [REM] The key `k` being associated to the (new) weight string `m.join(',')`
				// there's no need to update TB. Indeed, TM[k] will return the new weight(s)
				// and ~.W1BA already associates the level1 weight to the correct Base Key.
				// E.g `Y ==Z` leads to TM['Y']=WM['Z'] so Weight(Y)==Weight(Z) through TM,
				//     and W1BA[W] is 'Z' for the level1 weight W associated to Y.
				// ---
				if( '==' == op ){ TM[k]=m.join(','); continue; }

				// >(1|2|3) OPERATOR
				// ---
				t = m.pop().split(',');        // We only want to increase the weight of the *last* component.
				w = parseInt(t.pop(),36)>>>0;  // w :: 1111 1111 1111 1xxx 2222 222y 3333 3zzV
				w1 = 0;                        // uint16, new level1 weight if created.

				// [REM241204] `w` should be interpreted as the TRAILING value of the whole
				// reference weight m :: [ "w11,w12...", "w21,w22...", ... , < t=[...,<w>] > ]
				// -- last item was 'popped' from both m and t -- It is then assumed that
				// increasing w (only) at level N is sufficient to satisfy `>N` operator.
				// Also, the V flag of `w` will be preserved. If other mechanisms are required
				// in the future, it is still possible to add new operators...
				// ---
				// The minimal weight in WMAP (excl. zero) is "b8y1" :
				//    wMin :: 0000 0000 0000 1000 0000 0010 0000 1001
				//    struc   1111 1111 1111 1xxx 2222 222y 3333 3zzV
				// ---
				switch( op )
				{
					case '>1':

						// [FIX241204] L2L3 MINIMUM (last 16bits) : ... 0000 0010 0000 100V (keep V flag)
						WZ = (1&w) ? 0x209 : 0x208;

						// Increase (if possible) the L1 extra bits `xxx` : 000=>001=>010=>etc=>111
						// and reset to WZ the last 16 bits.
						// ---
						b = w>>>16; // 1111 1111 1111 1xxx
						7 == (7&b) && (WRN[WRN.length] = __("No enough LEVEL1 extra bits for the key %1. Need anyway to increment that level for tailoring. Make sure that's the expected behavior!", k.toSource()));

						w1 = ++b;   // [ADD220405] Store the final uint16 in w1.
						if( MAX1 <= b ) return __("LEVEL1 weight limit reached (%1) for the key %2. Fix your tailoring rules.", b.toHexa('0x'), k.toSource());

						// [REM241204] Make room for L2L3 bits :: `... 2222 222y 3333 3zzV`
						// ---  L1+    L2L3
						w = ( (b<<16) | WZ );
						break;

					case '>2':

						// [FIX241204] L3 MINIMUM (last 8bits) : ... 0000 100V (keep V flag)
						WZ = (1&w) ? 0x9 : 0x8;
					
						// Set (if possible) the level2 extra bit `y`
						// and reset to WZ the last 8 bits
						// ---
						b = 0xFF&(w>>>8); // 2222 222y
						1 == (1&b) && (WRN[WRN.length] = __("The LEVEL2 extra bit is already set for the key %1. Need anyway to increment that level for tailoring. Make sure that's the expected behavior!", k.toSource()));

						++b;
						if( 0xFF <= b ) return __("LEVEL2 weight limit reached (%1) for the key %2. Fix your tailoring rules.", b.toHexa('0x'), k.toSource());

						// [REM241204] Make room for L3 bits :: `... 3333 3zzV`
						// ---      L1           L2+    L3
						w = ( (0xFFFF0000&w) | (b<<8) | WZ );
						break;

					case '>3':
					
						// [FIX241204] Preserve V flag.
						WZ = 1&w;

						// Increase (if possible) the level3 extra bits `zz`: 00=>01=>10=>11
						// and KEEP the V flag.
						// ---
						b = 0x7F&(w>>>1); // 3333 3zz   (7 bits, 2 available)
						3 == (3&b) && (WRN[WRN.length] = __("No enough LEVEL3 extra bits for the key %1. Need anyway to increment that level for tailoring. Make sure that's the expected behavior!", k.toSource()));

						++b;
						if( 0x7F <= b ) return __("LEVEL3 weight limit reached (%1) for the key %2. Fix your tailoring rules.", b.toHexa('0x'), k.toSource());

						// ---     L1L2          L3+    V
						w = ( (0xFFFFFF00&w) | (b<<1) | WZ );
						break;

					default:
						return __("Wrong operator (%1).", op);
				}
				
				t.push((w>>>0).toString(36));
				m.push(t.join(','));

				// alert([ "k="+k, "w="+(w>>>0).toString(2), "stored: "+m.join(',') ].join('\r') );

				TM[k] = m.join(',');           // Add k=>WS to the map.

				0 < w1 && (TB[CHR(w1)]=k);     // [ADD220405] Append new level1=>k association
				                               // E.g  ...=>"ch" and  ...=>"c'h"  in BR tailoring.
			}

			// Update the matching regex in ~.SPLT.
			// ---
			if( i=keys.length )
			{
				keys.sort();
				while( i-- ) keys[i] = RegExp.escape(keys[i].slice(1));
				this.SPLT.CUR_MTCH = RegExp( keys.join('|') + '|' + this.MTCH.source, 'g');
			}
		}
		.setup
		({
			DATA:  {}, // key=>WS
			BASE:  {}, // W=>BaseKey [ADD220405]
			WARNS: [],
		}),
		
		WG_3: function(/*str[]*/keys,/*obj*/TM,/*bool=0*/IGNORE_VARS,/*?obj*/wRemap,/*bool=0*/RV3,  s1,s2,s3,n,i,k,ws,x,t,p)
		//----------------------------------
		// (Weight-1-to-3.) Alpha+Diacritics+Case. Get the Weight String associated
		// to the array of input keys for L1-L3 comparison. Result has the form
		//          "<S1><0><S2><0><S3>"
		// where each <S_i>::(\uHHHH)+  represents the weights at level i.
		// ---
		// `TM`          :: Active weight map (TMAP.DATA or ~.WMAP)
		// `IGNORE_VARS` :: Ignore variable elements.
		// `wRemap`      :: Optional object for remapping particular weight sequences
		//                  (old_WS=>new_WS.) Used to customize variable elems.
		// `RV3`         :: [ADD200812] Reverse L3 weights.
		// ---
		// [WARNING] keys.length is not reliable, use keys.SIZE instead.
		// `this` :: ~
		// ---
		// => str   :: <L1_Weights>\0<L2_Weights>\0<L3_Weights>
		{
			const CHR = String.fromCharCode;
			const ZR = this.ZROS;
			const WM = this.WMAP;

			for( s1=s2=s3='', n=keys.SIZE, i=-1 ; ++i < n ; )
			{
				if( 0 <= ZR.indexOf(k=keys[i]) ) continue;               // Ignore zero-weight keys.
				ws = TM.hasOwnProperty(k) ? TM[k] : WM[k];               // Get (tailored or default) weight seq.
				wRemap && wRemap.hasOwnProperty(ws) && (ws=wRemap[ws]);  // [ADD200708]

				do
				{
					x = parseInt(ws,36);                                 // x :: 1111 1111 1111 1xxx 2222 222y 3333 3zzV
					if( IGNORE_VARS && (1&x) ) continue;
					(t=x>>>16) && (s1+=CHR(t));                          // add only if t!=0 (level1)
					(t=0xFF&(x>>>8)) && (s2+=CHR(t));                    // add only if t!=0 (level2)
					(t=0x7F&(x>>>1)) && (s3+=CHR(RV3?(0x80-t):t));       // add only if t!=0 (level3)
				}
				while( 0 < (p=ws.indexOf(',')) && (ws=ws.slice(1+p)).length );
			}

			return s1 + '\0' + s2 + '\0' + s3;
		},

		/*
		An implementation may allow the maximum level to be set to a smaller level than
		the available levels in the collation element array. For example, if the maximum
		level is set to 2, then level 3 and higher weights are not appended to the sort
		key. Thus any differences at levels 3 and higher will be ignored, effectively
		ignoring any such differences in determination of the final result for the
		string comparison.
		*/

		WG_2: function(/*str[]*/keys,/*obj*/TM,/*bool=0*/IGNORE_VARS,/*?obj*/wRemap,/*reserved*/_,/*bool=0*/FILL,  s1,s2,n,i,k,ws,x,t,p)
		//----------------------------------
		// (Weight-1-to-2.) Alpha+Diacritics. Get the Weight String associated
		// to the array of input keys for L1-L2 comparison. Result has the form
		//          "<S1><0><S2>" (unless FILL is set)
		// where each <S_i>::(\uHHHH)+  represents the weights at level i.
		// ---
		// [ADD230130] Sometimes you still need a full `<S1><0><S2><0><S3>`
		// result for consistent formatting, the option `FILL` has been added
		// for that purpose. It then adds a minimal L3 weight `<0>x02` after
		// level2 --> `<S1><0><S2><0>\x02`
		// ---
		// -> See WG_3 for additional params.
		// [WARNING] keys.length is not reliable, use keys.SIZE instead.
		// `this` :: ~
		// ---
		// => str   :: <L1_Weights>\0<L2_Weights>
		{
			const CHR = String.fromCharCode;
			const ZR = this.ZROS;
			const WM = this.WMAP;

			for( s1=s2='', n=keys.SIZE, i=-1 ; ++i < n ; )
			{
				if( 0 <= ZR.indexOf(k=keys[i]) ) continue;               // Ignore zero-weight keys.
				ws = TM.hasOwnProperty(k) ? TM[k] : WM[k];               // Get (tailored or default) weight seq.
				wRemap && wRemap.hasOwnProperty(ws) && (ws=wRemap[ws]);  // [ADD200708]

				do
				{
					x = parseInt(ws,36);                                 // x :: 1111 1111 1111 1xxx 2222 222y 3333 3zzV
					if( IGNORE_VARS && (1&x) ) continue;
					(t=x>>>16) && (s1+=CHR(t));                          // add only if t!=0 (level1)
					(t=0xFF&(x>>>8)) && (s2+=CHR(t));                    // add only if t!=0 (level2)
				}
				while( 0 < (p=ws.indexOf(',')) && (ws=ws.slice(1+p)).length );
			}
			
			return s1 + '\0' + s2 + (FILL?'\0\x02':'');
		},

		WG_4: function(/*str[]*/keys,/*obj*/TM,/*bool=0*/IGNORE_VARS,/*?obj*/wRemap,/*bool=0*/RV3,/*bool=0*/FILL,  s1,s3,n,i,k,ws,x,t,p)
		//----------------------------------
		// (Weight-1-and-3.) [ADD200812] Alpha+Case (special routine that ignores L2 only.)
		// Get the Weight String associated to the array of input keys for L1+L3 comparison.
		// Result has the form "<S1><0><S3>" (unless FILL is set)
		// where each <S_i>::(\uHHHH)+  represents the weights at level i.
		// ---
		// [ADD230130] Sometimes you still need a full `<S1><0><S2><0><S3>`
		// result for consistent formatting, the option `FILL` has been added
		// for that purpose. It then adds a minimal L3 weight `<0>x02` after
		// level2 --> `<S1><0><S2><0>\x02`
		// ---
		// -> See WG_3 for additional params.
		// [WARNING] keys.length is not reliable, use keys.SIZE instead.
		// `this` :: ~
		// ---
		// => str   :: <L1_Weights>\0<L3_Weights>
		{
			const CHR = String.fromCharCode;
			const ZR = this.ZROS;
			const WM = this.WMAP;

			for( s1=s3='', n=keys.SIZE, i=-1 ; ++i < n ; )
			{
				if( 0 <= ZR.indexOf(k=keys[i]) ) continue;               // Ignore zero-weight keys.
				ws = TM.hasOwnProperty(k) ? TM[k] : WM[k];               // Get (tailored or default) weight seq.
				wRemap && wRemap.hasOwnProperty(ws) && (ws=wRemap[ws]);  // [ADD200708]

				do
				{
					x = parseInt(ws,36);                                 // x :: 1111 1111 1111 1xxx 2222 222y 3333 3zzV
					if( IGNORE_VARS && (1&x) ) continue;
					(t=x>>>16) && (s1+=CHR(t));                          // add only if t!=0 (level1)
					(t=0x7F&(x>>>1)) && (s3+=CHR(RV3?(0x80-t):t));       // add only if t!=0 (level3)
				}
				while( 0 < (p=ws.indexOf(',')) && (ws=ws.slice(1+p)).length );
			}
			
			return s1 + (FILL?'\0\x02':'') + '\0' + s3;
		},

		WG_1: function(/*str[]*/keys,/*obj*/TM,/*bool=0*/IGNORE_VARS,/*?obj*/wRemap,/*reserved*/_,/*bool=0*/FILL,  s1,n,i,k,ws,x,t,p)
		//----------------------------------
		// (Weight-1.) Alpha-Only. Get the Weight String associated to the array
		// of input keys for L1 comparison. Result has the form (\uHHHH)+ unless
		// FILL is set.
		// ---
		// [ADD230130] Sometimes you still need a full "<S1><0>S2<0><S3>" result for consistent formatting,
		// the option `FILL` has been added for that purpose. It then adds minimal L2/L3 weights after
		// <S1> --> `<S1><0>\x02<0>\x02`
		// ---
		// -> See WG_3 for additional params.
		// [WARNING] keys.length is not reliable, use keys.SIZE instead.
		// `this` :: ~
		// ---
		// => str   :: <L1_Weights>
		{
			const CHR = String.fromCharCode;
			const ZR = this.ZROS;
			const WM = this.WMAP;

			for( s1='', n=keys.SIZE, i=-1 ; ++i < n ; )
			{
				if( 0 <= ZR.indexOf(k=keys[i]) ) continue;               // Ignore zero-weight keys.
				ws = TM.hasOwnProperty(k) ? TM[k] : WM[k];               // Get (tailored or default) weight seq.
				wRemap && wRemap.hasOwnProperty(ws) && (ws=wRemap[ws]);  // [ADD200708]

				do
				{
					x = parseInt(ws,36);                                 // x :: 1111 1111 1111 1xxx 2222 222y 3333 3zzV
					if( IGNORE_VARS && (1&x) ) continue;
					(t=x>>>16) && (s1+=CHR(t));                          // add only if t!=0 (level1)
				}
				while( 0 < (p=ws.indexOf(',')) && (ws=ws.slice(1+p)).length );
			}

			return s1 + (FILL?'\0\x02\0\x02':'');
		},
	})

	//==========================================================================
	// PREPROCESSING [ADD200709]
	//==========================================================================

	[PRIVATE]
	
	({

		UNVA: function(/*obj*/TM,/*`(KKKK[=<])+`*/vKeys,  WM,a,n,b,i,k,x,r,t,s,j)
		//----------------------------------
		// (UnVar.) Map the weight string of each `vKeys` class
		// to a new weight string whose V flag is zeroed. Make sure that
		// the resulting weights are ordered as specified in `vKeys`.
		// => new { wsOld => wsNew }
		{
			WM = this.WMAP;
			
			a = vKeys.split(callee.RINF);
			n = a.length;

			for
			(
				b=Array(n), i=-1 ;
				++i < n ;
				(k = callee[a[i].slice(0,4)].charAt(0)),
				(x = parseInt(TM[k]||WM[k],36)),
				((1&x)&&(x^=1)),
				(b[i]=x>>>0)
			);
			b.sort(callee.COMP);

			r = {};
			for( i=-1 ; ++i < n ; )
			{
				x = b[i].toString(36);
				t = a[i].split(callee.REQU);
				while( s=t.shift() )
				{
					s = callee[s]||'';
					for( j=-1 ; ++j < s.length ; k=s.charAt(j), r[TM[k]||WM[k]]=x );
				}
			}

			return r;
		}
		.setup
		({
			COMP: function(x,y){ return x < y ? -1 : +(x!=y) },
			RINF: /\</g,
			REQU: /\=/g,

			// Spaces and hyphens classes used in Word-by-Word system.
			// ---
			SPCE: ' \u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2008\u2009\u200A\u205F\xA0\u2007\u202F',
			HYPH: '-\uFF0D\uFE63\u058A\u2010\u2010\u2011\u2011\u2012\u2013\u2014\u2015',

			// Left-parentheses and commas classes used in Word-by-Word and Letter-by-Letter systems.
			// ---
			LPAR: '(\uFF08\uFE59\u207D\u208D',
			CMMA: ',\uFF0C\uFE50\uFE10',
		}),

		ZPAD: function(/*str*/s)
		//----------------------------------
		// (Zero-Padding.) [CHG210516] Simplified replacement:
		// supports #+ (integers) and #+.# (dot decimal point.)
		// The numeral must start at a word boundary.
		{
			return s.replace(callee.REGX, callee.REPL);
		}
		.setup
		({
			REGX: /\b\d+(?:\.\d|\b)/g, // [CHG210516] Simplified.
			REPL: function($m,p,s,z)
			//----------------------------------
			{
				// $m :: #+ | #+.#
				// ---
				0 <= (p=$m.indexOf('.'))
				? ( s=$m.slice(p), p=$m.slice(0,p) )
				: ( s='', p=$m );
				
				// Prepend '000..'
				// ---
				p.length < (z=callee.ZROS).length && (p=z.concat(p).slice(-z.length));
				
				return p + s;
			}
			.setup
			({
				ZROS: '000000000000',
			}),
		}),
		
		PLBL: function(/*str*/s,  F,re)
		//----------------------------------
		// (Preprocess-Letter-by-Letter.)
		// Remove *initial* left-parentheses and commas.
		{
			F = this.UNVA;
			re = callee.REGX || (callee.REGX=RegExp('^['+RegExp.escape(F.LPAR+F.CMMA)+']+', 'g'));
			return s.replace(re,'');
		},

		PWBW: function(/*str*/s,  F,re1,re2)
		//----------------------------------
		// (Preprocess-Word-by-Word.)
		// [CHG210514] Added 2nd replacement to comply with Chicago Manual of Style [2010, p. 833]
		// (1) Remove *initial* left-parentheses, commas, spaces and hyphens.
		// (2) Remove spaces and hyphens *followed* by left-parenthesis or comma
		{
			F = this.UNVA;
			re1 = callee.REG1 || (callee.REG1=RegExp('^['+RegExp.escape(F.HYPH+F.SPCE+F.LPAR+F.CMMA)+']+', 'g'));
			re2 = callee.REG2 || (callee.REG2=RegExp( '['+RegExp.escape(F.HYPH+F.SPCE)+']+(?=['+RegExp.escape(F.LPAR+F.CMMA)+'])', 'g')); // [ADD210514]
			return s.replace(re1,'').replace(re2,'');
		},

	})

	//==========================================================================
	// LANGUAGES/ISO HELPERS
	//==========================================================================
	
	[PRIVATE]
	
	({
		LCHK: function(  $$,T,L,z,k,t)
		//----------------------------------
		// (Ling-Check.) Check that all reduced tailor keys (~.TLRM) are present in ~.LING.
		// `this` :: ~
		// => 1 [OK]  |  0 [KO]
		{
			$$ = $.global[callee.µ.__root__]; // agnostic reference
			
			T = this.TLRM;
			L = this.LING;
			
			z = 0;
			for( k in T )
			{
				if( !T.hasOwnProperty(k) ) continue;
				if( 'EOR' == k ) continue;
				t = k.split('_')[0];
				L.hasOwnProperty(t) || ( ++z, $$.trace( __("%1 => KO", t) ) );
			}
			
			return z ? 0 : 1;
		},

		ITOK: function(/*str*/isoKey,  T,L,zz,tk,q,S,k,i)
		//----------------------------------
		// (Iso-to-TailorKey.) If isoKey is a tailorKey, return it;
		// otherwise return the best matching tailorKey (if found.)
		// `this` :: ~
		// => key [OK]  |  0 [KO]
		{
			T = this.TLRM;
			if( 'ROOT'==(tk=isoKey.toUpperCase()) || 'EOR' == tk || T.hasOwnProperty(tk=isoKey.toLowerCase()) ) return tk;

			L = this.LING;
			if( !L.hasOwnProperty(tk) ) return 0;
			
			if( !(q=callee.Q) )
			{
				q = callee.Q = [];
				S = this.SUFX;
				for( k in S ) S[k].def && (q[q.length]=k);
			}
			
			for( i=q.length ; i-- ; )if( T.hasOwnProperty(k=tk+q[i]) ) return k;
			return L[tk].dft;
		},

		LIST: function(/*bool=0*/VERBOSE,  q,T,L,S,i,o,k,t,sf,zz,en,na,s)
		//----------------------------------
		// (Ling-List.) Rich array of YALT-localized languages that
		// Collator actually supports or may support in the future.
		// The returned Array has additional mappings:
		//    `_<LocName>`         => <TailorKey>
		//    `µ<LocName>`         => zz  (ISO code, lowercase, 2 or 3 letters, cf Linguist.LISO)
		//    `=<TailorOrIsoKey>   => <LocName>
		//    `§<LocName>`         => <NativeName>
		// `this` :: ~
		// ---
		// => str[]&
		{
			// Cache.
			// ---
			if( (q=callee.DATA).length ) return q;

			T = this.TLRM;
			L = this.LING;
			S = this.SUFX;
			
			i = 0;
			o = {};
			const DF = { def:1, ptn:"%1" };
			for( k in T )
			{
				if( !T.hasOwnProperty(k) ) continue;
				if( 'EOR' == k ) continue;

				// k :: 'de_phone'  ; zz :: 'de' ; sf :: '_phone'  (def=0)
				// k :: 'es_modern' ; zz :: 'es' ; sf :: '_modern' (def=1)
				// k :: 'fr'        ; zz :: 'fr' ; sf :: ''
				// ---
				zz = -1 == (t=k.indexOf('_'))
				? ( (sf=''), k )
				: ( (sf=k.slice(t)), k.slice(0,t) );

				// Nude EN name.
				// E.g "Spanish" | "Emilian-Romagnol" | "Norwegian (Bokmål)" etc
				// ---
				t = L[zz] || 0;                             // { name, dft, natv }
				en = t.name || zz.toUpperCase();
				na = t.natv || en;
				
				// L10N name.
				// ---
				t = (sf && S[sf]) || DF;                    // { def:0|1, ptn:`..%1..` }
				q[i++] = s = __(t.ptn, __(en));             // LocName
				q['_'+s] = k;                               // _LocName => TailorKey
				q['µ'+s] = zz;                              // µLocName => zz [ADD220504]
				q['='+k] = s;                               // =TailorK => LocName
				q['§'+s] = na;                              // §LocName => NatName
				if( t.def )
				{
					zz != k && (q['='+zz]=s);
					o[zz] = 1;                              // Done (no need to parse zz in L.)
				}
			}

			const BP = VERBOSE ? callee.VERB_PTN : 0;
			sf = "%1";
			for( zz in L )
			{
				if( !L.hasOwnProperty(zz) ) continue;
				if(  q.hasOwnProperty('='+zz) || o.hasOwnProperty(zz) ) continue;
				
				t = L[zz];                                  // { name, dft, natv }
				en = t.name;
				na = t.natv||en;
				k =  t.dft||'';                             // 'EOR' | 'ROOT';
				BP && (sf=BP[k.toUpperCase()]||"%1");

				// L10N name.
				// ---
				q[i++] = s = __(sf,__(en));                 // LocName [EOR|DUCET]
				q['_'+s] = k;                               // _LocName => TailorKey
				q['µ'+s] = zz;                              // µLocName => zz [ADD220504]
				q['='+zz] = s;                              // =IsoKey  => LocName
				q['§'+s] = na;                              // §LocName => NatName
			}

			callee.µ.localeSort(q,2,1);
			q.unshift
			(
				__("Default Unicode Collation [DUCET]"),
				__("European Ordering Rules [EOR]"),
				"-"
			);
			s = q[0]; q['_'+s] = q['µ'+s] = q['§'+s] = 'ROOT';         // index 0 : ROOT
			q['=ROOT'] = s;
			s = q[1]; q['_'+s] = q['µ'+s] = q['§'+s] = 'EOR';          // index 1 : EOR
			q['=EOR'] = s;

			return q;
		}
		.setup
		({
			VERB_PTN:
			{
				EOR:  "%1 [EOR]",
				ROOT: "%1 [DUCET]",
			},

			DATA: [],
		}),
		
		SHOW: function(/*str|''*/iso,  host,q,sel,w,t)
		//----------------------------------
		// (Show-List.) Show the Ling-List and let the user select an item.
		// `this` :: ~
		// => tailorKey [OK]  |  false [Cancel]
		{
			host = callee;
			q = this.LIST();

			sel = q.hasOwnProperty('='+iso) ? q['='+iso] : -1;

			w = ScriptUI.builder.call(host,
			{
				properties:                 { type:'dialog', text:host.WIN_TITLE, },
				margins:                    host.MARGINS,
				spacing:                    host.MARGINS,
				orientation:                'column',
				alignChildren:              ScriptUI.CT,

				Group$Main:
				{
					properties:             { },
					margins:                host.MARGINS,
					spacing:                10,
					orientation:            'column',

					DropDownList$List:
					{
						properties:         { items:q },
						optimalSize:        { width:host.WIDTH, height:24 },
						onChange:           callee.ON_LCHG,
					},

					StaticText$Info:
					{
						properties:         { text:'' },
						optimalSize:        { width:host.WIDTH, height:24 },
					},
				},

				Group$Footer:
				{
					orientation:            'row',
					Button$OK:
					{
						properties:         { text:__("OK"), name:'OK' },
					},
					Button$KO:
					{
						properties:         { text:__("Cancel"), name:'Cancel' },
					},
				},
				
				onShow:                      callee.ON_WSHW,
			});
			
			'string' == typeof sel && (sel=w.List.find(sel)) && (callee.ON_WSHW.SEL_IDX=sel.index);

			return 1 == w.show() ? (t=w.List.selection, callee.ON_WSHW.SEL_IDX=t.index, q['_'+t.text]) : false;
		}
		.setup
		({
			WIN_TITLE:   __("Language"),
			WIDTH:       200,
			MARGINS:     20,

			ON_WSHW: function onShow(  idx,wg)
			//----------------------------------
			// this :: Window
			{
				idx = callee.SEL_IDX || 1;
				(wg=this.List).active = true;
				wg.selection = idx;
				wg.onChange();
			}
			.setup
			({
				SEL_IDX: 1,
			}),
			
			ON_LCHG: function onChange(  wg,q,s,tk,bullet,nv)
			//----------------------------------
			// this :: DropDownList
			{
				wg = this.window.Info;
				q = this.properties.items;
				s = this.selection.text;
				tk = q['_'+s];
				bullet = ( 'ROOT'==tk || 'EOR'==tk ) ? '\u25B7' : '\u25B6';
				nv = q['§'+s];
				nv==tk ? (nv='') : (nv=' '+nv);
				wg.text = bullet + nv + '  [' + tk + ']';
			},

		}),

	})

	//==========================================================================
	// API
	//==========================================================================

	[PUBLIC]
	
	({
		sort: function sort_L_ý_bk_o_L(/*str[]&*/arr,/*1|2|3|4=1*/level,/*bool|'LBL'|'WBW'=0*/punctMode,/*{}=0*/ops,  $$,I,WG,TM,noVar,i,t,o)
		//----------------------------------
		// Sort alphabetically an array of *at most 65,534* strings based on the active tailoring rules.
		// A stable sort is performed by default, that is, original ranks are preserved for strings that
		// share the same ordering key. (If a stable sort is not required, set `ops.nonStable`.)
		// ---
		// `arr`          :: Input/ouput array to be reordered.
		// `level`        :: Depth of the collation algorithm:
		//                1 - L1 (default) -> Ignores case/L3 and diacritics/L2 differences.
		//                2 - L1+L2        -> Ignores case/L3 diffs, but orders diacritics/L2 diffs.
		//                3 - L1+L2+L3     -> Full sort.
		//                4 - L1+L3        -> Ignore diacritics/L2 diffs, but orders case/L3 diffs.
		//                                    [ADD200812] Added to allow case-centered sorts.
		// `punctMode`    :: Manages 'variable' elements (mostly punctuation marks.)
		//                falsy  -> Ignores all variable elements (punctuation marks,
		//                          spaces, line breaks, etc). Default option.
		//                truthy -> Takes care of variable elems with respect to their
		//                          respective weight (*<L1>.1.1)
		//                'LBL'  -> Letter-by-Letter system: ignores variable elems
		//                          but left-parentheses and commas (in that order.)
		//                'WBW'  -> Word-by-Word system: ignores variable elems
		//                          but left-parentheses, commas, and spaces/hyphens;
		//                          spaces and hyphens are then considered equivalent.
		// `ops`          :: Additional options supplied as an object:
		//  .sortNumbers  (bool) Whether separate digits sequence should be interpreted
		//                as numbers, and ordered. Default is false.
		//  .nonStable    (bool) Whether stable sort is not required. Default is false.
		//  .upperFirst   (bool) If set, L3 weights will be sorted in reverse order.
		//                Default is false ; this option has no effect if level < 3.
		// ---
		// [ADD200812] Added level 4 and `ops.upperFirst`.
		// [ADD200811] Added stability.
		// [CHG200709] Added `ops` arg -> `ops.sortNumbers`.
		// [CHG200709] Changed `PUNCT_SENSITIVE` arg into `punctMode` with more options.
		// [CHG200618] The character U+0000 ('\0') is in principle not allowed in input
		// strings as it is used internally. However, if a string matches "abc\0...\0xyz",
		// where the first (resp. last) `\0` denotes the first (resp. last) occurence of
		// U+0000, then:
		// (1) Only the `abc` part (prefix) will be considered while computing collation
		//     keys, the next characters being *entirely ignored*.
		// (2) Only the `xyz` part (suffix) *will be present* in the output array. Note
		//     that an input of the form "abc...\0" will lead to an empty output ("").
		// ---
		// => arr&
		{
			$$ = $.global[callee.µ.__root__]; // agnostic reference
			I = callee.µ['~'];
			
			2===level || 3===level || 4===level || (level=1);
			WG = I['WG_'+level];
			(TM=I.TMAP.DATA).__count__ || (TM=I.WMAP);

			// Preprocessing.
			// ---
			const PP = I.SPLT.PREP;
			i = 0;
			ops || (ops={});
			ops.sortNumbers && (PP[i++]='ZPAD');
			
			// [ADD200708] Parse punctMode.
			// ---
			switch( punctMode )
			{
				case 'LBL':
					o = I.UNVA( TM, 'LPAR<CMMA' );
					PP[i++]='PLBL';
					noVar=1; // Ignores other variable elems.
					break;
				case 'WBW':
					o = I.UNVA( TM, 'LPAR<CMMA<SPCE=HYPH' );
					PP[i++]='PWBW';
					noVar=1; // Ignores other variable elems.
					break;
				default:
					o = 0;
					noVar = punctMode ? 0 : 1;
			}
			PP.SIZE = i;

			// [ADD200812] Uppercase first (i.e reverse L3 weights.)
			// Note: has no effect if level < 3.
			// ---
			const RV3 = ops.upperFirst ? 1 : 0;

			// [ADD200811] Stable sort?
			// ---
			const SB = ops.nonStable ? 0 : String.fromCharCode;

			// Sort.
			// ---
			(+$$.trace) && $$.Log.chrono().trace(__("%1 > Sorting the string list at level %2 (%3 elements.)",callee.µ,level,arr.length));
			// ---
			for
			(
				i=arr.length ;
				i-- ;
				(t=arr[i]),
				arr[i] = WG.call(I, I.SPLT(t=String(t)), TM, noVar, o, RV3) + (SB?SB(0,1+i):'') + '\0' + t
			);
			arr.sort();
			for
			(
				i=arr.length ;
				i-- ;
				(t=arr[i]),
				arr[i] = t.slice(1+t.lastIndexOf('\0'))
			);
			// ---
			(+$$.trace) && $$.trace(__("%1 > Collation completed in %2 ms.",callee.µ,+$$.Log.chrono));
			
			return arr;
		},

		setTailor: function setTailor_K$false$_(/*key|false*/isoKey,  $$,I,tk,msg,i,x)
		//----------------------------------
		// Activate the tailoring rules associated to the specified key.
		// (a) If `isoKey` is false or 'ROOT', reset the rules to the DUCET (default ordering)
		// (b) If `isoKey` is a TLRM key ('EOR', 'af', 'ast', ..., 'de_phone'), select it.
		// (c) If `isoKey` is a LING key, select the best matching tailoring rules for that language.
		// ---
		// => undef
		{
			$$ = $.global[callee.µ.__root__]; // agnostic reference
			I = callee.µ['~'];

			// Checkpoint.
			// ---
			( false===isoKey && (isoKey='ROOT') )
			|| 'string'==typeof isoKey
			|| $$.error(__("Wrong `isoKey` argument (%1). String or FALSE expected.",typeof isoKey),callee);

			// Get the implied tailoring key.
			// ---
			( tk=I.ITOK(isoKey) )
			|| $$.error(__("The key %1 is not defined.",isoKey.toSource()),callee);

			// No need to reset the same key.
			// ---
			if( tk == callee.CUR_TK ) return;
			
			// Set/unset the tailoring map.
			// ---
			x = 'ROOT' == tk ? false : I.TLRM[tk];
			(msg=I.TMAP(x)) && $$.error(__("Fatal error: %1.",msg),callee);
			if( +$$.warn ) for( msg=I.TMAP.WARNS, i=-1 ; ++i < msg.length ; $$.warn(__("%1 > %2",callee.µ,msg[i])) );

			// Backup the key.
			// ---
			callee.CUR_TK = tk;

			(+$$.trace) && x && $$.trace(__("%1 > Tailored weights for [%2]: %3", callee.µ, tk, $$.JSON(I.TMAP.DATA)));
		}
		.setup
		({
			CUR_TK: 'ROOT',
		}),

		findTailor: function findTailor_S_K(/*str*/isoKey)
		//----------------------------------
		// If isoKey is a tailorKey, return it; otherwise return the best matching tailorKey (if found.)
		// => key [OK]  |  '' [KO]
		{
			return callee.µ['~'].ITOK(String(isoKey||'ROOT')) || '';
		},

		getTailor: function getTailor_K()
		//----------------------------------
		// Return the active tailor key.
		// E.g: 'ROOT', 'EOR', 'fr', 'de_phone', etc
		// => str
		{
			return callee.µ.setTailor.CUR_TK;
		},
		
		getRichList: function getRichList_t_ËA(/*-1|0|1*/RET_MODE,  a)
		//----------------------------------
		// Get the array of YALT-localized languages that Collator actually supports
		// or may support in the future. The returned Array is an entity with extra
		// mappings:
		//    `_<LocName>`         => <TailorKey>
		//    `µ<LocName>`         => zz  (ISO code, lowercase, 2 or 3 letters, cf Linguist.LISO)
		//                         or ROOT|EOR
		//    `=<TailorOrIsoKey>`  => <LocName>
		//    `§<LocName>`         => <NativeName>
		// [REM] By default indices 0 to 2 are predefined as follows:
		//       0 => <ROOT> ; 1 => <EOR> ; 2 => '-' 
		// Since the returned entity is a reference, make sure you won't alter it. If
		// you need a simple, mutable array, set RET_MODE to 1. In that case
		// index-2 element ('-') is removed
		// [ADD200613] Use RET_MODE == -1 to get a full clone of the rich array instead.
		// ---
		// => str[]& | str[]
		{
			a = callee.µ['~'].LIST();
			switch( RET_MODE||0 )
			{
				case  1: a = a.slice().splice(2,1); break;
				case -1: a = $.global[callee.µ.__root__].clone(a);
				default:;
			}
			return a;
		},
		
		selectLanguage: function selectLanguage_s_(/*?str*/hint,  tk)
		//----------------------------------
		// Open a modal dialog to let the user select a tailoring key
		// throughout a language list. If the user presses OK,
		// µ.setTailor() is called accordingly.
		// `hint` :: if supplied, existing iso or tailorkey (e.g 'es',
		//           'fr', 'es_modern'...) that will be used by default.
		// ---
		// => undef
		{
			(tk=callee.µ['~'].SHOW(hint||'')) && callee.µ.setTailor(tk);
		},

		getLocaleKey: function getLocaleKey_b_K(/*bool=0*/AS_ISO,  µ,zz)
		//----------------------------------
		// Get the most relevant tailor key associated to the Env locale.
		// (The 'ROOT' key is returned as a fallback for CJK locales.)
		// If `AS_ISO` is set, return the iso key (in `zz` form) rather than
		// the corresponding tailor key.
		// => key
		{
			µ = callee.µ;
			zz = callee.LOC2ISO[$.global[µ.__root__].Env.localePrefix()]||'en';
			return AS_ISO ? zz : (µ['~'].ITOK(zz)||'ROOT');
		}
		.setup
		({
			LOC2ISO:
			// Simple ISO keys associated to ID locale names.
			// ---
			{
				ARABIC                 : 'ar',
				CZECH                  : 'cs',
				DANISH                 : 'da',
				ENGLISH                : 'en',
				FINNISH                : 'fi',
				FRENCH                 : 'fr',
				GERMAN                 : 'de',
				GREEK                  : 'el',
				HEBREW                 : 'he',
				HUNGARIAN              : 'hu',
				INTERNATIONAL_ENGLISH  : 'en',
				ITALIAN                : 'it',
				JAPANESE               : 'ja',
				KOREAN                 : 'ko',
				POLISH                 : 'pl',
				PORTUGUESE             : 'pt',
				ROMANIAN               : 'ro',
				RUSSIAN                : 'ru',
				SIMPLIFIED_CHINESE     : 'zh',
				SPANISH                : 'es',
				SWEDISH                : 'sv',
				TRADITIONAL_CHINESE    : 'zh',
				TURKISH                : 'tr',
				UKRAINIAN              : 'uk',
			},
		}),

		localeSort: function localeSort_L_ý_bk_o_L(/*str[]&*/arr,/*1|2|3|4=1*/level,/*bool|'LBL'|WBW'=0*/punctMode,/*{}=0*/ops,  µ,bkp)
		//----------------------------------
		// Sort alphabetically an array of strings based on the current locale ($$.Env.locale.)
		// -> All parameters are detailed in `µ.sort`.
		// This function *temporarily* switches the tailoring rules, then restore them.
		// [REM] Since CJK collation is not supported, the DUCET is used as a fallback.
		// ---
		// => arr&
		{
			µ = callee.µ;
			bkp = µ.getTailor();

			// Adjust the tailor key.
			// ---
			µ.setTailor(µ.getLocaleKey());
			
			// Sort.
			// ---
			µ.sort(arr,level,punctMode||0,ops||0);

			// Restore.
			// ---
			µ.setTailor(bkp);
			
			return arr;
		},
		
		baseKey: function baseKey_S_k_S(/*str*/input,/*?key*/attractor,  I,TM,t,w1,w1Tailored,r,atts,attStr,i,a,s)
		//----------------------------------
		// Get the first 'base key' (usually, a letter) found in the
		// input string w.r.t. the current tailoring rules. A base
		// key is typically an alphabetic character without diacritics.
		// In some cases it may be a n-gram (like 'CH' in Breton or 'LL'
		// in traditional Spanish) or an accented letter ('Ñ' in Spanish,
		// 'Ё' in Belarusian, etc) depending on tailored level1 weights.
		// The result *must be considered case-insensitive* and the
		// function always return the upperCase() form.
		// - attractor :: 'LATIN'|'GREEK'|'CYRILLIC' [more keys coming soon]
		//   If supplied, the 'attractor' specifies a simplified alphabet
		//   within a given writing system (e.g Latin: A..Z) and then
		//   the routine try to coerce unusual letters (`Ⱥ`,`Ɖ`...) having
		//   a dedicated L1 weight into more common letters ('A','D'...).
		//   This feature (experimental!) is not needed for basic diacritics
		//   removal since diacritics are ignored at level 1.
		//   [CHG220409] You can also specifies multiple attractors,
		//   separated by `_`, e.g. 'LATIN_GREEK'. Each individual key
		//   must be a valid attractor per se. Unknown keys are ignored.
		// [ADD220518] Set the `TAILORED_RESULT` flag if a specific tailored
		// base key was returned.
		// ---
		// E.g   µ.baseKey("électeur") => 'E'
		//       µ.baseKey("ǟxxx")     => 'A'
		//       µ.baseKey("ύ...")     => 'Υ' (Greek)
		//       µ.setTailor('es_tradi');µ.baseKey("llamar") => 'LL'
		//       µ.baseKey("ђ...")     => 'Ђ' (Cyrillic)
		// ---
		// => char|str [OK]  |  '' [KO]   ;  + `TAILORED_RESULT` flag
		{
			callee.TAILORED_RESULT = 0;

			if( 'string' != typeof input || (!input.length) ) return '';

			I = callee.µ['~'];
			(TM=I.TMAP.DATA).__count__ || (TM=I.WMAP);
			
			// t :: level1 weight string.
			// E.g "\u75D0\u78C0\u74D0\u7A30\u79F8\u7BA0\u75D0"
			// ---
			t = I.WG_1(I.SPLT(input), TM, 1);  // 1 <-> ignore variable elems
			if( !t.length ) return '';
			
			w1 = t.charAt(0);

			( w1Tailored = callee.TAILORED_RESULT = ((t=I.TMAP.BASE).__count__ && t.hasOwnProperty(w1)) )
			|| (t=I.W1BA);

			r = (t[w1]||'').toUpperCase();
			
			// Attractors only inspect *non-tailored* single char. [FIX220501]
			// ---
			if( !w1Tailored && 1 == r.length && 'string' == typeof attractor )
			for( atts=attractor.toUpperCase().split('_'), t=I.ATTR, i=-1 ; ++i < atts.length ; )
			{
				// Valid attractor key?
				// ---
				if( !(attStr=t[atts[i]]) ) continue;
				
				// Don't go further if r is already in the attractor string `attStr`
				// ---
				if( 0 <= attStr.indexOf(r) ) break;
				
				// There must be as many level1 weights in `a` than characters in `attStr` (1-to-1 mapping.)
				// ---
				if( attStr.length != (a=I.WG_1(I.SPLT(attStr), TM, 1).split('')).length ) continue;
				
				// Find the base key in `attStr`.
				// ---
				if( false!==(s=callee.REFN(w1,attStr,a,false)) ){ r=s; break; }
			}

			return r;
		}
		.setup
		({
			REFN: function(/*char::\uWWWW*/w1,/*strN*/attStr,/*\uWWWW[N]*/attWgs,/*any*/defRet,  n,a,i,x)
			//----------------------------------
			// Find the index `i` s.t. attWgs[i] <= w1 < attWgs[1+i]
			// and return attStr[i] (if found), defRet otherwise.
			{
				// E.g
				// w1     :: "\u74D8"
				// attStr :: "ABCDEFGHIJKLMNOPQRSTUVWXYZ\xDE"
				// attWgs :: ["\u74D0", "\u7518", "\u7550", "\u7590", "\u75D0", "\u7658", "\u7690", "\u76E8", "\u7748", "\u7788", "\u77B8", "\u77F0", "\u7888", "\u78C0", "\u7918", "\u79B0", "\u79F8", "\u7A30", "\u7AF0", "\u7B58", "\u7BA0", "\u7C20", "\u7C58", "\u7C70", "\u7CB0", "\u7CE8", "\u7D50"]

				n = attWgs.length;
				if( 2 > n || w1 < attWgs[0] || attWgs[n-1] <= w1 ) return defRet;
				for
				(
					a=[i=0,n-1] ;
					( ((x=1), w1 < attWgs[i=(a[0]+a[1])>>>1]) || ((x=0),attWgs[1+i] <= w1) ) && ( 1 < a[1]-a[0] || (i=false) ) ;
					a[x] = i
				);
				
				return false===i ? defRet : attStr.charAt(i);
			},
		}),

	})