@salve-software/react-native-nitro-jsdom 1.0.1 → 2.0.0

package/cpp/quickjs/bindings/BlobBindings.cpp

@@ -0,0 +1,164 @@
+#include "BlobBindings.hpp"
+#include <cstring>
+
+namespace margelo::nitro::nitrojsdom {
+
+namespace {
+
+const char* kBlobBootstrapScript = R"JS(
+(function() {
+  function partToBytes(part) {
+    if (part instanceof ArrayBuffer) {
+      return Array.prototype.slice.call(new Uint8Array(part));
+    }
+    if (part && typeof part.byteLength === 'number' && part.buffer !== undefined) {
+      return Array.prototype.slice.call(new Uint8Array(part.buffer, part.byteOffset, part.byteLength));
+    }
+    if (part instanceof Blob) {
+      return part._bytes.slice();
+    }
+    return Array.prototype.slice.call(new TextEncoder().encode(String(part)));
+  }
+
+  function normalizeBlobType(type) {
+    if (type === undefined || type === null) return '';
+    var s = String(type);
+    for (var i = 0; i < s.length; i++) {
+      var code = s.charCodeAt(i);
+      if (code < 0x20 || code > 0x7e) return '';
+    }
+    return s.toLowerCase();
+  }
+
+  function Blob(parts, options) {
+    var bytes = [];
+    if (parts) {
+      for (var i = 0; i < parts.length; i++) {
+        bytes = bytes.concat(partToBytes(parts[i]));
+      }
+    }
+    this._bytes = bytes;
+    this.size = bytes.length;
+    this.type = normalizeBlobType(options && options.type);
+  }
+  Blob.prototype.slice = function(start, end, contentType) {
+    var sliced = this._bytes.slice(start, end);
+    var result = new Blob([]);
+    result._bytes = sliced;
+    result.size = sliced.length;
+    result.type = contentType ? String(contentType) : '';
+    return result;
+  };
+  Blob.prototype.text = function() {
+    var bytes = this._bytes;
+    var buf = new ArrayBuffer(bytes.length);
+    var view = new Uint8Array(buf);
+    for (var i = 0; i < bytes.length; i++) view[i] = bytes[i];
+    return Promise.resolve(new TextDecoder().decode(buf));
+  };
+  Blob.prototype.arrayBuffer = function() {
+    var bytes = this._bytes;
+    var buf = new ArrayBuffer(bytes.length);
+    var view = new Uint8Array(buf);
+    for (var i = 0; i < bytes.length; i++) view[i] = bytes[i];
+    return Promise.resolve(buf);
+  };
+  globalThis.Blob = Blob;
+
+  function File(parts, name, options) {
+    Blob.call(this, parts, options);
+    var lastModified;
+    if (options && options.lastModified !== undefined) {
+      var n = Number(options.lastModified);
+      lastModified = (isNaN(n) || !isFinite(n)) ? 0 : Math.trunc(n);
+    } else {
+      lastModified = Date.now();
+    }
+
+    Object.defineProperty(this, 'name', { value: String(name), enumerable: true, configurable: true });
+    Object.defineProperty(this, 'lastModified', { value: lastModified, enumerable: true, configurable: true });
+  }
+  File.prototype = Object.create(Blob.prototype);
+  File.prototype.constructor = File;
+  globalThis.File = File;
+
+  function FileReader() {
+    this.readyState = 0;
+    this.result = null;
+    this.error = null;
+    this.onload = null;
+    this.onloadend = null;
+    this.onerror = null;
+    this._listeners = {};
+  }
+  FileReader.EMPTY = 0;
+  FileReader.LOADING = 1;
+  FileReader.DONE = 2;
+  FileReader.prototype.addEventListener = function(type, cb) {
+    if (!this._listeners[type]) this._listeners[type] = [];
+    if (this._listeners[type].indexOf(cb) === -1) this._listeners[type].push(cb);
+  };
+  FileReader.prototype.removeEventListener = function(type, cb) {
+    var list = this._listeners[type];
+    if (!list) return;
+    var idx = list.indexOf(cb);
+    if (idx !== -1) list.splice(idx, 1);
+  };
+  FileReader.prototype._fire = function(type) {
+    var evt = { type: type, target: this };
+    var handlerProp = 'on' + type;
+    if (typeof this[handlerProp] === 'function') this[handlerProp](evt);
+    var list = this._listeners[type];
+    if (list) list.slice().forEach(function(cb) { cb(evt); });
+  };
+  FileReader.prototype._read = function(blob, mode) {
+    var self = this;
+    self.readyState = 1;
+    setTimeout(function() {
+      if (!blob) {
+        self.error = new Error('FileReader was given no blob to read');
+        self.readyState = 2;
+        self._fire('error');
+        self._fire('loadend');
+        return;
+      }
+      var bytes = blob._bytes || [];
+      if (mode === 'text') {
+        var buf = new ArrayBuffer(bytes.length);
+        var view = new Uint8Array(buf);
+        for (var i = 0; i < bytes.length; i++) view[i] = bytes[i];
+        self.result = new TextDecoder().decode(buf);
+      } else if (mode === 'dataurl') {
+        var binary = '';
+        for (var j = 0; j < bytes.length; j++) binary += String.fromCharCode(bytes[j]);
+        self.result = 'data:' + (blob.type || '') + ';base64,' + btoa(binary);
+      } else if (mode === 'arraybuffer') {
+        var arrBuf = new ArrayBuffer(bytes.length);
+        var arrView = new Uint8Array(arrBuf);
+        for (var k = 0; k < bytes.length; k++) arrView[k] = bytes[k];
+        self.result = arrBuf;
+      }
+      self.readyState = 2;
+      self._fire('load');
+      self._fire('loadend');
+    }, 0);
+  };
+  FileReader.prototype.readAsText = function(blob) { this._read(blob, 'text'); };
+  FileReader.prototype.readAsDataURL = function(blob) { this._read(blob, 'dataurl'); };
+  FileReader.prototype.readAsArrayBuffer = function(blob) { this._read(blob, 'arraybuffer'); };
+  globalThis.FileReader = FileReader;
+})();
+)JS";
+
+} // namespace
+
+void BlobBindings::install(JSContext* ctx) {
+  JSValue result = JS_Eval(ctx, kBlobBootstrapScript, strlen(kBlobBootstrapScript),
+                            "<blob-bootstrap>", JS_EVAL_TYPE_GLOBAL);
+  if (JS_IsException(result)) {
+    JS_FreeValue(ctx, JS_GetException(ctx));
+  }
+  JS_FreeValue(ctx, result);
+}
+
+} // namespace margelo::nitro::nitrojsdom

