ranger-compiler 3.5.1 → 3.5.2

package/dist/lib/evg/EVGGradient.rgr

@@ -0,0 +1,322 @@
+; SPDX-License-Identifier: MIT
+
+; EVGGradient.rgr - Gradient parsing and storage for EVG layout
+; Supports: linear-gradient, radial-gradient with multiple color stops
+
+Import "EVGColor.rgr"
+
+; A single color stop in a gradient
+class EVGGradientStop {
+    def percentage:double 0.0   ; 0.0 to 1.0 (or 0 to 100 if not normalized)
+    def color:EVGColor (new EVGColor())
+    
+    Constructor () {
+    }
+    
+    sfn create:EVGGradientStop (pct:double col:EVGColor) {
+        def stop:EVGGradientStop (new EVGGradientStop())
+        stop.percentage = pct
+        stop.color = col
+        return stop
+    }
+}
+
+; Gradient definition with type, angle, and color stops
+class EVGGradient {
+    def isSet:boolean false
+    def isLinear:boolean true     ; true = linear, false = radial
+    def angle:double 0.0          ; degrees for linear gradient (0 = to top, 90 = to right)
+    def stops:[EVGGradientStop]
+    
+    Constructor () {
+        def s:[EVGGradientStop]
+        stops = s
+    }
+    
+    ; Get the first color (for simple 2-color gradients)
+    fn getStartColor:EVGColor () {
+        if ((array_length stops) > 0) {
+            def stop:EVGGradientStop (itemAt stops 0)
+            return stop.color
+        }
+        return (EVGColor.noColor())
+    }
+    
+    ; Get the last color (for simple 2-color gradients)
+    fn getEndColor:EVGColor () {
+        def len:int (array_length stops)
+        if (len > 0) {
+            def stop:EVGGradientStop (itemAt stops (len - 1))
+            return stop.color
+        }
+        return (EVGColor.noColor())
+    }
+    
+    ; Get number of color stops
+    fn getStopCount:int () {
+        return (array_length stops)
+    }
+    
+    ; Get a specific color stop
+    fn getStop:EVGGradientStop (index:int) {
+        return (itemAt stops index)
+    }
+    
+    ; Add a color stop
+    fn addStop:void (percentage:double color:EVGColor) {
+        def stop:EVGGradientStop (EVGGradientStop.create(percentage color))
+        push stops stop
+    }
+    
+    ; Parse a CSS gradient string like:
+    ; linear-gradient(90deg, #3498db, #9b59b6)
+    ; linear-gradient(45deg, #e74c3c, #f39c12)
+    ; radial-gradient(circle, #9b59b6, #2c3e50)
+    ; linear-gradient(90deg, #e74c3c, #f39c12, #2ecc71, #3498db)
+    sfn parse:EVGGradient (gradStr:string) {
+        def grad:EVGGradient (new EVGGradient())
+
+        def len:int (strlen gradStr)
+        if (len == 0) {
+            return grad
+        }
+
+        def linearIdx:int (indexOf gradStr "linear-gradient")
+        def radialIdx:int (indexOf gradStr "radial-gradient")
+
+        if (linearIdx >= 0) {
+            grad.isLinear = true
+            grad.isSet = true
+            ; CSS with no direction runs TOP TO BOTTOM. The field's own default
+            ; is 0 — to the top — so a gradient written the shortest way came
+            ; out upside down, and every painter agreed with the other about
+            ; the wrong answer.
+            grad.angle = 180.0
+        }
+        if (radialIdx >= 0) {
+            grad.isLinear = false
+            grad.isSet = true
+        }
+
+        if (grad.isSet == false) {
+            return grad
+        }
+
+        ; The arguments, split where CSS splits them. A naive split on every
+        ; comma cuts `rgb(52,120,90)` into three pieces that are not colors,
+        ; which is why a gradient written in `rgb()` used to parse to a
+        ; gradient with NO STOPS — and an element with no stops emitted no
+        ; background at all, so the node disappeared from the picture.
+        def args:[string]
+        EVGGradient.splitArgs(gradStr args)
+        def n:int (array_length args)
+        if (n == 0) {
+            return grad
+        }
+
+        def first:int 0
+        def head:string (trim (itemAt args 0))
+        if ((EVGGradient.colorOf(head)).isSet) {
+        } {
+            ; Not a color, so it is the direction (or a radial's shape).
+            first = 1
+            if grad.isLinear {
+                grad.angle = (EVGGradient.angleOf(head grad.angle))
+            }
+        }
+
+        def colors:[EVGColor]
+        def stopsAt:[double]
+        def i:int first
+        while (i < n) {
+            def arg:string (trim (itemAt args i))
+            def col:EVGColor (EVGGradient.colorOf(arg))
+            if col.isSet {
+                push colors col
+                push stopsAt (EVGGradient.positionOf(arg))
+            }
+            i = (i + 1)
+        }
+
+        def numColors:int (array_length colors)
+        if (numColors > 0) {
+            def colorIdx:int 0
+            while (colorIdx < numColors) {
+                def pct:double (itemAt stopsAt colorIdx)
+                if (pct < 0.0) {
+                    pct = 0.0
+                    if (numColors > 1) {
+                        pct = ((to_double colorIdx) / (to_double (numColors - 1)))
+                    }
+                }
+                def col:EVGColor (itemAt colors colorIdx)
+                grad.addStop(pct col)
+                colorIdx = colorIdx + 1
+            }
+        }
+
+        return grad
+    }
+
+    ; What is inside the outermost parentheses, cut at the commas that are not
+    ; inside a nested call.
+    sfn splitArgs:void (src:string out:[string]) {
+        def len:int (strlen src)
+        def open:int (indexOf src "(")
+        if (open < 0) {
+            return
+        }
+        def depth:int 0
+        def cur:string ""
+        def i:int open
+        while (i < len) {
+            def c:int (charAt src i)
+            if (c == 40) {
+                depth = (depth + 1)
+                if (depth > 1) {
+                    cur = (cur + "(")
+                }
+            } {
+                if (c == 41) {
+                    depth = (depth - 1)
+                    if (depth == 0) {
+                        if ((strlen (trim cur)) > 0) {
+                            push out cur
+                        }
+                        return
+                    }
+                    cur = (cur + ")")
+                } {
+                    if ((c == 44) && (depth == 1)) {
+                        if ((strlen (trim cur)) > 0) {
+                            push out cur
+                        }
+                        cur = ""
+                    } {
+                        cur = (cur + (substring src i (i + 1)))
+                    }
+                }
+            }
+            i = (i + 1)
+        }
+        if ((strlen (trim cur)) > 0) {
+            push out cur
+        }
+    }
+
+    ; The color in one argument, ignoring a stop position written after it.
+    ; `rgb(…)` and friends end at their own closing bracket; everything else
+    ; ends at the first space.
+    sfn colorOf:EVGColor (arg:string) {
+        def text:string (trim arg)
+        def n:int (strlen text)
+        if (n == 0) {
+            return (EVGColor.noColor())
+        }
+        def close:int (indexOf text ")")
+        if (close >= 0) {
+            return (EVGColor.parse((substring text 0 (close + 1))))
+        }
+        def sp:int (indexOf text " ")
+        if (sp > 0) {
+            return (EVGColor.parse((substring text 0 sp)))
+        }
+        return (EVGColor.parse(text))
+    }
+
+    ; A stop written as a percentage, or -1 when the argument does not say.
+    sfn positionOf:double (arg:string) {
+        def text:string (trim arg)
+        def pct:int (indexOf text "%")
+        if (pct <= 0) {
+            return (0.0 - 1.0)
+        }
+        def start:int pct
+        while (start > 0) {
+            def c:int (charAt text (start - 1))
+            def isNum:boolean (((c >= 48) && (c <= 57)) || ((c == 46) || (c == 45)))
+            if (isNum == false) {
+                break
+            }
+            start = (start - 1)
+        }
+        if (start == pct) {
+            return (0.0 - 1.0)
+        }
+        def v@(optional):double (to_double (substring text start pct))
+        if (null? v) {
+            return (0.0 - 1.0)
+        }
+        return ((unwrap v) / 100.0)
+    }
+
+    ; `45deg`, or the `to …` keywords CSS accepts in place of one. An angle is
+    ; the direction the ramp TRAVELS, 0 to the top and 90 to the right.
+    sfn angleOf:double (spec:string fallback:double) {
+        def text:string (trim spec)
+        def deg:int (indexOf text "deg")
+        if (deg > 0) {
+            def v@(optional):double (to_double (trim (substring text 0 deg)))
+            if (null? v) {
+                return fallback
+            }
+            return (unwrap v)
+        }
+        if ((indexOf text "to ") == 0) {
+            def toTop:boolean ((indexOf text "top") > 0)
+            def toBottom:boolean ((indexOf text "bottom") > 0)
+            def toLeft:boolean ((indexOf text "left") > 0)
+            def toRight:boolean ((indexOf text "right") > 0)
+            if (toTop && toRight) {
+                return 45.0
+            }
+            if (toBottom && toRight) {
+                return 135.0
+            }
+            if (toBottom && toLeft) {
+                return 225.0
+            }
+            if (toTop && toLeft) {
+                return 315.0
+            }
+            if toTop {
+                return 0.0
+            }
+            if toRight {
+                return 90.0
+            }
+            if toBottom {
+                return 180.0
+            }
+            if toLeft {
+                return 270.0
+            }
+        }
+        return fallback
+    }
+
+    ; Convert back to CSS string
+    fn toCSSString:string () {
+        if (isSet == false) {
+            return ""
+        }
+        
+        def result:string ""
+        if isLinear {
+            result = "linear-gradient(" + (to_string angle) + "deg"
+        } {
+            result = "radial-gradient(circle"
+        }
+        
+        def numStops:int (array_length stops)
+        def i:int 0
+        while (i < numStops) {
+            def stop:EVGGradientStop (itemAt stops i)
+            result = result + ", " + (stop.color.toCSSString())
+            i = i + 1
+        }
+        
+        result = result + ")"
+        return result
+    }
+}

package/dist/lib/evg/EVGGrapheme.rgr

@@ -0,0 +1,190 @@
+; SPDX-License-Identifier: MIT
+
+; EVGGrapheme.rgr — the unit a reader calls "one character"
+;
+; A codepoint is not it. 🇫🇮 is two, 👍🏽 is two, 1️⃣ is three, 👨‍👩‍👧 is five, and
+; every one of them is one thing on the page: one glyph, one advance, one
+; position a cursor can sit at, and one place a line may not break.
+;
+; Stepping by codepoint instead cost three separate things:
+;
+;   the FACE was chosen per codepoint, so 1️⃣ put the "1" in the text face and
+;       the keycap in the emoji face — two runs, and the ligature that makes
+;       the keycap never got the chance to fire;
+;   the WIDTH was the sum of the parts, so a family of four measured four
+;       advances wide and drew one;
+;   the /ToUnicode entry named a single codepoint for a glyph made of five,
+;       so copying the emoji out of a PDF returned a fragment.
+;
+; This is a deliberate subset of UAX #29 — the emoji-relevant rules and the
+; combining marks, not the full property tables, which would mean shipping
+; Unicode data this engine has no other use for. What it does not model, it
+; leaves as separate clusters, which is the same behaviour as before rather
+; than a new kind of wrong.
+
+Import "EVGCodepoint.rgr"
+
+class EVGGrapheme {
+
+    ; U+200D ZERO WIDTH JOINER — the glue in 👨‍👩‍👧.
+    sfn isZWJ:boolean (cp:int) {
+        return (cp == 8205)
+    }
+
+    ; Regional indicators, U+1F1E6..U+1F1FF. A flag is exactly two of them,
+    ; and the pairing is why a run of four is two flags rather than one long
+    ; cluster.
+    sfn isRegionalIndicator:boolean (cp:int) {
+        if (cp < 127462) {
+            return false
+        }
+        return (cp <= 127487)
+    }
+
+    ; Skin tone modifiers, U+1F3FB..U+1F3FF.
+    sfn isEmojiModifier:boolean (cp:int) {
+        if (cp < 127995) {
+            return false
+        }
+        return (cp <= 127999)
+    }
+
+    ; Tag characters, U+E0020..U+E007F — the subdivision flags (🏴󠁧󠁢󠁳󠁣󠁴󠁿) spell
+    ; a region code out of these.
+    sfn isTag:boolean (cp:int) {
+        if (cp < 917536) {
+            return false
+        }
+        return (cp <= 917631)
+    }
+
+    ; Anything that attaches to the character before it: combining marks,
+    ; variation selectors, the enclosing keycap, skin tones, tags.
+    ;
+    ; The ranges are the ones that actually occur in text this engine sets;
+    ; a codepoint outside them starts a new cluster, which is the conservative
+    ; answer.
+    sfn isExtend:boolean (cp:int) {
+        ; Combining diacritical marks and their supplements/extensions.
+        if ((cp >= 768) && (cp <= 879)) {
+            return true
+        }
+        if ((cp >= 6832) && (cp <= 6911)) {
+            return true
+        }
+        if ((cp >= 7616) && (cp <= 7679)) {
+            return true
+        }
+        ; Combining marks for symbols, U+20D0..U+20FF — U+20E3 KEYCAP is here.
+        if ((cp >= 8400) && (cp <= 8447)) {
+            return true
+        }
+        ; Variation selectors VS1..VS16.
+        if ((cp >= 65024) && (cp <= 65039)) {
+            return true
+        }
+        ; Combining half marks.
+        if ((cp >= 65056) && (cp <= 65071)) {
+            return true
+        }
+        if (EVGGrapheme.isEmojiModifier(cp)) {
+            return true
+        }
+        return (EVGGrapheme.isTag(cp))
+    }
+
+    ; Index one past the cluster starting at `start`.
+    ;
+    ; Always advances by at least one, so a caller looping on this terminates
+    ; even on input the rules below say nothing about.
+    sfn clusterEnd:int (cps:[int] start:int) {
+        def n:int (array_length cps)
+        if (start >= n) {
+            return n
+        }
+        def i:int (start + 1)
+
+        ; A flag is a PAIR of regional indicators and no more. Without the
+        ; limit, 🇫🇮🇸🇪 would be one four-part cluster and neither flag would
+        ; find its ligature.
+        if (EVGGrapheme.isRegionalIndicator((itemAt cps start))) {
+            if (i < n) {
+                if (EVGGrapheme.isRegionalIndicator((itemAt cps i))) {
+                    i = (i + 1)
+                }
+            }
+            return i
+        }
+
+        def more:boolean true
+        while more {
+            more = false
+            if (i < n) {
+                def cp:int (itemAt cps i)
+                if (EVGGrapheme.isExtend(cp)) {
+                    i = (i + 1)
+                    more = true
+                } {
+                    ; A joiner takes the character after it into the cluster —
+                    ; and a trailing joiner with nothing after it does not,
+                    ; because there is nothing to join to.
+                    if (EVGGrapheme.isZWJ(cp)) {
+                        if ((i + 1) < n) {
+                            i = (i + 2)
+                            more = true
+                        }
+                    }
+                }
+            }
+        }
+        return i
+    }
+
+    ; Cluster boundaries as codepoint indices, ending with the length.
+    ; `starts[k]`..`starts[k+1]` is cluster k.
+    sfn boundaries:[int] (cps:[int]) {
+        def out:[int]
+        def i:int 0
+        def n:int (array_length cps)
+        while (i < n) {
+            push out i
+            i = (EVGGrapheme.clusterEnd(cps i))
+        }
+        push out n
+        return out
+    }
+
+    ; How many clusters — "how long is this text" as a reader would answer it.
+    ; (`count` is taken by the language, hence the name.)
+    sfn clusterCount:int (s:string) {
+        def cps:[int] (EVGCodepoint.toArray(s))
+        def n:int 0
+        def i:int 0
+        while (i < (array_length cps)) {
+            i = (EVGGrapheme.clusterEnd(cps i))
+            n = (n + 1)
+        }
+        return n
+    }
+
+    ; The cluster starting at UTF-16 index `i`, as a string. Convenient where
+    ; a caller works in strings rather than codepoint arrays.
+    sfn clusterAt:string (s:string i:int) {
+        def cps:[int] (EVGCodepoint.toArray(s))
+        ; Map the UTF-16 index to a codepoint index.
+        def cpIdx:int 0
+        def u:int 0
+        while (u < i) {
+            u = (u + (EVGCodepoint.unitsAt(s u)))
+            cpIdx = (cpIdx + 1)
+        }
+        def end:int (EVGGrapheme.clusterEnd(cps cpIdx))
+        def out:string ""
+        def k:int cpIdx
+        while (k < end) {
+            out = out + (EVGCodepoint.toStr((itemAt cps k)))
+            k = (k + 1)
+        }
+        return out
+    }
+}