xbintsc 0.5.32 → 0.5.37

package/runtime/ext_gui/dom_api_node.cpp

@@ -4,6 +4,7 @@
  */
 
 #include "dom_api_internal.h"
+#include "listener_options.h"
 
 #include <algorithm>
 #include <cmath>
@@ -217,13 +218,19 @@ METHOD(node_get_bounding_rect) {
   if (node == nullptr || win == nullptr || win->document == nullptr) return XT_UNDEFINED;
   const xtgui::LayoutBox *box = win->document->boxOf(node);
   if (box == nullptr) return XT_UNDEFINED;
-  /* Like the DOM: the rectangle of the *transformed* border box. */
+  /* Like the DOM: the rectangle of the *transformed* border box. The legacy
+   * `top`/`right`/`bottom`/`left` members are the same rectangle in the other
+   * spelling; libraries read both. */
   xtgui::LayoutRect rect = xtgui::xt_layout_transformed_bounds(box);
   xt_value object = xt_object_new();
   xt_object_set(object, xt_string_from_cstr("x"), xt_number(rect.x));
   xt_object_set(object, xt_string_from_cstr("y"), xt_number(rect.y));
   xt_object_set(object, xt_string_from_cstr("width"), xt_number(rect.width));
   xt_object_set(object, xt_string_from_cstr("height"), xt_number(rect.height));
+  xt_object_set(object, xt_string_from_cstr("top"), xt_number(rect.y));
+  xt_object_set(object, xt_string_from_cstr("right"), xt_number(rect.x + rect.width));
+  xt_object_set(object, xt_string_from_cstr("bottom"), xt_number(rect.y + rect.height));
+  xt_object_set(object, xt_string_from_cstr("left"), xt_number(rect.x));
   return object;
 }
 
