xbintsc 0.3.18 → 0.3.35

package/runtime/ext_gui/dom_api_node_read.cpp

@@ -0,0 +1,294 @@
+/*
+ * xbintsc GUI engine — element handle getters/setters (`tagName`, `id`,
+ * `className`, `textContent`, tree navigation, `classList`, `style`, ...).
+ */
+
+#include "dom_api_internal.h"
+
+#include <cctype>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace domapi {
+
+static std::string to_upper(std::string text) {
+  for (char &c : text) c = (char)std::toupper((unsigned char)c);
+  return text;
+}
+
+static void collect_text(const xtgui::Node *node, std::string &out) {
+  if (node->isText()) {
+    out += node->text;
+    return;
+  }
+  for (const std::unique_ptr<xtgui::Node> &child : node->children) collect_text(child.get(), out);
+}
+
+#define METHOD(name) xt_value name(xt_value self, xt_value env, int32_t argc, xt_value *argv)
+
+METHOD(node_tag_name_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  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());
+}
+
+METHOD(node_node_type_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_number(1);
+  if (node->isText()) return xt_number(3);
+  return xt_number(9);
+}
+
+METHOD(node_id_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xtgui::Node *node = resolve_node(self, nullptr);
+  if (node == nullptr || !node->isElement()) return xt_string_from_cstr("");
+  const std::string *value = node->attr("id");
+  return xt_string_from_cstr(value != nullptr ? value->c_str() : "");
+}
+
+METHOD(node_id_set) {
+  (void)env;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  if (node == nullptr || !node->isElement()) return XT_UNDEFINED;
+  set_attribute(win, node, "id", argc >= 1 ? to_string_value(xt_arg(argc, argv, 0)) : "");
+  return XT_UNDEFINED;
+}
+
+METHOD(node_class_name_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xtgui::Node *node = resolve_node(self, nullptr);
+  if (node == nullptr || !node->isElement()) return xt_string_from_cstr("");
+  return xt_string_from_cstr(class_name_of(node).c_str());
+}
+
+METHOD(node_class_name_set) {
+  (void)env;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  if (node == nullptr || !node->isElement()) return XT_UNDEFINED;
+  set_class_name(win, node, argc >= 1 ? to_string_value(xt_arg(argc, argv, 0)) : "");
+  return XT_UNDEFINED;
+}
+
+METHOD(node_text_content_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xtgui::Node *node = resolve_node(self, nullptr);
+  if (node == nullptr) return XT_UNDEFINED;
+  std::string out;
+  collect_text(node, out);
+  return xt_string_from_cstr(out.c_str());
+}
+
+METHOD(node_text_content_set) {
+  (void)env;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  if (node == nullptr || !node->isElement()) return XT_UNDEFINED;
+  std::string text = argc >= 1 ? to_string_value(xt_arg(argc, argv, 0)) : "";
+  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);
+  if (!text.empty()) node->addText(text);
+  mark_dirty(win);
+  return XT_UNDEFINED;
+}
+
+METHOD(node_inner_html_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xtgui::Node *node = resolve_node(self, nullptr);
+  if (node == nullptr) return XT_UNDEFINED;
+  std::string out;
+  for (const std::unique_ptr<xtgui::Node> &child : node->children) {
+    out += xtgui::xt_dom_to_string(child.get());
+  }
+  return xt_string_from_cstr(out.c_str());
+}
+
+METHOD(node_inner_html_set) {
+  (void)env;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  if (node == nullptr || !node->isElement()) return XT_UNDEFINED;
+  std::string html = argc >= 1 ? to_string_value(xt_arg(argc, argv, 0)) : "";
+  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);
+  std::unique_ptr<xtgui::Node> fragment = xtgui::xt_html_parse(html);
+  for (std::unique_ptr<xtgui::Node> &child : fragment->children) node->append(std::move(child));
+  mark_dirty(win);
+  return XT_UNDEFINED;
+}
+
+METHOD(node_parent_node_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  if (node == nullptr || node->parent == nullptr || node->parent->isDocument()) return XT_UNDEFINED;
+  return xt_gui_node_handle(win, node->parent);
+}
+
+METHOD(node_parent_element_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  if (node == nullptr || node->parent == nullptr || !node->parent->isElement()) return XT_UNDEFINED;
+  return xt_gui_node_handle(win, node->parent);
+}
+
+METHOD(node_children_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  xt_value array = xt_array_new(0, NULL);
+  if (node == nullptr) return array;
+  for (const std::unique_ptr<xtgui::Node> &child : node->children) {
+    if (child->isElement()) xt_array_push(array, xt_gui_node_handle(win, child.get()));
+  }
+  return array;
+}
+
+METHOD(node_child_nodes_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  xt_value array = xt_array_new(0, NULL);
+  if (node == nullptr) return array;
+  for (const std::unique_ptr<xtgui::Node> &child : node->children) {
+    xt_array_push(array, xt_gui_node_handle(win, child.get()));
+  }
+  return array;
+}
+
+METHOD(node_child_element_count_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xtgui::Node *node = resolve_node(self, nullptr);
+  if (node == nullptr) return xt_number(0);
+  double count = 0;
+  for (const std::unique_ptr<xtgui::Node> &child : node->children) {
+    if (child->isElement()) count += 1;
+  }
+  return xt_number(count);
+}
+
+METHOD(node_first_element_child_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  if (node == nullptr) return XT_UNDEFINED;
+  return xt_gui_node_handle(win, node->firstElementChild());
+}
+
+METHOD(node_last_element_child_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  if (node == nullptr) return XT_UNDEFINED;
+  for (auto it = node->children.rbegin(); it != node->children.rend(); ++it) {
+    if ((*it)->isElement()) return xt_gui_node_handle(win, it->get());
+  }
+  return XT_UNDEFINED;
+}
+
+METHOD(node_next_element_sibling_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  if (node == nullptr || node->parent == nullptr) return XT_UNDEFINED;
+  bool found = false;
+  for (const std::unique_ptr<xtgui::Node> &sibling : node->parent->children) {
+    if (sibling.get() == node) {
+      found = true;
+      continue;
+    }
+    if (found && sibling->isElement()) return xt_gui_node_handle(win, sibling.get());
+  }
+  return XT_UNDEFINED;
+}
+
+METHOD(node_previous_element_sibling_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  if (node == nullptr || node->parent == nullptr) return XT_UNDEFINED;
+  xtgui::Node *previous = nullptr;
+  for (const std::unique_ptr<xtgui::Node> &sibling : node->parent->children) {
+    if (sibling.get() == node) break;
+    if (sibling->isElement()) previous = sibling.get();
+  }
+  return xt_gui_node_handle(win, previous);
+}
+
+METHOD(node_is_connected_get) {
+  (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_FALSE;
+  return win->document->root()->contains(node) ? XT_TRUE : XT_FALSE;
+}
+
+METHOD(node_class_list_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xt_value cached = xt_object_get_cstr(self, "__xt_gui_class_list");
+  if (XT_IS_OBJECT(cached)) return cached;
+  xt_value list = xt_object_new_with_proto(class_list_proto());
+  xt_object_set(list, xt_string_from_cstr("__xt_gui_node"), self);
+  xt_object_set(self, xt_string_from_cstr("__xt_gui_class_list"), list);
+  return list;
+}
+
+METHOD(node_style_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xt_value cached = xt_object_get_cstr(self, "__xt_gui_style");
+  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);
+  xt_object_set(self, xt_string_from_cstr("__xt_gui_style"), style);
+  return style;
+}
+
+#undef METHOD
+
+}  // namespace domapi

