From 3b2c6c0deb0ee84bebebf17f37540e3e95f2ddd5 Mon Sep 17 00:00:00 2001 From: SGavrl <277843151+SGavrl@users.noreply.github.com> Date: Thu, 4 Jun 2026 15:19:29 +0000 Subject: [PATCH] WPT conformance: legacy-charset URL encoding, IDL attribute reflection, FileAPI, Storage, Range (#237) * dom: complete detached documents; add ProgressEvent and parseHTMLUnsafe createHTMLDocument returned a document whose body was null: parsing the skeleton string as innerHTML of collapsed through the fragment parser and kept only . Build head>title and body explicitly instead. The DOMParser doc node also gains appendChild/removeChild/insertBefore and a doctype getter, and createDocument carries its doctype argument. This lets dom/common.js setupRangeTests() finish (it builds fixtures with new Document(), createHTMLDocument(), createDocument()) instead of aborting at harness setup, so the dom/ranges files run. Range-collapse 186/186, Range-attributes 1/1, Range-cloneRange 55/62, StaticRange-constructor 14/17. The large O(ranges x points) matrix files (Range-set, comparePoint, compareBoundaryPoints) still time out: the boundary-point comparison walks the tree through per-step DOM ops, which is too slow for those matrices. Speeding that up (a Rust node-position op) is a separate change. Also add globalThis.ProgressEvent (Event subclass with lengthComputable/ loaded/total) and the static Document.parseHTMLUnsafe(html). * perf(dom): compute Range tree-order in Rust ops The Range boundary-point algorithms compared nodes by walking ancestor chains and sibling lists from JS, one DOM op per step. The dom/ranges matrices (testRanges x testPoints, thousands of comparisons) made that time out. Add node_index, compare_order, and node_root ops that do the walk in Rust over the DOM tree (slab lookups, no per-step FFI), and use them in _rngNodeIndex, _rngOrder, and _rngRoot. Range-comparePoint 3534/5580, Range-isPointInRange 5197/5733, Range-compareBoundaryPoints 6441/9313, all completing in under 10s where they previously did not finish. Not on any engine hot path (querySelector, mutation, navigation, fetch do not use these). * fileapi: real byte-backed Blob/File, FileReader state machine, Request.blob Blob was a one-line stub that string-joined its parts (wrong size for binary or multibyte input) and exposed only text(). Replace it with a Uint8Array-backed Blob: normalizes string/ArrayBuffer/typed-array/Blob parts, correct size, slice(), text()/arrayBuffer()/bytes(), type normalization (lowercased, cleared when non-ASCII), the endings option (native CRLF normalization), and Symbol.toStringTag. File adds name/lastModified, the 2-argument requirement, and its own toStringTag. FileReader becomes a real state machine: EMPTY/LOADING/DONE, throws InvalidStateError when a read starts while already LOADING, and fires loadstart/progress/load/loadend (and abort) to both on* handlers and addEventListener. readAsText/DataURL/ArrayBuffer/BinaryString produce correct results. Request gains blob(). FileReader-multiple-reads 6/6, File-constructor-endings 10/11, Blob-slice 141/150. * encoding: TextDecoder supports legacy charsets via encoding_rs TextDecoder was a UTF-8-only JS shim that ignored its label, so new TextDecoder('shift_jis'|'euc-jp'|'big5'|'gbk'|'windows-1252'|'iso-8859-1') .decode() returned garbage. That matters for scraping: pages and scripts decode legacy-encoded bytes (XHR/fetch responses, File/Blob text) all the time. Back it with encoding_rs (already used by the net layer for response bodies): obscura-net gains label_name() and decode_with_label(), exposed to JS as op_encoding_for_label and op_text_decode. The constructor validates the label (RangeError) and sets the canonical .encoding/.fatal/.ignoreBOM; decode() supports fatal mode (TypeError on invalid input) and BOM handling. Plain UTF-8 non-fatal decoding keeps a pure-JS fast path (no op, no JSON), so Response.text()/Blob.text() on large bodies are unchanged; the op only runs for legacy encodings or fatal mode. textdecoder-labels 222/222, textdecoder-fatal 36/36, byte-order-marks 3/3, utf16-surrogates 10/10, single-byte-decoder 168/504. * selection: real Selection over Range (single instance per document) getSelection() returned a fresh plain object each call, so it was not a Selection instance, had no identity (window.getSelection() !== document.getSelection()), and was missing removeRange/empty/collapseToStart/collapseToEnd/setPosition/ setBaseAndExtent/modify while collapse/extend/getRangeAt were broken stubs. That was ~4862 failing 'selection[method] is not a function' subtests. Replace it with a real Selection class built on the live Range: one cached instance per document (window.getSelection() === document.getSelection(), null for documents with no defaultView), an internal range + direction, derived anchor/focus/isCollapsed/type/rangeCount, and the full method set (getRangeAt with IndexSizeError, addRange, removeRange, removeAllRanges/empty, collapse/setPosition, collapseToStart/End, extend, setBaseAndExtent, selectAllChildren, containsNode, toString) with the spec DOMException names. modify() stays a no-op (needs visual layout). No ops.rs changes; not on any hot path. setBaseAndExtent 120/120, removeAllRanges 104/104, collapseToStartEnd 51/51, type 26/26, extend-exception 1/1. * forms: HTMLInputElement valueAsNumber/valueAsDate/stepUp/stepDown These were absent. Implement the number/date conversion API for the applicable types (number, range, date, month, week, time, datetime-local): parsers and formatters per type (Date.UTC for date/datetime-local, ISO-week Monday math for week, months-since-epoch for month), valueAsNumber get/set, valueAsDate get/set, and stepUp/stepDown(n) with the step scale/default per type, step-base snapping, and min/max clamping. Non-applicable types and step="any" throw InvalidStateError; non-finite valueAsNumber throws TypeError; range with empty value reads as the midpoint (50 for 0..100). Plus min/max/step attribute reflection. All on Element accessors gated by input type, only evaluated on explicit access; not on any hot path. input-stepup 51/53, input-valueasnumber 60/64, input-valueasdate 27/30. * perf(encoding): skip label op for no-arg TextDecoder (Response/Blob text path) new TextDecoder() with no argument (what Response.text()/Blob.text() and most pages use) is UTF-8; resolve that without the op_encoding_for_label round trip. Explicit labels still validate via the op. * core: HTMLDialogElement, Node.normalize, Range.createContextualFragment HTMLDialogElement was a bare alias of Element, so ~40 Core files crashed at the first dialog.show()/showModal(). Add the dialog members on Element.prototype (matching the popover/input convention): open reflection, returnValue (internal slot, String coercion), oncancel/onclose defaulting to null, show()/showModal() /close()/requestClose() with the open-state transitions, InvalidStateError throwing (show-on-modal, showModal-on-open, showModal-disconnected), the async non-bubbling close event, the synchronous cancelable cancel event (no re-entrant cancel), beforetoggle/toggle, and closedBy. matches(':modal') reports a modally shown dialog (like :popover-open). Modal top-layer/focus/render stays unhandled (layout). Node.normalize() now merges adjacent Text nodes and drops empty ones (was a no-op). Range.createContextualFragment(html) parses a fragment. createContextualFragment 34/35, dialog-open 3/3, dialog-return-value 1/1, dialog-showModal 5/10, dialog-requestclose 22/75. Not on hot paths. * custom-elements: CustomElementRegistry class, getName, ElementInternals, HTMLUnknownElement customElements was a bare object literal, so 'CustomElementRegistry is not defined' crashed ~22 Core files at top level (idlharness/feature-detect), and HTMLUnknownElement/ElementInternals/attachInternals/getName were missing. Promote the registry to a real CustomElementRegistry class (window.customElements is now an instance, so 'define in CustomElementRegistry.prototype' works and the class is exposed). Add spec define() validation/throw order (TypeError for a non-constructor, SyntaxError for an invalid name, NotSupportedError for a duplicate name/constructor or reentrant define), getName(), and a SyntaxError reject in whenDefined for invalid names. The existing define -> upgrade -> connectedCallback path (used by lit/Polymer on real pages) is preserved. Add HTMLUnknownElement, ElementInternals (setFormValue/setValidity/checkValidity/ validity/validationMessage/form/states), and Element.attachInternals() with its NotSupportedError cases. Does NOT include the [[HTMLConstructor]] (new.target) construction rework or the reaction wiring into appendChild/setAttribute (hot paths) - deferred to avoid element-model and perf risk. getName 4/4. * shadow-dom: ShadowRoot.adoptedStyleSheets (mirror Document) ShadowRoot lacked adoptedStyleSheets; constructible-stylesheet adoption into a shadow root threw. Add the getter/setter on ShadowRoot.prototype, matching Document.adoptedStyleSheets. * conformance: charset/URL encoding override, IDL reflection, Range and Storage fixes Encoding: track the detected document character encoding and expose it as document.characterSet/charset/inputEncoding instead of hardcoding UTF-8. Add the WHATWG URL encoding override for <a>/<area> hrefs, so a legacy-charset document percent-encodes the query in its own encoding (EUC-JP U+8108 becomes %CC%AE). ASCII delimiters stay literal so structured queries are unaffected, and unmappable code points become %26%23NNN%3B. UTF-8 documents take an early-return so the href getter hot path is unchanged. fetch()/XHR text() now decode using the response Content-Type charset instead of always UTF-8. Adds op_url_encode_query and a document_encoding op; encoding state is plumbed through Page and the runtime. Reflection: install the reflected IDL attribute layer once on Element.prototype (no per-element defineProperty, so element creation and query paths are untouched): global attributes (title, lang, dir, accessKey, slot, autofocus, hidden, tabIndex) with correct type coercion and enum canonicalization, plus the ARIAMixin (aria-* reflected as the ariaXxx nullable DOMString properties). Range: compareBoundaryPoints ToUint16-converts the how argument (NaN/Infinity no longer false-throw) and raises a real WrongDocumentError DOMException for ranges that do not share a root. Storage: reimplement localStorage/sessionStorage as a WHATWG Proxy so property access (localStorage.foo = x, delete, in, Object.keys) stays in sync with length, key() and iteration. --- crates/obscura-browser/src/page.rs | 11 +- crates/obscura-js/js/bootstrap.js | 616 ++++++++++++++++++++++++++--- crates/obscura-js/src/ops.rs | 41 ++ crates/obscura-js/src/runtime.rs | 7 + crates/obscura-net/src/encoding.rs | 156 +++++++- crates/obscura-net/src/lib.rs | 5 +- 6 files changed, 781 insertions(+), 55 deletions(-) diff --git a/crates/obscura-browser/src/page.rs b/crates/obscura-browser/src/page.rs index 9cc8db9..c1271bb 100644 --- a/crates/obscura-browser/src/page.rs +++ b/crates/obscura-browser/src/page.rs @@ -134,6 +134,11 @@ pub struct Page { pub http_client: Arc<ObscuraHttpClient>, pub context: Arc<BrowserContext>, pub title: String, + /// WHATWG canonical name of the current document's character encoding + /// (e.g. "UTF-8", "EUC-JP"), detected when the response body is decoded. + /// Exposed to JS as `document.characterSet` and used for the URL query + /// encoding override on `<a>`/`<area>` hrefs in legacy-charset documents. + pub encoding: String, /// Navigation history for Page.getNavigationHistory / navigateToHistoryEntry. /// Entries are URLs in visit order; `history_index` is the current position. /// Pushed on every successful navigation; truncated on goBack -> new nav. @@ -188,6 +193,7 @@ impl Page { http_client, context, title: String::new(), + encoding: "UTF-8".to_string(), history: Vec::new(), history_index: 0, network_events: Vec::new(), @@ -248,6 +254,7 @@ impl Page { self.context.proxy_url.clone(), ); rt.set_url(&self.url_string()); + rt.set_encoding(&self.encoding); rt.set_title(&self.title); #[cfg(feature = "stealth")] @@ -861,7 +868,9 @@ impl Page { // in the first 1KB → UTF-8 fallback. Without this, every non-UTF-8 // page (GBK, Big5, Shift-JIS, Windows-125x, EUC-KR, ISO-8859-x) // came through as replacement characters. - let body_text = obscura_net::decode_response(&response.body, response.content_type()); + let (body_text, encoding_name) = + obscura_net::decode_response_with_name(&response.body, response.content_type()); + self.encoding = encoding_name.to_string(); let dom = parse_html(&body_text); self.title = dom diff --git a/crates/obscura-js/js/bootstrap.js b/crates/obscura-js/js/bootstrap.js index 28b4898..6b3aa25 100644 --- a/crates/obscura-js/js/bootstrap.js +++ b/crates/obscura-js/js/bootstrap.js @@ -422,7 +422,24 @@ class Node { return 4; // DOCUMENT_POSITION_FOLLOWING } getRootNode() { return globalThis.document; } - normalize() {} // no-op + normalize() { + // Merge adjacent exclusive Text nodes, drop empty ones, recurse. Detached + // removed nodes keep their own data (read from the backing node by nid). + let child = this.firstChild; + while (child) { + const next = child.nextSibling; + if (child.nodeType === 3) { + let data = child.data, sib = child.nextSibling; + while (sib && sib.nodeType === 3) { const after = sib.nextSibling; data += sib.data; this.removeChild(sib); sib = after; } + if (data.length === 0) { this.removeChild(child); child = sib; continue; } + if (data !== child.data) child.data = data; + child = sib; continue; + } else if (child.nodeType === 1 || child.nodeType === 11) { + child.normalize(); + } + child = next; + } + } isEqualNode(other) { if (!other) return false; if (this._nid === other._nid) return true; @@ -631,6 +648,49 @@ class ProcessingInstruction extends CharacterData { cloneNode() { return new ProcessingInstruction(+_dom("create_text_node", this.data), this._target); } } +// Document character encoding (WHATWG canonical name, e.g. "UTF-8", "EUC-JP"). +// Cached per runtime: the encoding is fixed for a document's lifetime and this +// is read on every <a>/<area> URL-component access, so the UTF-8 common case +// must reduce to a single cached-boolean read with no op call and no allocation. +let __docEncoding; +let __docIsUtf8; +function _docEncoding() { + if (__docEncoding === undefined) { + const e = _domParse("document_encoding"); + __docEncoding = (typeof e === 'string' && e) ? e : 'UTF-8'; + __docIsUtf8 = __docEncoding.toLowerCase() === 'utf-8'; + } + return __docEncoding; +} +function _docIsUtf8() { if (__docIsUtf8 === undefined) _docEncoding(); return __docIsUtf8; } +// WHATWG "special scheme" check (these get the special-query percent-encode set). +function _isSpecialScheme(protocol) { + const s = (protocol || '').replace(/:$/, '').toLowerCase(); + return s === 'http' || s === 'https' || s === 'ws' || s === 'wss' || s === 'ftp' || s === 'file'; +} +// Apply the WHATWG URL "encoding override": in a legacy (non-UTF-8) document +// the query of an <a>/<area> href is percent-encoded in the document charset, +// not UTF-8. The url op already produced a UTF-8-encoded query; recover the +// original characters (percent-decode + UTF-8) and re-encode them through the +// document charset. Pure-ASCII queries round-trip unchanged. +function _applyDocQueryEncoding(u) { + if (!u || !u.search || u.search.length < 2) return u; + let decoded; + try { decoded = decodeURIComponent(u.search.slice(1)); } catch (e) { return u; } + let reencoded; + try { reencoded = Deno.core.ops.op_url_encode_query(decoded, _docEncoding(), _isSpecialScheme(u.protocol)); } + catch (e) { return u; } + const newSearch = '?' + reencoded; + if (newSearch === u.search) return u; + const hashIdx = u.href.indexOf('#'); + const frag = hashIdx >= 0 ? u.href.slice(hashIdx) : ''; + const beforeHash = hashIdx >= 0 ? u.href.slice(0, hashIdx) : u.href; + const qIdx = beforeHash.indexOf('?'); + u.href = (qIdx >= 0 ? beforeHash.slice(0, qIdx) : beforeHash) + newSearch + frag; + u.search = newSearch; + return u; +} + // HTMLHyperlinkElementUtils helpers (the <a>/<area> URL-decomposition members). // The element's href attribute is parsed against the document base URL via the // WHATWG url op; component getters read it, setters rewrite the href attribute. @@ -638,7 +698,9 @@ function _anchorBase() { return _domParse("document_url") || "about:blank"; } function _elemHrefURL(el) { const raw = el.getAttribute('href'); if (raw === null || raw === undefined) return null; - return _urlParseOp(raw, _anchorBase()); + const u = _urlParseOp(raw, _anchorBase()); + if (u && !_docIsUtf8()) return _applyDocQueryEncoding(u); + return u; } function _setElemHrefPart(el, part, value) { const u = _elemHrefURL(el); @@ -647,6 +709,42 @@ function _setElemHrefPart(el, part, value) { if (c) el.setAttribute('href', c.href); } +// --- <input> number/date conversion (valueAsNumber/valueAsDate/stepUp/Down) --- +// Applicable types and their step scale factor + default step (HTML spec). +const _INPUT_NUM_TYPES = { date: 1, month: 1, week: 1, time: 1, 'datetime-local': 1, number: 1, range: 1 }; +const _INPUT_DATE_TYPES = { date: 1, month: 1, week: 1, time: 1, 'datetime-local': 1 }; +const _INPUT_STEP_SCALE = { date: 86400000, 'datetime-local': 1000, month: 1, number: 1, range: 1, time: 1000, week: 604800000 }; +const _INPUT_STEP_DEFAULT = { date: 1, 'datetime-local': 60, month: 1, number: 1, range: 1, time: 60, week: 1 }; +function _pad(n, w) { n = String(Math.abs(n | 0)); while (n.length < w) n = '0' + n; return n; } +function _daysInMonth(y, m) { return [31, ((y % 4 === 0 && y % 100 !== 0) || y % 400 === 0) ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][m - 1]; } +function _isoWeek1Monday(y) { const jan4 = Date.UTC(y, 0, 4); const dow = (new Date(jan4).getUTCDay() + 6) % 7; return jan4 - dow * 86400000; } +// Parse an <input> value string to its numeric form per type; NaN if invalid. +function _inputParseNumber(type, v) { + v = String(v == null ? '' : v); + let m; + switch (type) { + case 'number': case 'range': { if (v === '') return NaN; const n = Number(v); return isFinite(n) ? n : NaN; } + case 'date': if ((m = /^(\d{4,})-(\d{2})-(\d{2})$/.exec(v))) { const y = +m[1], mo = +m[2], d = +m[3]; if (mo >= 1 && mo <= 12 && d >= 1 && d <= _daysInMonth(y, mo)) return Date.UTC(y, mo - 1, d); } return NaN; + case 'month': if ((m = /^(\d{4,})-(\d{2})$/.exec(v))) { const y = +m[1], mo = +m[2]; if (mo >= 1 && mo <= 12) return (y - 1970) * 12 + (mo - 1); } return NaN; + case 'week': if ((m = /^(\d{4,})-W(\d{2})$/.exec(v))) { const y = +m[1], w = +m[2]; if (w >= 1 && w <= 53) return _isoWeek1Monday(y) + (w - 1) * 604800000; } return NaN; + case 'time': if ((m = /^(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{1,3}))?)?$/.exec(v))) { const h = +m[1], mi = +m[2], s = m[3] ? +m[3] : 0, ms = m[4] ? +((m[4] + '00').slice(0, 3)) : 0; if (h <= 23 && mi <= 59 && s <= 59) return ((h * 60 + mi) * 60 + s) * 1000 + ms; } return NaN; + case 'datetime-local': if ((m = /^(\d{4,})-(\d{2})-(\d{2})T(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{1,3}))?)?$/.exec(v))) { const y = +m[1], mo = +m[2], d = +m[3], h = +m[4], mi = +m[5], s = m[6] ? +m[6] : 0, ms = m[7] ? +((m[7] + '00').slice(0, 3)) : 0; if (mo >= 1 && mo <= 12 && d >= 1 && d <= _daysInMonth(y, mo) && h <= 23 && mi <= 59 && s <= 59) return Date.UTC(y, mo - 1, d, h, mi, s, ms); } return NaN; + } + return NaN; +} +// Format a numeric value back to an <input> value string per type. +function _inputFormatNumber(type, n) { + switch (type) { + case 'number': case 'range': return String(n); + case 'date': { const dt = new Date(n); return _pad(dt.getUTCFullYear(), 4) + '-' + _pad(dt.getUTCMonth() + 1, 2) + '-' + _pad(dt.getUTCDate(), 2); } + case 'month': { const y = 1970 + Math.floor(n / 12); const mo = ((n % 12) + 12) % 12 + 1; return _pad(y, 4) + '-' + _pad(mo, 2); } + case 'week': { const d = new Date(n); const dow = (d.getUTCDay() + 6) % 7; const thu = n - dow * 86400000 + 3 * 86400000; const ty = new Date(thu).getUTCFullYear(); const w = Math.round((n - dow * 86400000 - _isoWeek1Monday(ty)) / 604800000) + 1; return _pad(ty, 4) + '-W' + _pad(w, 2); } + case 'time': { n = ((n % 86400000) + 86400000) % 86400000; const ms = n % 1000; n = Math.floor(n / 1000); const s = n % 60; n = Math.floor(n / 60); const mi = n % 60; const h = Math.floor(n / 60); let str = _pad(h, 2) + ':' + _pad(mi, 2); if (s || ms) { str += ':' + _pad(s, 2); if (ms) str += '.' + _pad(ms, 3); } return str; } + case 'datetime-local': { const dt = new Date(n); let str = _pad(dt.getUTCFullYear(), 4) + '-' + _pad(dt.getUTCMonth() + 1, 2) + '-' + _pad(dt.getUTCDate(), 2) + 'T' + _pad(dt.getUTCHours(), 2) + ':' + _pad(dt.getUTCMinutes(), 2); const s = dt.getUTCSeconds(), ms = dt.getUTCMilliseconds(); if (s || ms) { str += ':' + _pad(s, 2); if (ms) str += '.' + _pad(ms, 3); } return str; } + } + return String(n); +} + class Element extends Node { constructor(nid) { super(nid); @@ -822,6 +920,14 @@ class Element extends Node { if (rest === "") return true; return this.matches(rest); } + // :modal is a JS-observable dialog state (a dialog opened via showModal()), + // not understood by the native selector engine; handle it like :popover-open. + if (typeof s === "string" && s.indexOf(":modal") !== -1) { + if (this._dialogModal !== true) return false; + const rest = s.replace(/:modal/g, "").trim(); + if (rest === "") return true; + return this.matches(rest); + } const parent = this.parentNode; if (!parent || !parent.querySelectorAll) return false; const matches = parent.querySelectorAll(s); @@ -1022,6 +1128,65 @@ class Element extends Node { setTimeout(() => { try { target.dispatchEvent(new ToggleEvent("toggle", { oldState: "open", newState: "closed" })); } catch (e) {} }, 0); } } + // HTMLDialogElement members (live on Element.prototype like popover/input; + // meaningful only when localName === 'dialog'). Modal top-layer/focus/render + // is layout (out of scope); the open state, returnValue, and beforetoggle/ + // toggle/close/cancel events are JS-observable and implemented here. + get open() { return this.hasAttribute('open'); } + set open(v) { if (v) { if (!this.hasAttribute('open')) this.setAttribute('open', ''); } else if (this.hasAttribute('open')) { this.removeAttribute('open'); this._dialogModal = false; } } + get returnValue() { return this._returnValue != null ? this._returnValue : ''; } + set returnValue(v) { this._returnValue = String(v); } + get oncancel() { return this._oncancel || null; } + set oncancel(f) { this._oncancel = typeof f === 'function' ? f : null; } + get onclose() { return this._onclose || null; } + set onclose(f) { this._onclose = typeof f === 'function' ? f : null; } + get closedBy() { const v = (this.getAttribute('closedby') || '').toLowerCase(); return (v === 'any' || v === 'closerequest' || v === 'none') ? v : 'auto'; } + set closedBy(v) { this.setAttribute('closedby', String(v)); } + show() { + if (this.hasAttribute('open')) { if (this._dialogModal) throw new DOMException("The dialog is already open as a modal dialog.", "InvalidStateError"); return; } + const before = new ToggleEvent("beforetoggle", { cancelable: true, oldState: "closed", newState: "open" }); + if (!this.dispatchEvent(before)) return; + if (this.hasAttribute('open')) return; + this.setAttribute('open', ''); this._dialogModal = false; + const self = this; setTimeout(() => { try { self.dispatchEvent(new ToggleEvent("toggle", { oldState: "closed", newState: "open" })); } catch (e) {} }, 0); + } + showModal() { + if (this.hasAttribute('open')) throw new DOMException("The dialog is already open.", "InvalidStateError"); + if (!this.isConnected) throw new DOMException("The dialog is not connected to a document.", "InvalidStateError"); + const before = new ToggleEvent("beforetoggle", { cancelable: true, oldState: "closed", newState: "open" }); + if (!this.dispatchEvent(before)) return; + if (this.hasAttribute('open')) return; + this.setAttribute('open', ''); this._dialogModal = true; + const self = this; setTimeout(() => { try { self.dispatchEvent(new ToggleEvent("toggle", { oldState: "closed", newState: "open" })); } catch (e) {} }, 0); + } + _dialogClose(result, fireClose) { + if (!this.hasAttribute('open')) return; + this.dispatchEvent(new ToggleEvent("beforetoggle", { oldState: "open", newState: "closed" })); + this.removeAttribute('open'); this._dialogModal = false; + if (result !== undefined) this._returnValue = String(result); + const self = this; + setTimeout(() => { try { self.dispatchEvent(new ToggleEvent("toggle", { oldState: "open", newState: "closed" })); } catch (e) {} }, 0); + if (fireClose) setTimeout(() => { try { self.dispatchEvent(new Event('close', { bubbles: false, cancelable: false })); } catch (e) {} }, 0); + } + close(result) { this._dialogClose(result, true); } + requestClose(result) { + if (!this.hasAttribute('open')) return; + if (this._dialogCancelFiring) return; // no re-entrant cancel + this._dialogCancelFiring = true; + let canceled = false; + try { const ev = new Event('cancel', { bubbles: false, cancelable: true }); this.dispatchEvent(ev); canceled = ev.defaultPrevented; } + finally { this._dialogCancelFiring = false; } + if (canceled) return; + this._dialogClose(result, true); + } + attachInternals() { + const reg = (typeof customElements !== 'undefined' && customElements._registry) ? customElements._registry : null; + if (!reg || !reg.get(this.localName)) throw new DOMException("Failed to execute 'attachInternals' on 'HTMLElement': Unable to attach ElementInternals to non-custom elements.", "NotSupportedError"); + if (this.getAttribute('is')) throw new DOMException("Failed to execute 'attachInternals' on 'HTMLElement': Unable to attach ElementInternals to a customized built-in element.", "NotSupportedError"); + if (this._internalsAttached) throw new DOMException("Failed to execute 'attachInternals' on 'HTMLElement': ElementInternals for the specified element was already attached.", "NotSupportedError"); + this._internalsAttached = true; + return new ElementInternals(this); + } get value() { const tag = this.localName; if (tag === 'select') { @@ -1065,6 +1230,78 @@ class Element extends Node { this.textContent = String(v); } } + get min() { return this.getAttribute('min') || ''; } + set min(v) { this.setAttribute('min', v); } + get max() { return this.getAttribute('max') || ''; } + set max(v) { this.setAttribute('max', v); } + get step() { return this.getAttribute('step') || ''; } + set step(v) { this.setAttribute('step', v); } + _inputType() { return this.localName === 'input' ? (this.getAttribute('type') || 'text').toLowerCase() : ''; } + get valueAsNumber() { + const t = this._inputType(); + if (!_INPUT_NUM_TYPES[t]) return NaN; + if (t === 'range') { + let minN = _inputParseNumber('range', this.getAttribute('min')); if (isNaN(minN)) minN = 0; + let maxN = _inputParseNumber('range', this.getAttribute('max')); if (isNaN(maxN)) maxN = 100; + if (maxN < minN) maxN = minN; + const v = _inputParseNumber('range', this.value); + let n = isNaN(v) ? (minN + (maxN - minN) / 2) : v; + if (n < minN) n = minN; if (n > maxN) n = maxN; + return n; + } + return _inputParseNumber(t, this.value); + } + set valueAsNumber(n) { + const t = this._inputType(); + if (!_INPUT_NUM_TYPES[t]) throw new DOMException("Failed to set the 'valueAsNumber' property on 'HTMLInputElement': This input element does not support Number values.", 'InvalidStateError'); + n = Number(n); + if (isNaN(n)) { this.value = ''; return; } + if (!isFinite(n)) throw new TypeError("Failed to set the 'valueAsNumber' property on 'HTMLInputElement': The value provided is infinite."); + this.value = _inputFormatNumber(t, n); + } + get valueAsDate() { + const t = this._inputType(); + if (!_INPUT_DATE_TYPES[t]) return null; + const n = _inputParseNumber(t, this.value); + if (isNaN(n)) return null; + if (t === 'month') { const y = 1970 + Math.floor(n / 12); const mo = ((n % 12) + 12) % 12; return new Date(Date.UTC(y, mo, 1)); } + return new Date(n); + } + set valueAsDate(d) { + const t = this._inputType(); + if (!_INPUT_DATE_TYPES[t]) throw new DOMException("Failed to set the 'valueAsDate' property on 'HTMLInputElement': This input element does not support Date values.", 'InvalidStateError'); + if (d === null) { this.value = ''; return; } + if (!(d instanceof Date)) throw new TypeError("Failed to set the 'valueAsDate' property on 'HTMLInputElement': The provided value is not a Date."); + const ms = d.getTime(); + if (isNaN(ms)) { this.value = ''; return; } + if (t === 'month') { this.value = _inputFormatNumber('month', (d.getUTCFullYear() - 1970) * 12 + d.getUTCMonth()); return; } + this.value = _inputFormatNumber(t, ms); + } + stepUp(n) { this._stepBy(n === undefined ? 1 : (n | 0)); } + stepDown(n) { this._stepBy(-(n === undefined ? 1 : (n | 0))); } + _stepBy(delta) { + const t = this._inputType(); + const stepAttr = this.getAttribute('step'); + if (!_INPUT_STEP_SCALE[t] || (stepAttr && stepAttr.trim().toLowerCase() === 'any')) { + throw new DOMException("Failed to execute 'stepUp' on 'HTMLInputElement': This form element does not have allowed value steps.", 'InvalidStateError'); + } + const scale = _INPUT_STEP_SCALE[t]; + let stepN = _INPUT_STEP_DEFAULT[t]; + if (stepAttr) { const s = Number(stepAttr); if (isFinite(s) && s > 0) stepN = s; } + const allowed = stepN * scale; + const minN = _inputParseNumber(t, this.getAttribute('min')); + const maxN = _inputParseNumber(t, this.getAttribute('max')); + const stepBase = isNaN(minN) ? 0 : minN; + let value = this.valueAsNumber; + if (isNaN(value)) value = isNaN(minN) ? 0 : minN; + value += delta * allowed; + value = stepBase + Math.round((value - stepBase) / allowed) * allowed; + const effMin = (t === 'range' && isNaN(minN)) ? 0 : minN; + const effMax = (t === 'range' && isNaN(maxN)) ? 100 : maxN; + if (!isNaN(effMin) && value < effMin) value = effMin; + if (!isNaN(effMax) && value > effMax) value = effMax; + this.value = _inputFormatNumber(t, value); + } get checked() { if (_formChecked[this._nid] !== undefined) return _formChecked[this._nid]; return this.hasAttribute("checked"); @@ -1092,6 +1329,8 @@ class Element extends Node { if (ln === 'a' || ln === 'area') { const raw = this.getAttribute('href'); if (raw === null) return ''; + // Legacy-charset document: href must reflect the encoding-override query. + if (!_docIsUtf8()) { const u = _elemHrefURL(this); return u ? u.href : raw; } const r = _urlResolveOp(raw, _anchorBase()); return r !== null ? r : raw; } @@ -1386,6 +1625,105 @@ function _convertNodes(nodes) { return out; } +// ---- Reflected IDL attributes (WHATWG) --------------------------------------- +// Installed ONCE on Element.prototype as shared getter/setter pairs. This is +// data-driven so there is no per-element defineProperty: element creation and +// the querySelector/mutation hot paths are unaffected (each access is a normal +// prototype getter that reads the backing attribute). Covers the global content +// attributes reflected on every element plus the ARIAMixin (aria-* + ariaXxx). +(function installElementReflectors() { + const P = Element.prototype; + const def = (name, get, set) => { + if (Object.prototype.hasOwnProperty.call(P, name)) return; // never clobber an existing member + Object.defineProperty(P, name, { get, set, enumerable: true, configurable: true }); + }; + // WHATWG "rules for parsing integers"; returns a JS number or null on failure. + const parseIntAttr = (s) => { + if (s === null || s === undefined) return null; + const m = /^[ \t\n\f\r]*([+-]?[0-9]+)/.exec(String(s)); + if (!m) return null; + const n = parseInt(m[1], 10); + return Number.isFinite(n) ? n : null; + }; + // IDL `long` conversion (ToInt32): finite, truncated, wrapped to 32-bit signed. + const toLong = (v) => { + let n = Number(v); + if (!Number.isFinite(n)) n = 0; + n = Math.trunc(n) % 4294967296; + if (n >= 2147483648) n -= 4294967296; + else if (n < -2147483648) n += 4294967296; + return n; + }; + // DOMString reflect: get -> attribute or ""; set -> setAttribute(String(v)). + const reflectStr = (name, attr) => def(name, + function () { const v = this.getAttribute(attr); return v === null ? "" : v; }, + function (v) { this.setAttribute(attr, String(v)); }); + // boolean reflect: get -> hasAttribute; set -> truthy ? add("") : remove. + const reflectBool = (name, attr) => def(name, + function () { return this.hasAttribute(attr); }, + function (v) { if (v) this.setAttribute(attr, ""); else this.removeAttribute(attr); }); + // long reflect: get -> parse else default (static value or per-element fn); + // set -> setAttribute(String(ToInt32(v))). + const reflectLong = (name, attr, dflt) => def(name, + function () { + const r = parseIntAttr(this.getAttribute(attr)); + if (r !== null && r >= -2147483648 && r <= 2147483647) return r; + return typeof dflt === "function" ? dflt.call(this) : dflt; + }, + function (v) { this.setAttribute(attr, String(toLong(v))); }); + // enumerated reflect: get -> canonical (lowercased) keyword, else missing/ + // invalid default; set -> setAttribute(String(v)) (canonicalization on get). + const reflectEnum = (name, attr, keywords, missingDefault, invalidDefault) => def(name, + function () { + const v = this.getAttribute(attr); + if (v === null) return missingDefault; + const lc = String(v).toLowerCase(); + return keywords.indexOf(lc) !== -1 ? lc : invalidDefault; + }, + function (v) { this.setAttribute(attr, String(v)); }); + // nullable DOMString reflect (ARIA): get -> attribute or null; set -> null/ + // undefined removes, else setAttribute(String(v)). + const reflectNullable = (name, attr) => def(name, + function () { return this.getAttribute(attr); }, + function (v) { if (v === null || v === undefined) this.removeAttribute(attr); else this.setAttribute(attr, String(v)); }); + + // Global content attributes reflected on every element (HTML "global attributes"). + reflectStr("title", "title"); + reflectStr("lang", "lang"); + reflectStr("accessKey", "accesskey"); + reflectStr("slot", "slot"); + reflectEnum("dir", "dir", ["ltr", "rtl", "auto"], "", ""); + reflectBool("autofocus", "autofocus"); + reflectBool("hidden", "hidden"); + // tabIndex default is element-dependent (0 for natively-focusable, else -1); + // reflection.js does not assert it, but match the common case anyway. + reflectLong("tabIndex", "tabindex", function () { + const ln = this.localName; + if (ln === "a" || ln === "area" || ln === "link") return this.hasAttribute("href") ? 0 : -1; + return (ln === "button" || ln === "input" || ln === "select" || ln === "textarea" || ln === "iframe") ? 0 : -1; + }); + + // ARIAMixin: aria-* content attributes reflected as nullable DOMString IDL + // properties (ariaAtomic <-> aria-atomic, ...). + const ARIA = { + ariaAtomic: "aria-atomic", ariaAutoComplete: "aria-autocomplete", ariaBrailleLabel: "aria-braillelabel", + ariaBrailleRoleDescription: "aria-brailleroledescription", ariaBusy: "aria-busy", ariaChecked: "aria-checked", + ariaColCount: "aria-colcount", ariaColIndex: "aria-colindex", ariaColIndexText: "aria-colindextext", + ariaColSpan: "aria-colspan", ariaCurrent: "aria-current", ariaDescription: "aria-description", + ariaDisabled: "aria-disabled", ariaExpanded: "aria-expanded", ariaHasPopup: "aria-haspopup", + ariaHidden: "aria-hidden", ariaInvalid: "aria-invalid", ariaKeyShortcuts: "aria-keyshortcuts", + ariaLabel: "aria-label", ariaLevel: "aria-level", ariaLive: "aria-live", ariaModal: "aria-modal", + ariaMultiLine: "aria-multiline", ariaMultiSelectable: "aria-multiselectable", ariaOrientation: "aria-orientation", + ariaPlaceholder: "aria-placeholder", ariaPosInSet: "aria-posinset", ariaPressed: "aria-pressed", + ariaReadOnly: "aria-readonly", ariaRelevant: "aria-relevant", ariaRequired: "aria-required", + ariaRoleDescription: "aria-roledescription", ariaRowCount: "aria-rowcount", ariaRowIndex: "aria-rowindex", + ariaRowIndexText: "aria-rowindextext", ariaRowSpan: "aria-rowspan", ariaSelected: "aria-selected", + ariaSetSize: "aria-setsize", ariaSort: "aria-sort", ariaValueMax: "aria-valuemax", + ariaValueMin: "aria-valuemin", ariaValueNow: "aria-valuenow", ariaValueText: "aria-valuetext", + }; + for (const prop in ARIA) reflectNullable(prop, ARIA[prop]); +})(); + class Document extends Node { get documentElement() { return _wrapEl(+_dom("document_element")); } get head() { return this.querySelector("head"); } @@ -1411,7 +1749,13 @@ class Document extends Node { get nodeName() { return "#document"; } get ownerDocument() { return null; } // Document has no ownerDocument get compatMode() { return "CSS1Compat"; } - get characterSet() { return "UTF-8"; } + // The document's character encoding, detected from the response charset + // (HTTP Content-Type -> <meta charset>). characterSet/charset/inputEncoding + // are WHATWG aliases. A node-less document (DOMParser/createDocument) has no + // backing encoding and reports UTF-8. + get characterSet() { return (this._nid === undefined || this._nid === null) ? "UTF-8" : _docEncoding(); } + get charset() { return this.characterSet; } + get inputEncoding() { return this.characterSet; } get contentType() { // An explicit type set by DOMParser/createDocument wins. if (this._contentType) return this._contentType; @@ -1642,7 +1986,7 @@ class Document extends Node { createNodeIterator(root, whatToShow, filter) { return this.createTreeWalker(root, whatToShow, filter); } - getSelection() { return globalThis.getSelection(); } + getSelection() { return this.defaultView ? _selectionFor(this) : null; } get activeElement() { return globalThis.__obscura_focused || this.body; } get implementation() { const ownerDoc = this; @@ -2495,6 +2839,23 @@ if (typeof Request === 'undefined') { }; } +// Decode a response body honoring the Content-Type charset, so fetch()/XHR +// over non-UTF-8 resources (GBK, Shift_JIS, ISO-8859-x, ...) return correctly +// decoded text instead of mojibake. The UTF-8 case (the overwhelming majority) +// takes the plain TextDecoder fast path; only an explicit non-UTF-8 charset +// routes through TextDecoder(label), which falls back to UTF-8 on a bad label. +function _decodeBodyWithCharset(bytes, headers) { + let label = ''; + try { + const ct = headers && typeof headers.get === 'function' ? (headers.get('content-type') || '') : ''; + const m = /charset\s*=\s*"?([^";]+)"?/i.exec(ct); + if (m) label = m[1].trim(); + } catch (e) {} + if (!label || /^utf-?8$/i.test(label)) return new TextDecoder().decode(bytes); + try { return new TextDecoder(label).decode(bytes); } + catch (e) { return new TextDecoder().decode(bytes); } +} + if (typeof Response === 'undefined') { globalThis.Response = class Response { constructor(body, init = {}) { @@ -2503,7 +2864,7 @@ if (typeof Response === 'undefined') { this.headers = new Headers(init.headers); this.type = init.type || 'basic'; this.url = init.url || ''; this.redirected = !!init.redirected; } - async text() { return new TextDecoder().decode(this._bodyBytes); } + async text() { return _decodeBodyWithCharset(this._bodyBytes, this.headers); } async json() { return JSON.parse(await this.text()); } async arrayBuffer() { return _arrayBufferFromBytes(this._bodyBytes); } async blob() { return new Blob([this._bodyBytes]); } @@ -2629,23 +2990,52 @@ if (typeof TextEncoder === 'undefined') { encodeInto(str, dest) { const enc = this.encode(str); dest.set(enc.slice(0, dest.length)); return { read: str.length, written: Math.min(enc.length, dest.length) }; } }; } +// Fast pure-JS UTF-8 decode (the common case: Response/Blob .text(), most +// pages). Avoids the op + JSON round trip for plain UTF-8. +function _utf8DecodeBytes(bytes, start) { + let str = '', i = start | 0; + const n = bytes.length; + while (i < n) { + let c = bytes[i++]; + if (c < 0x80) str += String.fromCharCode(c); + else if (c < 0xE0) str += String.fromCharCode(((c & 0x1F) << 6) | (bytes[i++] & 0x3F)); + else if (c < 0xF0) { const b1 = bytes[i++], b2 = bytes[i++]; str += String.fromCharCode(((c & 0x0F) << 12) | ((b1 & 0x3F) << 6) | (b2 & 0x3F)); } + else { const b1 = bytes[i++], b2 = bytes[i++], b3 = bytes[i++]; const cp = ((c & 0x07) << 18) | ((b1 & 0x3F) << 12) | ((b2 & 0x3F) << 6) | (b3 & 0x3F); if (cp > 0xFFFF) { const s = cp - 0x10000; str += String.fromCharCode(0xD800 + (s >> 10), 0xDC00 + (s & 0x3FF)); } else str += String.fromCharCode(cp); } + } + return str; +} if (typeof TextDecoder === 'undefined') { globalThis.TextDecoder = class TextDecoder { - constructor(label) { this.encoding = label || 'utf-8'; } - decode(buf) { - if (!buf) return ''; - const bytes = ArrayBuffer.isView(buf) - ? new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength) - : new Uint8Array(buf); - let str = '', i = 0; - while (i < bytes.length) { - let c = bytes[i++]; - if (c < 0x80) str += String.fromCharCode(c); - else if (c < 0xE0) str += String.fromCharCode(((c&0x1F)<<6)|(bytes[i++]&0x3F)); - else if (c < 0xF0) { const b1=bytes[i++], b2=bytes[i++]; str += String.fromCharCode(((c&0x0F)<<12)|((b1&0x3F)<<6)|(b2&0x3F)); } - else { const b1=bytes[i++], b2=bytes[i++], b3=bytes[i++]; const cp=((c&0x07)<<18)|((b1&0x3F)<<12)|((b2&0x3F)<<6)|(b3&0x3F); if(cp>0xFFFF){const s=cp-0x10000;str+=String.fromCharCode(0xD800+(s>>10),0xDC00+(s&0x3FF));}else str+=String.fromCharCode(cp); } + constructor(label, options) { + // No-arg construction (Response.text()/Blob.text() and most pages) is + // UTF-8; skip the label-validation op on that hot path. + let name; + if (label === undefined) { + name = 'utf-8'; + } else { + name = Deno.core.ops.op_encoding_for_label(String(label)); + if (!name) throw new RangeError("Failed to construct 'TextDecoder': The encoding label provided ('" + label + "') is invalid."); } - return str; + const o = options || {}; + Object.defineProperty(this, 'encoding', { value: name, enumerable: true }); + Object.defineProperty(this, 'fatal', { value: !!o.fatal, enumerable: true }); + Object.defineProperty(this, 'ignoreBOM', { value: !!o.ignoreBOM, enumerable: true }); + } + decode(input, options) { + if (input === undefined) return ''; + const bytes = ArrayBuffer.isView(input) + ? new Uint8Array(input.buffer, input.byteOffset, input.byteLength) + : new Uint8Array(input); + // Fast path: plain UTF-8, non-fatal (Response/Blob text, most pages). + if (this.encoding === 'utf-8' && !this.fatal) { + let off = 0; + if (!this.ignoreBOM && bytes.length >= 3 && bytes[0] === 0xEF && bytes[1] === 0xBB && bytes[2] === 0xBF) off = 3; + return _utf8DecodeBytes(bytes, off); + } + // Legacy encodings / fatal mode: encoding_rs via the op. + const r = JSON.parse(Deno.core.ops.op_text_decode(this.encoding, bytes, this.fatal, this.ignoreBOM)); + if (!r.ok) throw new TypeError("Failed to execute 'decode' on 'TextDecoder': The encoded data was not valid."); + return r.v; } }; } @@ -2736,22 +3126,16 @@ globalThis.getComputedStyle = (el) => { }, }); }; +// Returns the one Selection instance for a document (cached on the document), +// so window.getSelection() === document.getSelection(). The real Selection +// class is defined below, after Range. _selectionFor is hoisted. +function _selectionFor(doc) { + if (!doc) return null; + if (!doc._selection) doc._selection = new Selection(doc); + return doc._selection; +} globalThis.getSelection = _markNative(function getSelection() { - return { - rangeCount: 0, - anchorNode: null, anchorOffset: 0, - focusNode: null, focusOffset: 0, - isCollapsed: true, type: 'None', - removeAllRanges() { this.rangeCount = 0; }, - addRange(range) { this.rangeCount = 1; this._range = range; }, - getRangeAt(i) { return this._range || null; }, - collapse(node, offset) { this.anchorNode = node; this.anchorOffset = offset || 0; this.isCollapsed = true; }, - extend(node, offset) { this.focusNode = node; this.focusOffset = offset || 0; }, - selectAllChildren(node) {}, - deleteFromDocument() {}, - containsNode(node) { return false; }, - toString() { return ''; }, - }; + return _selectionFor(globalThis.document); }); globalThis.CSSStyleSheet = class CSSStyleSheet { @@ -2879,12 +3263,35 @@ globalThis.__notifyMutation = function(type, target_nid, addedNodes, removedNode }; globalThis.ShadowRoot = class ShadowRoot extends DocumentFragment {}; +// Constructible-stylesheet adoption, mirroring Document.adoptedStyleSheets. +Object.defineProperty(globalThis.ShadowRoot.prototype, 'adoptedStyleSheets', { + get() { return this._adoptedStyleSheets || []; }, + set(sheets) { this._adoptedStyleSheets = sheets; }, + configurable: true, +}); globalThis.__obscura_shadowHostNames = new Set(['article','aside','blockquote','body','div','footer','h1','h2','h3','h4','h5','h6','header','main','nav','p','section','span']); -globalThis.customElements = { - _registry: new Map(), - _whenDefinedResolvers: new Map(), +function _isConstructorCE(v) { + if (typeof v !== 'function') return false; + try { Reflect.construct(function () {}, [], v); return true; } catch (e) { return false; } +} +const _CE_RESERVED = new Set(['annotation-xml', 'color-profile', 'font-face', 'font-face-src', 'font-face-uri', 'font-face-format', 'font-face-name', 'missing-glyph']); +function _isValidCustomElementName(name) { + if (typeof name !== 'string' || _CE_RESERVED.has(name)) return false; + // PotentialCustomElementName (approx): lowercase start, a hyphen, no uppercase. + return /^[a-z][a-z0-9._·À-￿-]*-[a-z0-9._·À-￿-]*$/.test(name); +} +class CustomElementRegistry { + constructor() { this._registry = new Map(); this._byCtor = new Map(); this._whenDefinedResolvers = new Map(); this._defining = false; } define(name, cls, opts) { - if (this._registry.has(name)) return; + if (!_isConstructorCE(cls)) throw new TypeError("Failed to execute 'define' on 'CustomElementRegistry': parameter 2 is not a constructor."); + if (!_isValidCustomElementName(name)) throw new DOMException("Failed to execute 'define' on 'CustomElementRegistry': \"" + name + "\" is not a valid custom element name", "SyntaxError"); + if (this._defining) throw new DOMException("Failed to execute 'define' on 'CustomElementRegistry': operation is not supported while a definition is in progress", "NotSupportedError"); + if (this._registry.has(name)) throw new DOMException("Failed to execute 'define' on 'CustomElementRegistry': the name \"" + name + "\" has already been used with this registry", "NotSupportedError"); + if (this._byCtor.has(cls)) throw new DOMException("Failed to execute 'define' on 'CustomElementRegistry': the constructor has already been used with this registry", "NotSupportedError"); + this._defining = true; + try { this._byCtor.set(cls, name); this._defineInner(name, cls, opts); } finally { this._defining = false; } + } + _defineInner(name, cls, opts) { this._registry.set(name, cls); // Upgrade existing matching elements: instantiate the class on each, // fire connectedCallback if the element is in the document. Without @@ -2900,7 +3307,7 @@ globalThis.customElements = { for (const r of resolvers) r(cls); this._whenDefinedResolvers.delete(name); } - }, + } _upgradeElement(el, cls) { if (el.__customUpgraded) return; el.__customUpgraded = true; @@ -2924,9 +3331,14 @@ globalThis.customElements = { try { el.connectedCallback(); } catch (e) {} } } catch (e) {} - }, - get(name) { return this._registry.get(name); }, + } + get(name) { return this._registry.get(name); } + getName(cls) { + if (!_isConstructorCE(cls)) throw new TypeError("Failed to execute 'getName' on 'CustomElementRegistry': parameter 1 is not a constructor."); + return this._byCtor.has(cls) ? this._byCtor.get(cls) : null; + } whenDefined(name) { + if (!_isValidCustomElementName(name)) return Promise.reject(new DOMException("Failed to execute 'whenDefined' on 'CustomElementRegistry': \"" + name + "\" is not a valid custom element name", "SyntaxError")); const cls = this._registry.get(name); if (cls) return Promise.resolve(cls); return new Promise((resolve) => { @@ -2934,14 +3346,41 @@ globalThis.customElements = { list.push(resolve); this._whenDefinedResolvers.set(name, list); }); - }, + } upgrade(root) { if (!root || !root.querySelectorAll) return; for (const [name, cls] of this._registry.entries()) { const matches = root.querySelectorAll(name); for (const el of matches) this._upgradeElement(el, cls); } - }, + } +} +globalThis.CustomElementRegistry = CustomElementRegistry; +globalThis.customElements = new CustomElementRegistry(); +globalThis.HTMLUnknownElement = Element; +// ElementInternals: form-associated custom element internals. Validity/state +// are JS-observable; ARIA reflection that needs the accessibility tree is not. +globalThis.ElementInternals = class ElementInternals { + constructor(el) { this._el = el; this._valid = true; this._flags = {}; this._message = ''; this._value = null; this._states = new Set(); } + setFormValue(value, state) { this._value = value; } + setValidity(flags, message, anchor) { + flags = flags || {}; + const bad = Object.keys(flags).some((k) => k !== 'valid' && flags[k]); + if (bad && (message == null || message === '')) throw new TypeError("Failed to execute 'setValidity' on 'ElementInternals': The second argument should not be empty if one or more flags in the first argument are true."); + this._flags = flags; this._valid = !bad; this._message = bad ? String(message) : ''; + } + checkValidity() { return this._valid; } + reportValidity() { return this._valid; } + get validity() { + const f = this._flags || {}; + return { valid: this._valid, valueMissing: !!f.valueMissing, typeMismatch: !!f.typeMismatch, patternMismatch: !!f.patternMismatch, tooLong: !!f.tooLong, tooShort: !!f.tooShort, rangeUnderflow: !!f.rangeUnderflow, rangeOverflow: !!f.rangeOverflow, stepMismatch: !!f.stepMismatch, badInput: !!f.badInput, customError: !!f.customError }; + } + get validationMessage() { return this._message || ''; } + get willValidate() { return true; } + get form() { return this._el && this._el.closest ? this._el.closest('form') : null; } + get labels() { return _nodeList([]); } + get shadowRoot() { return (this._el && this._el._shadowRoot) || null; } + get states() { return this._states; } }; globalThis.NodeFilter = { SHOW_ELEMENT: 1, SHOW_TEXT: 4, SHOW_ALL: 0xFFFFFFFF }; // ResizeObserver is defined earlier with real per-target firing; the stub @@ -3514,15 +3953,36 @@ globalThis.crypto = globalThis.crypto || { getRandomValues(arr) { for(let i=0;i< globalThis.structuredClone = globalThis.structuredClone || ((v) => JSON.parse(JSON.stringify(v))); globalThis.reportError = globalThis.reportError || ((e) => console.error(e)); +// WHATWG Storage as a legacy platform object: a Proxy routes property access +// (localStorage.foo, localStorage["foo"], delete, `in`, Object.keys) through +// the named getter/setter so length/key()/iteration stay in sync with the +// backing map. Plain prototype methods alone could not intercept direct +// property access, so `localStorage.foo = x` never updated length before. globalThis.Storage = function Storage() {}; -Storage.prototype.getItem = function(k) { return (this._data && this._data[k]) ?? null; }; -Storage.prototype.setItem = function(k, v) { if (this._data) this._data[k] = String(v); }; -Storage.prototype.removeItem = function(k) { if (this._data) delete this._data[k]; }; -Storage.prototype.clear = function() { if (this._data) for (var k in this._data) delete this._data[k]; }; -Object.defineProperty(Storage.prototype, 'length', { get: function() { return this._data ? Object.keys(this._data).length : 0; } }); -Storage.prototype.key = function(i) { return this._data ? Object.keys(this._data)[i] ?? null : null; }; +Storage.prototype.getItem = function(k) { k = String(k); return Object.prototype.hasOwnProperty.call(this._data, k) ? this._data[k] : null; }; +Storage.prototype.setItem = function(k, v) { this._data[String(k)] = String(v); }; +Storage.prototype.removeItem = function(k) { delete this._data[String(k)]; }; +Storage.prototype.clear = function() { const d = this._data; for (const k in d) delete d[k]; }; +Storage.prototype.key = function(i) { const ks = Object.keys(this._data); i = i >>> 0; return i < ks.length ? ks[i] : null; }; +Object.defineProperty(Storage.prototype, 'length', { get: function() { return Object.keys(this._data).length; }, configurable: true }); -const _mkStore = () => { var s = Object.create(Storage.prototype); s._data = {}; return s; }; +const _mkStore = () => { + const target = Object.create(Storage.prototype); + Object.defineProperty(target, '_data', { value: Object.create(null), writable: true, enumerable: false, configurable: true }); + const isReal = (p) => p === '_data' || p === 'constructor' || (p in Storage.prototype); + return new Proxy(target, { + get(t, p, recv) { if (typeof p === 'symbol' || isReal(p)) return Reflect.get(t, p, recv); const v = t.getItem(p); return v === null ? undefined : v; }, + set(t, p, v, recv) { if (typeof p === 'symbol' || isReal(p)) return Reflect.set(t, p, v, recv); t.setItem(p, v); return true; }, + has(t, p) { if (typeof p === 'symbol' || isReal(p)) return true; return Object.prototype.hasOwnProperty.call(t._data, p); }, + deleteProperty(t, p) { if (typeof p === 'symbol' || isReal(p)) return Reflect.deleteProperty(t, p); t.removeItem(p); return true; }, + ownKeys(t) { return Object.keys(t._data); }, + getOwnPropertyDescriptor(t, p) { + if (typeof p !== 'symbol' && Object.prototype.hasOwnProperty.call(t._data, p)) + return { value: t._data[p], writable: true, enumerable: true, configurable: true }; + return Reflect.getOwnPropertyDescriptor(t, p); + }, + }); +}; globalThis.localStorage = _mkStore(); globalThis.sessionStorage = _mkStore(); @@ -3835,15 +4295,25 @@ globalThis.Range = class Range { return _rngCmp(n, o, this._sc, this._so) >= 0 && _rngCmp(n, o, this._ec, this._eo) <= 0; } compareBoundaryPoints(how, other) { + // `how` is a WebIDL `unsigned short`: ToUint16-convert before validating, + // so NaN/Infinity become 0 (START_TO_START) rather than throwing. + let h = Math.trunc(Number(how)); + if (!Number.isFinite(h)) h = 0; + h = ((h % 65536) + 65536) % 65536; let a, b; - switch (how) { + switch (h) { case 0: a = [this._sc, this._so]; b = [other._sc, other._so]; break; // START_TO_START case 1: a = [this._ec, this._eo]; b = [other._sc, other._so]; break; // START_TO_END case 2: a = [this._ec, this._eo]; b = [other._ec, other._eo]; break; // END_TO_END case 3: a = [this._sc, this._so]; b = [other._ec, other._eo]; break; // END_TO_START default: throw new DOMException("invalid comparison type", "NotSupportedError"); } - if (_rngRoot(a[0])._nid !== _rngRoot(b[0])._nid) throw new DOMException("ranges are in different trees", "WrongDocumentError"); + // Different roots -> WrongDocumentError. Guard so a null/foreign container + // raises that DOMException rather than a raw TypeError from _rngRoot. + let differ; + try { differ = _rngRoot(a[0])._nid !== _rngRoot(b[0])._nid; } + catch (e) { differ = true; } + if (differ) throw new DOMException("The two Ranges are not in the same tree.", "WrongDocumentError"); return _rngCmp(a[0], a[1], b[0], b[1]); } intersectsNode(n) { @@ -3854,6 +4324,14 @@ globalThis.Range = class Range { return _rngCmp(p, o, this._ec, this._eo) < 0 && _rngCmp(p, o + 1, this._sc, this._so) > 0; } cloneRange() { const r = new Range(); r._sc = this._sc; r._so = this._so; r._ec = this._ec; r._eo = this._eo; return r; } + createContextualFragment(html) { + if (arguments.length < 1) throw new TypeError("Failed to execute 'createContextualFragment' on 'Range': 1 argument required, but only 0 present."); + const node = this._sc; + const ownerDoc = (node && node.ownerDocument) || globalThis.document; + const frag = ownerDoc.createDocumentFragment(); + frag.innerHTML = String(html); + return frag; + } toString() { const sc = this._sc, ec = this._ec; if (!sc) return ""; @@ -3906,6 +4384,40 @@ globalThis.StaticRange = class StaticRange { get endOffset() { return this._eo; } get collapsed() { return _rngSame(this._sc, this._ec) && this._so === this._eo; } }; +// Live Selection over the real Range: at most one range + a direction, one +// instance per document. Everything except modify() (needs visual line/word +// layout) is layout-free, built on the Range boundary-point helpers above. +globalThis.Selection = class Selection { + constructor(doc) { this._doc = doc; this._range = null; this._direction = 'none'; } + _setRange(r, dir) { this._range = r; this._direction = dir; } + _inDoc(node) { return !!(node && this._doc && this._doc.contains && this._doc.contains(node)); } + get rangeCount() { return this._range ? 1 : 0; } + get isCollapsed() { return !this._range || this._range.collapsed; } + get type() { return !this._range ? 'None' : (this._range.collapsed ? 'Caret' : 'Range'); } + get _anchor() { const r = this._range; if (!r) return null; return this._direction === 'backwards' ? [r.endContainer, r.endOffset] : [r.startContainer, r.startOffset]; } + get _focus() { const r = this._range; if (!r) return null; return this._direction === 'backwards' ? [r.startContainer, r.startOffset] : [r.endContainer, r.endOffset]; } + get anchorNode() { return this._anchor ? this._anchor[0] : null; } + get anchorOffset() { return this._anchor ? this._anchor[1] : 0; } + get focusNode() { return this._focus ? this._focus[0] : null; } + get focusOffset() { return this._focus ? this._focus[1] : 0; } + getRangeAt(i) { i = +i; if (!this._range || i < 0 || i > 0) throw new DOMException('The index provided is out of range.', 'IndexSizeError'); return this._range; } + addRange(range) { if (this._range) return; if (!(range instanceof Range)) return; if (!this._inDoc(range.startContainer) || !this._inDoc(range.endContainer)) return; this._setRange(range, 'forwards'); } + removeRange(range) { if (!(range instanceof Range)) throw new TypeError("Failed to execute 'removeRange' on 'Selection': parameter 1 is not a Range."); if (this._range === range) this._setRange(null, 'none'); else throw new DOMException('The range was not found.', 'NotFoundError'); } + removeAllRanges() { this._setRange(null, 'none'); } + empty() { this.removeAllRanges(); } + collapse(node, offset) { if (node == null) { this.removeAllRanges(); return; } offset = offset >>> 0; _rngCheckOffset(node, offset); if (!this._inDoc(node)) return; const r = new Range(); r.setStart(node, offset); r.setEnd(node, offset); this._setRange(r, 'forwards'); } + setPosition(node, offset) { this.collapse(node, offset); } + collapseToStart() { if (!this._range) throw new DOMException('There is no selection to collapse.', 'InvalidStateError'); const r = new Range(); r.setStart(this._range.startContainer, this._range.startOffset); r.setEnd(this._range.startContainer, this._range.startOffset); this._setRange(r, 'forwards'); } + collapseToEnd() { if (!this._range) throw new DOMException('There is no selection to collapse.', 'InvalidStateError'); const r = new Range(); r.setStart(this._range.endContainer, this._range.endOffset); r.setEnd(this._range.endContainer, this._range.endOffset); this._setRange(r, 'forwards'); } + extend(node, offset) { if (!this._range) throw new DOMException('There is no selection to extend.', 'InvalidStateError'); if (!this._inDoc(node)) return; offset = offset >>> 0; _rngCheckOffset(node, offset); const a = this._anchor; const r = new Range(); if (_rngRoot(node)._nid !== _rngRoot(a[0])._nid) { r.setStart(node, offset); r.setEnd(node, offset); this._setRange(r, 'forwards'); return; } if (_rngCmp(a[0], a[1], node, offset) <= 0) { r.setStart(a[0], a[1]); r.setEnd(node, offset); this._setRange(r, 'forwards'); } else { r.setStart(node, offset); r.setEnd(a[0], a[1]); this._setRange(r, 'backwards'); } } + setBaseAndExtent(aN, aO, fN, fO) { if (arguments.length < 4) throw new TypeError("Failed to execute 'setBaseAndExtent' on 'Selection': 4 arguments required."); if (aN == null || fN == null) throw new TypeError("Failed to execute 'setBaseAndExtent' on 'Selection': nodes must not be null."); aO = +aO; fO = +fO; if (aO < 0 || aO > _rngNodeLength(aN)) throw new DOMException('anchor offset out of range', 'IndexSizeError'); if (fO < 0 || fO > _rngNodeLength(fN)) throw new DOMException('focus offset out of range', 'IndexSizeError'); if (!this._inDoc(aN) || !this._inDoc(fN)) { this.removeAllRanges(); return; } const r = new Range(); if (_rngCmp(aN, aO, fN, fO) <= 0) { r.setStart(aN, aO); r.setEnd(fN, fO); this._setRange(r, 'forwards'); } else { r.setStart(fN, fO); r.setEnd(aN, aO); this._setRange(r, 'backwards'); } } + selectAllChildren(node) { if (node && node.nodeType === 10) throw new DOMException('cannot selectAllChildren of a DocumentType', 'InvalidNodeTypeError'); if (!this._inDoc(node)) return; const len = _rngNodeLength(node); const r = new Range(); r.setStart(node, 0); r.setEnd(node, len); this._setRange(r, 'forwards'); } + containsNode(node, allowPartial) { const r = this._range; if (!r || !node) return false; if (_rngRoot(node)._nid !== _rngRoot(r.startContainer)._nid) return false; const len = _rngNodeLength(node); if (allowPartial) return _rngCmp(node, len, r.startContainer, r.startOffset) > 0 && _rngCmp(node, 0, r.endContainer, r.endOffset) < 0; return _rngCmp(node, 0, r.startContainer, r.startOffset) >= 0 && _rngCmp(node, len, r.endContainer, r.endOffset) <= 0; } + deleteFromDocument() { if (this._range) this._range.deleteContents(); } + toString() { return this._range ? this._range.toString() : ''; } + modify() {} +}; +_markNative(globalThis.Selection); [ navigator.getBattery, navigator.getGamepads, navigator.sendBeacon, diff --git a/crates/obscura-js/src/ops.rs b/crates/obscura-js/src/ops.rs index efa7546..72581c3 100644 --- a/crates/obscura-js/src/ops.rs +++ b/crates/obscura-js/src/ops.rs @@ -41,6 +41,10 @@ pub struct InterceptedRequest { pub struct ObscuraState { pub dom: Option<DomTree>, pub url: String, + /// WHATWG canonical name of the document's character encoding (e.g. + /// "UTF-8", "EUC-JP"). Backs `document.characterSet` and the URL query + /// encoding override for `<a>`/`<area>` hrefs in legacy-charset documents. + pub encoding: String, pub title: String, pub blocked_urls: Vec<String>, pub cookie_jar: Option<Arc<CookieJar>>, @@ -60,6 +64,7 @@ impl ObscuraState { ObscuraState { dom: None, url: "about:blank".to_string(), + encoding: "UTF-8".to_string(), title: String::new(), blocked_urls: Vec::new(), cookie_jar: None, @@ -89,6 +94,7 @@ fn op_dom(state: &OpState, #[string] cmd: String, #[string] arg1: String, #[stri "document_node_id" => dom.document().index().to_string(), "document_title" => serde_json::to_string(&gs.title).unwrap_or("\"\"".into()), "document_url" => serde_json::to_string(&gs.url).unwrap_or("\"\"".into()), + "document_encoding" => serde_json::to_string(&gs.encoding).unwrap_or("\"UTF-8\"".into()), "document_element" => { for cid in dom.children(dom.document()) { if let Some(n) = dom.get_node(cid) { @@ -1132,6 +1138,38 @@ fn op_url_resolve(#[string] href: &str, #[string] base: &str) -> String { .unwrap_or_default() } +/// Canonical (lowercased) WHATWG name for a TextDecoder label, or "" if the +/// label is unknown (the JS constructor turns "" into a RangeError). +#[op2] +#[string] +fn op_encoding_for_label(#[string] label: &str) -> String { + obscura_net::label_name(label).unwrap_or_default() +} + +/// Decode bytes with a legacy/explicit encoding via encoding_rs. Returns +/// {"ok":true,"v":<string>} or {"ok":false} (unknown label, or a fatal decode +/// error). The UTF-8 non-fatal common case is handled in JS without this op. +#[op2] +#[string] +fn op_text_decode(#[string] label: &str, #[buffer] bytes: &[u8], fatal: bool, ignore_bom: bool) -> String { + match obscura_net::decode_with_label(label, bytes, fatal, ignore_bom) { + Some(s) => serde_json::json!({ "ok": true, "v": s }).to_string(), + None => "{\"ok\":false}".to_string(), + } +} + +/// Re-encode a URL query component using a non-UTF-8 document encoding override +/// (the WHATWG "encoding override"). `query` is the already-UTF-8-decoded query +/// string; `label` the target charset; `special` whether the URL has a special +/// scheme (adds `'` to the percent-encode set). Returns the encoded query, or +/// the input unchanged if the label is unknown. Only called by the JS anchor +/// path when the document is non-UTF-8, so the UTF-8 hot path never reaches it. +#[op2] +#[string] +fn op_url_encode_query(#[string] query: &str, #[string] label: &str, special: bool) -> String { + obscura_net::url_encode_query(query, label, special).unwrap_or_else(|| query.to_string()) +} + pub fn build_extension() -> Extension { Extension { name: "obscura_dom", @@ -1148,6 +1186,9 @@ pub fn build_extension() -> Extension { op_url_parse(), op_url_set(), op_url_resolve(), + op_encoding_for_label(), + op_text_decode(), + op_url_encode_query(), ]), ..Default::default() } diff --git a/crates/obscura-js/src/runtime.rs b/crates/obscura-js/src/runtime.rs index 5e60f6b..efec5d3 100644 --- a/crates/obscura-js/src/runtime.rs +++ b/crates/obscura-js/src/runtime.rs @@ -85,6 +85,13 @@ impl ObscuraJsRuntime { self.state.borrow_mut().url = url.to_string(); } + /// Set the document's character encoding (WHATWG canonical name). Backs + /// `document.characterSet` and the `<a>`/`<area>` URL query encoding + /// override for legacy-charset documents. + pub fn set_encoding(&self, encoding: &str) { + self.state.borrow_mut().encoding = encoding.to_string(); + } + pub fn set_title(&self, title: &str) { self.state.borrow_mut().title = title.to_string(); } diff --git a/crates/obscura-net/src/encoding.rs b/crates/obscura-net/src/encoding.rs index dffe2ce..7590a77 100644 --- a/crates/obscura-net/src/encoding.rs +++ b/crates/obscura-net/src/encoding.rs @@ -13,7 +13,38 @@ //! //! For non-HTML resources (JS, CSS, JSON), only steps 1 and 3 apply. -use encoding_rs::{Encoding, UTF_8}; +use encoding_rs::{DecoderResult, EncoderResult, Encoding, UTF_8}; + +/// WHATWG canonical (lowercased) name for an encoding label, or None if the +/// label is not a known encoding. Backs `TextDecoder`'s label validation and +/// its `.encoding` property. +pub fn label_name(label: &str) -> Option<String> { + Encoding::for_label(label.as_bytes()).map(|e| e.name().to_ascii_lowercase()) +} + +/// Decode `bytes` with an explicit encoding label, with TextDecoder semantics. +/// Returns None when the label is unknown, or (when `fatal`) when the input is +/// not valid in that encoding. Non-fatal decoding replaces errors with U+FFFD. +pub fn decode_with_label(label: &str, bytes: &[u8], fatal: bool, ignore_bom: bool) -> Option<String> { + let enc = Encoding::for_label(label.as_bytes())?; + let mut dec = if ignore_bom { + enc.new_decoder_without_bom_handling() + } else { + enc.new_decoder() + }; + if fatal { + let mut out = String::with_capacity(bytes.len() + 1); + let (res, _) = dec.decode_to_string_without_replacement(bytes, &mut out, true); + match res { + DecoderResult::InputEmpty => Some(out), + _ => None, + } + } else { + let mut out = String::with_capacity(bytes.len() * 2 + 1); + let _ = dec.decode_to_string(bytes, &mut out, true); + Some(out) + } +} /// Decode an HTTP response body. `content_type_header` is the raw header /// value if present (e.g. `text/html; charset=gbk`). For HTML resources, @@ -24,6 +55,98 @@ pub fn decode_response(bytes: &[u8], content_type_header: Option<&str>) -> Strin cow.into_owned() } +/// Like `decode_response`, but also returns the WHATWG canonical name of the +/// encoding that was used (e.g. "EUC-JP", "Shift_JIS", "UTF-8"). Callers use +/// the name to expose `document.characterSet` and to do document-encoding-aware +/// URL query serialization (the WHATWG "encoding override"). +pub fn decode_response_with_name( + bytes: &[u8], + content_type_header: Option<&str>, +) -> (String, &'static str) { + let (encoding, _) = detect_encoding(bytes, content_type_header); + let (cow, _, _) = encoding.decode(bytes); + (cow.into_owned(), encoding.name()) +} + +const PCT_HEX: &[u8; 16] = b"0123456789ABCDEF"; + +fn push_pct(out: &mut String, b: u8) { + out.push('%'); + out.push(PCT_HEX[(b >> 4) as usize] as char); + out.push(PCT_HEX[(b & 0x0F) as usize] as char); +} + +/// Append an ASCII `byte` to a URL query string, percent-encoding it when it is +/// in the WHATWG query percent-encode set (C0 controls, space, `"`, `#`, `<`, +/// `>`, 0x7F), plus `'` for special schemes (the special-query set). ASCII +/// delimiters like `=` and `&` are left literal, so structured queries survive. +fn push_query_ascii(out: &mut String, b: u8, special: bool) { + let must_encode = b <= 0x20 + || b == 0x7F + || matches!(b, 0x22 | 0x23 | 0x3C | 0x3E) + || (special && b == 0x27); + if must_encode { + push_pct(out, b); + } else { + out.push(b as char); + } +} + +/// Encode a run of non-ASCII code points to the target charset and percent- +/// encode EVERY resulting byte. The bytes serialize a non-ASCII character, so +/// all of them are escaped (this is what the WPT legacy-mb encode-href tests +/// expect, e.g. Big5 `一` -> `%A4%40` even though the 0x40 trail byte is ASCII). +/// Unmappable code points become the literal `%26%23<decimal>%3B` sequence (a +/// percent-encoded `&#NNN;` numeric character reference), per the URL spec. +fn encode_run_pct(out: &mut String, run: &str, enc: &'static Encoding) { + let mut encoder = enc.new_encoder(); + let mut input = run; + let mut buf = [0u8; 256]; + loop { + let (result, read, written) = + encoder.encode_from_utf8_without_replacement(input, &mut buf, true); + for &b in &buf[..written] { + push_pct(out, b); + } + input = &input[read..]; + match result { + EncoderResult::InputEmpty => break, + EncoderResult::OutputFull => continue, + EncoderResult::Unmappable(c) => { + out.push_str("%26%23"); + out.push_str(&(c as u32).to_string()); + out.push_str("%3B"); + } + } + } +} + +/// WHATWG URL "percent-encode after encoding" for the query component, using a +/// non-UTF-8 document encoding override (`label`). `query` is the already +/// UTF-8-percent-decoded query string. ASCII code points use the (special-) +/// query percent-encode set so real query delimiters (`=`, `&`) stay literal; +/// runs of non-ASCII code points are encoded to the target charset with every +/// byte percent-encoded. Returns None when the label is unknown. +pub fn url_encode_query(query: &str, label: &str, special: bool) -> Option<String> { + let enc = Encoding::for_label(label.as_bytes())?; + let mut out = String::with_capacity(query.len() * 3); + let mut run_start: Option<usize> = None; + for (idx, c) in query.char_indices() { + if c.is_ascii() { + if let Some(s) = run_start.take() { + encode_run_pct(&mut out, &query[s..idx], enc); + } + push_query_ascii(&mut out, c as u8, special); + } else if run_start.is_none() { + run_start = Some(idx); + } + } + if let Some(s) = run_start { + encode_run_pct(&mut out, &query[s..], enc); + } + Some(out) +} + /// Same as `decode_response` but skips the `<meta charset>` sniff. Use for /// non-HTML resources where embedded HTML meta tags are not authoritative /// (script and style bodies, JSON, plain text). @@ -186,6 +309,37 @@ mod tests { assert!(s.contains("<meta charset=")); } + #[test] + fn url_encode_query_eucjp_high_bytes() { + // U+8108 (脈) is EUC-JP CC AE; both bytes are above 0x7E so both encode. + assert_eq!(url_encode_query("\u{8108}", "euc-jp", true).unwrap(), "%CC%AE"); + } + + #[test] + fn url_encode_query_unmappable_becomes_ncr() { + // A code point not in shift_jis becomes the percent-encoded &#NNN;. + // U+3402 is a CJK ext-A han char not in shift_jis. + let got = url_encode_query("\u{3402}", "shift_jis", true).unwrap(); + assert_eq!(got, "%26%2313314%3B"); + } + + #[test] + fn url_encode_query_big5_low_trail_byte_is_escaped() { + // U+4E00 (一) is Big5 A4 40; the 0x40 trail byte is ASCII '@' but must + // still be percent-encoded because it serializes a non-ASCII char. + assert_eq!(url_encode_query("\u{4e00}", "big5", true).unwrap(), "%A4%40"); + } + + #[test] + fn url_encode_query_keeps_ascii_structure() { + // ASCII delimiters in a real query stay literal (standard query set): + // only the non-ASCII value is re-encoded to the target charset. + assert_eq!( + url_encode_query("a=\u{8108}&b=c", "euc-jp", true).unwrap(), + "a=%CC%AE&b=c" + ); + } + #[test] fn meta_sniff_only_scans_first_1kb() { let mut bytes = vec![b' '; 2048]; diff --git a/crates/obscura-net/src/lib.rs b/crates/obscura-net/src/lib.rs index 0aaa061..02fbaa6 100644 --- a/crates/obscura-net/src/lib.rs +++ b/crates/obscura-net/src/lib.rs @@ -12,7 +12,10 @@ pub use client::{ Response, }; pub use cookies::{CookieInfo, CookieJar}; -pub use encoding::{decode_non_html, decode_response}; +pub use encoding::{ + decode_non_html, decode_response, decode_response_with_name, decode_with_label, label_name, + url_encode_query, +}; pub use robots::RobotsCache; pub use blocklist::is_blocked as is_tracker_blocked; #[cfg(feature = "stealth")]