xbintsc 0.5.45 → 0.5.52

package/runtime/ext_gui/dom_api_webgl_source.cpp

@@ -16,7 +16,9 @@
 #include "canvas.h"
 #include "image.h"
 #include "image_bitmap.h"
+#include "image_api.h"
 #include "webgl.h"
+#include "webgl_feature.h"
 
 namespace domapi {
 namespace {
@@ -121,10 +123,11 @@ bool webgl_read_source(xt_value source, int *width, int *height, std::vector<uin
   XtGuiWindow *win = nullptr;
   xtgui::Node *node = resolve_node(source, &win);
   const xtgui::Image *image = nullptr;
+  const XtImageApi *images = xt_image_api();
   std::vector<uint8_t> owned;
   if (node != nullptr && node->isElement() && node->isTag("img")) {
     const std::string *src = node->attr("src");
-    if (src != nullptr) image = xtgui::xt_image_load(*src);
+    if (src != nullptr && images != nullptr) image = images->load(*src, 0, 0);
   } else if (node != nullptr && node->isElement() && node->isTag("video")) {
     xtgui::MediaPlayer *player = xt_gui_media_player(win, node);
     if (player != nullptr) image = player->frame();
@@ -161,7 +164,7 @@ bool webgl_read_source(xt_value source, int *width, int *height, std::vector<uin
     xt_value src = xt_object_get_cstr(source, "src");
     if (XT_IS_STRING(src)) {
       const char *path = xt_string_data(xt_to_string(src));
-      if (path != nullptr && path[0] != '\0') image = xtgui::xt_image_load(path);
+      if (path != nullptr && path[0] != '\0' && images != nullptr) image = images->load(path, 0, 0);
     }
   }
   if (image == nullptr || image->width <= 0 || image->height <= 0) return false;

package/runtime/ext_gui/effect_values.cpp

@@ -37,18 +37,72 @@ static bool parseTimeSeconds(const std::string &text, float *out) {
   return true;
 }
 
+static std::vector<std::string> splitCommas(const std::string &text);
+static std::vector<std::string> splitTokens(const std::string &text);
+
+/** Parse a CSS timing function. Besides the five keywords this accepts
+ * `cubic-bezier(x1, y1, x2, y2)` and `steps(n[, start|end|jump-*])`. */
 static bool parseTimingFunction(const std::string &text, TimingFunction *out) {
   std::string token = xt_css_lower(xt_css_trim(text));
   if (token == "linear") {
-    *out = TimingFunction::Linear;
+    *out = TimingFunction();
+    out->kind = TimingFunction::Kind::Linear;
   } else if (token == "ease") {
-    *out = TimingFunction::Ease;
+    *out = TimingFunction();
   } else if (token == "ease-in") {
-    *out = TimingFunction::EaseIn;
+    *out = TimingFunction();
+    out->kind = TimingFunction::Kind::EaseIn;
   } else if (token == "ease-out") {
-    *out = TimingFunction::EaseOut;
+    *out = TimingFunction();
+    out->kind = TimingFunction::Kind::EaseOut;
   } else if (token == "ease-in-out") {
-    *out = TimingFunction::EaseInOut;
+    *out = TimingFunction();
+    out->kind = TimingFunction::Kind::EaseInOut;
+  } else if (token == "step-start") {
+    *out = TimingFunction();
+    out->kind = TimingFunction::Kind::StepsStart;
+    out->steps = 1;
+  } else if (token == "step-end") {
+    *out = TimingFunction();
+    out->kind = TimingFunction::Kind::StepsEnd;
+    out->steps = 1;
+  } else if (token.compare(0, 13, "cubic-bezier(") == 0 && token.back() == ')') {
+    std::vector<std::string> args =
+        splitCommas(token.substr(13, token.size() - 14));
+    if (args.size() != 4) return false;
+    float values[4];
+    for (int i = 0; i < 4; i++) {
+      if (!xt_css_parse_number(args[i], &values[i])) return false;
+    }
+    TimingFunction fn;
+    fn.kind = TimingFunction::Kind::CubicBezier;
+    fn.x1 = values[0] < 0.0f ? 0.0f : (values[0] > 1.0f ? 1.0f : values[0]);
+    fn.y1 = values[1];
+    fn.x2 = values[2] < 0.0f ? 0.0f : (values[2] > 1.0f ? 1.0f : values[2]);
+    fn.y2 = values[3];
+    *out = fn;
+  } else if (token.compare(0, 6, "steps(") == 0 && token.back() == ')') {
+    std::string inner = token.substr(6, token.size() - 7);
+    for (char &c : inner) {
+      if (c == ',') c = ' ';
+    }
+    std::vector<std::string> args = xt_css_split_whitespace(inner);
+    if (args.empty()) return false;
+    float count = 0;
+    if (!xt_css_parse_number(args[0], &count) || count < 1.0f) return false;
+    bool stepStart = false;
+    if (args.size() > 1) {
+      std::string position = xt_css_lower(args[1]);
+      if (position == "start" || position == "jump-start" || position == "jump-both") {
+        stepStart = true;
+      } else if (position != "end" && position != "jump-end" && position != "jump-none") {
+        return false;
+      }
+    }
+    TimingFunction fn;
+    fn.kind = stepStart ? TimingFunction::Kind::StepsStart : TimingFunction::Kind::StepsEnd;
+    fn.steps = (int)(count + 0.5f);
+    *out = fn;
   } else {
     return false;
   }
@@ -56,28 +110,21 @@ static bool parseTimingFunction(const std::string &text, TimingFunction *out) {
 }
 
 static std::vector<std::string> splitCommas(const std::string &text) {
-  std::vector<std::string> parts;
-  size_t start = 0;
-  for (size_t i = 0; i <= text.size(); i++) {
-    if (i == text.size() || text[i] == ',') {
-      std::string part = xt_css_trim(text.substr(start, i - start));
-      if (!part.empty()) parts.push_back(part);
-      start = i + 1;
-    }
-  }
-  return parts;
+  /* Top-level commas only: a timing function or colour function may contain
+   * its own comma (`steps(4, end)`, `rgb(1, 2, 3)`). */
+  return xt_css_split_commas(text);
 }
 
 static void parseTransitionShorthand(const std::string &value, std::vector<TransitionSpec> *out) {
   out->clear();
   for (const std::string &group : splitCommas(value)) {
-    std::vector<std::string> tokens = xt_css_split_whitespace(group);
+    std::vector<std::string> tokens = splitTokens(group);
     if (tokens.empty()) continue;
     TransitionSpec spec;
     int time_seen = 0;
     for (const std::string &token : tokens) {
       float seconds = 0;
-      TimingFunction timing = TimingFunction::Ease;
+      TimingFunction timing;
       if (parseTimeSeconds(token, &seconds)) {
         if (time_seen == 0) {
           spec.duration = seconds;
@@ -89,6 +136,8 @@ static void parseTransitionShorthand(const std::string &value, std::vector<Trans
         spec.timing = timing;
       } else {
         spec.property = xt_css_lower(token);
+        /* The shorthand animates its colour component. */
+        if (spec.property == "background") spec.property = "background-color";
       }
     }
     out->push_back(spec);
@@ -99,7 +148,7 @@ static void parseTransitionShorthand(const std::string &value, std::vector<Trans
 /* -- filters, shadows and generated content -------------------------------- */
 
 /** Split on whitespace outside function parentheses (`rgb(1, 2, 3)` stays one). */
-static std::vector<std::string> splitShadowTokens(const std::string &text) {
+static std::vector<std::string> splitTokens(const std::string &text) {
   std::vector<std::string> parts;
   std::string current;
   int depth = 0;
@@ -152,7 +201,7 @@ static bool parseAngleDegrees(const std::string &raw, float *out) {
 
 static bool parseShadowLengths(const std::string &value, Length *dx, Length *dy, Length *blur,
                                Color *color, bool *hasColor) {
-  std::vector<std::string> tokens = splitShadowTokens(value);
+  std::vector<std::string> tokens = splitTokens(value);
   Length lengths[3];
   size_t count = 0;
   for (const std::string &token : tokens) {
@@ -255,11 +304,106 @@ static bool parseTextShadow(const std::string &value, std::vector<TextShadow> *o
   return true;
 }
 
+/** Parse a comma-separated `box-shadow` list. Offsets are `<dx> <dy>
+ * [<blur> [<spread>]]`, and the optional `inset` keyword plus a colour may
+ * appear anywhere in the entry, as in CSS. */
+static bool parseBoxShadow(const std::string &value, std::vector<BoxShadow> *out) {
+  std::string text = xt_css_trim(value);
+  std::string lower = xt_css_lower(text);
+  out->clear();
+  if (lower == "none" || text.empty()) return true;
+  for (const std::string &part : splitCommas(value)) {
+    BoxShadow shadow;
+    Length lengths[4];
+    size_t count = 0;
+    for (const std::string &token : splitTokens(part)) {
+      std::string tokenLower = xt_css_lower(token);
+      if (tokenLower == "inset") {
+        shadow.inset = true;
+        continue;
+      }
+      Length length = xt_css_parse_length(token);
+      if (length.unit != Unit::Invalid && length.unit != Unit::Auto &&
+          length.unit != Unit::None) {
+        if (count < 4) lengths[count++] = length;
+        continue;
+      }
+      Color color = xt_css_parse_color(token);
+      if (color.valid) {
+        shadow.color = color;
+        shadow.has_color = true;
+      }
+    }
+    if (count < 2) return false;
+    shadow.dx = lengths[0];
+    shadow.dy = lengths[1];
+    shadow.blur = count > 2 ? lengths[2] : Length{0.0f, Unit::Px};
+    shadow.spread = count > 3 ? lengths[3] : Length{0.0f, Unit::Px};
+    out->push_back(shadow);
+  }
+  return true;
+}
+
+static bool parseAnimationShorthand(const std::string &value, std::vector<AnimationSpec> *out) {
+  out->clear();
+  for (const std::string &group : splitCommas(value)) {
+    std::vector<std::string> tokens = splitTokens(group);
+    if (tokens.empty()) continue;
+    AnimationSpec spec;
+    int time_seen = 0;
+    for (const std::string &token : tokens) {
+      std::string lower = xt_css_lower(token);
+      float seconds = 0;
+      TimingFunction timing;
+      if (parseTimeSeconds(token, &seconds)) {
+        if (time_seen == 0) spec.duration = seconds;
+        else if (time_seen == 1) spec.delay = seconds;
+        time_seen++;
+      } else if (parseTimingFunction(token, &timing)) {
+        spec.timing = timing;
+      } else if (lower == "infinite") {
+        spec.iterations = -1.0f;
+      } else if (lower == "normal") {
+        spec.direction = AnimationDirection::Normal;
+      } else if (lower == "reverse") {
+        spec.direction = AnimationDirection::Reverse;
+      } else if (lower == "alternate") {
+        spec.direction = AnimationDirection::Alternate;
+      } else if (lower == "alternate-reverse") {
+        spec.direction = AnimationDirection::AlternateReverse;
+      } else if (lower == "none") {
+        spec.fill = AnimationFillMode::None;
+      } else if (lower == "forwards") {
+        spec.fill = AnimationFillMode::Forwards;
+      } else if (lower == "backwards") {
+        spec.fill = AnimationFillMode::Backwards;
+      } else if (lower == "both") {
+        spec.fill = AnimationFillMode::Both;
+      } else if (lower == "paused") {
+        spec.paused = true;
+      } else if (lower == "running") {
+        spec.paused = false;
+      } else {
+        float count = 0;
+        if (xt_css_parse_number(token, &count)) spec.iterations = count;
+        else spec.name = token;
+      }
+    }
+    out->push_back(spec);
+  }
+  return true;
+}
+
 bool xt_style_apply_effect(XtStyle *style, const std::string &property,
                            const std::string &value) {
   if (property == "filter") return parseFilterList(value, &style->filters);
   if (property == "backdrop-filter") return parseFilterList(value, &style->backdrop_filters);
   if (property == "text-shadow") return parseTextShadow(value, &style->text_shadow);
+  if (property == "box-shadow") return parseBoxShadow(value, &style->box_shadow);
+  if (property == "animation") {
+    parseAnimationShorthand(value, &style->animations);
+    return true;
+  }
   if (property == "content") {
     std::string text = xt_css_lower(xt_css_trim(value));
     if (text == "none" || text == "normal") {
@@ -283,7 +427,11 @@ bool xt_style_apply_transition(XtStyle *style, const std::string &property,
   if (property == "transition-property") {
     std::vector<std::string> parts = splitCommas(value);
     style->transitions.resize(parts.size());
-    for (size_t i = 0; i < parts.size(); i++) style->transitions[i].property = xt_css_lower(parts[i]);
+    for (size_t i = 0; i < parts.size(); i++) {
+      style->transitions[i].property = xt_css_lower(parts[i]);
+      if (style->transitions[i].property == "background")
+        style->transitions[i].property = "background-color";
+    }
     return true;
   }
   if (property == "transition-duration" || property == "transition-delay") {
@@ -301,7 +449,7 @@ bool xt_style_apply_transition(XtStyle *style, const std::string &property,
     std::vector<std::string> parts = splitCommas(value);
     style->transitions.resize(parts.size());
     for (size_t i = 0; i < parts.size(); i++) {
-      TimingFunction timing = TimingFunction::Ease;
+      TimingFunction timing;
       if (parseTimingFunction(parts[i], &timing)) style->transitions[i].timing = timing;
     }
     return true;
@@ -309,4 +457,80 @@ bool xt_style_apply_transition(XtStyle *style, const std::string &property,
   return false;
 }
 
+bool xt_style_apply_animation(XtStyle *style, const std::string &property,
+                              const std::string &value) {
+  if (property == "animation-name") {
+    std::vector<std::string> parts = splitCommas(value);
+    style->animations.resize(parts.size());
+    for (size_t i = 0; i < parts.size(); i++) {
+      style->animations[i].name = parts[i];
+    }
+    return true;
+  }
+  if (property == "animation-duration" || property == "animation-delay") {
+    std::vector<std::string> parts = splitCommas(value);
+    style->animations.resize(parts.size());
+    for (size_t i = 0; i < parts.size(); i++) {
+      float seconds = 0;
+      if (!parseTimeSeconds(parts[i], &seconds)) continue;
+      if (property == "animation-duration") style->animations[i].duration = seconds;
+      else style->animations[i].delay = seconds;
+    }
+    return true;
+  }
+  if (property == "animation-timing-function") {
+    std::vector<std::string> parts = splitCommas(value);
+    style->animations.resize(parts.size());
+    for (size_t i = 0; i < parts.size(); i++) {
+      TimingFunction timing;
+      if (parseTimingFunction(parts[i], &timing)) style->animations[i].timing = timing;
+    }
+    return true;
+  }
+  if (property == "animation-iteration-count") {
+    std::vector<std::string> parts = splitCommas(value);
+    style->animations.resize(parts.size());
+    for (size_t i = 0; i < parts.size(); i++) {
+      std::string lower = xt_css_lower(parts[i]);
+      float count = 0;
+      if (lower == "infinite") style->animations[i].iterations = -1.0f;
+      else if (xt_css_parse_number(parts[i], &count)) style->animations[i].iterations = count;
+    }
+    return true;
+  }
+  if (property == "animation-direction") {
+    static const char *const names[] = {"normal", "reverse", "alternate", "alternate-reverse"};
+    std::vector<std::string> parts = splitCommas(value);
+    style->animations.resize(parts.size());
+    for (size_t i = 0; i < parts.size(); i++) {
+      std::string lower = xt_css_lower(parts[i]);
+      for (int d = 0; d < 4; d++) {
+        if (lower == names[d]) style->animations[i].direction = (AnimationDirection)d;
+      }
+    }
+    return true;
+  }
+  if (property == "animation-fill-mode") {
+    static const char *const names[] = {"none", "forwards", "backwards", "both"};
+    std::vector<std::string> parts = splitCommas(value);
+    style->animations.resize(parts.size());
+    for (size_t i = 0; i < parts.size(); i++) {
+      std::string lower = xt_css_lower(parts[i]);
+      for (int f = 0; f < 4; f++) {
+        if (lower == names[f]) style->animations[i].fill = (AnimationFillMode)f;
+      }
+    }
+    return true;
+  }
+  if (property == "animation-play-state") {
+    std::vector<std::string> parts = splitCommas(value);
+    style->animations.resize(parts.size());
+    for (size_t i = 0; i < parts.size(); i++) {
+      style->animations[i].paused = xt_css_lower(parts[i]) == "paused";
+    }
+    return true;
+  }
+  return false;
+}
+
 }  // namespace xtgui

package/runtime/ext_gui/gpu_bridge.c

@@ -0,0 +1,28 @@
+/*
+ * xbintsc GUI engine — `gpu` link feature registration bridge.
+ *
+ * This tiny C translation unit is compiled and linked *only* when the compiler
+ * decides the program may compile GLSL (`getContext("webgl…")`,
+ * `mix-blend-mode`, or markup built at run time). Its constructor calls
+ * `xt_gpu_feature_register` in `gpu_feature.cpp`, which installs the shader
+ * table and references glslang/SPIRV-Cross; those references are what make the
+ * linker extract the translator members from `gui.a`.
+ *
+ * When the feature is inactive this object is absent, so nothing references the
+ * translator and the table in `gpu_shader.cpp` stays null.
+ */
+
+extern void xt_gpu_feature_register(void);
+
+#if defined(__GNUC__) || defined(__clang__)
+/* clang targeting Windows (the toolchain xbintsc uses there) implements this
+ * attribute with a `.CRT$XCU` entry, which the MSVC CRT runs before `main`. */
+__attribute__((constructor)) static void xt_gpu_feature_boot(void) {
+  xt_gpu_feature_register();
+}
+#elif defined(_MSC_VER)
+void xt_gpu_feature_boot(void);
+#pragma section(".CRT$XCU", read)
+__declspec(allocate(".CRT$XCU")) static void (*const xt_gpu_feature_ctor)(void) = xt_gpu_feature_boot;
+void xt_gpu_feature_boot(void) { xt_gpu_feature_register(); }
+#endif

package/runtime/ext_gui/gpu_feature.cpp

@@ -0,0 +1,30 @@
+/*
+ * xbintsc GUI engine — `gpu` link feature implementation.
+ *
+ * This translation unit is the only place in `gui.a` that references glslang and
+ * SPIRV-Cross. It is pulled out of the archive only when `gpu_bridge.c` (the
+ * feature's C registration object) is linked, which happens only when the
+ * compiler detects that the program may compile shaders. Without it the engine
+ * sees a null table (`gpu_shader.cpp`) and no glslang member is extracted.
+ */
+
+#include "gpu_shader_api.h"
+#include "webgl_msl.h"
+
+namespace {
+
+const xtgui::GpuShaderApi kGpuShaderApi = {
+    xtgui::unroll_glsl_pragmas,
+    xtgui::scan_glsl,
+    xtgui::rewrite_glsl,
+    xtgui::compile_glsl,
+    xtgui::reflect_uniform_block,
+    xtgui::reflect_attributes,
+    xtgui::cross_compile_msl,
+};
+
+}  // namespace
+
+extern "C" void xt_gpu_feature_register(void) {
+  xtgui::gpu_shader_install(&kGpuShaderApi);
+}

package/runtime/ext_gui/gpu_shader.cpp

@@ -0,0 +1,22 @@
+/*
+ * xbintsc GUI engine — core-side registry for the optional GPU shader table.
+ *
+ * Kept in `gui.a` and free of any glslang/SPIRV-Cross dependency: the table is
+ * installed by the `gpu` feature's bridge when that feature is linked, and stays
+ * null otherwise. See `gpu_shader_api.h`.
+ */
+
+#include "gpu_shader_api.h"
+
+namespace xtgui {
+namespace {
+
+const GpuShaderApi *g_api = nullptr;
+
+}  // namespace
+
+void gpu_shader_install(const GpuShaderApi *api) { g_api = api; }
+
+const GpuShaderApi *gpu_shader_api() { return g_api; }
+
+}  // namespace xtgui

package/runtime/ext_gui/gpu_shader_api.h

@@ -0,0 +1,50 @@
+/*
+ * xbintsc GUI engine — optional GPU shader translation table.
+ *
+ * WebGL shaders and the `mix-blend-mode` compositor both need GLSL→SPIR-V
+ * translation (glslang), and on Metal a second SPIR-V→MSL pass (SPIRV-Cross).
+ * Those are the largest optional third-party dependencies in the GUI engine, so
+ * the engine reaches them through this table instead of linking them directly.
+ *
+ * The implementation lives in `gpu_feature.cpp` and is only pulled out of
+ * `gui.a` when the `gpu` link feature's bridge is linked. Without it the table is
+ * null: the blend compositor falls back to ordinary painting and WebGL reports a
+ * shader compile log, but a DOM/2D-canvas page still runs.
+ */
+#ifndef XT_GUI_GPU_SHADER_API_H
+#define XT_GUI_GPU_SHADER_API_H
+
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include "webgl_glsl.h"
+
+namespace xtgui {
+
+/** The GLSL preprocessing/translation/reflection entry points the engine calls
+ * on demand. */
+struct GpuShaderApi {
+  std::string (*unroll_glsl_pragmas)(const std::string &source);
+  void (*scan_glsl)(const std::string &source, bool fragment, GlslShaderInfo *info);
+  std::string (*rewrite_glsl)(const std::string &source, bool fragment,
+                              const GlslLinkLayout &layout, const GlslShaderInfo &info);
+  bool (*compile_glsl)(const std::string &source, bool fragment,
+                       std::vector<uint32_t> *spirv, std::string *log);
+  bool (*reflect_uniform_block)(const std::vector<uint32_t> &spirv,
+                                std::vector<GlslBlockMember> *out);
+  bool (*reflect_attributes)(const std::vector<uint32_t> &spirv,
+                             std::unordered_map<std::string, int> *out);
+  bool (*cross_compile_msl)(const std::vector<uint32_t> &spirv, bool fragment,
+                            std::string *source, std::string *entry, std::string *log);
+};
+
+/** Install the table. Called by the `gpu` feature bridge before `main`. */
+void gpu_shader_install(const GpuShaderApi *api);
+
+/** The installed table, or null when the `gpu` feature was not linked. */
+const GpuShaderApi *gpu_shader_api();
+
+}  // namespace xtgui
+
+#endif /* XT_GUI_GPU_SHADER_API_H */

package/runtime/ext_gui/gradient_values.cpp

@@ -474,10 +474,34 @@ void xt_style_apply_background(XtStyle *style, const std::string &value) {
   std::vector<BackgroundLayer> layers;
   parseLayers(value, &layers, &color, &hasColor, true);
   style->background_layers = std::move(layers);
+  style->background_sizes.clear();
   if (hasColor) {
     style->background = color;
     style->has_background = true;
   }
 }
 
+bool xt_style_apply_background_size(XtStyle *style, const std::string &value) {
+  std::vector<BackgroundSize> sizes;
+  for (const std::string &part : splitCommas(value)) {
+    std::vector<std::string> tokens = splitTokens(part);
+    if (tokens.empty()) continue;
+    BackgroundSize size;
+    for (size_t i = 0; i < tokens.size() && i < 2; i++) {
+      std::string token = xt_css_lower(xt_css_trim(tokens[i]));
+      Length length{0.0f, Unit::Auto};
+      if (token != "auto" && token != "cover" && token != "contain") {
+        Length parsed = xt_css_parse_length(token);
+        if (parsed.unit != Unit::Invalid && parsed.unit != Unit::None) length = parsed;
+      }
+      if (i == 0) size.width = length;
+      else size.height = length;
+    }
+    if (tokens.size() == 1) size.height = Length{0.0f, Unit::Auto};
+    sizes.push_back(size);
+  }
+  style->background_sizes = std::move(sizes);
+  return true;
+}
+
 }  // namespace xtgui

package/runtime/ext_gui/grid_values.cpp

@@ -223,6 +223,29 @@ bool xt_style_apply_grid_property(XtStyle *style, const std::string &property,
     parseGridLine(value, &style->grid_row_start, &style->grid_row_end);
     return true;
   }
+  if (property == "grid-area") {
+    std::vector<std::string> parts;
+    std::string current;
+    int depth = 0;
+    for (char c : value) {
+      if (c == '(') depth++;
+      if (c == ')') depth--;
+      if (c == '/' && depth == 0) {
+        parts.push_back(xt_css_trim(current));
+        current.clear();
+      } else {
+        current.push_back(c);
+      }
+    }
+    parts.push_back(xt_css_trim(current));
+    style->grid_row_start = style->grid_column_start = 0;
+    style->grid_row_end = style->grid_column_end = 0;
+    if (parts.size() >= 1) parseGridLineNumber(parts[0], &style->grid_row_start);
+    if (parts.size() >= 2) parseGridLineNumber(parts[1], &style->grid_column_start);
+    if (parts.size() >= 3) parseGridLineNumber(parts[2], &style->grid_row_end);
+    if (parts.size() >= 4) parseGridLineNumber(parts[3], &style->grid_column_end);
+    return true;
+  }
 
   return false;
 }

package/runtime/ext_gui/gui.cpp

@@ -15,7 +15,7 @@
 
 #include "gui_internal.h"
 
-#include "image.h"
+#include "image_api.h"
 #include "paint.h"
 
 #include <stdio.h>
@@ -36,40 +36,9 @@ int g_window_count = 0;
  * `createWindow`), so the next `createWindow` adopts it. */
 int g_implicit_window = 0;
 
-/* Optional application icon embedded at compile time by the driver (`--icon` /
- * `app.icon`). The symbols live in a small object the driver links into every
- * GUI program (an empty object when no icon is configured), so the references
- * are plain: `xt_app_icon_size == 0` means "no icon". */
-extern "C" {
-extern const unsigned char xt_app_icon_data[];
-extern const unsigned long long xt_app_icon_size;
-extern const char xt_app_icon_format[];
-extern const unsigned int xt_app_icon_width;
-extern const unsigned int xt_app_icon_height;
-}
-
-/**
- * Set the window / taskbar / Dock icon from the embedded PNG, if any. Decoding
- * goes through the same stb_image path as `<img>`, so the icon needs no extra
- * dependency. Failures are silent: an icon is cosmetic and must never stop the
- * program from starting.
- */
-void xt_gui_apply_icon(SDL_Window *window) {
-  if (window == NULL) return;
-  size_t size = (size_t)xt_app_icon_size;
-  if (size == 0) return;
-  if (strcmp(xt_app_icon_format, "png") != 0) return;
-
-  xtgui::Image image;
-  if (!xtgui::xt_image_decode(xt_app_icon_data, size, &image)) return;
-  if (image.width <= 0 || image.height <= 0) return;
-
-  SDL_Surface *surface = SDL_CreateSurfaceFrom(
-      image.width, image.height, SDL_PIXELFORMAT_RGBA32, image.pixels.data(), image.width * 4);
-  if (surface == NULL) return;
-  SDL_SetWindowIcon(window, surface);
-  SDL_DestroySurface(surface);
-}
+/* The application icon is decoded and applied by the optional `images` feature
+ * (`XtImageApi::apply_icon`), which is forced on when an icon is configured.
+ * Keeping it there lets a text-only program drop SDL's surface/blit code. */
 
 /* -- garbage collector roots ---------------------------------------------- */
 
@@ -247,7 +216,7 @@ static XtGuiWindow *create_window_record(const char *title, int width, int heigh
     SDL_DestroyWindow(window);
     return NULL;
   }
-  xt_gui_apply_icon(window);
+  if (const XtImageApi *images = xt_image_api()) images->apply_icon(window);
 
   int index = g_window_count++;
   XtGuiWindow *record = &g_windows[index];
@@ -470,7 +439,7 @@ extern "C" xt_value xt_gui_run(int32_t argc, xt_value *argv) {
   }
   /* Drop the decoded-image caches (including parsed SVG documents) now that
    * the GPU textures that referenced them are gone. */
-  xtgui::xt_image_shutdown();
+  if (const XtImageApi *images = xt_image_api()) images->shutdown();
   g_window_count = 0;
   return XT_UNDEFINED;
 }