xbintsc 0.5.41 → 0.5.43

package/runtime/ext_gui/gui_events.cpp

@@ -471,23 +471,26 @@ void xt_gui_render_window(XtGuiWindow *win) {
         }
         win->present_deferred = 0;
         xtgui::g_perf_frame.presents += 1;
-        SDL_GPUColorTargetInfo target;
-        memset(&target, 0, sizeof(target));
-        target.texture = swapchain;
-        target.clear_color.r = win->background[0];
-        target.clear_color.g = win->background[1];
-        target.clear_color.b = win->background[2];
-        target.clear_color.a = win->background[3];
-        target.load_op = SDL_GPU_LOADOP_CLEAR;
-        target.store_op = SDL_GPU_STOREOP_STORE;
-        SDL_GPURenderPass *pass = SDL_BeginGPURenderPass(cmd, &target, 1, NULL);
         if (can_paint) {
           float density = SDL_GetWindowPixelDensity(win->window);
           if (density <= 0.0f) density = 1.0f;
-          xt_gui_renderer_draw(cmd, pass, &win->geometry, &win->text_geometry,
-                               &win->image_geometry, viewport_width, viewport_height, density);
+          xt_gui_renderer_draw(cmd, swapchain, win->background, &win->geometry,
+                               &win->text_geometry, &win->image_geometry,
+                               win->display_list, viewport_width, viewport_height, density);
+        } else {
+          /* No renderer (no usable shader backend): still clear the window. */
+          SDL_GPUColorTargetInfo target;
+          memset(&target, 0, sizeof(target));
+          target.texture = swapchain;
+          target.clear_color.r = win->background[0];
+          target.clear_color.g = win->background[1];
+          target.clear_color.b = win->background[2];
+          target.clear_color.a = win->background[3];
+          target.load_op = SDL_GPU_LOADOP_CLEAR;
+          target.store_op = SDL_GPU_STOREOP_STORE;
+          SDL_GPURenderPass *pass = SDL_BeginGPURenderPass(cmd, &target, 1, NULL);
+          if (pass != NULL) SDL_EndGPURenderPass(pass);
         }
