xbintsc 0.5.32 → 0.5.37

package/runtime/ext_gui/dom_api_document.cpp

@@ -93,17 +93,31 @@ METHOD(doc_create_element) {
   return xt_gui_node_handle(win, win->document->createElement(tag));
 }
 
-/** `createElementNS(ns, name)`: the engine has no namespaces, so the qualified
- * name after `:` is what gets created (`createElementNS(svgNS, "svg:rect")`). */
+/** `createElementNS(ns, name)`: the namespace is recorded (so `namespaceURI`
+ * answers it) and the qualified name's prefix is preserved. HTML names are
+ * lowercased, but names in another namespace keep their case — SVG is
+ * case-sensitive (`linearGradient`, `clipPath`). */
 METHOD(doc_create_element_ns) {
   (void)env;
   XtGuiWindow *win = resolve_window(self);
   if (win == nullptr || win->document == nullptr || argc < 2) return XT_UNDEFINED;
+  std::string ns = to_string_value(xt_arg(argc, argv, 0));
   std::string name = to_string_value(xt_arg(argc, argv, 1));
+  std::string prefix;
   size_t colon = name.rfind(':');
-  if (colon != std::string::npos) name = name.substr(colon + 1);
-  for (char &c : name) c = (char)std::tolower((unsigned char)c);
-  return xt_gui_node_handle(win, win->document->createElement(name));
+  if (colon != std::string::npos) {
+    prefix = name.substr(0, colon);
+    name = name.substr(colon + 1);
+  }
+  const bool html = ns.empty() || ns == "http://www.w3.org/1999/xhtml";
+  if (html) {
+    for (char &c : name) c = (char)std::tolower((unsigned char)c);
+  }
+  xtgui::Node *node = win->document->createElement(name);
+  if (node == nullptr) return XT_UNDEFINED;
+  node->ns = ns;
+  node->ns_prefix = prefix;
+  return xt_gui_node_handle(win, node);
 }
 
 /** `document.hidden` / `visibilityState`: a window in the main loop is always
@@ -124,6 +138,15 @@ METHOD(doc_visibility_state_get) {
   return xt_string_from_cstr("visible");
 }
 
+/** `document.hasFocus()`: true after `window.focus()` until `window.blur()`. */
+METHOD(doc_has_focus) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  XtGuiWindow *win = resolve_window(self);
+  return win != nullptr && win->focused ? XT_TRUE : XT_FALSE;
+}
+
 /** `document.readyState`: the page is fully parsed before any script runs. */
 METHOD(doc_ready_state_get) {
   (void)self;
@@ -149,6 +172,36 @@ METHOD(doc_title_get) {
   return xt_string_from_cstr(text.c_str());
 }
 
+/** `document.title = text`: replace the text of the document's `<title>`.
+ * A page without one gets a `<title>` (and a `<head>`, if the parser did not
+ * create one), so the assignment is not silently lost. */
+METHOD(doc_title_set) {
+  (void)env;
+  XtGuiWindow *win = resolve_window(self);
+  if (win == nullptr || win->document == nullptr) return XT_UNDEFINED;
+  std::string text;
+  if (argc >= 1) text = to_string_value(xt_arg(argc, argv, 0));
+  xtgui::Node *root = const_cast<xtgui::Node *>(win->document->root());
+  xtgui::Node *title = const_cast<xtgui::Node *>(find_by_tag(root, "title"));
+  if (title == nullptr) {
+    xtgui::Node *head = const_cast<xtgui::Node *>(find_by_tag(root, "head"));
+    if (head == nullptr) {
+      head = win->document->createElement("head");
+      if (head == nullptr) return XT_UNDEFINED;
+      /* `<head>` belongs before the body, not after it. */
+      xtgui::Node *body = const_cast<xtgui::Node *>(find_by_tag(root, "body"));
+      win->document->insertBefore(root, head, body);
+    }
+    title = win->document->createElement("title");
+    if (title == nullptr) return XT_UNDEFINED;
+    win->document->appendChild(head, title);
+  }
+  title->children.clear();
+  if (!text.empty()) title->addText(text);
+  mark_dirty(win);
+  return XT_UNDEFINED;
+}
+
 METHOD(doc_default_view_get) {
   (void)env;
   (void)argc;

package/runtime/ext_gui/dom_api_events.cpp

@@ -4,6 +4,7 @@
  */
 
 #include "dom_api_internal.h"
+#include "listener_options.h"
 
 #include <string>
 #include <vector>
@@ -15,8 +16,14 @@ static xt_value make_dom_event(XtGuiWindow *win, const char *type, const xtgui::
   xt_value event = xt_object_new_with_proto(event_proto());
   xt_object_set(event, xt_string_from_cstr("type"), xt_string_from_cstr(type));
   xt_object_set(event, xt_string_from_cstr("target"), xt_gui_node_handle(win, target));
+  xt_object_set(event, xt_string_from_cstr("currentTarget"), XT_NULL);
   xt_object_set(event, xt_string_from_cstr("defaultPrevented"), XT_FALSE);
   xt_object_set(event, xt_string_from_cstr("bubbles"), XT_TRUE);
+  xt_object_set(event, xt_string_from_cstr("cancelable"), XT_TRUE);
+  xt_object_set(event, xt_string_from_cstr("composed"), XT_TRUE);
+  xt_object_set(event, xt_string_from_cstr("isTrusted"), XT_TRUE);
+  xt_object_set(event, xt_string_from_cstr("eventPhase"), xt_number(0));
+  xt_object_set(event, xt_string_from_cstr("timeStamp"), xt_number((double)SDL_GetTicks()));
   if (XT_IS_OBJECT(legacy)) {
     static const char *const fields[] = {
         "x",     "y",    "clientX", "clientY", "button", "clicks",
@@ -31,23 +38,43 @@ static xt_value make_dom_event(XtGuiWindow *win, const char *type, const xtgui::
   return event;
 }
 
-/** A detached event object, as `new Event(type)` / `new CustomEvent(type, init)`
- * builds: no target yet, but the standard fields and `detail`. */
+/** Set `field` to `value` unless `init` already supplied one. */
+static void default_field(xt_value event, const char *field, xt_value value) {
+  if (XT_IS_UNDEFINED(xt_object_get_cstr(event, field))) {
+    xt_object_set(event, xt_string_from_cstr(field), value);
+  }
+}
+
+/** A detached event object, as `new Event(type, init)` /
+ * `new CustomEvent(type, init)` (and the other `*Event` constructors) builds:
+ * no target yet, the standard fields, and every member of `init` — so
+ * `composed`, `detail` and the mouse/keyboard fields all survive construction
+ * instead of being silently dropped. */
 xt_value event_construct(xt_value type, xt_value init) {
   std::string name = to_string_value(type);
   xt_value event = xt_object_new_with_proto(event_proto());
+  if (XT_IS_OBJECT(init)) {
+    xt_value keys = xt_object_keys(init);
+    int32_t count = (int32_t)xt_to_number(xt_array_length(keys));
+    for (int32_t i = 0; i < count; i++) {
+      xt_value key = xt_array_get(keys, xt_number((double)i));
+      xt_object_set(event, key, xt_object_get(init, key));
+    }
+  }
   xt_object_set(event, xt_string_from_cstr("type"), xt_string_from_cstr(name.c_str()));
-  xt_object_set(event, xt_string_from_cstr("target"), XT_NULL);
-  xt_object_set(event, xt_string_from_cstr("currentTarget"), XT_NULL);
-  xt_object_set(event, xt_string_from_cstr("defaultPrevented"), XT_FALSE);
-  xt_value bubbles = xt_object_get_cstr(init, "bubbles");
-  xt_object_set(event, xt_string_from_cstr("bubbles"), XT_IS_UNDEFINED(bubbles) ? XT_FALSE : bubbles);
-  xt_value cancelable = xt_object_get_cstr(init, "cancelable");
-  xt_object_set(event, xt_string_from_cstr("cancelable"),
-                XT_IS_UNDEFINED(cancelable) ? XT_FALSE : cancelable);
-  xt_value detail = xt_object_get_cstr(init, "detail");
-  xt_object_set(event, xt_string_from_cstr("detail"),
-                XT_IS_UNDEFINED(detail) ? XT_NULL : detail);
+  default_field(event, "target", XT_NULL);
+  default_field(event, "currentTarget", XT_NULL);
+  default_field(event, "defaultPrevented", XT_FALSE);
+  default_field(event, "bubbles", XT_FALSE);
+  default_field(event, "cancelable", XT_FALSE);
+  default_field(event, "composed", XT_FALSE);
+  default_field(event, "isTrusted", XT_FALSE);
+  default_field(event, "eventPhase", xt_number(0));
+  default_field(event, "detail", XT_NULL);
+  default_field(event, "timeStamp", xt_number((double)SDL_GetTicks()));
+  /* Marks an event object built here, so `dispatchEvent(ev)` can reuse it (an
+   * event keeps its identity through dispatch, as in the DOM). */
+  xt_object_set(event, xt_string_from_cstr("__xt_gui_event"), XT_TRUE);
   return event;
 }
 
@@ -64,18 +91,32 @@ void remove_listener(XtGuiWindow *win, xtgui::Node *node, const std::string &typ
   }
 }
 
+/** Call one listener batch. `phase` mirrors the DOM constants (1 capture,
+ * 2 at target, 3 bubble) so `event.eventPhase` is observable, and a passive
+ * listener runs with `preventDefault()` disabled. */
 static bool call_node_listeners(XtGuiWindow *win, xtgui::Node *node, const char *type,
-                                xt_value event, bool capture) {
+                                xt_value event, bool capture, int32_t phase) {
   auto found = win->node_listeners.find(node);
   if (found == win->node_listeners.end()) return false;
   std::vector<XtGuiNodeListener> snapshot = found->second;
+  xt_value previousPassive = xt_object_get_cstr(event, "__xt_gui_passive");
   for (const XtGuiNodeListener &listener : snapshot) {
     if (listener.type != type || listener.capture != capture) continue;
+    /* An aborted `AbortSignal` removes the listener. Drop it here so it also
+     * stops consuming the slot for future dispatches. */
+    if (xt_gui_signal_aborted(listener.signal)) {
+      remove_listener(win, node, listener.type, listener.fn, listener.capture);
+      continue;
+    }
     if (listener.once) remove_listener(win, node, listener.type, listener.fn, listener.capture);
     xt_value self = xt_gui_node_handle(win, node);
     xt_object_set(event, xt_string_from_cstr("currentTarget"), self);
+    xt_object_set(event, xt_string_from_cstr("eventPhase"), xt_number((double)phase));
+    xt_object_set(event, xt_string_from_cstr("__xt_gui_passive"),
+                  listener.passive ? XT_TRUE : XT_FALSE);
     xt_value args[1] = {event};
     xt_call_with_this(listener.fn, self, 1, args);
+    xt_object_set(event, xt_string_from_cstr("__xt_gui_passive"), previousPassive);
     if (value_truthy(xt_object_get_cstr(event, "__stopImmediate"))) return true;
     if (value_truthy(xt_object_get_cstr(event, "__stop"))) return true;
   }
@@ -88,6 +129,9 @@ METHOD(event_prevent_default) {
   (void)env;
   (void)argc;
   (void)argv;
+  /* A listener registered with `{ passive: true }` promised not to cancel: the
+   * browser ignores the call (and warns), so the engine ignores it too. */
+  if (value_truthy(xt_object_get_cstr(self, "__xt_gui_passive"))) return XT_UNDEFINED;
   xt_object_set(self, xt_string_from_cstr("defaultPrevented"), XT_TRUE);
   return XT_UNDEFINED;
 }
@@ -109,6 +153,22 @@ METHOD(event_stop_immediate_propagation) {
   return XT_UNDEFINED;
 }
 
+/** `event.composedPath()`: the propagation path recorded by the dispatcher,
+ * target first, as element handles. A detached event has an empty path. */
+METHOD(event_composed_path) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xt_value result = xt_array_new(0, nullptr);
+  xt_value path = xt_object_get_cstr(self, "__xt_gui_path");
+  if (!XT_IS_ARRAY(path)) return result;
+  int32_t count = (int32_t)xt_to_number(xt_array_length(path));
+  for (int32_t i = 0; i < count; i++) {
+    xt_array_push(result, xt_array_get(path, xt_number((double)i)));
+  }
+  return result;
+}
+
 #undef METHOD
 
 }  // namespace domapi
@@ -123,13 +183,29 @@ void xt_gui_emit_dom_event(XtGuiWindow *win, const char *type, const xtgui::Node
     path.push_back(node);
   }
   xt_value event = make_dom_event(win, type, target, legacy);
+  /* `element.dispatchEvent(ev)` hands over a real event object: dispatch that
+   * same object (identity is observable), only rebinding its target/path. */
+  if (XT_IS_OBJECT(legacy) && value_truthy(xt_object_get_cstr(legacy, "__xt_gui_event"))) {
+    event = legacy;
+    xt_object_set(event, xt_string_from_cstr("target"), xt_gui_node_handle(win, target));
+    xt_object_set(event, xt_string_from_cstr("currentTarget"), XT_NULL);
+    xt_object_set(event, xt_string_from_cstr("eventPhase"), xt_number(0));
+  }
+  xt_value handlePath = xt_array_new(0, nullptr);
+  for (xtgui::Node *node : path) xt_array_push(handlePath, xt_gui_node_handle(win, node));
+  xt_object_set(event, xt_string_from_cstr("__xt_gui_path"), handlePath);
+  bool bubbles = value_truthy(xt_object_get_cstr(event, "bubbles"));
   /* Capture phase: root -> target. */
   for (auto it = path.rbegin(); it != path.rend(); ++it) {
-    if (call_node_listeners(win, *it, type, event, true)) return;
+    int32_t phase = *it == target ? 2 : 1;
+    if (call_node_listeners(win, *it, type, event, true, phase)) return;
   }
-  /* Bubble phase: target -> root. */
+  /* Bubble phase: target -> root; a non-bubbling event stops after the target
+   * (its non-capture listeners still run there). */
   for (auto it = path.begin(); it != path.end(); ++it) {
-    if (call_node_listeners(win, *it, type, event, false)) return;
+    if (!bubbles && *it != target) break;
+    int32_t phase = *it == target ? 2 : 3;
+    if (call_node_listeners(win, *it, type, event, false, phase)) return;
   }
 }
 

package/runtime/ext_gui/dom_api_internal.h

@@ -27,6 +27,7 @@ extern xt_value g_document_proto;
 extern xt_value g_event_proto;
 extern xt_value g_class_list_proto;
 extern xt_value g_style_proto;
+extern xt_value g_computed_style_proto;
 extern xt_value g_canvas_proto;
 extern xt_value g_canvas_gradient_proto;
 extern xt_value g_webgl_proto;
@@ -49,10 +50,16 @@ xt_value document_proto();
 xt_value event_proto();
 xt_value class_list_proto();
 xt_value style_proto();
+xt_value computed_style_proto();
 xt_value canvas_proto();
 xt_value canvas_gradient_proto();
 xt_value webgl_proto();
 xt_value webgl2_proto();
+/** `AbortController` / `AbortSignal` prototypes and constructors. */
+xt_value abort_controller_proto();
+xt_value abort_signal_proto();
+xt_value abort_controller_new();
+xt_value abort_signal_new(bool aborted);
 /** The prototype a WebGL object of `kind` inherits (`buffer`, `texture`, …),
  * so `buffer instanceof WebGLBuffer` holds. */
 xt_value webgl_object_proto(const std::string &kind);
@@ -60,6 +67,16 @@ xt_value webgl_object_proto(const std::string &kind);
 /** Create/return the 2D context for a pending `<canvas>` handle (before load). */
 xt_value xt_canvas_pending_context(xt_value self, XtGuiWindow *win);
 
+/* -- Path2D --------------------------------------------------------------- */
+
+/** True when `value` is a `Path2D` handle. */
+bool path2d_is(xt_value value);
+/** The user-space subpaths a `Path2D` handle holds. */
+std::vector<xtgui::CanvasSubpath> path2d_subpaths(xt_value value);
+/** `new Path2D()` / `new Path2D(other)`. */
+xt_value path2d_create(xt_value source);
+xt_value path2d_proto();
+
 /* -- canvas helpers shared by `dom_api_canvas*.cpp` ----------------------- */
 
 /** The engine canvas behind a 2D context handle, or null when stale/foreign. */
@@ -77,6 +94,9 @@ uint64_t canvas_gradient_id(xt_value handle, const xtgui::Canvas2D *canvas);
 
 /** The engine WebGL context behind a context handle, or null. */
 xtgui::WebGLContext *webgl_from_context(xt_value self);
+/** Like `webgl_from_context`, but null while the context is lost: every GL
+ * entry point except `getError`/`isContextLost` is a no-op in that state. */
+xtgui::WebGLContext *webgl_live_context(xt_value self);
 /** The numeric context id stored on a context handle (0 when absent). */
 uint64_t webgl_context_id(xt_value self);
 /** Create the JavaScript handle for a canvas's WebGL context. */
@@ -95,9 +115,19 @@ std::vector<double> webgl_numbers(xt_value value);
 std::vector<uint8_t> webgl_bytes(xt_value value);
 /** Store `count` bytes into a typed array / array handle. */
 void webgl_write_bytes(xt_value target, const uint8_t *bytes, size_t count);
+/** Convert a source pixel array (RGBA/RGB/LUMINANCE/…) to RGBA8. */
+void webgl_convert_pixels(const uint8_t *source, int count, int format, bool premultiply,
+                          std::vector<uint8_t> *out);
+/** Decode a `texImage2D` source (`<img>`, `<canvas>`, `<video>`, `ImageData`,
+ * `ImageBitmap`) into top-down RGBA8. */
+bool webgl_read_source(xt_value source, int *width, int *height,
+                       std::vector<uint8_t> *rgba, bool premultiply);
 /** Read the `UNPACK_FLIP_Y_WEBGL` / `UNPACK_PREMULTIPLY_ALPHA_WEBGL` flags set
  * through `pixelStorei`. */
 void webgl_unpack_flags(xt_value context, bool *flip_y, bool *premultiply);
+/** Extension object for a compressed-texture family (null when unsupported,
+ * undefined when the name is not one of those extensions). */
+xt_value webgl_compressed_extension(const std::string &name, xtgui::WebGLContext *context);
 
 /** How a pending handle names the node it will bind to. */
 enum PendingKind { pending_by_id = 1, pending_by_selector = 2 };
@@ -144,7 +174,9 @@ METHOD(doc_create_element_ns);
 METHOD(doc_hidden_get);
 METHOD(doc_visibility_state_get);
 METHOD(doc_ready_state_get);
+METHOD(doc_has_focus);
 METHOD(doc_title_get);
+METHOD(doc_title_set);
 METHOD(doc_default_view_get);
 METHOD(doc_create_text_node);
 METHOD(doc_body_get);
@@ -153,6 +185,9 @@ METHOD(doc_document_element_get);
 /* node getters */
 METHOD(node_tag_name_get);
 METHOD(node_node_type_get);
+METHOD(node_namespace_uri_get);
+METHOD(node_local_name_get);
+METHOD(node_prefix_get);
 METHOD(node_id_get);
 METHOD(node_id_set);
 METHOD(node_class_name_get);
@@ -183,6 +218,10 @@ METHOD(node_query_selector);
 METHOD(node_query_selector_all);
 METHOD(node_matches);
 METHOD(node_append_child);
+METHOD(node_append);
+METHOD(node_prepend);
+METHOD(node_replace_children);
+METHOD(node_insert_adjacent_html);
 METHOD(node_insert_before);
 METHOD(node_remove_child);
 METHOD(node_replace_child);
@@ -206,6 +245,7 @@ xt_value event_construct(xt_value type, xt_value init);
 METHOD(event_prevent_default);
 METHOD(event_stop_propagation);
 METHOD(event_stop_immediate_propagation);
+METHOD(event_composed_path);
 
 /* media (`<video>`/`<audio>`) */
 METHOD(node_play);
@@ -272,11 +312,21 @@ METHOD(canvas_stroke);
 METHOD(canvas_clear_rect);
 METHOD(canvas_fill_rect);
 METHOD(canvas_stroke_rect);
-METHOD(canvas_measure_text);
-METHOD(canvas_fill_text);
+METHOD(canvas_measure_text);METHOD(canvas_fill_text);
 METHOD(canvas_stroke_text);
 METHOD(canvas_draw_image);
 METHOD(canvas_get_image_data);
+METHOD(canvas_get_context_attributes);
+METHOD(canvas_put_image_data);
+METHOD(canvas_create_image_data);
+METHOD(canvas_create_pattern);
+METHOD(canvas_to_data_url);
+METHOD(canvas_to_blob);
+/** The cached `CanvasPattern` handle for `id` on `canvas`. */
+xt_value canvas_pattern_handle(xt_value context, const xtgui::Canvas2D *canvas, uint64_t id);
+/** The pattern id stored on a handle, or 0 when it is not a pattern for
+ * `canvas` (stale or created by another canvas). */
+uint64_t canvas_pattern_id(xt_value handle, const xtgui::Canvas2D *canvas);
 METHOD(canvas_ellipse);
 METHOD(canvas_round_rect);
 METHOD(canvas_line_cap_get);
@@ -303,7 +353,23 @@ METHOD(class_list_contains);
 /* style methods */
 METHOD(style_set_property);
 METHOD(style_get_property_value);
+METHOD(style_get_property_priority);
 METHOD(style_remove_property);
+METHOD(style_css_text_get);
+METHOD(style_css_text_set);
+METHOD(style_length_get);
+METHOD(style_item);
+/** Install the dynamic named-property hooks on a `style` handle
+ * (`style.width = "50%"`). */
+void install_style_hooks(xt_value style);
+
+/* `dataset` (a DOMStringMap over `data-*` attributes) and computed style */
+METHOD(node_dataset_get);
+METHOD(computed_style_get_property_value);
+METHOD(computed_style_get_property_priority);
+/** Build the computed-style handle for an element (and optional pseudo). */
+xt_value computed_style_handle(xt_value element, xt_value pseudo);
+xt_value computed_style_proto();
 
 /* WebGL context: state and queries */
 METHOD(webgl_canvas_get);
@@ -426,6 +492,8 @@ METHOD(webgl_tex_parameterf);
 METHOD(webgl_get_tex_parameter);
 METHOD(webgl_tex_image_2d);
 METHOD(webgl_tex_sub_image_2d);
+METHOD(webgl_compressed_tex_image_2d);
+METHOD(webgl_compressed_tex_sub_image_2d);
 METHOD(webgl_generate_mipmap);
 METHOD(webgl_create_framebuffer);
 METHOD(webgl_delete_framebuffer);
@@ -495,6 +563,7 @@ METHOD(webgl2_get_uniform_block_index);
 METHOD(webgl2_get_active_uniform_block_parameter);
 METHOD(webgl2_get_active_uniform_block_name);
 METHOD(webgl2_uniform_block_binding);
+METHOD(webgl2_drawing_buffer_storage);
 METHOD(webgl2_tex_storage_2d);
 METHOD(webgl2_tex_storage_3d);
 METHOD(webgl2_tex_image_3d);

package/runtime/ext_gui/dom_api_mutation.cpp

@@ -0,0 +1,159 @@
+/*
+ * xbintsc GUI engine — the parent/child convenience mutators.
+ *
+ * `append`, `prepend`, `replaceChildren` and `insertAdjacentHTML` are the APIs
+ * modern pages actually use to build DOM (they accept nodes and plain strings
+ * in one call); the engine previously only had `appendChild`/`innerHTML`.
+ * Strings become text nodes, as in the DOM.
+ */
+
+#include "dom_api_internal.h"
+
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace domapi {
+
+namespace {
+
+/** A node handle, or a new text node for a string argument. */
+xtgui::Node *argument_node(XtGuiWindow *win, xt_value value) {
+  xtgui::Node *node = resolve_node(value, nullptr);
+  if (node != nullptr) return node;
+  if (XT_IS_UNDEFINED(value) || value == XT_NULL) return nullptr;
+  return win->document->createTextNode(to_string_value(value));
+}
+
+void insert_argument(XtGuiWindow *win, xtgui::Node *parent, xt_value value, xtgui::Node *before) {
+  xtgui::Node *node = argument_node(win, value);
+  if (node == nullptr) return;
+  if (before != nullptr) {
+    win->document->insertBefore(parent, node, before);
+  } else {
+    win->document->appendChild(parent, node);
+  }
+}
+
+/** Copy a parsed fragment's children into `dest`, inserting before `before`
+ * (nullptr appends). The parser's nodes belong to a standalone tree, so they are
+ * recreated through the document rather than adopted. */
+void import_children(XtGuiWindow *win, xtgui::Node *dest, const xtgui::Node *parsed,
+                     xtgui::Node *before) {
+  for (const std::unique_ptr<xtgui::Node> &child : parsed->children) {
+    xtgui::Node *copy = nullptr;
+    if (child->isText()) {
+      copy = win->document->createTextNode(child->text);
+    } else {
+      copy = win->document->createElement(child->tag);
+      if (copy == nullptr) continue;
+      for (const xtgui::Attr &attr : child->attrs) copy->attrs.push_back(attr);
+      import_children(win, copy, child.get(), nullptr);
+    }
+    if (copy == nullptr) continue;
+    if (before != nullptr) {
+      win->document->insertBefore(dest, copy, before);
+    } else {
+      win->document->appendChild(dest, copy);
+    }
+  }
+}
+
+xtgui::Node *next_sibling(xtgui::Node *parent, xtgui::Node *node) {
+  if (parent == nullptr) return nullptr;
+  for (size_t i = 0; i + 1 < parent->children.size(); i++) {
+    if (parent->children[i].get() == node) return parent->children[i + 1].get();
+  }
+  return nullptr;
+}
+
+xtgui::Node *first_child(xtgui::Node *node) {
+  return node->children.empty() ? nullptr : node->children.front().get();
+}
+
+}  // namespace
+
+#define METHOD(name) xt_value name(xt_value self, xt_value env, int32_t argc, xt_value *argv)
+
+METHOD(node_append) {
+  (void)env;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  if (node == nullptr || win == nullptr) return XT_UNDEFINED;
+  for (int32_t i = 0; i < argc; i++) insert_argument(win, node, xt_arg(argc, argv, i), nullptr);
+  mark_dirty(win);
+  return XT_UNDEFINED;
+}
+
+METHOD(node_prepend) {
+  (void)env;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  if (node == nullptr || win == nullptr) return XT_UNDEFINED;
+  /* The reference stays the original first child; inserting each argument before
+   * it keeps the argument order. */
+  xtgui::Node *reference = first_child(node);
+  for (int32_t i = 0; i < argc; i++) {
+    insert_argument(win, node, xt_arg(argc, argv, i), reference);
+  }
+  mark_dirty(win);
+  return XT_UNDEFINED;
+}
+
+METHOD(node_replace_children) {
+  (void)env;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  if (node == nullptr || win == nullptr || win->document == nullptr) return XT_UNDEFINED;
+  /* Detach node arguments first: one of them may be a current child that the
+   * replacement keeps. */
+  for (int32_t i = 0; i < argc; i++) {
+    xtgui::Node *child = resolve_node(xt_arg(argc, argv, i), nullptr);
+    if (child == nullptr) continue;
+    if (child->parent == node) win->document->removeChild(node, child);
+  }
+  std::vector<xtgui::Node *> existing;
+  for (const std::unique_ptr<xtgui::Node> &child : node->children) {
+    existing.push_back(child.get());
+  }
+  for (xtgui::Node *child : existing) {
+    win->document->removeChild(node, child);
+    discard_subtree(win, child);
+  }
+  for (int32_t i = 0; i < argc; i++) insert_argument(win, node, xt_arg(argc, argv, i), nullptr);
+  mark_dirty(win);
+  return XT_UNDEFINED;
+}
+
+/** `insertAdjacentHTML(position, html)`; `position` is beforebegin,
+ * afterbegin, beforeend or afterend. Scripts in the fragment do not run. */
+METHOD(node_insert_adjacent_html) {
+  (void)env;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  if (node == nullptr || win == nullptr || win->document == nullptr || argc < 2) {
+    return XT_UNDEFINED;
+  }
+  std::string position = to_string_value(xt_arg(argc, argv, 0));
+  std::string html = to_string_value(xt_arg(argc, argv, 1));
+  std::unique_ptr<xtgui::Node> parsed = xtgui::xt_html_parse(html);
+  if (!parsed) return XT_UNDEFINED;
+  if (position == "beforebegin" || position == "afterend") {
+    xtgui::Node *parent = node->parent;
+    if (parent == nullptr || parent->isDocument()) return XT_UNDEFINED;
+    xtgui::Node *reference = position == "beforebegin" ? node : next_sibling(parent, node);
+    import_children(win, parent, parsed.get(), reference);
+  } else if (position == "afterbegin") {
+    import_children(win, node, parsed.get(), first_child(node));
+  } else if (position == "beforeend") {
+    import_children(win, node, parsed.get(), nullptr);
+  } else {
+    return XT_UNDEFINED;
+  }
+  mark_dirty(win);
+  return XT_UNDEFINED;
+}
+
+#undef METHOD
+
+}  // namespace domapi