package/cpp/quickjs/bindings/BlobBindings.hpp

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "quickjs.h"
+
+namespace margelo::nitro::nitrojsdom {
+
+// Registers globalThis.Blob, globalThis.File, and globalThis.FileReader.
+// Pure JS on top of TextEncoder/TextDecoder and btoa, so must run after
+// TextEncodingBindings and WindowBindings.
+struct BlobBindings {
+  static void install(JSContext* ctx);
+};
+
+} // namespace margelo::nitro::nitrojsdom

package/cpp/quickjs/bindings/CSSOMBindings.cpp

@@ -0,0 +1,290 @@
+#include "CSSOMBindings.hpp"
+#include <cstring>
+
+namespace margelo::nitro::nitrojsdom {
+
+namespace {
+
+const char* kCSSOMBootstrapScript = R"JS(
+(function() {
+  function stripComments(text) {
+    return text.replace(/\/\*[\s\S]*?\*\//g, '');
+  }
+
+  function camelToKebab(name) {
+    return name.replace(/[A-Z]/g, function(c) { return '-' + c.toLowerCase(); });
+  }
+
+  // Splits a stylesheet's raw text into top-level rule descriptors, tracking
+  // brace depth so a nested block (e.g. the rules inside @media) is captured
+  // as one opaque chunk rather than mis-parsed as a sibling rule.
+  function splitTopLevelRules(cssText) {
+    var text = stripComments(String(cssText === undefined ? '' : cssText));
+    var descriptors = [];
+    var i = 0;
+    var len = text.length;
+    while (i < len) {
+      while (i < len && /\s/.test(text.charAt(i))) i++;
+      if (i >= len) break;
+      var start = i;
+      var depth = 0;
+      var j = i;
+      while (j < len) {
+        var c = text.charAt(j);
+        if (c === '{') {
+          depth++;
+        } else if (c === '}') {
+          depth--;
+          if (depth <= 0) { j++; break; }
+        } else if (c === ';' && depth === 0) {
+          j++;
+          break;
+        }
+        j++;
+      }
+      var raw = text.slice(start, j);
+      if (raw.trim()) descriptors.push(parseOneRule(raw));
+      i = j;
+    }
+    return descriptors;
+  }
+
+  function parseOneRule(raw) {
+    var trimmed = raw.trim();
+    var braceIdx = trimmed.indexOf('{');
+    if (trimmed.charAt(0) === '@' || braceIdx === -1) {
+      return { kind: 'unknown', cssText: trimmed };
+    }
+    var selectorText = trimmed.slice(0, braceIdx).trim();
+    var body = trimmed.slice(braceIdx + 1, trimmed.length - 1);
+    return { kind: 'style', selectorText: selectorText, declarationText: body.trim() };
+  }
+
+  // Parses "color: red; font-size: 12px" into ordered [name, value] pairs —
+  // same informal model StyleBindings.cpp uses for inline element.style.
+  function parseDeclarations(text) {
+    var pairs = [];
+    var parts = String(text === undefined ? '' : text).split(';');
+    for (var i = 0; i < parts.length; i++) {
+      var part = parts[i].trim();
+      if (!part) continue;
+      var colonIdx = part.indexOf(':');
+      if (colonIdx === -1) continue;
+      var prop = part.slice(0, colonIdx).trim().toLowerCase();
+      var value = part.slice(colonIdx + 1).trim();
+      if (prop) pairs.push([prop, value]);
+    }
+    return pairs;
+  }
+
+  function makeRuleStyle(initialText) {
+    var pairs = parseDeclarations(initialText);
+
+    var target = {
+      getPropertyValue: function(name) {
+        var kebab = camelToKebab(String(name));
+        for (var i = 0; i < pairs.length; i++) if (pairs[i][0] === kebab) return pairs[i][1];
+        return '';
+      },
+      setProperty: function(name, value) {
+        var kebab = camelToKebab(String(name));
+        for (var i = 0; i < pairs.length; i++) {
+          if (pairs[i][0] === kebab) { pairs[i][1] = String(value); return; }
+        }
+        pairs.push([kebab, String(value)]);
+      },
+      removeProperty: function(name) {
+        var kebab = camelToKebab(String(name));
+        var old = '';
+        var next = [];
+        for (var i = 0; i < pairs.length; i++) {
+          if (pairs[i][0] === kebab && !old) { old = pairs[i][1]; continue; }
+          next.push(pairs[i]);
+        }
+        pairs = next;
+        return old;
+      },
+      get cssText() {
+        var out = '';
+        for (var i = 0; i < pairs.length; i++) out += pairs[i][0] + ': ' + pairs[i][1] + '; ';
+        return out.trim();
+      },
+      set cssText(text) {
+        pairs = parseDeclarations(text);
+      },
+    };
+
+    return new Proxy(target, {
+      get: function(t, prop, receiver) {
+        if (typeof prop === 'string' && !(prop in t)) {
+          var kebab = camelToKebab(prop);
+          for (var i = 0; i < pairs.length; i++) if (pairs[i][0] === kebab) return pairs[i][1];
+          return undefined;
+        }
+        return Reflect.get(t, prop, receiver);
+      },
+      set: function(t, prop, value, receiver) {
+        if (typeof prop === 'string' && !(prop in t)) {
+          t.setProperty(prop, value);
+          return true;
+        }
+        return Reflect.set(t, prop, value, receiver);
+      },
+    });
+  }
+
+  function CSSRule() {}
+  CSSRule.STYLE_RULE = 1;
+  CSSRule.MEDIA_RULE = 4;
+  CSSRule.prototype.type = 0;
+
+  function CSSStyleRule(selectorText, declarationText, parentStyleSheet) {
+    this.selectorText = selectorText;
+    this.style = makeRuleStyle(declarationText);
+    this.parentStyleSheet = parentStyleSheet || null;
+    this.type = CSSRule.STYLE_RULE;
+  }
+  CSSStyleRule.prototype = Object.create(CSSRule.prototype);
+  CSSStyleRule.prototype.constructor = CSSStyleRule;
+  Object.defineProperty(CSSStyleRule.prototype, 'cssText', {
+    get: function() { return this.selectorText + ' { ' + this.style.cssText + ' }'; },
+    configurable: true,
+  });
+
+  function makeUnknownRule(cssText, parentStyleSheet) {
+    return { type: 0, cssText: cssText, parentStyleSheet: parentStyleSheet || null };
+  }
+
+  function ruleFromDescriptor(d, sheet) {
+    return d.kind === 'style'
+      ? new CSSStyleRule(d.selectorText, d.declarationText, sheet)
+      : makeUnknownRule(d.cssText, sheet);
+  }
+
+  function makeRuleList(rules) {
+    var arr = rules.slice();
+    arr.item = function(i) { return this[i] !== undefined ? this[i] : null; };
+    return arr;
+  }
+
+  function CSSStyleSheet(ownerNode) {
+    this.ownerNode = ownerNode || null;
+    this.cssRules = makeRuleList([]);
+    this.rules = this.cssRules;
+  }
+  CSSStyleSheet.prototype.insertRule = function(ruleText, index) {
+    var idx = (index === undefined) ? this.cssRules.length : index;
+    if (idx < 0 || idx > this.cssRules.length) {
+      throw new DOMException(
+        'The index provided (' + idx + ') is not in the allowed range.', 'IndexSizeError');
+    }
+    var rule = ruleFromDescriptor(parseOneRule(String(ruleText)), this);
+    Array.prototype.splice.call(this.cssRules, idx, 0, rule);
+    return idx;
+  };
+  CSSStyleSheet.prototype.deleteRule = function(index) {
+    if (index < 0 || index >= this.cssRules.length) {
+      throw new DOMException(
+        'The index provided (' + index + ') is not in the allowed range.', 'IndexSizeError');
+    }
+    Array.prototype.splice.call(this.cssRules, index, 1);
+  };
+
+  function parseStylesheetInto(sheet, cssText) {
+    var descriptors = splitTopLevelRules(cssText);
+    for (var i = 0; i < descriptors.length; i++) {
+      sheet.cssRules.push(ruleFromDescriptor(descriptors[i], sheet));
+    }
+  }
+
+  globalThis.CSSRule = CSSRule;
+  globalThis.CSSStyleRule = CSSStyleRule;
+  globalThis.CSSStyleSheet = CSSStyleSheet;
+
+  Object.defineProperty(Element.prototype, 'sheet', {
+    get: function() {
+      if (this.tagName !== 'STYLE') return null;
+      if (!this._sheet) {
+        var sheet = new CSSStyleSheet(this);
+        parseStylesheetInto(sheet, this.textContent);
+        this._sheet = sheet;
+      }
+      return this._sheet;
+    },
+    configurable: true,
+  });
+
+  Object.defineProperty(document, 'styleSheets', {
+    get: function() {
+      var styleEls = document.querySelectorAll('style');
+      var sheets = [];
+      for (var i = 0; i < styleEls.length; i++) {
+        var sheet = styleEls[i].sheet;
+        if (sheet) sheets.push(sheet);
+      }
+      sheets.item = function(i) { return this[i] !== undefined ? this[i] : null; };
+      return sheets;
+    },
+    configurable: true,
+  });
+
+  // ── getComputedStyle ──────────────────────────────────────────────────
+  // No layout/cascade engine backs this sandbox — there is no stylesheet
+  // specificity resolution or inheritance, only the element's own inline
+  // `style` attribute. `display` falls back to a small user-agent-stylesheet
+  // approximation (block/inline/inline-block/none by tag name, or 'none' for
+  // a `hidden` attribute) since "is this element visible" is the one
+  // getComputedStyle check real-world embedded scripts actually make;
+  // `visibility`/`opacity` fall back to their initial values. Every other
+  // unset property returns '', not a computed initial value.
+  var kBlockTags = { ADDRESS: 1, ARTICLE: 1, ASIDE: 1, BLOCKQUOTE: 1, DETAILS: 1, DIALOG: 1, DD: 1, DIV: 1,
+    DL: 1, DT: 1, FIELDSET: 1, FIGCAPTION: 1, FIGURE: 1, FOOTER: 1, FORM: 1, H1: 1, H2: 1, H3: 1, H4: 1,
+    H5: 1, H6: 1, HEADER: 1, HGROUP: 1, HR: 1, LI: 1, MAIN: 1, NAV: 1, OL: 1, P: 1, PRE: 1, SECTION: 1,
+    TABLE: 1, UL: 1, HTML: 1, BODY: 1 };
+  var kNoneTags = { SCRIPT: 1, STYLE: 1, HEAD: 1, TITLE: 1, META: 1, LINK: 1, TEMPLATE: 1 };
+  var kInlineBlockTags = { IMG: 1, BUTTON: 1, INPUT: 1, SELECT: 1, TEXTAREA: 1 };
+
+  function defaultDisplay(tagName) {
+    if (kNoneTags[tagName]) return 'none';
+    if (kInlineBlockTags[tagName]) return 'inline-block';
+    if (kBlockTags[tagName]) return 'block';
+    return 'inline';
+  }
+
+  function resolveProperty(el, kebabName) {
+    var v = el.style.getPropertyValue(kebabName);
+    if (v) return v;
+    if (kebabName === 'display') return el.hasAttribute('hidden') ? 'none' : defaultDisplay(el.tagName);
+    if (kebabName === 'visibility') return 'visible';
+    if (kebabName === 'opacity') return '1';
+    return '';
+  }
+
+  globalThis.getComputedStyle = function(el) {
+    if (!el || typeof el.tagName !== 'string') {
+      throw new TypeError("Failed to execute 'getComputedStyle': parameter 1 is not of type 'Element'.");
+    }
+    return new Proxy({}, {
+      get: function(_target, prop) {
+        if (prop === 'getPropertyValue') return function(name) { return resolveProperty(el, String(name)); };
+        if (prop === 'getPropertyPriority') return function() { return ''; };
+        if (typeof prop !== 'string') return undefined;
+        return resolveProperty(el, camelToKebab(prop));
+      },
+    });
+  };
+})();
+)JS";
+
+} // namespace
+
+void CSSOMBindings::install(JSContext* ctx) {
+  JSValue result = JS_Eval(ctx, kCSSOMBootstrapScript, strlen(kCSSOMBootstrapScript),
+                            "<cssom-bootstrap>", JS_EVAL_TYPE_GLOBAL);
+  if (JS_IsException(result)) {
+    JS_FreeValue(ctx, JS_GetException(ctx));
+  }
+  JS_FreeValue(ctx, result);
+}
+
+} // namespace margelo::nitro::nitrojsdom

