112 lines
3.8 KiB
Text
112 lines
3.8 KiB
Text
export : define [CreateEmptyTable] {.languages {.} .features {.} .lookups {.}}
|
|
|
|
export : define [pick-language sink tag] : begin
|
|
if sink.languages.(tag) : return sink.languages.(tag)
|
|
define lang {.features {}}
|
|
set sink.languages.(tag) lang
|
|
return lang
|
|
|
|
export : define [copy-language sink tag tagFrom] : begin
|
|
define langFrom : pick-language sink tagFrom
|
|
define langTo : pick-language sink tag
|
|
foreach [feat : items-of langFrom.features] : langTo.features.push feat
|
|
return langTo
|
|
|
|
export : define [add-lang-feature lang fea] : begin
|
|
define index : lang.features.indexOf fea.name
|
|
if (index < 0) : lang.features.push fea.name
|
|
|
|
export : define [add-feature sink tag] : begin
|
|
define lookupArray {}
|
|
local n 0
|
|
while true : begin
|
|
if [not sink.features.(tag + '_' + n)] : begin
|
|
set sink.features.(tag + '_' + n) lookupArray
|
|
return {.name (tag + '_' + n) .lookups lookupArray}
|
|
set n : n + 1
|
|
|
|
export : define [pick-feature sink name] : begin
|
|
if sink.features.(name) : return { .name name .lookups sink.features.(name) }
|
|
define featObj { .name name .lookups {} }
|
|
set sink.features.(name) featObj.lookups
|
|
return featObj
|
|
|
|
export : define [add-feature-lookup fea lookupName] : begin
|
|
define index : fea.lookups.indexOf lookupName
|
|
if (index < 0) : fea.lookups.push lookupName
|
|
|
|
export : define [add-lookup sink data] : begin
|
|
local n 0
|
|
while true : begin
|
|
if [not sink.lookups.('_lut_' + n)] : begin
|
|
set sink.lookups.('_lut_' + n) data
|
|
return ('_lut_' + n)
|
|
set n : n + 1
|
|
|
|
export : define [pick-lookup sink name fallback] : begin
|
|
if sink.lookups.(name) : return sink.lookups.(name)
|
|
set sink.lookups.(name) fallback
|
|
return sink.lookups.(name)
|
|
|
|
export : define [add-common-feature sink fea] : begin
|
|
define dfltDflt : pick-language sink 'DFLT_DFLT'
|
|
define latnDflt : pick-language sink 'latn_DFLT'
|
|
define grekDflt : pick-language sink 'grek_DFLT'
|
|
define cyrlDflt : pick-language sink 'cyrl_DFLT'
|
|
|
|
add-lang-feature dfltDflt fea
|
|
add-lang-feature latnDflt fea
|
|
add-lang-feature grekDflt fea
|
|
add-lang-feature cyrlDflt fea
|
|
|
|
return fea
|
|
|
|
export : define [ChainRuleBuilder sink] : begin
|
|
define [lookup-single f t] : begin
|
|
local subtable {.}
|
|
foreach [j : range 0 f.length] : set subtable.(f.(j)) t.(j)
|
|
return : add-lookup sink {.type 'gsub_single' .subtables {subtable}}
|
|
|
|
define [getsublookup left right] : piecewise
|
|
[not right] null
|
|
([typeof right] === "string") right
|
|
(right <@ Function) : getsublookup left [right left]
|
|
true : begin
|
|
local found null
|
|
foreach [{name lookup} : pairs-of sink.lookups] : match lookup
|
|
{.type "gsub_single" .subtables {st}} : begin
|
|
local check true
|
|
foreach [j : range 0 left.length] : if (st.(left.(j)) !== right.(j)) : set check false
|
|
if check : set found name
|
|
if found : return found
|
|
|
|
return : lookup-single left right
|
|
|
|
define [chain-rule] : begin
|
|
local terms : [{}.slice.call arguments 0].map (x -> [if x.left x {.left x .right null}])
|
|
local subtable {.match {} .apply {} .inputBegins 0 .inputEnds 0}
|
|
local foundi false
|
|
local founde false
|
|
foreach [j : range 0 terms.length] : if (!foundi && terms.(j).right) : begin
|
|
set subtable.inputBegins j
|
|
set foundi true
|
|
foreach [j : range (terms.length - 1) downtill 0] : if (!founde && terms.(j).right) : begin
|
|
set subtable.inputEnds (j + 1)
|
|
set founde true
|
|
foreach [j : range 0 terms.length] : begin
|
|
local term terms.(j)
|
|
subtable.match.push term.left
|
|
local lutn : getsublookup term.left term.right
|
|
if lutn : subtable.apply.push {.at j .lookup lutn}
|
|
return subtable
|
|
|
|
return chain-rule
|
|
|
|
export : define [query-related-glyphs glyphs para entries] : begin
|
|
define sink {}
|
|
foreach [gid : items-of entries] : if glyphs.(gid) : begin
|
|
sink.push gid
|
|
if para.enableCvSs : if glyphs.(gid).featureSelector : begin
|
|
foreach [{k v} : pairs-of glyphs.(gid).featureSelector] : begin
|
|
sink.push v
|
|
return sink
|