ranger-compiler 3.5.1 → 3.5.2

package/dist/lib/evg/EVGHostMeasurerTest.rgr

@@ -0,0 +1,281 @@
+; SPDX-License-Identifier: MIT
+
+; ==============================================================================
+; EVGHostMeasurerTest — does a platform's one function reach every layout?
+; ==============================================================================
+;
+; `EVGHostTextMeasurer` is the seam PLAN_NATIVE_HOSTS.md S0 adds: a platform
+; hands over one function and every layout in the process measures with it.
+; This drives the Ranger half with a made-up platform — widths and vertical
+; metrics nothing like the table's, so a layout that still used the table
+; is caught by the numbers — and asks:
+;
+;   * does a layout built after `EVGDefaultMeasurer.install` measure with it,
+;     with no call on the layout itself, and one built after `clear` not;
+;   * does the `-Bold` suffix `effectiveFontFamily` writes reach the host as
+;     a flag, with the family stripped;
+;   * is the platform asked for a face's vertical metrics ONCE per face and
+;     never per run, and for a width once per distinct run through the
+;     engine's cache;
+;   * does `line-height: normal` become the face's own line box;
+;   * does an unattached measurer fall back to the table, and does attaching
+;     later move `measureKey` so an engine re-measures;
+;   * does a text node in a real layout wrap where the host's widths say.
+;
+;   npm run evg:hostmeasurer:test
+; ==============================================================================
+
+Import "EVGHostTextMeasurer.rgr"
+Import "EVGTextEngine.rgr"
+Import "EVGLayout.rgr"
+Import "EVGElement.rgr"
+Import "EVGUnit.rgr"
+
+class EVGHostMeasurerTest {
+    def passed:int 0
+    def failed:int 0
+    ; What the fake platform was asked, for the assertions on call counts
+    ; and on what reached it.
+    def lastFamily:string ""
+    def lastBold:boolean false
+    def lastText:string ""
+
+    sfn m@(main):void () {
+        def t (new EVGHostMeasurerTest())
+        t.run()
+    }
+
+    fn ok:void (what:string cond:boolean) {
+        if cond {
+            passed = (passed + 1)
+            print ("  PASS  " + what)
+        } {
+            failed = (failed + 1)
+            print ("  FAIL  " + what)
+        }
+    }
+
+    fn near:void (what:string a:double b:double) {
+        def d:double (a - b)
+        if (d < 0.0) {
+            d = (0.0 - d)
+        }
+        this.ok((what + " (" + (to_string a) + " vs " + (to_string b) + ")") (d < 0.001))
+    }
+
+    ; The made-up platform: every glyph is 0.7em wide (0.9em bold), the
+    ; ascent 1.0em, the descent 0.3em, the gap 0.2em — so the normal line box
+    ; is 1.5em where the table says 1.15, and no width agrees with the table.
+    fn fakePlatform:EVGHostTextMeasurer () {
+        def hm (new EVGHostTextMeasurer())
+        hm.attach((fn:double (kind:int text:string family:string size:double bold:boolean italic:boolean) {
+            lastFamily = family
+            lastBold = bold
+            lastText = text
+            if (kind == 0) {
+                def per:double 0.7
+                if bold {
+                    per = 0.9
+                }
+                return ((to_double (strlen text)) * size * per)
+            }
+            if (kind == 1) {
+                return (size * 1.0)
+            }
+            if (kind == 2) {
+                return (size * 0.3)
+            }
+            return (size * 0.2)
+        }) "fake")
+        return hm
+    }
+
+    fn run:void () {
+        print "=== EVGHostTextMeasurer ==="
+        this.testDefaultReachesFreshLayouts()
+        this.testBoldSuffix()
+        this.testFaceCacheAndRunCache()
+        this.testLineHeight()
+        this.testUnattachedFallsBackThenAttaches()
+        this.testWrapInRealLayout()
+        this.testHasFace()
+        EVGDefaultMeasurer.uninstall()
+        print ""
+        print ("passed = " + (to_string passed) + "  failed = " + (to_string failed))
+        if (failed > 0) {
+            print "FAILURES"
+        } {
+            print "ALL PASS"
+        }
+    }
+
+    fn testDefaultReachesFreshLayouts:void () {
+        print "-- the default reaches a layout that never heard of it"
+        EVGDefaultMeasurer.uninstall()
+        def before (new EVGLayout())
+        def te0:EVGTextEngine (before.getTextEngine())
+        def m0:EVGTextMetrics (te0.measureRun("abcd" "sans-serif" 10.0))
+        this.ok("without an install a layout measures with the table" (m0.width < 28.0))
+
+        def hm:EVGHostTextMeasurer (this.fakePlatform())
+        EVGDefaultMeasurer.install(hm)
+        this.ok("isInstalled" (EVGDefaultMeasurer.isInstalled()))
+        def lay (new EVGLayout())
+        def te:EVGTextEngine (lay.getTextEngine())
+        def m:EVGTextMetrics (te.measureRun("abcd" "sans-serif" 10.0))
+        this.near("a fresh layout measures with the host" m.width 28.0)
+        this.ok("and reports itself font-accurate" (te.measurer.isFontAccurate()))
+
+        def eng (new EVGTextEngine())
+        def m2:EVGTextMetrics (eng.measureRun("ab" "sans-serif" 10.0))
+        this.near("a fresh engine too" m2.width 14.0)
+
+        EVGDefaultMeasurer.uninstall()
+        def after (new EVGLayout())
+        def te2:EVGTextEngine (after.getTextEngine())
+        def m3:EVGTextMetrics (te2.measureRun("abcd" "sans-serif" 10.0))
+        this.ok("after clear a new layout is back on the table" (m3.width < 28.0))
+        this.near("and the old one keeps the host it was built with" ((te.measureRun("abcd" "sans-serif" 10.0)).width) 28.0)
+    }
+
+    fn testBoldSuffix:void () {
+        print "-- the -Bold suffix reaches the host as a flag"
+        def hm:EVGHostTextMeasurer (this.fakePlatform())
+        def m:EVGTextMetrics (hm.measureText("ab" "Inter-Bold" 10.0))
+        this.ok("family stripped" (lastFamily == "Inter"))
+        this.ok("bold set" lastBold)
+        this.near("bold width" m.width 18.0)
+        def m2:EVGTextMetrics (hm.measureText("ab" "Inter" 10.0))
+        this.ok("plain family unchanged" (lastFamily == "Inter"))
+        this.ok("bold clear" (lastBold == false))
+        this.near("plain width" m2.width 14.0)
+        this.ok("a family that merely ends in Bold is not stripped twice" ((EVGHostTextMeasurer.baseFamily("Bold")) == "Bold"))
+        def el (EVGElement.createSpan())
+        el.setAttribute("font-family" "Inter")
+        el.setAttribute("font-weight" "bold")
+        this.ok("effectiveFontFamily is Family-Bold" ((el.effectiveFontFamily()) == "Inter-Bold"))
+    }
+
+    fn testFaceCacheAndRunCache:void () {
+        print "-- the platform is asked per face and per distinct run, not per call"
+        def hm:EVGHostTextMeasurer (this.fakePlatform())
+        def eng (new EVGTextEngine())
+        eng.setMeasurer(hm)
+        def i:int 0
+        while (i < 50) {
+            eng.measureRun("hello" "sans-serif" 12.0)
+            eng.measureRun("hello world" "sans-serif" 12.0)
+            i = (i + 1)
+        }
+        this.ok("three vertical calls for one face" (hm.faceCalls == 3))
+        this.ok("two width calls for two runs through the engine" (hm.widthCalls == 2))
+        eng.measureRun("hello" "sans-serif-Bold" 12.0)
+        this.ok("a bold face is a second face" (hm.faceCalls == 6))
+        eng.measureRun("hello" "sans-serif" 13.0)
+        this.ok("a size is a third" (hm.faceCalls == 9))
+        this.ok("the empty run costs no width call" (((hm.measureText("" "sans-serif" 12.0)).width) == 0.0))
+        this.ok("and asked the host for nothing" (hm.widthCalls == 4))
+    }
+
+    fn testLineHeight:void () {
+        print "-- line-height: normal is the face's line box"
+        def hm:EVGHostTextMeasurer (this.fakePlatform())
+        this.near("ascent + descent + gap" (hm.getLineHeight("sans-serif" 10.0)) 15.0)
+        def m:EVGTextMetrics (hm.measureText("x" "sans-serif" 10.0))
+        this.near("ascent" m.ascent 10.0)
+        this.near("descent" m.descent 3.0)
+        this.near("the run carries the same line height" m.lineHeight 15.0)
+        ; A host that does not know the gap says so with a negative number.
+        def noGap (new EVGHostTextMeasurer())
+        noGap.attach((fn:double (kind:int text:string family:string size:double bold:boolean italic:boolean) {
+            if (kind == 3) {
+                return (0.0 - 1.0)
+            }
+            if (kind == 0) {
+                return (size * (to_double (strlen text)))
+            }
+            return (size * 0.5)
+        }) "nogap")
+        this.near("an unknown gap is zero, not negative" (noGap.getLineHeight("sans-serif" 10.0)) 10.0)
+    }
+
+    fn testUnattachedFallsBackThenAttaches:void () {
+        print "-- unattached measures like the table; attaching moves the key"
+        def hm (new EVGHostTextMeasurer())
+        def table (new SimpleTextMeasurer())
+        def a:EVGTextMetrics (hm.measureText("Päiväkirja" "sans-serif" 14.0))
+        def b:EVGTextMetrics (table.measureText("Päiväkirja" "sans-serif" 14.0))
+        this.near("width as the table" a.width b.width)
+        this.near("line height as the table" (hm.getLineHeight("sans-serif" 14.0)) (table.getLineHeight("sans-serif" 14.0)))
+        this.ok("not font-accurate before attach" ((hm.isFontAccurate()) == false))
+        this.ok("no face before attach" ((hm.hasFace("sans-serif")) == false))
+        def k0:string (hm.measureKey())
+        def eng (new EVGTextEngine())
+        eng.setMeasurer(hm)
+        def w0:double ((eng.measureRun("hello" "sans-serif" 10.0)).width)
+        hm.attach((fn:double (kind:int text:string family:string size:double bold:boolean italic:boolean) {
+            if (kind == 0) {
+                return (size * 2.0 * (to_double (strlen text)))
+            }
+            return (size * 0.5)
+        }) "late")
+        def k1:string (hm.measureKey())
+        this.ok("the key moved" (k0 != k1))
+        this.ok("the key names the host" ((indexOf k1 "late") >= 0))
+        def w1:double ((eng.measureRun("hello" "sans-serif" 10.0)).width)
+        this.ok("the engine measured again without clearCache" (w1 != w0))
+        this.near("with the host's width" w1 100.0)
+        hm.invalidate()
+        this.ok("invalidate moves the key again" ((hm.measureKey()) != k1))
+    }
+
+    fn testWrapInRealLayout:void () {
+        print "-- a text node wraps where the host's widths say"
+        ; 0.7em a glyph at 10px is 7px; "aaaa bbbb cccc" is 14 glyphs = 98px.
+        ; In a 60px box the host wraps it into three lines; the table
+        ; (0.556em) fits "aaaa bbbb" in 50px and makes two.
+        def hm:EVGHostTextMeasurer (this.fakePlatform())
+        EVGDefaultMeasurer.install(hm)
+        def root (EVGElement.createDiv())
+        root.setAttribute("width" "60px")
+        root.setAttribute("height" "200px")
+        def span (EVGElement.createSpan())
+        span.setAttribute("width" "60px")
+        span.setAttribute("font-size" "10px")
+        span.setAttribute("font-family" "sans-serif")
+        span.textContent = "aaaa bbbb cccc"
+        root.addChild(span)
+        def lay (new EVGLayout())
+        lay.setPageSize(60.0 200.0)
+        lay.layout(root)
+        ; Three lines of the face's 15px line box.
+        this.near("three lines at the host's line height" span.calculatedHeight 45.0)
+        def te:EVGTextEngine (lay.getTextEngine())
+        this.ok("the engine counts three" ((te.lineCount("aaaa bbbb cccc" "sans-serif" 10.0 60.0)) == 3))
+        EVGDefaultMeasurer.uninstall()
+        def lay2 (new EVGLayout())
+        def root2 (EVGElement.createDiv())
+        root2.setAttribute("width" "60px")
+        root2.setAttribute("height" "200px")
+        def span2 (EVGElement.createSpan())
+        span2.setAttribute("width" "60px")
+        span2.setAttribute("font-size" "10px")
+        span2.setAttribute("font-family" "sans-serif")
+        span2.textContent = "aaaa bbbb cccc"
+        root2.addChild(span2)
+        lay2.setPageSize(60.0 200.0)
+        lay2.layout(root2)
+        this.ok("the table makes fewer" (span2.calculatedHeight < 45.0))
+    }
+
+    fn testHasFace:void () {
+        print "-- hasFace: a substituting host has every face, a strict one names them"
+        def hm:EVGHostTextMeasurer (this.fakePlatform())
+        this.ok("resolvesAll by default" (hm.hasFace("Whatever")))
+        hm.setResolvesAll(false)
+        this.ok("strict: unknown family has no face" ((hm.hasFace("Whatever")) == false))
+        hm.addKnownFamily("Inter")
+        this.ok("strict: a known family has one" (hm.hasFace("Inter")))
+        this.ok("strict: and its bold" (hm.hasFace("Inter-Bold")))
+    }
+}