package/cpp/quickjs/bindings/CSSOMBindings.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "quickjs.h"
+
+namespace margelo::nitro::nitrojsdom {
+
+// Registers a minimal CSSOM: globalThis.CSSRule/CSSStyleRule/CSSStyleSheet,
+// Element.prototype.sheet (tag-checked for "style"), document.styleSheets,
+// and globalThis.getComputedStyle (inline-style + tag-default-display only,
+// no real cascade — see the bootstrap script for the exact fallback rules).
+//
+// Rules are split by a hand-rolled top-level brace scanner rather than
+// Lexbor's CSS rule/declaration AST (lxb_css_rule_t) — mirrors how
+// StyleBindings.cpp already treats inline "style" text as informally-parsed
+// property:value pairs rather than integrating Lexbor's typed CSS value
+// engine. At-rules (@media, @keyframes, ...) are captured as opaque stub
+// rules (cssText only, no nested-rule access) rather than fully parsed.
+//
+// Must run after ElementBindings (globalThis.Element) and DocumentBindings
+// (globalThis.document).
+struct CSSOMBindings {
+  static void install(JSContext* ctx);
+};
+
+} // namespace margelo::nitro::nitrojsdom

package/cpp/quickjs/bindings/ClassListBindings.cpp

@@ -1,4 +1,5 @@
 #include "ClassListBindings.hpp"