package/runtime/ext_gui/dom_api_proto.cpp

@@ -0,0 +1,130 @@
+/*
+ * xbintsc GUI engine — lazy construction of the DOM prototypes (node,
+ * document, event, classList, style).
+ */
+
+#include "dom_api_internal.h"
+
+namespace domapi {
+
+static void define_method(xt_value proto, const char *name, void *fn) {
+  xt_object_set(proto, xt_string_from_cstr(name), xt_closure_new(fn, 0, NULL));
+}
+
+static void define_getter(xt_value proto, const char *name, void *fn) {
+  xt_object_define_getter(proto, xt_string_from_cstr(name), xt_closure_new(fn, 0, NULL));
+}
+
+static void define_setter(xt_value proto, const char *name, void *fn) {
+  xt_object_define_setter(proto, xt_string_from_cstr(name), xt_closure_new(fn, 0, NULL));
+}
+
+xt_value node_proto() {
+  if (XT_IS_OBJECT(g_node_proto)) return g_node_proto;
+  xt_value proto = xt_object_new();
+  /* Getters. */
+  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, "id", (void *)node_id_get);
+  define_getter(proto, "className", (void *)node_class_name_get);
+  define_getter(proto, "textContent", (void *)node_text_content_get);
+  define_getter(proto, "innerText", (void *)node_text_content_get);
+  define_getter(proto, "innerHTML", (void *)node_inner_html_get);
+  define_getter(proto, "parentNode", (void *)node_parent_node_get);
+  define_getter(proto, "parentElement", (void *)node_parent_element_get);
+  define_getter(proto, "children", (void *)node_children_get);
+  define_getter(proto, "childNodes", (void *)node_child_nodes_get);
+  define_getter(proto, "childElementCount", (void *)node_child_element_count_get);
+  define_getter(proto, "firstElementChild", (void *)node_first_element_child_get);
+  define_getter(proto, "lastElementChild", (void *)node_last_element_child_get);
+  define_getter(proto, "nextElementSibling", (void *)node_next_element_sibling_get);
+  define_getter(proto, "previousElementSibling", (void *)node_previous_element_sibling_get);
+  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, "offsetWidth", (void *)node_offset_width_get);
+  define_getter(proto, "offsetHeight", (void *)node_offset_height_get);
+  /* Setters. */
+  define_setter(proto, "id", (void *)node_id_set);
+  define_setter(proto, "className", (void *)node_class_name_set);
+  define_setter(proto, "textContent", (void *)node_text_content_set);
+  define_setter(proto, "innerText", (void *)node_text_content_set);
+  define_setter(proto, "innerHTML", (void *)node_inner_html_set);
+  /* Methods. */
+  define_method(proto, "getAttribute", (void *)node_get_attribute);
+  define_method(proto, "setAttribute", (void *)node_set_attribute);
+  define_method(proto, "removeAttribute", (void *)node_remove_attribute);
+  define_method(proto, "hasAttribute", (void *)node_has_attribute);
+  define_method(proto, "querySelector", (void *)node_query_selector);
+  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, "insertBefore", (void *)node_insert_before);
+  define_method(proto, "removeChild", (void *)node_remove_child);
+  define_method(proto, "replaceChild", (void *)node_replace_child);
+  define_method(proto, "remove", (void *)node_remove);
+  define_method(proto, "cloneNode", (void *)node_clone_node);
+  define_method(proto, "getBoundingClientRect", (void *)node_get_bounding_rect);
+  define_method(proto, "contains", (void *)node_contains);
+  define_method(proto, "focus", (void *)node_focus);
+  define_method(proto, "blur", (void *)node_blur);
+  define_method(proto, "click", (void *)node_click);
+  define_method(proto, "addEventListener", (void *)node_add_event_listener);
+  define_method(proto, "removeEventListener", (void *)node_remove_event_listener);
+  define_method(proto, "dispatchEvent", (void *)node_dispatch_event);
+  g_node_proto = proto;
+  return proto;
+}
+
+xt_value document_proto() {
+  if (XT_IS_OBJECT(g_document_proto)) return g_document_proto;
+  xt_value proto = xt_object_new_with_proto(node_proto());
+  define_getter(proto, "body", (void *)doc_body_get);
+  define_getter(proto, "documentElement", (void *)doc_document_element_get);
+  define_method(proto, "querySelector", (void *)doc_query_selector);
+  define_method(proto, "querySelectorAll", (void *)doc_query_selector_all);
+  define_method(proto, "getElementById", (void *)doc_get_element_by_id);
+  define_method(proto, "createElement", (void *)doc_create_element);
+  define_method(proto, "createTextNode", (void *)doc_create_text_node);
+  /* `document.addEventListener` / element listener plumbing come from the node
+   * prototype and operate on the document root node. */
+  define_method(proto, "addEventListener", (void *)node_add_event_listener);
+  define_method(proto, "removeEventListener", (void *)node_remove_event_listener);
+  define_method(proto, "dispatchEvent", (void *)node_dispatch_event);
+  g_document_proto = proto;
+  return proto;
+}
+
+xt_value event_proto() {
+  if (XT_IS_OBJECT(g_event_proto)) return g_event_proto;
+  xt_value proto = xt_object_new();
+  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);
+  g_event_proto = proto;
+  return proto;
+}
+
+xt_value class_list_proto() {
+  if (XT_IS_OBJECT(g_class_list_proto)) return g_class_list_proto;
+  xt_value proto = xt_object_new();
+  define_method(proto, "add", (void *)class_list_add);
+  define_method(proto, "remove", (void *)class_list_remove);
+  define_method(proto, "toggle", (void *)class_list_toggle);
+  define_method(proto, "contains", (void *)class_list_contains);
+  g_class_list_proto = proto;
+  return proto;
+}
+
+xt_value style_proto() {
+  if (XT_IS_OBJECT(g_style_proto)) return g_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, "removeProperty", (void *)style_remove_property);
+  g_style_proto = proto;
+  return proto;
+}
+
+}  // namespace domapi

