xbintsc 0.5.36 → 0.5.38

package/doc/zh-CN/unimplemented/deviations.md

@@ -8,6 +8,7 @@
 | --- | --- |
 | 正则按字节匹配 | 引擎按 UTF-8 字节匹配：多字节字面量仍可匹配，但 `.` 与字符类每次只消费一个字节（`\d`/`\w` 仍是 ASCII）。`exec` / `search` / 替换回调返回的偏移会转换为 UTF-16 码元 |
 | 全局正则 `lastIndex` | `/g`、`/y` 正则的 `test` / `exec` 不推进也不读取调用方设置的 `lastIndex` |
+| `URL` 解析器 | 只读 WHATWG 子集：未实现路径百分号编码、IDNA、setter 与 `searchParams` 实时联动；无协议引用按工作目录解析为 `file:` URL |
 | `String.normalize` | 未实现 |
 | 内置方法一等公民 | 以未绑定方法值实现（见[函数](./functions.md)）；`fn.toString()` 返回占位字符串而非源码文本 |
 | `for...in` | 枚举对象 / 数组 / 字符串的自身键；不含原型链属性 |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xbintsc",
-  "version": "0.5.36",
+  "version": "0.5.38",
   "description": "xbintsc - a TypeScript binary compiler (TypeScript -> LLVM IR -> native binary)",
   "type": "module",
   "license": "MIT",