@@ -252,12 +259,30 @@ METHOD(node_contains) {
 
 METHOD(node_focus) {
   (void)env;
-  (void)argc;
-  (void)argv;
   XtGuiWindow *win = nullptr;
   xtgui::Node *node = resolve_node(self, &win);
   if (node == nullptr || win == nullptr || win->document == nullptr) return XT_UNDEFINED;
+  /* `{ preventScroll: true }` keeps the current page offset; otherwise the
+   * focused box is scrolled into view, like the browser default. */
+  bool prevent_scroll = false;
+  xt_value options = xt_arg(argc, argv, 0);
+  if (XT_IS_OBJECT(options)) {
+    prevent_scroll = value_truthy(xt_object_get_cstr(options, "preventScroll"));
+  }
   if (win->document->setFocus(node)) win->geometry.dirty = 1;
+  const xtgui::LayoutBox *box = win->document->boxOf(node);
+  if (!prevent_scroll && box != nullptr) {
+    float viewport_width = 0;
+    float viewport_height = 0;
+    xt_gui_window_viewport(win, &viewport_width, &viewport_height);
+    float x = win->scroll_x;
+    float y = win->scroll_y;
+    if (box->x < x) x = box->x;
+    else if (box->x + box->width > x + viewport_width) x = box->x + box->width - viewport_width;
+    if (box->y < y) y = box->y;
+    else if (box->y + box->height > y + viewport_height) y = box->y + box->height - viewport_height;
+    xt_gui_scroll_to(win, x, y);
+  }
   return XT_UNDEFINED;
 }
 
@@ -290,20 +315,18 @@ METHOD(node_add_event_listener) {
   if (node == nullptr || win == nullptr || argc < 2) return self;
   xt_value fn = xt_arg(argc, argv, 1);
   if (!XT_IS_FUNCTION(fn)) return self;
-  bool capture = false;
-  bool once = false;
-  xt_value options = xt_arg(argc, argv, 2);
-  if (XT_IS_OBJECT(options)) {
-    capture = value_truthy(xt_object_get_cstr(options, "capture"));
-    once = value_truthy(xt_object_get_cstr(options, "once"));
-  } else if (XT_IS_BOOL(options)) {
-    capture = value_truthy(options);
-  }
+  XtGuiListenerOptions options = xt_gui_listener_options(xt_arg(argc, argv, 2));
+  /* `{ signal: controller.signal }` removes the listener: an already-aborted
+   * signal means it was never installed, and a later abort is honoured at
+   * dispatch time (see `call_node_listeners`). */
+  if (xt_gui_signal_aborted(options.signal)) return self;
   XtGuiNodeListener listener;
   listener.type = to_string_value(xt_arg(argc, argv, 0));
   listener.fn = fn;
-  listener.once = once;
-  listener.capture = capture;
+  listener.once = options.once;
+  listener.capture = options.capture;
+  listener.passive = options.passive;
+  listener.signal = options.signal;
   win->node_listeners[node].push_back(listener);
   return self;
 }
@@ -313,11 +336,9 @@ METHOD(node_remove_event_listener) {
   XtGuiWindow *win = nullptr;
   xtgui::Node *node = resolve_node(self, &win);
   if (node == nullptr || win == nullptr || argc < 2) return self;
-  bool capture = false;
-  xt_value options = xt_arg(argc, argv, 2);
-  if (XT_IS_OBJECT(options)) capture = value_truthy(xt_object_get_cstr(options, "capture"));
-  else if (XT_IS_BOOL(options)) capture = value_truthy(options);
-  remove_listener(win, node, to_string_value(xt_arg(argc, argv, 0)), xt_arg(argc, argv, 1), capture);
+  XtGuiListenerOptions options = xt_gui_listener_options(xt_arg(argc, argv, 2));
+  remove_listener(win, node, to_string_value(xt_arg(argc, argv, 0)), xt_arg(argc, argv, 1),
+                  options.capture);
   return self;
 }
 

package/runtime/ext_gui/dom_api_node_read.cpp

@@ -34,7 +34,10 @@ METHOD(node_tag_name_get) {
   XtGuiWindow *win = nullptr;
   xtgui::Node *node = resolve_node(self, &win);
   if (node == nullptr || !node->isElement()) return XT_UNDEFINED;
-  return xt_string_from_cstr(to_upper(node->tag).c_str());
+  /* `tagName` uppercases HTML element names but keeps the authored case in a
+   * foreign namespace (SVG's `linearGradient`, `clipPath`, …). */
+  const bool html = node->ns.empty() || node->ns == "http://www.w3.org/1999/xhtml";
+  return xt_string_from_cstr(html ? to_upper(node->tag).c_str() : node->tag.c_str());
 }
 
 METHOD(node_node_type_get) {
@@ -58,6 +61,38 @@ METHOD(node_id_get) {
   return xt_string_from_cstr(value != nullptr ? value->c_str() : "");
 }
 
+/** `namespaceURI`: the namespace passed to `createElementNS`, or the HTML
+ * namespace for an ordinary element. */
+METHOD(node_namespace_uri_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xtgui::Node *node = resolve_node(self, nullptr);
+  if (node == nullptr || !node->isElement()) return XT_NULL;
+  if (!node->ns.empty()) return xt_string_from_cstr(node->ns.c_str());
+  return xt_string_from_cstr("http://www.w3.org/1999/xhtml");
+}
+
+METHOD(node_local_name_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xtgui::Node *node = resolve_node(self, nullptr);
+  if (node == nullptr) return XT_UNDEFINED;
+  if (!node->isElement()) return XT_NULL;
+  return xt_string_from_cstr(node->tag.c_str());
+}
+
+METHOD(node_prefix_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xtgui::Node *node = resolve_node(self, nullptr);
+  if (node == nullptr) return XT_UNDEFINED;
+  if (node->ns_prefix.empty()) return XT_NULL;
+  return xt_string_from_cstr(node->ns_prefix.c_str());
+}
+
 METHOD(node_id_set) {
   (void)env;
   XtGuiWindow *win = nullptr;
@@ -295,6 +330,7 @@ METHOD(node_style_get) {
   if (XT_IS_OBJECT(cached)) return cached;
   xt_value style = xt_object_new_with_proto(style_proto());
   xt_object_set(style, xt_string_from_cstr("__xt_gui_node"), self);
+  install_style_hooks(style);
   xt_object_set(self, xt_string_from_cstr("__xt_gui_style"), style);
   return style;
 }

package/runtime/ext_gui/dom_api_path2d.cpp

@@ -0,0 +1,358 @@
+/*
+ * xbintsc GUI engine — `Path2D`.
+ *
+ * A path is stored on the runtime object itself as an array of subpaths, each a
+ * flat number list `[x0, y0, x1, y1, …]` (user space). Keeping the geometry in
+ * the JS heap means the collector owns it: a page that builds a path per frame
+ * does not grow a native registry. `ctx.fill(path)` / `ctx.stroke(path)` read it
+ * back with `path2d_subpaths` and draw it under the current transform.
+ */
+
+#include "dom_api_internal.h"
+
+#include <cmath>
+#include <string>
+#include <vector>
+
+#include "canvas.h"
+
+namespace domapi {
+
+namespace {
+
+xt_value g_path2d_proto = XT_UNDEFINED;
+constexpr float kPi = 3.14159265358979323846f;
+
+#define METHOD(name) xt_value name(xt_value self, xt_value env, int32_t argc, xt_value *argv)
+
+xt_value path_data(xt_value self, bool create) {
+  xt_value data = xt_object_get_cstr(self, "__xt_gui_path_data");
+  if (XT_IS_ARRAY(data) || !create) return data;
+  data = xt_array_new(0, nullptr);
+  xt_object_set(self, xt_string_from_cstr("__xt_gui_path_data"), data);
+  return data;
+}
+
+xt_value current_subpath(xt_value self, bool create) {
+  xt_value data = path_data(self, create);
+  if (!XT_IS_ARRAY(data)) return XT_UNDEFINED;
+  int32_t count = (int32_t)xt_to_number(xt_array_length(data));
+  if (count > 0) return xt_array_get(data, xt_number((double)(count - 1)));
+  if (!create) return XT_UNDEFINED;
+  xt_value subpath = xt_array_new(0, nullptr);
+  xt_array_push(data, subpath);
+  return subpath;
+}
+
+void push_point(xt_value subpath, float x, float y) {
+  xt_array_push(subpath, xt_number(x));
+  xt_array_push(subpath, xt_number(y));
+}
+
+float number_arg(int32_t argc, xt_value *argv, int32_t index, double fallback) {
+  if (index >= argc) return (float)fallback;
+  return (float)xt_to_number(xt_arg(argc, argv, index));
+}
+
+bool last_point(xt_value subpath, float *x, float *y) {
+  int32_t count = (int32_t)xt_to_number(xt_array_length(subpath));
+  if (count < 2) return false;
+  *x = (float)xt_to_number(xt_array_get(subpath, xt_number((double)(count - 2))));
+  *y = (float)xt_to_number(xt_array_get(subpath, xt_number((double)(count - 1))));
+  return true;
+}
+
+/** Append a flattened polyline, starting a new subpath when none is open. */
+void append_points(xt_value self, const std::vector<float> &flat) {
+  if (flat.size() < 2) return;
+  xt_value subpath = current_subpath(self, true);
+  float lx = 0.0f, ly = 0.0f;
+  size_t start = 0;
+  if (last_point(subpath, &lx, &ly)) {
+    if (lx != flat[0] || ly != flat[1]) push_point(subpath, flat[0], flat[1]);
+    start = 2;
+  }
+  for (size_t i = start; i + 1 < flat.size(); i += 2) push_point(subpath, flat[i], flat[i + 1]);
+}
+
+void flatten_arc(std::vector<float> *out, float cx, float cy, float rx, float ry, float rotation,
+                 float start, float sweep) {
+  if (sweep == 0.0f) return;
+  int segments = (int)std::ceil(std::fabs(sweep) / (kPi / 32.0f));
+  if (segments < 1) segments = 1;
+  if (segments > 2048) segments = 2048;
+  const float cosRotation = std::cos(rotation);
+  const float sinRotation = std::sin(rotation);
+  for (int i = 0; i <= segments; i++) {
+    float angle = start + sweep * ((float)i / (float)segments);
+    float px = rx * std::cos(angle);
+    float py = ry * std::sin(angle);
+    out->push_back(cx + px * cosRotation - py * sinRotation);
+    out->push_back(cy + px * sinRotation + py * cosRotation);
+  }
+}
+
+void normalize_sweep(float *sweep, bool counterclockwise) {
+  if (counterclockwise) {
+    while (*sweep > 0.0f) *sweep -= 2.0f * kPi;
+    while (*sweep < -2.0f * kPi) *sweep += 2.0f * kPi;
+  } else {
+    while (*sweep < 0.0f) *sweep += 2.0f * kPi;
+    while (*sweep > 2.0f * kPi) *sweep -= 2.0f * kPi;
+  }
+}
+
+METHOD(path2d_move_to) {
+  (void)env;
+  xt_value data = path_data(self, true);
+  xt_value subpath = xt_array_new(0, nullptr);
+  push_point(subpath, number_arg(argc, argv, 0, 0.0), number_arg(argc, argv, 1, 0.0));
+  xt_array_push(data, subpath);
+  return XT_UNDEFINED;
+}
+
+METHOD(path2d_line_to) {
+  (void)env;
+  xt_value subpath = current_subpath(self, true);
+  push_point(subpath, number_arg(argc, argv, 0, 0.0), number_arg(argc, argv, 1, 0.0));
+  return XT_UNDEFINED;
+}
+
+METHOD(path2d_close_path) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xt_value subpath = current_subpath(self, false);
+  if (!XT_IS_ARRAY(subpath)) return XT_UNDEFINED;
+  int32_t count = (int32_t)xt_to_number(xt_array_length(subpath));
+  if (count < 4) return XT_UNDEFINED;
+  float firstX = (float)xt_to_number(xt_array_get(subpath, xt_number(0)));
+  float firstY = (float)xt_to_number(xt_array_get(subpath, xt_number(1)));
+  float lx = 0.0f, ly = 0.0f;
+  if (last_point(subpath, &lx, &ly) && (lx != firstX || ly != firstY)) {
+    push_point(subpath, firstX, firstY);
+  }
+  return XT_UNDEFINED;
+}
+
+METHOD(path2d_rect) {
+  (void)env;
+  float x = number_arg(argc, argv, 0, 0.0);
+  float y = number_arg(argc, argv, 1, 0.0);
+  float w = number_arg(argc, argv, 2, 0.0);
+  float h = number_arg(argc, argv, 3, 0.0);
+  xt_value data = path_data(self, true);
+  xt_value subpath = xt_array_new(0, nullptr);
+  push_point(subpath, x, y);
+  push_point(subpath, x + w, y);
+  push_point(subpath, x + w, y + h);
+  push_point(subpath, x, y + h);
+  push_point(subpath, x, y);
+  xt_array_push(data, subpath);
+  return XT_UNDEFINED;
+}
+
+METHOD(path2d_round_rect) {
+  (void)env;
+  float x = number_arg(argc, argv, 0, 0.0);
+  float y = number_arg(argc, argv, 1, 0.0);
+  float w = number_arg(argc, argv, 2, 0.0);
+  float h = number_arg(argc, argv, 3, 0.0);
+  float radius = number_arg(argc, argv, 4, 0.0);
+  if (w < 0.0f) {
+    x += w;
+    w = -w;
+  }
+  if (h < 0.0f) {
+    y += h;
+    h = -h;
+  }
+  float maxRadius = std::min(w, h) * 0.5f;
+  if (radius < 0.0f) radius = 0.0f;
+  if (radius > maxRadius) radius = maxRadius;
+  xt_value data = path_data(self, true);
+  xt_value subpath = xt_array_new(0, nullptr);
+  std::vector<float> points;
+  flatten_arc(&points, x + w - radius, y + radius, radius, radius, 0.0f, -kPi * 0.5f, kPi * 0.5f);
+  flatten_arc(&points, x + w - radius, y + h - radius, radius, radius, 0.0f, 0.0f, kPi * 0.5f);
+  flatten_arc(&points, x + radius, y + h - radius, radius, radius, 0.0f, kPi * 0.5f, kPi * 0.5f);
+  flatten_arc(&points, x + radius, y + radius, radius, radius, 0.0f, kPi, kPi * 0.5f);
+  push_point(subpath, x + radius, y);
+  for (size_t i = 0; i + 1 < points.size(); i += 2) push_point(subpath, points[i], points[i + 1]);
+  push_point(subpath, x + radius, y);
+  xt_array_push(data, subpath);
+  return XT_UNDEFINED;
+}
+
+METHOD(path2d_arc) {
+  (void)env;
+  float sweep = number_arg(argc, argv, 4, 0.0) - number_arg(argc, argv, 3, 0.0);
+  normalize_sweep(&sweep, value_truthy(xt_arg(argc, argv, 5)));
+  std::vector<float> points;
+  flatten_arc(&points, number_arg(argc, argv, 0, 0.0), number_arg(argc, argv, 1, 0.0),
+              number_arg(argc, argv, 2, 0.0), number_arg(argc, argv, 2, 0.0), 0.0f,
+              number_arg(argc, argv, 3, 0.0), sweep);
+  append_points(self, points);
+  return XT_UNDEFINED;
+}
+
+METHOD(path2d_ellipse) {
+  (void)env;
+  float sweep = number_arg(argc, argv, 6, 0.0) - number_arg(argc, argv, 5, 0.0);
+  normalize_sweep(&sweep, value_truthy(xt_arg(argc, argv, 7)));
+  std::vector<float> points;
+  flatten_arc(&points, number_arg(argc, argv, 0, 0.0), number_arg(argc, argv, 1, 0.0),
+              number_arg(argc, argv, 2, 0.0), number_arg(argc, argv, 3, 0.0),
+              number_arg(argc, argv, 4, 0.0), number_arg(argc, argv, 5, 0.0), sweep);
+  append_points(self, points);
+  return XT_UNDEFINED;
+}
+
+METHOD(path2d_quadratic_curve_to) {
+  (void)env;
+  xt_value subpath = current_subpath(self, true);
+  float lx = 0.0f, ly = 0.0f;
+  if (!last_point(subpath, &lx, &ly)) {
+    lx = number_arg(argc, argv, 0, 0.0);
+    ly = number_arg(argc, argv, 1, 0.0);
+    push_point(subpath, lx, ly);
+  }
+  float cpx = number_arg(argc, argv, 0, 0.0);
+  float cpy = number_arg(argc, argv, 1, 0.0);
+  float tx = number_arg(argc, argv, 2, 0.0);
+  float ty = number_arg(argc, argv, 3, 0.0);
+  for (int i = 1; i <= 16; i++) {
+    float t = (float)i / 16.0f;
+    float a = 1.0f - t;
+    push_point(subpath, a * a * lx + 2.0f * a * t * cpx + t * t * tx,
+               a * a * ly + 2.0f * a * t * cpy + t * t * ty);
+  }
+  return XT_UNDEFINED;
+}
+
+METHOD(path2d_bezier_curve_to) {
+  (void)env;
+  xt_value subpath = current_subpath(self, true);
+  float lx = 0.0f, ly = 0.0f;
+  if (!last_point(subpath, &lx, &ly)) {
+    lx = number_arg(argc, argv, 0, 0.0);
+    ly = number_arg(argc, argv, 1, 0.0);
+    push_point(subpath, lx, ly);
+  }
+  float c1x = number_arg(argc, argv, 0, 0.0);
+  float c1y = number_arg(argc, argv, 1, 0.0);
+  float c2x = number_arg(argc, argv, 2, 0.0);
+  float c2y = number_arg(argc, argv, 3, 0.0);
+  float tx = number_arg(argc, argv, 4, 0.0);
+  float ty = number_arg(argc, argv, 5, 0.0);
+  for (int i = 1; i <= 24; i++) {
+    float t = (float)i / 24.0f;
+    float u = 1.0f - t;
+    push_point(subpath,
+               u * u * u * lx + 3.0f * u * u * t * c1x + 3.0f * u * t * t * c2x + t * t * t * tx,
+               u * u * u * ly + 3.0f * u * u * t * c1y + 3.0f * u * t * t * c2y + t * t * t * ty);
+  }
+  return XT_UNDEFINED;
+}
+
+/** `path.addPath(other, matrix?)` copies another path, optionally transformed. */
+METHOD(path2d_add_path) {
+  (void)env;
+  std::vector<xtgui::CanvasSubpath> source = path2d_subpaths(xt_arg(argc, argv, 0));
+  if (source.empty()) return XT_UNDEFINED;
+  xtgui::CanvasTransform transform;
+  if (argc >= 2 && XT_IS_OBJECT(xt_arg(argc, argv, 1))) {
+    xt_value matrix = xt_arg(argc, argv, 1);
+    static const char *const names[6] = {"a", "b", "c", "d", "e", "f"};
+    float values[6] = {1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f};
+    for (int i = 0; i < 6; i++) {
+      xt_value member = xt_object_get_cstr(matrix, names[i]);
+      if (XT_IS_NUMBER(member)) values[i] = (float)xt_to_number(member);
+    }
+    transform = xtgui::CanvasTransform{values[0], values[1], values[2],
+                                       values[3], values[4], values[5]};
+  }
+  xt_value data = path_data(self, true);
+  for (const xtgui::CanvasSubpath &subpath : source) {
+    xt_value copy = xt_array_new(0, nullptr);
+    for (const xtgui::CanvasPoint &point : subpath) {
+      float x = point.x, y = point.y;
+      transform.apply(point.x, point.y, &x, &y);
+      push_point(copy, x, y);
+    }
+    xt_array_push(data, copy);
+  }
+  return XT_UNDEFINED;
+}
+
+#undef METHOD
+
+}  // namespace
+
+bool path2d_is(xt_value value) { return XT_IS_OBJECT(value) && value_truthy(xt_object_get_cstr(value, "__xt_gui_path2d")); }
+
+std::vector<xtgui::CanvasSubpath> path2d_subpaths(xt_value value) {
+  std::vector<xtgui::CanvasSubpath> result;
+  if (!path2d_is(value)) return result;
+  xt_value data = xt_object_get_cstr(value, "__xt_gui_path_data");
+  if (!XT_IS_ARRAY(data)) return result;
+  int32_t count = (int32_t)xt_to_number(xt_array_length(data));
+  for (int32_t i = 0; i < count; i++) {
+    xt_value item = xt_array_get(data, xt_number((double)i));
+    if (!XT_IS_ARRAY(item)) continue;
+    xtgui::CanvasSubpath subpath;
+    int32_t numbers = (int32_t)xt_to_number(xt_array_length(item));
+    for (int32_t j = 0; j + 1 < numbers; j += 2) {
+      subpath.push_back(xtgui::CanvasPoint{
+          (float)xt_to_number(xt_array_get(item, xt_number((double)j))),
+          (float)xt_to_number(xt_array_get(item, xt_number((double)(j + 1))))});
+    }
+    if (!subpath.empty()) result.push_back(std::move(subpath));
+  }
+  return result;
+}
+
+xt_value path2d_proto() {
+  if (XT_IS_OBJECT(g_path2d_proto)) return g_path2d_proto;
+  g_path2d_proto = xt_object_new();
+  xt_gc_add_root(&g_path2d_proto);
+  struct Entry {
+    const char *name;
+    void *fn;
+  };
+  const Entry methods[] = {
+      {"moveTo", (void *)path2d_move_to},
+      {"lineTo", (void *)path2d_line_to},
+      {"closePath", (void *)path2d_close_path},
+      {"rect", (void *)path2d_rect},
+      {"roundRect", (void *)path2d_round_rect},
+      {"arc", (void *)path2d_arc},
+      {"ellipse", (void *)path2d_ellipse},
+      {"quadraticCurveTo", (void *)path2d_quadratic_curve_to},
+      {"bezierCurveTo", (void *)path2d_bezier_curve_to},
+      {"addPath", (void *)path2d_add_path},
+  };
+  for (const Entry &method : methods) {
+    xt_object_set(g_path2d_proto, xt_string_from_cstr(method.name),
+                  xt_closure_new(method.fn, 0, nullptr));
+  }
+  return g_path2d_proto;
+}
+
+/** `new Path2D()` and `new Path2D(otherPath)`; a string (SVG path data) is not
+ * parsed, so it yields an empty path instead of silently drawing nonsense. */
+xt_value path2d_create(xt_value source) {
+  xt_value path = xt_object_new_with_proto(path2d_proto());
+  xt_object_set(path, xt_string_from_cstr("__xt_gui_path2d"), XT_TRUE);
+  xt_object_set(path, xt_string_from_cstr("__xt_gui_path_data"), xt_array_new(0, nullptr));
+  if (path2d_is(source)) {
+    xt_value data = xt_object_get_cstr(source, "__xt_gui_path_data");
+    xt_value copy = xt_array_new(0, nullptr);
+    int32_t count = XT_IS_ARRAY(data) ? (int32_t)xt_to_number(xt_array_length(data)) : 0;
+    for (int32_t i = 0; i < count; i++) xt_array_push(copy, xt_array_get(data, xt_number((double)i)));
+    xt_object_set(path, xt_string_from_cstr("__xt_gui_path_data"), copy);
+  }
+  return path;
+}
+
+}  // namespace domapi

package/runtime/ext_gui/dom_api_proto.cpp

@@ -27,6 +27,9 @@ xt_value node_proto() {
   define_getter(proto, "tagName", (void *)node_tag_name_get);
   define_getter(proto, "nodeName", (void *)node_tag_name_get);
   define_getter(proto, "nodeType", (void *)node_node_type_get);
+  define_getter(proto, "namespaceURI", (void *)node_namespace_uri_get);
+  define_getter(proto, "localName", (void *)node_local_name_get);
+  define_getter(proto, "prefix", (void *)node_prefix_get);
   define_getter(proto, "id", (void *)node_id_get);
   define_getter(proto, "className", (void *)node_class_name_get);
   define_getter(proto, "textContent", (void *)node_text_content_get);
@@ -44,6 +47,7 @@ xt_value node_proto() {
   define_getter(proto, "isConnected", (void *)node_is_connected_get);
   define_getter(proto, "classList", (void *)node_class_list_get);
   define_getter(proto, "style", (void *)node_style_get);
+  define_getter(proto, "dataset", (void *)node_dataset_get);
   define_getter(proto, "offsetWidth", (void *)node_offset_width_get);
   define_getter(proto, "offsetHeight", (void *)node_offset_height_get);
   /* Media element properties (`<video>`/`<audio>`; harmless on any element). */
@@ -86,6 +90,10 @@ xt_value node_proto() {
   define_method(proto, "querySelectorAll", (void *)node_query_selector_all);
   define_method(proto, "matches", (void *)node_matches);
   define_method(proto, "appendChild", (void *)node_append_child);
+  define_method(proto, "append", (void *)node_append);
+  define_method(proto, "prepend", (void *)node_prepend);
+  define_method(proto, "replaceChildren", (void *)node_replace_children);
+  define_method(proto, "insertAdjacentHTML", (void *)node_insert_adjacent_html);
   define_method(proto, "insertBefore", (void *)node_insert_before);
   define_method(proto, "removeChild", (void *)node_remove_child);
   define_method(proto, "replaceChild", (void *)node_replace_child);
@@ -103,6 +111,9 @@ xt_value node_proto() {
   define_method(proto, "pause", (void *)node_pause);
   define_method(proto, "load", (void *)node_load);
   define_method(proto, "getContext", (void *)node_get_context);
+  /* `toDataURL`/`toBlob` belong to the canvas *element*, as in the DOM. */
+  define_method(proto, "toDataURL", (void *)canvas_to_data_url);
+  define_method(proto, "toBlob", (void *)canvas_to_blob);
   g_node_proto = proto;
   return proto;
 }
@@ -121,7 +132,9 @@ xt_value document_proto() {
   define_getter(proto, "hidden", (void *)doc_hidden_get);
   define_getter(proto, "visibilityState", (void *)doc_visibility_state_get);
   define_getter(proto, "readyState", (void *)doc_ready_state_get);
+  define_method(proto, "hasFocus", (void *)doc_has_focus);
   define_getter(proto, "title", (void *)doc_title_get);
+  define_setter(proto, "title", (void *)doc_title_set);
   define_getter(proto, "defaultView", (void *)doc_default_view_get);
   define_method(proto, "createTextNode", (void *)doc_create_text_node);
   /* `document.addEventListener` / element listener plumbing come from the node
@@ -140,6 +153,7 @@ xt_value event_proto() {
   define_method(proto, "preventDefault", (void *)event_prevent_default);
   define_method(proto, "stopPropagation", (void *)event_stop_propagation);
   define_method(proto, "stopImmediatePropagation", (void *)event_stop_immediate_propagation);
+  define_method(proto, "composedPath", (void *)event_composed_path);
   g_event_proto = proto;
   return proto;
 }
@@ -162,11 +176,26 @@ xt_value style_proto() {
   xt_value proto = xt_object_new();
   define_method(proto, "setProperty", (void *)style_set_property);
   define_method(proto, "getPropertyValue", (void *)style_get_property_value);
+  define_method(proto, "getPropertyPriority", (void *)style_get_property_priority);
   define_method(proto, "removeProperty", (void *)style_remove_property);
+  define_getter(proto, "cssText", (void *)style_css_text_get);
+  define_setter(proto, "cssText", (void *)style_css_text_set);
+  define_method(proto, "item", (void *)style_item);
+  define_getter(proto, "length", (void *)style_length_get);
   g_style_proto = proto;
   return proto;
 }
 
+xt_value computed_style_proto() {
+  xt_gc_add_root(&g_computed_style_proto);
+  if (XT_IS_OBJECT(g_computed_style_proto)) return g_computed_style_proto;
+  xt_value proto = xt_object_new();
+  define_method(proto, "getPropertyValue", (void *)computed_style_get_property_value);
+  define_method(proto, "getPropertyPriority", (void *)computed_style_get_property_priority);
+  g_computed_style_proto = proto;
+  return proto;
+}
+
 xt_value canvas_proto() {
   xt_gc_add_root(&g_canvas_proto);
   if (XT_IS_OBJECT(g_canvas_proto)) return g_canvas_proto;
@@ -224,6 +253,12 @@ xt_value canvas_proto() {
   define_method(proto, "strokeText", (void *)canvas_stroke_text);
   define_method(proto, "drawImage", (void *)canvas_draw_image);
   define_method(proto, "getImageData", (void *)canvas_get_image_data);
+  define_method(proto, "getContextAttributes", (void *)canvas_get_context_attributes);
+  define_method(proto, "putImageData", (void *)canvas_put_image_data);
+  define_method(proto, "createImageData", (void *)canvas_create_image_data);
+  define_method(proto, "createPattern", (void *)canvas_create_pattern);
+  define_method(proto, "toDataURL", (void *)canvas_to_data_url);
+  define_method(proto, "toBlob", (void *)canvas_to_blob);
   define_method(proto, "setLineDash", (void *)canvas_line_dash_set);
   define_method(proto, "getLineDash", (void *)canvas_line_dash_get);
   define_method(proto, "getTransform", (void *)canvas_get_transform);