package/runtime/ext_gui/dom_api_style.cpp

@@ -0,0 +1,192 @@
+/*
+ * xbintsc GUI engine — `classList` and inline `style` object methods.
+ */
+
+#include "dom_api_internal.h"
+
+#include <algorithm>
+#include <cctype>
+#include <string>
+#include <vector>
+
+namespace domapi {
+
+static std::vector<std::string> split_classes(const std::string &text) {
+  std::vector<std::string> out;
+  size_t index = 0;
+  while (index < text.size()) {
+    while (index < text.size() && std::isspace((unsigned char)text[index])) index++;
+    size_t start = index;
+    while (index < text.size() && !std::isspace((unsigned char)text[index])) index++;
+    if (index > start) out.push_back(text.substr(start, index - start));
+  }
+  return out;
+}
+
+static std::string join_classes(const std::vector<std::string> &names) {
+  std::string out;
+  for (size_t i = 0; i < names.size(); i++) {
+    if (i > 0) out += " ";
+    out += names[i];
+  }
+  return out;
+}
+
+static std::string inline_style_of(const xtgui::Node *node) {
+  const std::string *value = node->attr("style");
+  return value != nullptr ? *value : std::string();
+}
+
+static void write_declarations(xtgui::Node *node, const std::vector<xtgui::Declaration> &decls) {
+  std::string out;
+  for (const xtgui::Declaration &decl : decls) {
+    if (!out.empty()) out += ";";
+    out += decl.property + ":" + decl.value + (decl.important ? " !important" : "");
+  }
+  if (out.empty()) {
+    remove_attribute_raw(node, "style");
+  } else {
+    set_attribute_raw(node, "style", out);
+  }
+}
+
+static void set_style_property(XtGuiWindow *win, xtgui::Node *node, const std::string &name,
+                               const std::string &value) {
+  std::vector<xtgui::Declaration> decls = xtgui::xt_css_parse_declarations(inline_style_of(node));
+  bool found = false;
+  for (xtgui::Declaration &decl : decls) {
+    if (decl.property == name) {
+      decl.value = value;
+      decl.important = false;
+      found = true;
+    }
+  }
+  if (!found) decls.push_back({name, value, false});
+  write_declarations(node, decls);
+  mark_dirty(win);
+}
+
+static std::string get_style_property(const xtgui::Node *node, const std::string &name) {
+  std::vector<xtgui::Declaration> decls = xtgui::xt_css_parse_declarations(inline_style_of(node));
+  std::string value;
+  for (const xtgui::Declaration &decl : decls) {
+    if (decl.property == name) value = decl.value;
+  }
+  return value;
+}
+
+static void remove_style_property(XtGuiWindow *win, xtgui::Node *node, const std::string &name) {
+  std::vector<xtgui::Declaration> decls = xtgui::xt_css_parse_declarations(inline_style_of(node));
+  std::vector<xtgui::Declaration> kept;
+  for (const xtgui::Declaration &decl : decls) {
+    if (decl.property != name) kept.push_back(decl);
+  }
+  write_declarations(node, kept);
+  mark_dirty(win);
+}
+
+static xtgui::Node *class_list_node(xt_value self, XtGuiWindow **winOut) {
+  return resolve_node(xt_object_get_cstr(self, "__xt_gui_node"), winOut);
+}
+
+#define METHOD(name) xt_value name(xt_value self, xt_value env, int32_t argc, xt_value *argv)
+
+METHOD(class_list_add) {
+  (void)env;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = class_list_node(self, &win);
+  if (node == nullptr) return self;
+  std::vector<std::string> names = split_classes(class_name_of(node));
+  bool changed = false;
+  for (int32_t i = 0; i < argc; i++) {
+    std::string name = to_string_value(xt_arg(argc, argv, i));
+    if (name.empty() || std::find(names.begin(), names.end(), name) != names.end()) continue;
+    names.push_back(name);
+    changed = true;
+  }
+  if (changed) set_class_name(win, node, join_classes(names));
+  return self;
+}
+
+METHOD(class_list_remove) {
+  (void)env;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = class_list_node(self, &win);
+  if (node == nullptr) return self;
+  std::vector<std::string> names = split_classes(class_name_of(node));
+  bool changed = false;
+  for (int32_t i = 0; i < argc; i++) {
+    std::string name = to_string_value(xt_arg(argc, argv, i));
+    auto it = std::find(names.begin(), names.end(), name);
+    if (it != names.end()) {
+      names.erase(it);
+      changed = true;
+    }
+  }
+  if (changed) set_class_name(win, node, join_classes(names));
+  return self;
+}
+
+METHOD(class_list_toggle) {
+  (void)env;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = class_list_node(self, &win);
+  if (node == nullptr || argc < 1) return XT_FALSE;
+  std::string name = to_string_value(xt_arg(argc, argv, 0));
+  std::vector<std::string> names = split_classes(class_name_of(node));
+  auto it = std::find(names.begin(), names.end(), name);
+  if (it != names.end()) {
+    names.erase(it);
+    set_class_name(win, node, join_classes(names));
+    return XT_FALSE;
+  }
+  if (!name.empty()) {
+    names.push_back(name);
+    set_class_name(win, node, join_classes(names));
+  }
+  return XT_TRUE;
+}
+
+METHOD(class_list_contains) {
+  (void)env;
+  xtgui::Node *node = class_list_node(self, nullptr);
+  if (node == nullptr || argc < 1) return XT_FALSE;
+  std::string name = to_string_value(xt_arg(argc, argv, 0));
+  std::vector<std::string> names = split_classes(class_name_of(node));
+  return std::find(names.begin(), names.end(), name) != names.end() ? XT_TRUE : XT_FALSE;
+}
+
+static xtgui::Node *style_node(xt_value self, XtGuiWindow **winOut) {
+  return resolve_node(xt_object_get_cstr(self, "__xt_gui_node"), winOut);
+}
+
+METHOD(style_set_property) {
+  (void)env;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = style_node(self, &win);
+  if (node == nullptr || argc < 2) return XT_UNDEFINED;
+  set_style_property(win, node, to_string_value(xt_arg(argc, argv, 0)),
+                     to_string_value(xt_arg(argc, argv, 1)));
+  return XT_UNDEFINED;
+}
+
+METHOD(style_get_property_value) {
+  (void)env;
+  xtgui::Node *node = style_node(self, nullptr);
+  if (node == nullptr || argc < 1) return xt_string_from_cstr("");
+  return xt_string_from_cstr(
+      get_style_property(node, to_string_value(xt_arg(argc, argv, 0))).c_str());
+}
+
+METHOD(style_remove_property) {
+  (void)env;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = style_node(self, &win);
+  if (node == nullptr || argc < 1) return XT_UNDEFINED;
+  remove_style_property(win, node, to_string_value(xt_arg(argc, argv, 0)));
+  return XT_UNDEFINED;
+}
+
+#undef METHOD
+
+}  // namespace domapi