-        SDL_EndGPURenderPass(pass);
         firstFrame = !win->ready;
         win->ready = 1;
       } else {

package/runtime/ext_gui/image.cpp

@@ -64,13 +64,84 @@ std::string normalizePath(const std::string &input) {
   return out;
 }
 
-/** Decode a `data:` URL's base64 payload (the only encoding the engine emits
- * and the common one a page assigns). */
-bool decodeDataUrl(const std::string &url, std::vector<unsigned char> *out) {
-  const size_t comma = url.find(',');
-  if (comma == std::string::npos) return false;
-  const std::string header = url.substr(0, comma);
-  if (header.find(";base64") == std::string::npos) return false;
+/** One classified `data:` URL: whether its payload is SVG and the intrinsic
+ * size parsed from it (or from the raster header). Classification happens once
+ * per URL and is cached, so the renderer's vector probe does not decode the
+ * payload on every frame. */
+struct DataUrlEntry {
+  bool svg = false;
+  SizeEntry size;
+};
+
+std::unordered_map<std::string, DataUrlEntry> &dataUrlCache() {
+  static std::unordered_map<std::string, DataUrlEntry> cache;
+  return cache;
+}
+
+std::string lowercase(std::string value) {
+  for (char &c : value) c = (char)std::tolower((unsigned char)c);
+  return value;
+}
+
+std::string trim(const std::string &text) {
+  size_t start = 0;
+  while (start < text.size() && std::isspace((unsigned char)text[start])) start++;
+  size_t end = text.size();
+  while (end > start && std::isspace((unsigned char)text[end - 1])) end--;
+  return text.substr(start, end - start);
+}
+
+/** Decode `%XX` escapes. `+` stays a literal plus: a data URL uses URL
+ * percent-encoding, not form encoding. A malformed escape is left verbatim. */
+std::string percentDecode(const std::string &text) {
+  std::string out;
+  out.reserve(text.size());
+  for (size_t i = 0; i < text.size(); i++) {
+    if (text[i] == '%' && i + 2 < text.size() && std::isxdigit((unsigned char)text[i + 1]) &&
+        std::isxdigit((unsigned char)text[i + 2])) {
+      auto hex = [](char c) -> int {
+        if (c >= '0' && c <= '9') return c - '0';
+        return std::tolower((unsigned char)c) - 'a' + 10;
+      };
+      out.push_back((char)(hex(text[i + 1]) * 16 + hex(text[i + 2])));
+      i += 2;
+    } else {
+      out.push_back(text[i]);
+    }
+  }
+  return out;
+}
+
+/** True when one of the header's `;`-separated parameters is `base64`
+ * (case-insensitive, as the data-URL grammar specifies). */
+bool headerHasBase64(const std::string &header) {
+  size_t start = 0;
+  while (start <= header.size()) {
+    size_t end = header.find(';', start);
+    if (end == std::string::npos) end = header.size();
+    if (lowercase(trim(header.substr(start, end - start))) == "base64") return true;
+    if (end == header.size()) break;
+    start = end + 1;
+  }
+  return false;
+}
+
+/** The MIME type part of a data URL's header, lowercased. */
+std::string headerMime(const std::string &header) {
+  size_t semi = header.find(';');
+  return lowercase(trim(header.substr(0, semi)));
+}
+
+/** A cheap content sniff for a data URL whose MIME type is generic: look for
+ * `<svg` in the first chunk (after an XML declaration, doctype or comment). */
+bool bytesLookLikeSvg(const std::vector<unsigned char> &bytes) {
+  if (bytes.empty()) return false;
+  const size_t limit = bytes.size() < 1024 ? bytes.size() : 1024;
+  const std::string prefix(reinterpret_cast<const char *>(bytes.data()), limit);
+  return prefix.find("<svg") != std::string::npos;
+}
+
+bool base64Decode(const std::string &text, std::vector<unsigned char> *out) {
   static const signed char kDecode[128] = {
       -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
       -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
@@ -81,12 +152,11 @@ bool decodeDataUrl(const std::string &url, std::vector<unsigned char> *out) {
       -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
       41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1};
   out->clear();
-  out->reserve((url.size() - comma) * 3 / 4 + 4);
+  out->reserve(text.size() * 3 / 4 + 4);
   uint32_t accumulator = 0;
   int bits = 0;
-  for (size_t i = comma + 1; i < url.size(); i++) {
-    const unsigned char c = (unsigned char)url[i];
-    if (c == '=' || c == '\n' || c == '\r' || c == ' ') continue;
+  for (unsigned char c : text) {
+    if (c == '=' || std::isspace(c)) continue;
     if (c >= 128) return false;
     const int value = kDecode[c];
     if (value < 0) return false;
@@ -100,33 +170,107 @@ bool decodeDataUrl(const std::string &url, std::vector<unsigned char> *out) {
   return !out->empty();
 }
 
+/** Decode a `data:` URL's payload. Both `;base64` and percent-encoded (or
+ * plain) bodies are accepted; in the base64 case the body is percent-decoded
+ * first, which is what a browser does. `mime` receives the lowercased header
+ * type (empty when the URL omits one). */
+bool decodeDataUrl(const std::string &url, std::vector<unsigned char> *out, std::string *mime) {
+  const size_t comma = url.find(',');
+  if (comma == std::string::npos || comma < 5) return false;
+  const std::string header = url.substr(5, comma - 5);
+  if (mime != nullptr) *mime = headerMime(header);
+  const std::string body = percentDecode(url.substr(comma + 1));
+  if (headerHasBase64(header)) return base64Decode(body, out);
+  out->assign(body.begin(), body.end());
+  return !out->empty();
+}
+
+/** Classify (`SVG` vs raster) and measure a `data:` URL once. */
+DataUrlEntry &dataUrlEntry(const std::string &url) {
+  auto &cache = dataUrlCache();
+  auto found = cache.find(url);
+  if (found != cache.end()) return found->second;
+
+  DataUrlEntry entry;
+  std::vector<unsigned char> bytes;
+  std::string mime;
+  if (decodeDataUrl(url, &bytes, &mime)) {
+    /* Trust an explicit raster MIME type; sniff only when the type is absent
+     * or generic, so a PNG that happens to contain `<svg` in a text chunk is
+     * not mistaken for vector art. */
+    const bool generic_mime =
+        mime.empty() || mime == "text/plain" || mime == "application/octet-stream";
+    entry.svg = mime == "image/svg+xml" || (generic_mime && bytesLookLikeSvg(bytes));
+    if (entry.svg) {
+      const std::string markup(bytes.begin(), bytes.end());
+      int width = 0;
+      int height = 0;
+      if (xt_svg_markup_size(markup, &width, &height)) {
+        entry.size.valid = true;
+        entry.size.width = width;
+        entry.size.height = height;
+      }
+    } else {
+      int width = 0;
+      int height = 0;
+      int channels = 0;
+      if (stbi_info_from_memory(bytes.data(), (int)bytes.size(), &width, &height, &channels) != 0) {
+        entry.size.valid = true;
+        entry.size.width = width;
+        entry.size.height = height;
+      }
+    }
+  }
+  return cache.emplace(url, std::move(entry)).first->second;
+}
+
 }  // namespace
 
 const Image *xt_image_load(const std::string &raw_path, int target_width, int target_height) {
   /* A `data:` URL carries its bytes inline (a canvas used as a CSS
    * `background-image` reaches this path through `toDataURL()`). */
   if (raw_path.rfind("data:", 0) == 0) {
+    const DataUrlEntry &info = dataUrlEntry(raw_path);
+    int width = target_width;
+    int height = target_height;
+    if (info.svg && width <= 0 && height <= 0 && info.size.valid) {
+      width = info.size.width;
+      height = info.size.height;
+    }
+    /* A vector source is rasterised at the drawn size, so that size is part of
+     * its cache identity. A raster data URL decodes once at its intrinsic
+     * resolution. */
+    std::string key = raw_path;
+    if (info.svg) {
+      key = "data-svg:" + std::to_string(width) + "x" + std::to_string(height) + ":" + raw_path;
+    }
     auto &cache = imageCache();
-    auto found = cache.find(raw_path);
+    auto found = cache.find(key);
     if (found != cache.end()) {
       return found->second.width > 0 ? &found->second : nullptr;
     }
     Image image;
     std::vector<unsigned char> bytes;
-    if (decodeDataUrl(raw_path, &bytes)) {
-      int width = 0;
-      int height = 0;
-      int channels = 0;
-      unsigned char *data = stbi_load_from_memory(bytes.data(), (int)bytes.size(), &width, &height,
-                                                  &channels, 4);
-      if (data != nullptr) {
-        image.width = width;
-        image.height = height;
-        image.pixels.assign(data, data + (size_t)width * (size_t)height * 4);
-        stbi_image_free(data);
+    std::string mime;
+    if (decodeDataUrl(raw_path, &bytes, &mime)) {
+      if (info.svg) {
+        const std::string markup(bytes.begin(), bytes.end());
+        xt_svg_markup_render(markup, width, height, &image);
+      } else {
+        int decoded_width = 0;
+        int decoded_height = 0;
+        int channels = 0;
+        unsigned char *data = stbi_load_from_memory(bytes.data(), (int)bytes.size(),
+                                                    &decoded_width, &decoded_height, &channels, 4);
+        if (data != nullptr) {
+          image.width = decoded_width;
+          image.height = decoded_height;
+          image.pixels.assign(data, data + (size_t)decoded_width * (size_t)decoded_height * 4);
+          stbi_image_free(data);
+        }
       }
     }
-    auto inserted = cache.emplace(raw_path, std::move(image));
+    auto inserted = cache.emplace(key, std::move(image));
     return inserted.first->second.width > 0 ? &inserted.first->second : nullptr;
   }
   std::string path = normalizePath(raw_path);
@@ -165,6 +309,13 @@ const Image *xt_image_load(const std::string &raw_path, int target_width, int ta
 
 bool xt_image_size(const std::string &raw_path, int *width, int *height) {
   if (raw_path.rfind("data:", 0) == 0) {
+    const DataUrlEntry &info = dataUrlEntry(raw_path);
+    if (info.size.valid) {
+      if (width != nullptr) *width = info.size.width;
+      if (height != nullptr) *height = info.size.height;
+      return true;
+    }
+    if (info.svg) return false;
     const Image *image = xt_image_load(raw_path);
     if (image == nullptr) return false;
     if (width != nullptr) *width = image->width;
@@ -202,11 +353,15 @@ bool xt_image_decode(const unsigned char *data, size_t size, Image *out) {
   return true;
 }
 
-bool xt_image_is_vector(const std::string &path) { return xt_svg_is_svg(normalizePath(path)); }
+bool xt_image_is_vector(const std::string &path) {
+  if (path.rfind("data:", 0) == 0) return dataUrlEntry(path).svg;
+  return xt_svg_is_svg(normalizePath(path));
+}
 
 void xt_image_shutdown() {
   imageCache().clear();
   sizeCache().clear();
+  dataUrlCache().clear();
   xt_svg_shutdown();
 }
 

package/runtime/ext_gui/image.h

@@ -23,9 +23,11 @@ struct Image {
   std::vector<unsigned char> pixels;
 };
 
-/** Decode an image file (PNG/JPEG/BMP/GIF/TGA or SVG) to RGBA8. Returns
- * nullptr on failure. Results (including failures) are cached by path. A
- * `file://` prefix and URL percent-encoding are handled.
+/** Decode an image source (PNG/JPEG/BMP/GIF/TGA or SVG, from a file path or a
+ * `data:` URL) to RGBA8. Returns nullptr on failure. Results (including
+ * failures) are cached. A `file://` prefix and URL percent-encoding are
+ * handled for paths; a `data:` URL accepts a `;base64` or percent-encoded
+ * payload and is classified by MIME type/content (SVG or raster).
  *
  * `target_width`/`target_height` are the pixel size the image will be drawn at.
  * Raster formats ignore them (they decode at their intrinsic resolution), but
@@ -40,7 +42,7 @@ const Image *xt_image_load(const std::string &path, int target_width = 0, int ta
  * viewBox). Returns false when the file cannot be read/parsed. Cached. */
 bool xt_image_size(const std::string &path, int *width, int *height);
 
-/** Decode an in-memory buffer to RGBA8 (e.g. a future `data:` URI). */
+/** Decode an in-memory raster buffer to RGBA8 (used by the app icon). */
 bool xt_image_decode(const unsigned char *data, size_t size, Image *out);
 
 /** True when `path` is a vector source (SVG) that is rasterised on demand

package/runtime/ext_gui/paint.cpp

@@ -9,6 +9,7 @@
 #include "paint.h"
 
 #include <algorithm>
+#include <cstddef>
 #include <cstdio>
 #include <utility>
 
@@ -56,6 +57,9 @@ int zIndexOf(const LayoutBox *box) {
 void paintBox(const LayoutBox *box, DisplayList &out, const PaintClip &clip,
               const paint_detail::FilterChain &parentChain, float viewportWidth,
               float viewportHeight);
+void paintBoxInner(const LayoutBox *box, DisplayList &out, const PaintClip &clip,
+                   const paint_detail::FilterChain &parentChain, float viewportWidth,
+                   float viewportHeight);
 
 /** The clip a box imposes on its content: its padding box, intersected with the
  * clip already in effect. Only `overflow: hidden/scroll/auto` clips. A
@@ -149,9 +153,9 @@ void addTextRuns(const LayoutBox *box, const XtStyle &style, DisplayList &out,
   }
 }
 
-void paintBox(const LayoutBox *box, DisplayList &out, const PaintClip &clip,
-              const paint_detail::FilterChain &parentChain, float viewportWidth,
-              float viewportHeight) {
+void paintBoxInner(const LayoutBox *box, DisplayList &out, const PaintClip &clip,
+                   const paint_detail::FilterChain &parentChain, float viewportWidth,
+                   float viewportHeight) {
   if (box == nullptr) return;
   const XtStyle *style = box->style;
 
@@ -166,6 +170,11 @@ void paintBox(const LayoutBox *box, DisplayList &out, const PaintClip &clip,
     chain = paint_detail::extendFilter(parentChain, style->filters, *style, viewportWidth,
                                        viewportHeight);
   }
+  /* `opacity` is not inherited, but its effect is: every shape painted by the
+   * box or its descendants gets its alpha multiplied by the product down the
+   * chain. This makes fractional opacity visible instead of treating anything
+   * above zero as fully opaque. */
+  if (style != nullptr && !box->is_text) chain.opacity *= style->opacity;
 
   PaintClip own = clip;
   if (style != nullptr && box->display != Display::None && !box->is_text) {
@@ -252,6 +261,32 @@ void paintBox(const LayoutBox *box, DisplayList &out, const PaintClip &clip,
   paintChildren(box, out, clipForChildren(box, own), childChain, viewportWidth, viewportHeight);
 }
 
+/** Paint one box, wrapping it in a `mix-blend-mode` group when it declares one.
+ * The group's ops are bounded by `LayerBegin`/`LayerEnd`, so the renderer can
+ * draw the subtree to an offscreen texture and blend it over the backdrop as
+ * one unit (overlapping children must not blend twice). */
+void paintBox(const LayoutBox *box, DisplayList &out, const PaintClip &clip,
+              const paint_detail::FilterChain &parentChain, float viewportWidth,
+              float viewportHeight) {
+  if (box == nullptr) return;
+  const XtStyle *style = box->style;
+  const bool group = style != nullptr && !box->is_text && box->display != Display::None &&
+                     style->mix_blend_mode != MixBlendMode::Normal;
+  if (!group) {
+    paintBoxInner(box, out, clip, parentChain, viewportWidth, viewportHeight);
+    return;
+  }
+  size_t first = out.ops.size();
+  paintBoxInner(box, out, clip, parentChain, viewportWidth, viewportHeight);
+  if (out.ops.size() == first) return;  /* nothing painted (e.g. opacity: 0) */
+  PaintLayer layer;
+  layer.blend = style->mix_blend_mode;
+  uint32_t index = (uint32_t)out.layers.size();
+  out.layers.push_back(layer);
+  out.ops.insert(out.ops.begin() + (ptrdiff_t)first, PaintOp{PaintKind::LayerBegin, index, clip});
+  out.ops.push_back(PaintOp{PaintKind::LayerEnd, 0, clip});
+}
+
 }  // namespace
 
 void xt_paint_build(const LayoutBox *root, DisplayList &out, float viewportWidth,
@@ -311,6 +346,21 @@ std::string DisplayList::dump() const {
       }
       prefix += " ";
     }
+    if (op.kind == PaintKind::LayerBegin) {
+      static const char *const names[] = {
+          "normal",     "multiply",    "screen",      "overlay",     "darken",
+          "lighten",    "color-dodge", "color-burn",  "hard-light",  "soft-light",
+          "difference", "exclusion",   "hue",         "saturation",  "color",
+          "luminosity"};
+      const char *name = "normal";
+      if (op.index < layers.size()) name = names[(int)layers[op.index].blend];
+      text += prefix + "layer blend=" + name + "\n";
+      continue;
+    }
+    if (op.kind == PaintKind::LayerEnd) {
+      text += prefix + "end-layer\n";
+      continue;
+    }
     std::string suffix;
     if (op.kind == PaintKind::Rect) {
       suffix = transformSuffix(rects[op.index].transform);
@@ -330,7 +380,22 @@ std::string DisplayList::dump() const {
     } else {
       const PaintImage &image = images[op.index];
       suffix = transformSuffix(image.transform);
-      if (image.media_id != 0) {
+      if (image.gradient != nullptr) {
+        const PaintGradient &gradient = *image.gradient;
+        std::snprintf(buffer, sizeof(buffer),
+                      "image x=%.1f y=%.1f w=%.1f h=%.1f gradient=%s center=%.1f,%.1f "
+                      "radius=%.1f,%.1f stops=",
+                      image.x, image.y, image.width, image.height,
+                      gradient.repeating ? "repeating-radial" : "radial", gradient.center_x,
+                      gradient.center_y, gradient.radius_x, gradient.radius_y);
+        text += prefix + buffer;
+        for (size_t stop = 0; stop < gradient.stops.size(); stop++) {
+          std::snprintf(buffer, sizeof(buffer), "%s%s@%.4f", stop == 0 ? "" : ",",
+                        formatColor(gradient.stops[stop].color).c_str(),
+                        gradient.stops[stop].offset);
+          text += buffer;
+        }
+      } else if (image.media_id != 0) {
         std::snprintf(buffer, sizeof(buffer), "image x=%.1f y=%.1f w=%.1f h=%.1f media=%llu",
                       image.x, image.y, image.width, image.height,
                       (unsigned long long)image.media_id);

package/runtime/ext_gui/paint.h

@@ -14,6 +14,7 @@
 #define XT_GUI_PAINT_H
 
 #include <cstdint>
+#include <memory>
 #include <string>
 #include <vector>
 
@@ -24,6 +25,35 @@
 
 namespace xtgui {
 
+/** One resolved colour stop of a gradient. `offset` is a fraction of the
+ * gradient line and non-decreasing, as in CSS. */
+struct GradientStop {
+  float offset = 0.0f;
+  Color color;
+};
+
+/** A radial `background-image` layer resolved by the paint pass: the renderer
+ * rasterises it into one RGBA texture and draws that as a single image quad.
+ *
+ * Nesting translucent bands instead composites every band's alpha once per band
+ * — each band covers the whole interior — so a vignette whose stops fade to
+ * `transparent` turns into an opaque disc that hides the scene behind it.
+ * Resolving the ramp per pixel composites it exactly once. */
+struct PaintGradient {
+  std::vector<GradientStop> stops;
+  /** Centre in box-local logical pixels; the drawn quad spans the whole box. */
+  float center_x = 0.0f;
+  float center_y = 0.0f;
+  float radius_x = 0.0f;
+  float radius_y = 0.0f;
+  /** `repeating-radial-gradient()`: the stop pattern restarts every `period`
+   * (the last stop's offset) instead of clamping at the outer ellipse. */
+  bool repeating = false;
+  float period = 1.0f;
+  /** Identity of the ramp (stops and geometry) for the renderer's texture cache. */
+  std::string key;
+};
+
 /** A solid, optionally rounded, rectangle. Coordinates are viewport-relative. */
 struct PaintRect {
   float x = 0;
@@ -71,6 +101,10 @@ struct PaintImage {
   /** Modulating colour for the image shader (white normally; a filter's
    * multiplicative effect may tint it). */
   Color tint{1.0f, 1.0f, 1.0f, 1.0f};
+  /** A `background-image` radial gradient: the renderer rasterises it into the
+   * quad instead of loading `src`/`svg`. Its stops already carry the colour
+   * functions of the filter chain; `tint` still carries brightness/opacity. */
+  std::shared_ptr<const PaintGradient> gradient;
 };
 
 /** One triangle of a clip path in device-space logical pixels. The paint pass
@@ -102,7 +136,14 @@ struct PaintClip {
   int paths[2] = {-1, -1};
 };
 
-enum class PaintKind { Rect, Text, Image };
+enum class PaintKind { Rect, Text, Image, LayerBegin, LayerEnd };
+
+/** One `mix-blend-mode` compositing group. The ops between its `LayerBegin`
+ * and `LayerEnd` markers are rendered to an offscreen texture and composited
+ * over the backdrop as a group, so overlapping children blend once. */
+struct PaintLayer {
+  MixBlendMode blend = MixBlendMode::Normal;
+};
 
 /** One entry in painter order: which kind of shape, its index in the matching
  * payload vector, and the clip in effect. */
@@ -121,6 +162,8 @@ struct DisplayList {
   std::vector<PaintOp> ops;
   /** Device-space clip-path polygons shared by an element's ops. */
   std::vector<ClipPathGeometry> clip_paths;
+  /** `mix-blend-mode` groups referenced by `LayerBegin` ops. */
+  std::vector<PaintLayer> layers;
 
   void clear() {
     rects.clear();
@@ -128,12 +171,25 @@ struct DisplayList {
     images.clear();
     ops.clear();
     clip_paths.clear();
+    layers.clear();
   }
   bool empty() const { return rects.empty() && texts.empty() && images.empty(); }
   /** Human-readable dump, one shape per line, in painter order (diagnostics/tests). */
   std::string dump() const;
 };
 
+namespace paint_detail {
+
+/** Interpolate a gradient's colour at `t` (a fraction of the gradient line; any
+ * value when `repeating`). Stops interpolate in premultiplied alpha, as CSS
+ * does, so a `transparent` stop does not darken the ramp towards an opaque
+ * colour; the result is converted back to straight alpha, which is what both the
+ * band and the texture paths blend. */
+Color gradientColorAt(const std::vector<GradientStop> &stops, bool repeating, float period,
+                      float t);
+
+}  // namespace paint_detail
+
 /** Build the display list for a laid-out tree and append it to `out`. The
  * viewport size resolves `vw`/`vh` units inside `clip-path` and shadows; pass 0
  * to take it from the root box's containing block. */