@@ -72,12 +72,12 @@
     "vitest": "^2.1.8"
   },
   "optionalDependencies": {
-    "@xbintsc/linux-x64": "0.5.36",
-    "@xbintsc/linux-arm64": "0.5.36",
-    "@xbintsc/darwin-x64": "0.5.36",
-    "@xbintsc/darwin-arm64": "0.5.36",
-    "@xbintsc/win32-x64": "0.5.36",
-    "@xbintsc/win32-arm64": "0.5.36"
+    "@xbintsc/linux-x64": "0.5.38",
+    "@xbintsc/linux-arm64": "0.5.38",
+    "@xbintsc/darwin-x64": "0.5.38",
+    "@xbintsc/darwin-arm64": "0.5.38",
+    "@xbintsc/win32-x64": "0.5.38",
+    "@xbintsc/win32-arm64": "0.5.38"
   },
   "engines": {
     "node": ">=22"

package/runtime/ext_gui/browser.cpp

@@ -29,7 +29,6 @@ namespace {
 xt_value g_navigator = XT_UNDEFINED;
 xt_value g_local_storage = XT_UNDEFINED;
 xt_value g_location = XT_UNDEFINED;
-xt_value g_media_list = XT_UNDEFINED;
 xt_value g_document_global = XT_UNDEFINED;
 /** Type name -> the constructor value handed out for it (built on first use). */
 std::unordered_map<std::string, xt_value> g_types;
@@ -156,35 +155,28 @@ xt_value win_location_get(xt_value self, xt_value env, int32_t argc, xt_value *a
   return g_location;
 }
 
-xt_value media_list_build(const std::string &query, bool matches);
-
-/** `matchMedia(query)` -> a MediaQueryList-shaped object evaluated against the
- * current window's viewport, using the same evaluator as `@media` rules. The
- * list is a snapshot (there is no live change event), which matches the
- * engine's restyle-on-resize model. */
+/** `matchMedia(query)` -> a live `MediaQueryList` evaluated against the current
+ * viewport with the same evaluator as `@media` rules. The list is cached per
+ * window and query, and `change` listeners fire when a resize flips it. */
 xt_value win_match_media(xt_value self, xt_value env, int32_t argc, xt_value *argv) {
   (void)env;
   std::string query;
   if (argc >= 1) query = cstr(xt_arg(argc, argv, 0));
   XtGuiWindow *win = xt_gui_window_from_this(self);
-  if (win == NULL) {
-    xt_value handle = xt_gui_ensure_window();
-    win = xt_gui_window_from_this(handle);
-  }
-  float width = 0.0f;
-  float height = 0.0f;
-  if (win != NULL) xt_gui_window_viewport(win, &width, &height);
-  return media_list_build(query, xtgui::xt_css_media_matches(query, width, height));
+  if (win == NULL) win = xt_gui_window_from_this(xt_gui_ensure_window());
+  if (win == NULL) return xt_object_new();
+  return xt_browser_media_list(win->object, query);
 }
 
-/** `getComputedStyle(el)`: the engine exposes the element's style handle, which
- * answers `getPropertyValue` for everything the page set. */
+/** `getComputedStyle(el, pseudoElt)`: a live view of the *cascaded* style, so
+ * stylesheet rules (not only the inline `style` attribute) are visible. The
+ * optional pseudo-element selector ("::before"/"::after") resolves against the
+ * generated-content box; any other pseudo-element yields empty values, like a
+ * browser does for one the engine did not generate. */
 xt_value win_get_computed_style(xt_value self, xt_value env, int32_t argc, xt_value *argv) {
   (void)self;
   (void)env;
-  xt_value element = xt_arg(argc, argv, 0);
-  xt_value style = xt_get(element, xt_string_from_cstr("style"));
-  return XT_IS_OBJECT(style) ? style : xt_object_new();
+  return domapi::computed_style_handle(xt_arg(argc, argv, 0), xt_arg(argc, argv, 1));
 }
 
 xt_value win_alert(xt_value self, xt_value env, int32_t argc, xt_value *argv) {
@@ -196,19 +188,13 @@ xt_value win_alert(xt_value self, xt_value env, int32_t argc, xt_value *argv) {
 }
 
 xt_value win_confirm(xt_value self, xt_value env, int32_t argc, xt_value *argv) {
-  (void)self;
   (void)env;
-  (void)argc;
-  (void)argv;
-  return XT_FALSE;
+  return xt_browser_confirm(xt_gui_window_from_this(self), argc, argv);
 }
 
 xt_value win_prompt(xt_value self, xt_value env, int32_t argc, xt_value *argv) {
-  (void)self;
   (void)env;
-  (void)argc;
-  (void)argv;
-  return XT_UNDEFINED;
+  return xt_browser_prompt(xt_gui_window_from_this(self), argc, argv);
 }
 
 /* -- host objects --------------------------------------------------------- */
@@ -253,18 +239,6 @@ xt_value location_build(void) {
   return location;
 }
 
-xt_value media_list_build(const std::string &query, bool matches) {
-  xt_value list = xt_object_new();
-  set_prop(list, "media", xt_string_from_cstr(query.c_str()));
-  set_prop(list, "matches", matches ? XT_TRUE : XT_FALSE);
-  set_method(list, "addListener", (void *)noop);
-  set_method(list, "removeListener", (void *)noop);
-  set_method(list, "addEventListener", (void *)noop);
-  set_method(list, "removeEventListener", (void *)noop);
-  set_method(list, "dispatchEvent", (void *)noop);
-  return list;
-}
-
 /* -- localStorage --------------------------------------------------------- */
 
 xt_value storage_get_item(xt_value self, xt_value env, int32_t argc, xt_value *argv) {
@@ -338,7 +312,12 @@ xt_value host_type_construct(xt_value self, xt_value env, int32_t argc, xt_value
 /** The prototype a DOM type name should inherit, so `el instanceof Element`
  * holds for every element handle the engine hands out. */
 xt_value type_proto(const std::string &name) {
-  if (name == "Event" || name == "CustomEvent" || name == "ProgressEvent") {
+  if (name == "AbortController") return domapi::abort_controller_proto();
+  if (name == "AbortSignal") return domapi::abort_signal_proto();
+  if (name == "Event" || name == "CustomEvent" || name == "ProgressEvent" ||
+      name == "UIEvent" || name == "MouseEvent" || name == "PointerEvent" ||
+      name == "WheelEvent" || name == "KeyboardEvent" || name == "FocusEvent" ||
+      name == "InputEvent" || name == "SubmitEvent") {
     return domapi::event_proto();
   }
   if (name == "AudioContext" || name == "webkitAudioContext") return xt_gui_audio_proto();
@@ -357,6 +336,7 @@ xt_value type_proto(const std::string &name) {
   if (name == "WebGLQuery") return domapi::webgl_object_proto("query");
   if (name == "WebGLSync") return domapi::webgl_object_proto("sync");
   if (name == "WebGLTransformFeedback") return domapi::webgl_object_proto("transformfeedback");
+  if (name == "Path2D") return domapi::path2d_proto();
   if (name == "ImageBitmap") {
     /* A bitmap is a plain immutable object, not a DOM node: a node proto would
      * expose the element width/height accessors and answer 0. */
@@ -394,9 +374,15 @@ xt_value host_type_construct(xt_value self, xt_value env, int32_t argc, xt_value
   if (name == "AudioContext" || name == "webkitAudioContext") {
     return xt_gui_audio_create(argc, argv);
   }
-  if (name == "Event" || name == "CustomEvent" || name == "ProgressEvent") {
+  if (name == "AbortController") return domapi::abort_controller_new();
+  if (name == "AbortSignal") return domapi::abort_signal_new(false);
+  if (name == "Event" || name == "CustomEvent" || name == "ProgressEvent" ||
+      name == "UIEvent" || name == "MouseEvent" || name == "PointerEvent" ||
+      name == "WheelEvent" || name == "KeyboardEvent" || name == "FocusEvent" ||
+      name == "InputEvent" || name == "SubmitEvent") {
     return domapi::event_construct(xt_arg(argc, argv, 0), xt_arg(argc, argv, 1));
   }
+  if (name == "Path2D") return domapi::path2d_create(xt_arg(argc, argv, 0));
   xt_value target = xt_object_new_with_proto(type_proto(name));
   set_prop(target, "constructor", type_value(name));
   return target;
@@ -438,10 +424,6 @@ void ensure_singletons(void) {
     g_location = location_build();
     xt_gc_add_root(&g_location);
   }
-  if (!XT_IS_OBJECT(g_media_list)) {
-    g_media_list = media_list_build("", false);
-    xt_gc_add_root(&g_media_list);
-  }
 }
 
 }  // namespace
@@ -474,9 +456,8 @@ void xt_browser_install_window(xt_value proto) {
   set_method(proto, "confirm", (void *)win_confirm);
   set_method(proto, "prompt", (void *)win_prompt);
   set_method(proto, "escape", (void *)xt_browser_escape);
-  set_method(proto, "focus", (void *)noop);
-  set_method(proto, "blur", (void *)noop);
-  set_method(proto, "scrollTo", (void *)noop);
+  /* Page scroll and window focus/blur live in `browser_navigation.cpp`. */
+  xt_browser_install_window_navigation(proto);
 }
 
 /** `window` / `self`. */
@@ -581,3 +562,7 @@ xt_value xt_browser_alert(int32_t argc, xt_value *argv) {
 xt_value xt_browser_prompt(int32_t argc, xt_value *argv) {
   return win_prompt(XT_UNDEFINED, XT_UNDEFINED, argc, argv);
 }
+
+xt_value xt_browser_confirm_global(int32_t argc, xt_value *argv) {
+  return win_confirm(XT_UNDEFINED, XT_UNDEFINED, argc, argv);
+}

package/runtime/ext_gui/browser_abort.cpp

@@ -0,0 +1,249 @@
+/*
+ * xbintsc GUI engine — `AbortController` / `AbortSignal`.
+ *
+ * The pair exists so `addEventListener(..., { signal })` can actually remove a
+ * listener, as the DOM specifies. The engine has no Web-IDL machinery, so both
+ * objects are plain runtime objects with a shared hidden state:
+ *
+ *   controller.__xt_gui_abort_state   the state object
+ *   controller.__xt_gui_abort_signal  the signal handed out by `.signal`
+ *   signal.__xt_gui_abort_state       the same state object
+ *
+ * The state holds `aborted`, `reason` and the 'abort' listener list. Every value
+ * lives in a runtime object reachable from the handle the page kept, so the
+ * mark-sweep collector sees the whole graph.
+ */
+
+#include "dom_api_internal.h"
+#include "listener_options.h"
+
+namespace domapi {
+
+xt_value abort_signal_proto();
+xt_value abort_controller_proto();
+
+namespace {
+
+xt_value new_state() {
+  xt_value state = xt_object_new();
+  xt_object_set(state, xt_string_from_cstr("aborted"), XT_FALSE);
+  xt_object_set(state, xt_string_from_cstr("reason"), XT_UNDEFINED);
+  xt_object_set(state, xt_string_from_cstr("listeners"), xt_array_new(0, nullptr));
+  return state;
+}
+
+xt_value state_of(xt_value self) { return xt_object_get_cstr(self, "__xt_gui_abort_state"); }
+
+xt_value signal_of(xt_value self) { return xt_object_get_cstr(self, "__xt_gui_abort_signal"); }
+
+bool state_aborted(xt_value state) {
+  return XT_IS_OBJECT(state) && value_truthy(xt_object_get_cstr(state, "aborted"));
+}
+
+xt_value abort_signal_from_state(xt_value state, xt_value controller) {
+  xt_value signal = xt_object_new_with_proto(abort_signal_proto());
+  xt_object_set(signal, xt_string_from_cstr("__xt_gui_abort_state"), state);
+  if (!XT_IS_UNDEFINED(controller)) {
+    xt_object_set(signal, xt_string_from_cstr("__xt_gui_abort_controller"), controller);
+  }
+  return signal;
+}
+
+/** Call `fn` (or `{ handleEvent }`) with an `{ type, target }` event. */
+void call_abort_listener(xt_value fn, xt_value signal) {
+  xt_value event = xt_object_new_with_proto(event_proto());
+  xt_object_set(event, xt_string_from_cstr("type"), xt_string_from_cstr("abort"));
+  xt_object_set(event, xt_string_from_cstr("target"), signal);
+  xt_object_set(event, xt_string_from_cstr("currentTarget"), signal);
+  xt_object_set(event, xt_string_from_cstr("defaultPrevented"), XT_FALSE);
+  if (XT_IS_FUNCTION(fn)) {
+    xt_value args[1] = {event};
+    xt_call_with_this(fn, signal, 1, args);
+    return;
+  }
+  if (XT_IS_OBJECT(fn)) {
+    xt_value handler = xt_object_get_cstr(fn, "handleEvent");
+    if (XT_IS_FUNCTION(handler)) {
+      xt_value args[1] = {event};
+      xt_call_with_this(handler, fn, 1, args);
+    }
+  }
+}
+
+#define METHOD(name) xt_value name(xt_value self, xt_value env, int32_t argc, xt_value *argv)
+
+METHOD(signal_aborted_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  return state_aborted(state_of(self)) ? XT_TRUE : XT_FALSE;
+}
+
+METHOD(signal_reason_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xt_value state = state_of(self);
+  if (!XT_IS_OBJECT(state)) return XT_UNDEFINED;
+  return xt_object_get_cstr(state, "reason");
+}
+
+METHOD(signal_onabort_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  return xt_object_get_cstr(self, "__xt_gui_onabort");
+}
+
+METHOD(signal_onabort_set) {
+  (void)env;
+  if (argc >= 1) xt_object_set(self, xt_string_from_cstr("__xt_gui_onabort"), xt_arg(argc, argv, 0));
+  return XT_UNDEFINED;
+}
+
+/** `signal.addEventListener("abort", fn, options?)` — only 'abort' exists. */
+METHOD(signal_add_listener) {
+  (void)env;
+  xt_value state = state_of(self);
+  if (!XT_IS_OBJECT(state) || argc < 2) return XT_UNDEFINED;
+  std::string type = to_string_value(xt_arg(argc, argv, 0));
+  if (type != "abort") return XT_UNDEFINED;
+  xt_value fn = xt_arg(argc, argv, 1);
+  if (!XT_IS_FUNCTION(fn) && !XT_IS_OBJECT(fn)) return XT_UNDEFINED;
+  XtGuiListenerOptions options = xt_gui_listener_options(xt_arg(argc, argv, 2));
+  xt_value entry = xt_object_new();
+  xt_object_set(entry, xt_string_from_cstr("fn"), fn);
+  xt_object_set(entry, xt_string_from_cstr("once"), options.once ? XT_TRUE : XT_FALSE);
+  xt_array_push(xt_object_get_cstr(state, "listeners"), entry);
+  return XT_UNDEFINED;
+}
+
+METHOD(signal_remove_listener) {
+  (void)env;
+  xt_value state = state_of(self);
+  if (!XT_IS_OBJECT(state) || argc < 2) return XT_UNDEFINED;
+  xt_value listeners = xt_object_get_cstr(state, "listeners");
+  if (!XT_IS_ARRAY(listeners)) return XT_UNDEFINED;
+  xt_value fn = xt_arg(argc, argv, 1);
+  xt_value kept = xt_array_new(0, nullptr);
+  int32_t count = (int32_t)xt_to_number(xt_array_length(listeners));
+  for (int32_t i = 0; i < count; i++) {
+    xt_value entry = xt_array_get(listeners, xt_number((double)i));
+    if (!xt_truthy(xt_seq(xt_object_get_cstr(entry, "fn"), fn))) xt_array_push(kept, entry);
+  }
+  xt_object_set(state, xt_string_from_cstr("listeners"), kept);
+  return XT_UNDEFINED;
+}
+
+/** `signal.throwIfAborted()`: raise the abort reason (an `Error` by default). */
+METHOD(signal_throw_if_aborted) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xt_value state = state_of(self);
+  if (!state_aborted(state)) return XT_UNDEFINED;
+  xt_value reason = xt_object_get_cstr(state, "reason");
+  if (XT_IS_UNDEFINED(reason) || reason == XT_NULL) {
+    reason = xt_error_ctor_by_name(xt_string_from_cstr("Error"), 0, nullptr);
+  }
+  xt_throw(reason);
+  return XT_UNDEFINED;
+}
+
+METHOD(controller_signal_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xt_value signal = signal_of(self);
+  if (XT_IS_OBJECT(signal)) return signal;
+  xt_value state = state_of(self);
+  if (!XT_IS_OBJECT(state)) {
+    state = new_state();
+    xt_object_set(self, xt_string_from_cstr("__xt_gui_abort_state"), state);
+  }
+  signal = abort_signal_from_state(state, self);
+  xt_object_set(self, xt_string_from_cstr("__xt_gui_abort_signal"), signal);
+  return signal;
+}
+
+/** `controller.abort(reason)`: flip the state and dispatch 'abort' once. */
+METHOD(controller_abort) {
+  (void)env;
+  xt_value state = state_of(self);
+  if (!XT_IS_OBJECT(state) || state_aborted(state)) return XT_UNDEFINED;
+  xt_value reason = argc >= 1 ? xt_arg(argc, argv, 0) : XT_UNDEFINED;
+  if (XT_IS_UNDEFINED(reason)) {
+    xt_value message = xt_string_from_cstr("This operation was aborted");
+    reason = xt_error_ctor_by_name(xt_string_from_cstr("Error"), 1, &message);
+  }
+  xt_object_set(state, xt_string_from_cstr("aborted"), XT_TRUE);
+  xt_object_set(state, xt_string_from_cstr("reason"), reason);
+  xt_value signal = signal_of(self);
+  if (!XT_IS_OBJECT(signal)) signal = controller_signal_get(self, XT_UNDEFINED, 0, nullptr);
+  xt_value onabort = xt_object_get_cstr(signal, "__xt_gui_onabort");
+  if (XT_IS_FUNCTION(onabort)) call_abort_listener(onabort, signal);
+  xt_value listeners = xt_object_get_cstr(state, "listeners");
+  int32_t count = XT_IS_ARRAY(listeners) ? (int32_t)xt_to_number(xt_array_length(listeners)) : 0;
+  xt_value snapshot = xt_array_new(0, nullptr);
+  for (int32_t i = 0; i < count; i++) {
+    xt_array_push(snapshot, xt_array_get(listeners, xt_number((double)i)));
+  }
+  xt_object_set(state, xt_string_from_cstr("listeners"), xt_array_new(0, nullptr));
+  for (int32_t i = 0; i < count; i++) {
+    xt_value entry = xt_array_get(snapshot, xt_number((double)i));
+    call_abort_listener(xt_object_get_cstr(entry, "fn"), signal);
+  }
+  return XT_UNDEFINED;
+}
+
+#undef METHOD
+
+}  // namespace
+
+xt_value abort_signal_proto() {
+  static xt_value proto = XT_UNDEFINED;
+  if (XT_IS_OBJECT(proto)) return proto;
+  proto = xt_object_new();
+  xt_gc_add_root(&proto);
+  xt_object_define_getter(proto, xt_string_from_cstr("aborted"),
+                          xt_closure_new((void *)signal_aborted_get, 0, nullptr));
+  xt_object_define_getter(proto, xt_string_from_cstr("reason"),
+                          xt_closure_new((void *)signal_reason_get, 0, nullptr));
+  xt_object_define_getter(proto, xt_string_from_cstr("onabort"),
+                          xt_closure_new((void *)signal_onabort_get, 0, nullptr));
+  xt_object_define_setter(proto, xt_string_from_cstr("onabort"),
+                          xt_closure_new((void *)signal_onabort_set, 0, nullptr));
+  xt_object_set(proto, xt_string_from_cstr("addEventListener"),
+                xt_closure_new((void *)signal_add_listener, 0, nullptr));
+  xt_object_set(proto, xt_string_from_cstr("removeEventListener"),
+                xt_closure_new((void *)signal_remove_listener, 0, nullptr));
+  xt_object_set(proto, xt_string_from_cstr("throwIfAborted"),
+                xt_closure_new((void *)signal_throw_if_aborted, 0, nullptr));
+  return proto;
+}
+
+xt_value abort_controller_proto() {
+  static xt_value proto = XT_UNDEFINED;
+  if (XT_IS_OBJECT(proto)) return proto;
+  proto = xt_object_new();
+  xt_gc_add_root(&proto);
+  xt_object_define_getter(proto, xt_string_from_cstr("signal"),
+                          xt_closure_new((void *)controller_signal_get, 0, nullptr));
+  xt_object_set(proto, xt_string_from_cstr("abort"),
+                xt_closure_new((void *)controller_abort, 0, nullptr));
+  return proto;
+}
+
+xt_value abort_controller_new() {
+  xt_value controller = xt_object_new_with_proto(abort_controller_proto());
+  xt_object_set(controller, xt_string_from_cstr("__xt_gui_abort_state"), new_state());
+  return controller;
+}
+
+xt_value abort_signal_new(bool aborted) {
+  xt_value state = new_state();
+  if (aborted) xt_object_set(state, xt_string_from_cstr("aborted"), XT_TRUE);
+  return abort_signal_from_state(state, XT_UNDEFINED);
+}
+
+}  // namespace domapi

package/runtime/ext_gui/browser_dialogs.cpp

@@ -0,0 +1,76 @@
+/*
+ * xbintsc GUI engine — `window.confirm` / `window.prompt`.
+ *
+ * A compiled page has no browser chrome, so a blocking dialog is opt-in: with
+ * `XT_GUI_DIALOGS=1` and a live window the engine shows a native SDL message
+ * box. Otherwise (and always for `prompt`, which would need a text input) the
+ * message is written to stderr and the documented default is returned — the
+ * arguments are never silently dropped. `confirm` answers false and `prompt`
+ * answers `defaultValue` (or "") when no dialog is shown.
+ */
+
+#include "gui_engine.h"
+
+#include <stdio.h>
+#include <string>
+
+namespace {
+
+std::string message_of(int32_t argc, xt_value *argv) {
+  if (argc < 1) return std::string();
+  const char *data = xt_string_data(xt_to_string(xt_arg(argc, argv, 0)));
+  return data != nullptr ? data : "";
+}
+
+bool dialogs_enabled() {
+  const char *value = SDL_getenv("XT_GUI_DIALOGS");
+  return value != nullptr && value[0] == '1';
+}
+
+bool show_message(XtGuiWindow *win, const std::string &message, bool with_cancel) {
+  if (win == nullptr || win->window == nullptr) return false;
+  SDL_MessageBoxButtonData buttons[2];
+  SDL_zero(buttons);
+  int count = 1;
+  buttons[0].flags = SDL_MESSAGEBOX_BUTTON_RETURNKEY_DEFAULT;
+  buttons[0].buttonID = 1;
+  buttons[0].text = "OK";
+  if (with_cancel) {
+    buttons[1].flags = SDL_MESSAGEBOX_BUTTON_ESCAPEKEY_DEFAULT;
+    buttons[1].buttonID = 0;
+    buttons[1].text = "Cancel";
+    count = 2;
+  }
+  SDL_MessageBoxData data;
+  SDL_zero(data);
+  data.flags = SDL_MESSAGEBOX_INFORMATION;
+  data.window = win->window;
+  data.title = "xbintsc";
+  data.message = message.c_str();
+  data.numbuttons = count;
+  data.buttons = buttons;
+  int pressed = -1;
+  if (!SDL_ShowMessageBox(&data, &pressed)) return false;
+  return pressed == 1;
+}
+
+}  // namespace
+
+xt_value xt_browser_confirm(XtGuiWindow *win, int32_t argc, xt_value *argv) {
+  std::string message = message_of(argc, argv);
+  if (dialogs_enabled() && show_message(win, message, true)) return XT_TRUE;
+  fprintf(stderr, "confirm: %s\n", message.c_str());
+  return XT_FALSE;
+}
+
+xt_value xt_browser_prompt(XtGuiWindow *win, int32_t argc, xt_value *argv) {
+  std::string message = message_of(argc, argv);
+  std::string fallback;
+  if (argc >= 2) {
+    const char *data = xt_string_data(xt_to_string(xt_arg(argc, argv, 1)));
+    if (data != nullptr) fallback = data;
+  }
+  if (dialogs_enabled()) show_message(win, message, false);
+  fprintf(stderr, "prompt: %s\n", message.c_str());
+  return xt_string_from_cstr(fallback.c_str());
+}