package/runtime/ext_gui/dom_internal.h

@@ -0,0 +1,39 @@
+/*
+ * xbintsc GUI engine — shared helpers for the DOM translation units
+ * (`dom.cpp`, `dom_parse.cpp`, `dom_serialize.cpp`).
+ */
+#ifndef XT_GUI_DOM_INTERNAL_H
+#define XT_GUI_DOM_INTERNAL_H
+
+#include <cctype>
+#include <string>
+
+#include "dom.h"
+
+namespace xtgui {
+
+inline bool xt_dom_is_alpha(char c) {
+  return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
+}
+
+inline bool xt_dom_is_space(char c) {
+  return c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '\f';
+}
+
+inline std::string xt_dom_lower(const std::string &text) {
+  std::string out = text;
+  for (char &c : out) c = (char)std::tolower((unsigned char)c);
+  return out;
+}
+
+inline std::string xt_dom_trim(const std::string &text) {
+  size_t begin = 0;
+  size_t end = text.size();
+  while (begin < end && xt_dom_is_space(text[begin])) begin++;
+  while (end > begin && xt_dom_is_space(text[end - 1])) end--;
+  return text.substr(begin, end - begin);
+}
+
+}  // namespace xtgui
+
+#endif /* XT_GUI_DOM_INTERNAL_H */