package/dist/lib/evg/EVGHostTextMeasurer.rgr

@@ -0,0 +1,331 @@
+; SPDX-License-Identifier: MIT
+
+; ==============================================================================
+; EVGHostTextMeasurer — the platform measures, EVG breaks the lines
+; ==============================================================================
+;
+; PLAN_NATIVE_HOSTS.md, decision D3 and stage S0. Every painter below the
+; display list draws text with a face the PLATFORM chose — a browser's font
+; stack, CoreText on Apple, a `Typeface` on Android — while the layout above
+; it measured the run with `SimpleTextMeasurer`'s advance table, a snapshot of
+; one browser's sans fallback taken once. Where the two faces differ, a run
+; is drawn wider or narrower than the box that was sized for it: a label
+; clips, a caret lands beside its glyphs, a line wraps that paint would not
+; have wrapped.
+;
+; This measurer closes that gap the way `EVGContextMeasurer` closes it for
+; the software canvas: the host that will paint is the host that measures.
+; It is GENERIC on purpose — one measurer, every platform, every app — and
+; the whole of what a platform has to provide is ONE FUNCTION:
+;
+;     metric(kind text family size bold italic) -> double
+;
+;       kind 0  the advance width of `text` set in that face at that size
+;       kind 1  the face's ascent, in pixels, at that size   (text ignored)
+;       kind 2  the face's descent                            (text ignored)
+;       kind 3  the face's line gap, or a negative number for "unknown"
+;
+; The host writes it in its own language against its own text API — canvas
+; `measureText`, `CTLineGetTypographicBounds`, `Paint.measureText` — and
+; hands it over with `attach`. Everything else is here, written once:
+; the per-face cache of the vertical metrics (three host calls per face,
+; not three per run), the `-Bold` convention `EVGElement.effectiveFontFamily`
+; encodes the weight in, the cache key the text engine needs, and the
+; fallback to the table when no host has attached yet, so an app can install
+; this at start-up and attach the platform later — a browser after
+; `document.fonts.ready` — without ever measuring nothing.
+;
+; WHY A FUNCTION AND NOT A SUBCLASS. A host could extend this class in its own
+; language and override `measureText`; JavaScript, Swift and Kotlin all
+; allow it. But then each of the three hosts owns a copy of the face cache,
+; the weight convention and the key — the three things that were wrong in
+; three different ways when five painters each walked the tree. A closure
+; keeps the platform's contribution to the one thing only the platform
+; knows, and Ranger's lambda fields compile to a settable property of
+; function type on every target (`(Int, String, …) -> Double` in Kotlin, an
+; `@escaping` closure in Swift, a plain property in ES6).
+;
+; WHAT IT MEANS FOR PRINT PARITY. Nothing. The lines are still broken here,
+; by `EVGTextEngine`, one run per line; a PDF laid out with the TTF measurer
+; and a screen laid out with this one agree wherever they share a face, and
+; where they do not, the screen is now honest about its own face rather
+; than pretending to be the table.
+;
+; See `EVGHostMeasurerTest.rgr` (`npm run evg:hostmeasurer:test`) and the
+; three hosts: `gl/evg-measure.js`, `apple/Sources/CoreTextMeasurer.swift`,
+; `android/src/…/AndroidTextMeasurer.kt` (with its Java2D twin).
+; ==============================================================================
+
+Import "EVGTextMeasurer.rgr"
+
+class EVGHostTextMeasurer {
+    Extends(EVGTextMeasurer)
+
+    ; The one function. Unset until the host attaches; every question is then
+    ; answered by `fallback` below, so a measurer that was installed before
+    ; its platform arrived measures like the table did, not like nothing.
+    def metricFn@(optional):(fn:double (kind:int text:string family:string size:double bold:boolean italic:boolean))
+    def attached:boolean false
+    ; Which platform is on the other end — "canvas", "coretext", "android",
+    ; "awt", or whatever the host calls itself. It goes into `measureKey`, so
+    ; a text engine that outlives a host swap cannot hand back the old host's
+    ; widths.
+    def hostName:string ""
+    ; Bumped by `attach`, `detach` and `invalidate`. Same reason: the engine
+    ; caches by `measureKey`, and a face that finished loading is a different
+    ; answer to the same question.
+    def generation:int 0
+
+    ; Does the platform draw SOMETHING for every family it is asked for? A
+    ; browser's font stack and CoreText both substitute, so every family
+    ; "has a face" — the face the painter will use — and warning about it
+    ; would warn about every label on the page. A host that bundles exact
+    ; TTFs and wants a missing one reported sets this false and names what
+    ; it has through `addKnownFamily`.
+    def resolvesAll:boolean true
+    def known:[string]
+
+    ; The face cache: key -> ascent, descent, line gap, in pixels. A face is
+    ; a family, a size, a weight and a slant; a page asks for a handful of
+    ; them and thousands of runs in each, so the three vertical questions
+    ; are asked once per face and never per run.
+    def faceKeys:[string]
+    def faceAsc:[double]
+    def faceDesc:[double]
+    def faceGap:[double]
+    ; The last face looked up, because a wrap asks the same face for every
+    ; candidate line and a linear search over a dozen keys per call adds up.
+    def lastKey:string ""
+    def lastIdx:int (0 - 1)
+
+    ; How many times the host has been called, by kind. For the test and for
+    ; a bench: a measurer that calls the platform per character instead of
+    ; per run would pass every width check and cost a frame.
+    def widthCalls:int 0
+    def faceCalls:int 0
+
+    ; Answers everything while no host is attached.
+    def fallback:SimpleTextMeasurer (new SimpleTextMeasurer())
+
+    Constructor () {
+    }
+
+    ; --- the kinds, by name -------------------------------------------------
+
+    sfn KIND_WIDTH:int () {
+        return 0
+    }
+
+    sfn KIND_ASCENT:int () {
+        return 1
+    }
+
+    sfn KIND_DESCENT:int () {
+        return 2
+    }
+
+    sfn KIND_GAP:int () {
+        return 3
+    }
+
+    ; --- attaching the platform ---------------------------------------------
+
+    fn attach:void (f:(fn:double (kind:int text:string family:string size:double bold:boolean italic:boolean)) name:string) {
+        metricFn = f
+        hostName = name
+        attached = true
+        this.invalidate()
+    }
+
+    fn detach:void () {
+        attached = false
+        this.invalidate()
+    }
+
+    ; The host's answers changed — a face finished loading, the device's
+    ; font settings moved. The cache is dropped and the key moves on, so
+    ; every engine holding this measurer measures again.
+    fn invalidate:void () {
+        generation = (generation + 1)
+        def fk:[string]
+        faceKeys = fk
+        def fa:[double]
+        faceAsc = fa
+        def fd:[double]
+        faceDesc = fd
+        def fg:[double]
+        faceGap = fg
+        lastKey = ""
+        lastIdx = (0 - 1)
+    }
+
+    fn setResolvesAll:void (b:boolean) {
+        resolvesAll = b
+    }
+
+    fn addKnownFamily:void (name:string) {
+        if ((strlen name) == 0) {
+            return
+        }
+        def i:int 0
+        while (i < (array_length known)) {
+            if ((itemAt known i) == name) {
+                return
+            }
+            i = (i + 1)
+        }
+        push known name
+    }
+
+    fn isAttached:boolean () {
+        return attached
+    }
+
+    ; --- the EVGTextMeasurer contract ---------------------------------------
+
+    fn isFontAccurate:boolean () {
+        return attached
+    }
+
+    fn hasFace:boolean (fontFamily:string) {
+        if (attached == false) {
+            return false
+        }
+        if resolvesAll {
+            return true
+        }
+        def base:string (EVGHostTextMeasurer.baseFamily(fontFamily))
+        def i:int 0
+        while (i < (array_length known)) {
+            if ((itemAt known i) == base) {
+                return true
+            }
+            i = (i + 1)
+        }
+        return false
+    }
+
+    fn measureKey:string () {
+        def out@(mutable):string ("host:" + hostName + ":" + (to_string generation))
+        if (attached == false) {
+            out = (out + ":table")
+        }
+        return out
+    }
+
+    ; --- the family convention ------------------------------------------------
+    ;
+    ; `EVGElement.effectiveFontFamily` hands the layout `Family-Bold` for a
+    ; bold element and `Family` otherwise; that suffix is the only way the
+    ; weight reaches a measurer, and `FontManager.getFont` reads the same
+    ; convention for print. Italic has no such suffix today, so a slanted run
+    ; is measured upright — the same thing the table did, recorded here
+    ; rather than hidden.
+
+    sfn isBoldFace:boolean (face:string) {
+        def n:int (strlen face)
+        if (n < 6) {
+            return false
+        }
+        def tail:string (substring face (n - 5) n)
+        return (tail == "-Bold")
+    }
+
+    sfn baseFamily:string (face:string) {
+        if (EVGHostTextMeasurer.isBoldFace(face)) {
+            def n:int (strlen face)
+            return (substring face 0 (n - 5))
+        }
+        return face
+    }
+
+    ; --- the face cache -------------------------------------------------------
+
+    fn faceIndex:int (family:string size:double bold:boolean) {
+        def key:string (family + "|" + (to_string size) + "|" + (to_string bold))
+        if (key == lastKey) {
+            return lastIdx
+        }
+        def i:int 0
+        while (i < (array_length faceKeys)) {
+            if ((itemAt faceKeys i) == key) {
+                lastKey = key
+                lastIdx = i
+                return i
+            }
+            i = (i + 1)
+        }
+        def f:(fn:double (kind:int text:string family:string size:double bold:boolean italic:boolean)) (unwrap metricFn)
+        def asc:double (f(1 "" family size bold false))
+        def desc:double (f(2 "" family size bold false))
+        def gap:double (f(3 "" family size bold false))
+        faceCalls = (faceCalls + 3)
+        ; A host that cannot say what the gap is says so with a negative
+        ; number; the line box is then the face's ascent and descent alone.
+        if (gap < 0.0) {
+            gap = 0.0
+        }
+        ; A host that answers nothing for the vertical — a canvas without
+        ; `fontBoundingBox*`, say — gets the table's proportions, which are
+        ; measured off a real face rather than made up.
+        if ((asc + desc) <= 0.0) {
+            asc = (size * (EVGTextMeasurer.fallbackAscentEm()))
+            desc = (size * (EVGTextMeasurer.fallbackDescentEm()))
+        }
+        push faceKeys key
+        push faceAsc asc
+        push faceDesc desc
+        push faceGap gap
+        lastKey = key
+        lastIdx = ((array_length faceKeys) - 1)
+        return lastIdx
+    }
+
+    ; --- measurement ------------------------------------------------------------
+
+    fn measureText:EVGTextMetrics (text:string fontFamily:string fontSize:double) {
+        if (attached == false) {
+            return (fallback.measureText(text fontFamily fontSize))
+        }
+        def bold:boolean (EVGHostTextMeasurer.isBoldFace(fontFamily))
+        def family:string (EVGHostTextMeasurer.baseFamily(fontFamily))
+        def fi:int (this.faceIndex(family fontSize bold))
+        def w:double 0.0
+        if ((strlen text) > 0) {
+            def f:(fn:double (kind:int text:string family:string size:double bold:boolean italic:boolean)) (unwrap metricFn)
+            w = (f(0 text family fontSize bold false))
+            widthCalls = (widthCalls + 1)
+        }
+        def asc:double (itemAt faceAsc fi)
+        def desc:double (itemAt faceDesc fi)
+        def gap:double (itemAt faceGap fi)
+        def m (new EVGTextMetrics())
+        m.width = w
+        m.ascent = asc
+        m.descent = desc
+        m.lineHeight = (asc + desc + gap)
+        m.height = m.lineHeight
+        return m
+    }
+
+    fn measureTextWidth:double (text:string fontFamily:string fontSize:double) {
+        def m:EVGTextMetrics (this.measureText(text fontFamily fontSize))
+        return m.width
+    }
+
+    ; `line-height: normal` is the face's own line box — ascent, descent and
+    ; the gap the face asks for between lines. The table says 1.15em for its
+    ; sans; a host says what its face says.
+    fn getLineHeight:double (fontFamily:string fontSize:double) {
+        if (attached == false) {
+            return (fallback.getLineHeight(fontFamily fontSize))
+        }
+        def bold:boolean (EVGHostTextMeasurer.isBoldFace(fontFamily))
+        def family:string (EVGHostTextMeasurer.baseFamily(fontFamily))
+        def fi:int (this.faceIndex(family fontSize bold))
+        def asc:double (itemAt faceAsc fi)
+        def desc:double (itemAt faceDesc fi)
+        def gap:double (itemAt faceGap fi)
+        return (asc + desc + gap)
+    }
+}