+#include "DOMExceptionBindings.hpp"
 #include "../DOMBindingsInternal.hpp"
 #include "../QuickJSRuntime.hpp"
 #include "../MutationObservers.hpp"
@@ -36,13 +37,13 @@ std::string join_classes(const std::vector<std::string>& v) {
 // Validates a DOMTokenList token: throws on empty or whitespace-containing token.
 bool validate_token(JSContext* ctx, const char* token) {
   if (!token || token[0] == '\0') {
-    JS_ThrowTypeError(ctx, "The token provided must not be empty.");
+    throw_dom_exception(ctx, "SyntaxError", "The token provided must not be empty.");
     return false;
   }
   for (const char* p = token; *p; p++) {
     unsigned char c = (unsigned char)*p;
     if (c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '\f') {
-      JS_ThrowTypeError(ctx, "The token provided contains HTML space characters, which are not valid in tokens.");
+      throw_dom_exception(ctx, "InvalidCharacterError", "The token provided contains HTML space characters, which are not valid in tokens.");
       return false;
     }
   }

package/cpp/quickjs/bindings/CookieBindings.cpp

@@ -0,0 +1,118 @@
+#include "CookieBindings.hpp"
+#include "../DOMBindingsInternal.hpp"
+#include "../QuickJSRuntime.hpp"
+#include "../Storage.hpp"
+#include <string>
+#include <cctype>
+#include <cstdlib>
+#include <ctime>
+
+namespace margelo::nitro::nitrojsdom {
+
+namespace {
+
+std::string trim(const std::string& s) {
+  size_t start = s.find_first_not_of(" \t\n\r");
+  if (start == std::string::npos) return "";
+  size_t end = s.find_last_not_of(" \t\n\r");
+  return s.substr(start, end - start + 1);
+}
+
+std::string to_lower(std::string s) {
+  for (auto& c : s) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
+  return s;
+}
+
+// Best-effort: accepts the date formats real cookie strings actually use
+// (RFC 1123, RFC 850, asctime) — not a full HTTP-date parser.
+bool is_past_date(const std::string& value) {
+  static const char* kFormats[] = {
+    "%a, %d %b %Y %H:%M:%S", // RFC 1123: "Thu, 01 Jan 1970 00:00:00 GMT"
+    "%A, %d-%b-%y %H:%M:%S", // RFC 850
+    "%a %b %d %H:%M:%S %Y",  // asctime
+  };
+  for (const char* fmt : kFormats) {
+    struct tm parsed{};
+    if (strptime(value.c_str(), fmt, &parsed)) {
+      return timegm(&parsed) <= time(nullptr);
+    }
+  }
+  return false;
+}
+
+// A cookie write is a deletion when `max-age` is <= 0 or `expires` names a
+// date in the past — the two idioms real-world scripts use to clear a
+// cookie (most commonly `expires=Thu, 01 Jan 1970 00:00:00 GMT`).
+bool is_deletion(const std::string& attrs) {
+  size_t pos = 0;
+  while (pos < attrs.size()) {
+    size_t semi = attrs.find(';', pos);
+    std::string attr = attrs.substr(pos, semi == std::string::npos ? std::string::npos : semi - pos);
+    pos = semi == std::string::npos ? attrs.size() : semi + 1;
+
+    size_t eq = attr.find('=');
+    if (eq == std::string::npos) continue;
+    std::string key = to_lower(trim(attr.substr(0, eq)));
+    std::string value = trim(attr.substr(eq + 1));
+
+    if (key == "max-age") {
+      if (std::atol(value.c_str()) <= 0) return true;
+    } else if (key == "expires") {
+      if (is_past_date(value)) return true;
+    }
+  }
+  return false;
+}
+
+JSValue js_doc_get_cookie(JSContext* ctx, JSValue) {
+  auto* rctx = get_ctx(ctx);
+  if (!rctx) return JS_NewString(ctx, "");
+
+  std::string result;
+  for (size_t i = 0; i < rctx->cookie_jar.length(); i++) {
+    auto key = rctx->cookie_jar.key(i);
+    if (!key) continue;
+    auto value = rctx->cookie_jar.getItem(*key);
+    if (!value) continue;
+    if (!result.empty()) result += "; ";
+    result += *key + "=" + *value;
+  }
+  return JS_NewStringLen(ctx, result.data(), result.size());
+}
+
+JSValue js_doc_set_cookie(JSContext* ctx, JSValue, JSValue val) {
+  auto* rctx = get_ctx(ctx);
+  const char* str = JS_ToCString(ctx, val);
+  if (str && rctx) {
+    std::string input(str);
+    size_t semi = input.find(';');
+    std::string pair = semi == std::string::npos ? input : input.substr(0, semi);
+    std::string attrs = semi == std::string::npos ? "" : input.substr(semi + 1);
+    size_t eq = pair.find('=');
+    if (eq != std::string::npos) {
+      std::string name = trim(pair.substr(0, eq));
+      std::string value = trim(pair.substr(eq + 1));
+      if (!name.empty()) {
+        if (is_deletion(attrs)) {
+          rctx->cookie_jar.removeItem(name);
+        } else {
+          rctx->cookie_jar.setItem(name, value);
+        }
+      }
+    }
+  }
+  if (str) JS_FreeCString(ctx, str);
+  return JS_UNDEFINED;
+}
+
+} // namespace
+
+void CookieBindings::install(JSContext* ctx) {
+  JSValue global = JS_GetGlobalObject(ctx);
+  JSValue doc = JS_GetPropertyStr(ctx, global, "document");
+  define_prop(ctx, doc, "cookie", js_doc_get_cookie, js_doc_set_cookie);
+  JS_FreeValue(ctx, doc);
+  JS_FreeValue(ctx, global);
+}
+
+} // namespace margelo::nitro::nitrojsdom

package/cpp/quickjs/bindings/CookieBindings.hpp

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "quickjs.h"
+
+namespace margelo::nitro::nitrojsdom {
+
+// Registers document.cookie (get/set), backed by an in-memory per-runtime
+// cookie jar (RuntimeContext::cookie_jar — a name -> value map preserving
+// insertion order). jsdom backs this with a real tough-cookie CookieJar
+// scoped by domain/path/expiry; this sandbox has no navigation or multiple
+// origins, so scoping attributes (path/domain/secure/samesite) are parsed
+// off and discarded rather than enforced. `expires`/`max-age` are the
+// exception: a value in the past (or max-age <= 0) is treated as the
+// deletion idiom real-world scripts use it for, and removes the cookie
+// instead of leaving a stray "name=" entry in the jar. `expires` parsing is
+// best-effort (RFC 1123/850/asctime formats only, not a full HTTP-date parser).
+//
+// Must run after DocumentBindings (needs globalThis.document to exist).
+struct CookieBindings {
+  static void install(JSContext* ctx);
+};
+
+} // namespace margelo::nitro::nitrojsdom