rails-jsdom 0.1.0

data/lib/rails_jsdom/runtime.js

@@ -0,0 +1,926 @@
+"use strict"
+
+const fs = require("node:fs")
+const path = require("node:path")
+const readline = require("node:readline")
+const vm = require("node:vm")
+const { createRequire } = require("node:module")
+
+const STUB_NAMESPACE = "rails-jsdom-stub"
+const STUB_SOURCE = "module.exports = Object.create(new Proxy({}, { get: (target, key) => typeof key === 'symbol' || key === 'then' || key === '__esModule' ? undefined : () => {} }))"
+const INLINE_ELEMENTS = new Set(["a", "abbr", "b", "bdi", "bdo", "cite", "code", "data", "dfn", "em", "i", "kbd", "label", "mark", "output", "q", "s", "samp", "small", "span", "strong", "sub", "sup", "time", "u", "var"])
+const CLICKABLE = "button, input[type=submit], input[type=button], input[type=reset], input[type=image], input[type=checkbox], input[type=radio], a[href], summary, label, [role=button]"
+const BUTTON_INPUTS = "input[type=submit], input[type=button], input[type=reset], input[type=image]"
+const FIELDS = "input:not([type=hidden]), textarea, select"
+const FILLABLE = "input:not([type=hidden], [type=checkbox], [type=radio], [type=file], [type=submit], [type=button], [type=reset], [type=image]), textarea"
+const KINDS = { link: "a[href]", button: `button, ${BUTTON_INPUTS}`, link_or_button: `a[href], button, ${BUTTON_INPUTS}` }
+const DIALOG_HANDLERS = { alert: "accept_alert", confirm: "accept_confirm or dismiss_confirm", prompt: "accept_prompt or dismiss_prompt" }
+const UNANSWERED = { alert: undefined, confirm: false, prompt: null }
+const QUERY_KINDS = { css: "*", field: FIELDS, button: KINDS.button, link: KINDS.link }
+const FOCUSABLE = "a[href], button, input:not([type=hidden]), select, textarea, [tabindex], [contenteditable]"
+const PRESSABLE = "button, input[type=checkbox], input[type=radio], input[type=submit], input[type=button], input[type=reset]"
+const STEPPABLE = "input[type=range], input[type=number]"
+const KEYS = { enter: "Enter", tab: "Tab", backspace: "Backspace", delete: "Delete", escape: "Escape", space: " ", left: "ArrowLeft", right: "ArrowRight", up: "ArrowUp", down: "ArrowDown", home: "Home", end: "End", page_up: "PageUp", page_down: "PageDown" }
+const MODIFIERS = { shift: "shiftKey", control: "ctrlKey", ctrl: "ctrlKey", alt: "altKey", meta: "metaKey", command: "metaKey" }
+const NULL_BODY_STATUSES = new Set([101, 103, 204, 205, 304])
+const SETTLE_LIMIT = 10000
+const STREAM_SOURCES = "turbo-cable-stream-source[signed-stream-name][channel='Turbo::StreamsChannel'], turbo-cable-stream-source[signed-stream-name]:not([channel])"
+
+const replies = new Map()
+const fetchStubs = new Map()
+const pending = new Set()
+const errors = []
+const owners = new WeakMap()
+let nextFetchId = 1
+let nextPageId = 1
+let config = null
+let jsdom = null
+let bundle = null
+let page = null
+const sessions = new Map()
+let session = sessionNamed("default")
+let modal = null
+let modalMessages = []
+
+let output = null
+const send = message => output.write(`${JSON.stringify(message)}\n`)
+const tick = () => new Promise(resolve => setTimeout(resolve, 0))
+const normalize = text => String(text ?? "").replace(/\s+/g, " ").trim()
+
+let queue = Promise.resolve()
+
+function start(io) {
+  output = io.stdout
+  for (const method of ["log", "info", "warn", "error", "debug"]) {
+    console[method] = (...args) => io.stderr.write(`${args.map(String).join(" ")}\n`)
+  }
+  io.on("unhandledRejection", reason => errors.push(reason))
+  const input = readline.createInterface({ input: io.stdin })
+  input.on("line", line => {
+    const message = JSON.parse(line)
+    if (message.type === "fetch_response") {
+      const resolve = replies.get(message.id)
+      replies.delete(message.id)
+      resolve(message.response)
+    } else {
+      queue = queue.then(() => handle(message))
+    }
+  })
+  input.on("close", () => io.exit(0))
+}
+
+async function handle(message) {
+  try {
+    send({ type: "result", value: await perform(message) })
+  } catch (error) {
+    send({ type: "error", message: describeError(error) })
+  }
+}
+
+function describeError(error) {
+  return error && error.stack ? String(error.stack) : String(error)
+}
+
+const READS = {
+  setup: message => setup(message),
+  snapshot: message => snapshot(message.scope),
+  query: message => query(message),
+  read: message => describe(elementFor(message.handle)),
+  session: message => switchSession(message.name),
+  stub_fetch: message => stubFetch(message.url, message.response),
+  reset: () => reset(),
+  streams: () => streams(),
+  expect_modal: message => expectModal(message),
+  modal_messages: () => takeModalMessages()
+}
+
+const ACTIONS = {
+  load: message => loadFresh(message.html, message.url, message.history),
+  click: message => click(find(message, byClickable, KINDS[message.kind])),
+  hover: message => hover(find(message, byClickable)),
+  double_click: message => doubleClick(find(message, byClickable)),
+  right_click: message => rightClick(find(message, byClickable)),
+  fill_in: message => fill(find(message, byField, FILLABLE), message.with),
+  check: message => setChecked(find(message, byField, "input[type=checkbox]"), message.checked),
+  choose: message => setChecked(find(message, byField, "input[type=radio]"), true),
+  select: message => selectOption(message),
+  attach: message => attachFiles(find(message, byField, "input[type=file]"), message.files),
+  send_keys: message => sendKeys(null, message.keys),
+  element: message => elementAction(message),
+  traverse: message => traverse(message.delta),
+  evaluate: message => evaluate(message.script),
+  deliver: message => deliver(message.messages)
+}
+
+async function perform(message) {
+  if (READS[message.command]) return READS[message.command](message)
+  if (!ACTIONS[message.command]) throw new Error(`RailsJsdom: unknown command ${message.command}`)
+  errors.length = 0
+  const value = await ACTIONS[message.command](message)
+  await settle()
+  if (errors.length > 0) throw new Error(errors.splice(0).map(describeError).join("\n\n"))
+  return value === undefined ? null : JSON.parse(JSON.stringify(value) ?? "null")
+}
+
+function stubFetch(url, response) {
+  fetchStubs.set(url, response)
+  return null
+}
+
+function loadFresh(html, url, history) {
+  fetchStubs.clear()
+  return load(html, url, history)
+}
+
+async function setup(message) {
+  config = message
+  const appRequire = createRequire(path.join(config.root, "package.json"))
+  jsdom = appRequire("jsdom")
+  const esbuild = appRequire("esbuild")
+  const result = await esbuild.build({
+    stdin: { contents: entrySource(), resolveDir: config.root, sourcefile: "rails-jsdom-entry.js", loader: "js" },
+    bundle: true,
+    write: false,
+    format: "iife",
+    globalName: "RailsJsdomBundle",
+    logLevel: "silent",
+    plugins: [importmapPlugin()]
+  })
+  bundle = new vm.Script(result.outputFiles[0].text, { filename: "rails-jsdom-bundle.js" })
+  return {}
+}
+
+function controllerFiles(directory, prefix) {
+  return fs.readdirSync(directory, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name)).flatMap(entry => {
+    if (entry.isDirectory()) return controllerFiles(path.join(directory, entry.name), `${prefix}${entry.name}/`)
+    return entry.name.endsWith("_controller.js") ? [[`${prefix}${entry.name}`, path.join(directory, entry.name)]] : []
+  })
+}
+
+function identifierFor(relative) {
+  return relative.replace(/_controller\.js$/, "").replace(/\//g, "--").replace(/_/g, "-")
+}
+
+function entrySource() {
+  const files = controllerFiles(config.controllers, "")
+  return [
+    "import \"@hotwired/turbo-rails\"",
+    "export { Application } from \"@hotwired/stimulus\"",
+    ...files.map(([, file], index) => `import controller${index} from ${JSON.stringify(file)}`),
+    `export const controllers = { ${files.map(([relative], index) => `${JSON.stringify(identifierFor(relative))}: controller${index}`).join(", ")} }`
+  ].join("\n")
+}
+
+function importmapPlugin() {
+  return {
+    name: "rails-jsdom-importmap",
+    setup(build) {
+      build.onResolve({ filter: /^[^./]/ }, args => resolveImport(args.path))
+      build.onLoad({ filter: /.*/, namespace: STUB_NAMESPACE }, () => ({ contents: STUB_SOURCE, loader: "js" }))
+    }
+  }
+}
+
+function resolveImport(specifier) {
+  const directory = Object.keys(config.directories).find(prefix => specifier.startsWith(`${prefix}/`))
+  if (config.stubs.includes(specifier)) return { path: specifier, namespace: STUB_NAMESPACE }
+  if (config.modules[specifier]) return { path: config.modules[specifier] }
+  if (directory) return { path: `${path.join(config.directories[directory], specifier.slice(directory.length + 1))}.js` }
+  return undefined
+}
+
+class Clock {
+  constructor() {
+    this.now = 0
+    this.sequence = 0
+    this.timers = new Map()
+  }
+
+  install(window) {
+    window.setTimeout = (callback, delay, ...args) => this.schedule(callback, delay, args, false)
+    window.setInterval = (callback, delay, ...args) => this.schedule(callback, delay, args, true)
+    window.requestAnimationFrame = callback => this.schedule(() => callback(this.now), 0, [], false)
+    window.clearTimeout = window.clearInterval = window.cancelAnimationFrame = id => { this.timers.delete(id) }
+  }
+
+  schedule(callback, delay, args, repeat) {
+    const wait = Math.max(repeat ? 4 : 0, Number(delay) || 0)
+    this.sequence += 1
+    this.timers.set(this.sequence, { callback, args, at: this.now + wait, every: repeat ? wait : 0, order: this.sequence })
+    return this.sequence
+  }
+
+  due(limit) {
+    let next = null
+    for (const entry of this.timers) {
+      const timer = entry[1]
+      if (timer.at <= limit && (!next || timer.at < next[1].at || (timer.at === next[1].at && timer.order < next[1].order))) next = entry
+    }
+    return next
+  }
+
+  run([id, timer]) {
+    this.now = timer.at
+    if (timer.every) {
+      this.sequence += 1
+      timer.at += timer.every
+      timer.order = this.sequence
+    } else {
+      this.timers.delete(id)
+    }
+    try {
+      if (typeof timer.callback === "function") timer.callback(...timer.args)
+    } catch (error) {
+      errors.push(error)
+    }
+  }
+}
+
+async function settle() {
+  let idle = 0
+  let current = null
+  let limit = 0
+  for (let round = 0; idle < 3; round += 1) {
+    if (round > SETTLE_LIMIT) throw new Error("RailsJsdom: the page did not settle")
+    await tick()
+    if (current !== page) {
+      current = page
+      limit = page.clock.now + config.horizon
+    }
+    const timer = page.clock.due(limit)
+    if (pending.size > 0) {
+      idle = 0
+      await Promise.race(pending)
+    } else if (timer) {
+      idle = 0
+      page.clock.run(timer)
+    } else {
+      idle += 1
+    }
+  }
+}
+
+function track(promise) {
+  pending.add(promise)
+  const forget = () => pending.delete(promise)
+  promise.then(forget, forget)
+  return promise
+}
+
+function requestRails(request) {
+  const id = nextFetchId
+  nextFetchId += 1
+  return track(new Promise(resolve => {
+    replies.set(id, resolve)
+    send({ type: "fetch", id, request })
+  }))
+}
+
+function sessionNamed(name) {
+  if (!sessions.has(name)) sessions.set(name, { page: null, back: [], forward: [] })
+  return sessions.get(name)
+}
+
+function switchSession(name) {
+  session = sessionNamed(name)
+  page = session.page
+  return null
+}
+
+function load(html, url, history = "push") {
+  const previous = page
+  if (history === "push" && previous) pushHistory(previous.window.location.href)
+  const current = { id: nextPageId, clock: new Clock(), closed: false, position: 0, length: 1, handles: new Map(), ids: new WeakMap(), nextHandle: 0, edited: new Map() }
+  nextPageId += 1
+  const report = error => { if (page === current) errors.push(error) }
+  session.page = current
+  page = current
+  current.dom = new jsdom.JSDOM(html, {
+    url,
+    runScripts: "dangerously",
+    pretendToBeVisual: true,
+    virtualConsole: pageConsole(report),
+    beforeParse: window => prepare(window, current)
+  })
+  current.window = current.dom.window
+  bundle.runInContext(current.dom.getInternalVMContext())
+  boot(current.window, report)
+  if (previous) close(previous)
+  return current.id
+}
+
+function pushHistory(url) {
+  session.back.push(url)
+  session.forward = []
+}
+
+function pageConsole(report) {
+  const virtualConsole = new jsdom.VirtualConsole()
+  virtualConsole.forwardTo(console, { jsdomErrors: "none" })
+  virtualConsole.on("jsdomError", report)
+  return virtualConsole
+}
+
+async function evaluate(script) {
+  return await page.window.eval(script)
+}
+
+function reset() {
+  for (const each of sessions.values()) if (each.page) close(each.page)
+  sessions.clear()
+  session = sessionNamed("default")
+  page = null
+  modal = null
+  modalMessages = []
+  errors.length = 0
+  fetchStubs.clear()
+  replies.clear()
+  pending.clear()
+  return null
+}
+
+function close(target) {
+  target.closed = true
+  target.clock.timers.clear()
+  if (target.window) target.window.close()
+}
+
+function prepare(window, current) {
+  owners.set(window, current)
+  current.clock.install(window)
+  trackHistory(window, current)
+  window.fetch = (resource, init) => pageFetch(window, resource, init ?? {})
+  window.alert = message => dialog("alert", message)
+  window.confirm = message => dialog("confirm", message)
+  window.prompt = (message, defaultValue) => dialog("prompt", message, defaultValue)
+  window.HTMLFormElement.prototype.submit = function () { submitNatively(this, null) }
+  stubMissingBrowserApis(window)
+}
+
+function trackHistory(window, current) {
+  const pushState = window.history.pushState.bind(window.history)
+  window.history.pushState = (...args) => {
+    pushState(...args)
+    current.position += 1
+    current.length = current.position + 1
+  }
+}
+
+function stubMissingBrowserApis(window) {
+  window.Headers = Headers
+  window.Request = Request
+  window.Response = Response
+  window.matchMedia = media => ({ matches: false, media, onchange: null, addListener() {}, removeListener() {}, addEventListener() {}, removeEventListener() {}, dispatchEvent: () => false })
+  window.scrollTo = window.scroll = window.scrollBy = () => {}
+  window.Element.prototype.scrollIntoView = () => {}
+  window.IntersectionObserver = window.ResizeObserver = class {
+    observe() {}
+    unobserve() {}
+    disconnect() {}
+    takeRecords() { return [] }
+  }
+  Object.defineProperty(window.navigator, "clipboard", { configurable: true, value: { writeText: async () => {}, readText: async () => "" } })
+  window.HTMLDialogElement.prototype.show = window.HTMLDialogElement.prototype.showModal = function () { this.setAttribute("open", "") }
+  window.HTMLDialogElement.prototype.close = function (returnValue) {
+    if (returnValue !== undefined) this.returnValue = returnValue
+    if (this.hasAttribute("open")) {
+      this.removeAttribute("open")
+      this.dispatchEvent(new window.Event("close"))
+    }
+  }
+}
+
+function boot(window, report) {
+  const { Application, controllers } = window.RailsJsdomBundle
+  const application = Application.start()
+  const registered = new Set()
+  application.handleError = (error, message) => report(new Error(`${message}: ${describeError(error)}`))
+  window.Stimulus = application
+  const discover = () => {
+    for (const identifier of controllerIdentifiers(window.document)) {
+      if (controllers[identifier] && !registered.has(identifier)) {
+        registered.add(identifier)
+        application.register(identifier, controllers[identifier])
+      }
+    }
+  }
+  discover()
+  new window.MutationObserver(discover).observe(window.document, { subtree: true, childList: true, attributes: true, attributeFilter: ["data-controller"] })
+  fallBackLast(window, "click", event => followLink(window, event))
+  fallBackLast(window, "submit", event => submitUnhandled(event))
+}
+
+function controllerIdentifiers(document) {
+  return [...document.querySelectorAll("[data-controller]")].flatMap(element => element.getAttribute("data-controller").split(/\s+/))
+}
+
+function fallBackLast(window, type, listener) {
+  window.addEventListener(type, () => {
+    window.removeEventListener(type, listener)
+    window.addEventListener(type, listener)
+  }, true)
+}
+
+function followLink(window, event) {
+  const link = event.target.closest && event.target.closest("a[href]")
+  if (event.defaultPrevented || !link || staysInDocument(window, link.href)) return
+  event.preventDefault()
+  if (!link.hasAttribute("download") && ["", "_self"].includes(link.target) && ["http:", "https:"].includes(new window.URL(link.href).protocol)) navigate({ method: "GET", url: link.href })
+}
+
+function staysInDocument(window, href) {
+  const target = new window.URL(href)
+  const here = new window.URL(window.location.href)
+  return href.includes("#") && target.origin === here.origin && target.pathname === here.pathname && target.search === here.search
+}
+
+function submitUnhandled(event) {
+  if (!event.defaultPrevented) {
+    event.preventDefault()
+    submitNatively(event.target, event.submitter)
+  }
+}
+
+function submitNatively(form, submitter) {
+  const { window, method, action, data } = submission(form, submitter)
+  if (method === "dialog") {
+    form.closest("dialog")?.close(submitter?.value)
+  } else if (method === "get") {
+    action.search = new window.URLSearchParams(textEntries(data)).toString()
+    navigate({ method: "GET", url: action.href })
+  } else {
+    const headers = {}
+    const entries = form.enctype === "multipart/form-data" ? [...data] : textEntries(data)
+    track(encodeBody(window, entries, headers).then(body => navigate({ method: "POST", url: action.href, body, headers })))
+  }
+}
+
+function submission(form, submitter) {
+  const window = form.ownerDocument.defaultView
+  const data = new window.FormData(form)
+  if (submitter?.name) data.append(submitter.name, submitter.value)
+  return {
+    window,
+    method: (formSetting(form, submitter, "method") || "get").toLowerCase(),
+    action: new window.URL(formSetting(form, submitter, "action") || window.location.href, window.document.baseURI),
+    data
+  }
+}
+
+function formSetting(form, submitter, name) {
+  return submitter?.getAttribute(`form${name}`) || form.getAttribute(name)
+}
+
+function textEntries(data) {
+  return [...data].filter(([, value]) => typeof value === "string")
+}
+
+function navigate({ method, url, body = null, headers = {} }, history = "push") {
+  requestRails({ method, url, headers: { accept: "text/html,application/xhtml+xml", ...headers }, body }).then(reply => {
+    if (reply.error) errors.push(new Error(reply.error))
+    else load(reply.body, reply.url, history)
+  }).catch(error => errors.push(error))
+}
+
+function traverse(delta) {
+  if (!page) throw new Error("RailsJsdom: visit a page or mount a partial first")
+  const position = page.position + delta
+  if (position >= 0 && position < page.length) {
+    page.position = position
+    page.window.history.go(delta)
+    return null
+  }
+  const url = (delta < 0 ? session.back : session.forward).pop()
+  if (url) {
+    (delta < 0 ? session.forward : session.back).push(page.window.location.href)
+    navigate({ method: "GET", url }, "none")
+  }
+  return null
+}
+
+async function pageFetch(window, resource, init) {
+  if (owners.get(window).closed) return new Promise(() => {})
+  const url = resourceUrl(window, resource)
+  const headers = Object.fromEntries(new Headers(init.headers ?? {}))
+  const body = await encodeBody(window, init.body, headers)
+  const stub = stubFor(url)
+  const reply = stub ? { ...stub, url: url.href, redirected: false } : await requestRails({ method: String(init.method ?? "GET").toUpperCase(), url: url.href, headers, body })
+  if (reply.error) throw new TypeError(reply.error)
+  return pageResponse(reply)
+}
+
+function resourceUrl(window, resource) {
+  const address = typeof resource === "object" && "url" in resource ? resource.url : String(resource)
+  return new window.URL(address, window.document.baseURI)
+}
+
+function stubFor(url) {
+  return fetchStubs.get(url.href) || fetchStubs.get(`${url.pathname}${url.search}`)
+}
+
+function pageResponse(reply) {
+  const response = new Response(NULL_BODY_STATUSES.has(reply.status) ? null : reply.body, { status: reply.status, headers: reply.headers })
+  Object.defineProperties(response, { url: { value: reply.url }, redirected: { value: reply.redirected } })
+  return response
+}
+
+async function encodeBody(window, body, headers) {
+  if (body === undefined || body === null) return null
+  if (Array.isArray(body) || body instanceof window.FormData || body instanceof window.URLSearchParams) {
+    const entries = [...body]
+    if (entries.some(([, value]) => typeof value !== "string")) return multipart(entries, headers)
+    headers["content-type"] = "application/x-www-form-urlencoded;charset=UTF-8"
+    return Buffer.from(new window.URLSearchParams(entries).toString()).toString("base64")
+  }
+  return Buffer.from(String(body)).toString("base64")
+}
+
+async function multipart(entries, headers) {
+  const boundary = `----RailsJsdomBoundary${nextFetchId}${Date.now()}`
+  const quote = text => String(text).replace(/"/g, "%22").replace(/\r?\n/g, " ")
+  const parts = []
+  for (const [name, value] of entries) {
+    const file = typeof value !== "string"
+    const head = file ? `Content-Disposition: form-data; name="${quote(name)}"; filename="${quote(value.name)}"\r\nContent-Type: ${value.type || "application/octet-stream"}` : `Content-Disposition: form-data; name="${quote(name)}"`
+    parts.push(Buffer.from(`--${boundary}\r\n${head}\r\n\r\n`), file ? Buffer.from(await value.arrayBuffer()) : Buffer.from(value), Buffer.from("\r\n"))
+  }
+  parts.push(Buffer.from(`--${boundary}--\r\n`))
+  headers["content-type"] = `multipart/form-data; boundary=${boundary}`
+  return Buffer.concat(parts).toString("base64")
+}
+
+function expectModal({ type, accept, with: answer }) {
+  modal = { type, accept, answer }
+  modalMessages = []
+  return null
+}
+
+function takeModalMessages() {
+  const messages = modalMessages
+  modal = null
+  modalMessages = []
+  return messages
+}
+
+function dialog(type, message, defaultValue) {
+  if (!modal || modal.type !== type) {
+    errors.push(new Error(`RailsJsdom: unexpected ${type} dialog "${message}". Wrap the action in ${DIALOG_HANDLERS[type]}.`))
+    return UNANSWERED[type]
+  }
+  modalMessages.push(String(message))
+  if (type === "confirm") return modal.accept
+  if (type === "prompt") return modal.accept ? String(modal.answer ?? defaultValue ?? "") : null
+  return undefined
+}
+
+function find({ locator, scope, match }, strategy, kind) {
+  const root = scopeRoot(scope)
+  const candidates = [byAction, strategy, byCss].map(search => search(root, locator).filter(element => !kind || element.matches(kind))).find(list => list.length > 0) || []
+  if (candidates.length === 0) throw new Error(`RailsJsdom: unable to find ${JSON.stringify(locator)}`)
+  return pick(candidates, JSON.stringify(locator), match)
+}
+
+function scopeRoot(scope = []) {
+  return scope.reduce((parent, entry) => only(scoped(parent, entry), `within ${JSON.stringify(entry)}`), page.window.document)
+}
+
+function scoped(parent, entry) {
+  if (entry.handle !== undefined) return [elementFor(entry.handle)]
+  if (entry.fieldset !== undefined) return [...parent.querySelectorAll("fieldset")].filter(fieldset => fieldset.id === entry.fieldset || normalize(fieldset.querySelector(":scope > legend")?.textContent) === entry.fieldset)
+  if (entry.table !== undefined) return [...parent.querySelectorAll("table")].filter(table => table.id === entry.table || normalize(table.caption?.textContent) === entry.table)
+  return [...parent.querySelectorAll(entry.css)]
+}
+
+function pick(list, description, match) {
+  return match === "first" && list.length > 0 ? list[0] : only(list, description)
+}
+
+function only(list, description) {
+  if (list.length !== 1) throw new Error(`RailsJsdom: ${description} matches ${list.length} elements`)
+  return list[0]
+}
+
+function byAction(root, locator) {
+  if (!/^[\w-]+#\w+$/.test(locator)) return []
+  return [...root.querySelectorAll("[data-action]")].filter(element => element.getAttribute("data-action").split(/\s+/).some(token => token.split("->").pop().split(":")[0] === locator))
+}
+
+function byCss(root, locator) {
+  try {
+    return [...root.querySelectorAll(locator)]
+  } catch {
+    return []
+  }
+}
+
+function names(element) {
+  return [element.textContent, element.getAttribute("aria-label"), element.getAttribute("title"), element.id, element.matches(BUTTON_INPUTS) ? element.value : ""].map(normalize).filter(Boolean)
+}
+
+function byText(elements, text) {
+  const exact = elements.filter(element => names(element).includes(text))
+  return exact.length > 0 ? exact : elements.filter(element => names(element).some(name => name.includes(text)))
+}
+
+function byClickable(root, text) {
+  return byText([...root.querySelectorAll(CLICKABLE)], text)
+}
+
+function byField(root, text) {
+  const fields = [...root.querySelectorAll(FIELDS)]
+  const labelled = byText([...root.querySelectorAll("label")], text).map(label => label.control).filter(Boolean)
+  const attributes = ["placeholder", "name", "id", "aria-label"].map(attribute => fields.filter(field => field.getAttribute(attribute) === text))
+  return [labelled, ...attributes].find(list => list.length > 0) || []
+}
+
+function click(element) {
+  const window = element.ownerDocument.defaultView
+  const options = { bubbles: true, cancelable: true, composed: true, view: window }
+  if (element.disabled) throw new Error(`RailsJsdom: ${element.outerHTML.slice(0, 120)} is disabled`)
+  element.dispatchEvent(new window.MouseEvent("mousedown", options))
+  if (typeof element.focus === "function") element.focus()
+  element.dispatchEvent(new window.MouseEvent("mouseup", options))
+  if (typeof element.click === "function") element.click()
+  else element.dispatchEvent(new window.MouseEvent("click", options))
+}
+
+function fill(element, value) {
+  if (element.disabled || element.readOnly) throw new Error(`RailsJsdom: ${element.outerHTML.slice(0, 120)} is not editable`)
+  element.focus()
+  element.value = value
+  changed(element)
+}
+
+function changed(element) {
+  const window = element.ownerDocument.defaultView
+  element.dispatchEvent(new window.Event("input", { bubbles: true }))
+  element.dispatchEvent(new window.Event("change", { bubbles: true }))
+}
+
+function setChecked(element, checked) {
+  if (element.checked !== checked) click(element)
+}
+
+function setValue(element, value) {
+  if (element.matches("input[type=checkbox]")) return setChecked(element, Boolean(value))
+  if (element.matches("input[type=radio]")) return value ? setChecked(element, true) : null
+  if (element.matches(FILLABLE)) return fill(element, String(value))
+  if (element.matches("[contenteditable]:not([contenteditable=false])")) {
+    element.textContent = String(value)
+    return element.dispatchEvent(new element.ownerDocument.defaultView.Event("input", { bubbles: true }))
+  }
+  throw new Error(`RailsJsdom: set does not work on ${element.outerHTML.slice(0, 120)}; use select, attach_file or click`)
+}
+
+function chooseOption(option, selected) {
+  const select = option.closest("select")
+  if (!select) throw new Error("RailsJsdom: select_option works only on an option inside a select")
+  if (select.disabled) throw new Error(`RailsJsdom: ${select.outerHTML.slice(0, 120)} is disabled`)
+  if (!selected && !select.multiple) throw new Error("RailsJsdom: unselect works only on a select that allows multiple options")
+  select.focus()
+  option.selected = selected
+  changed(select)
+}
+
+function attachFiles(input, files) {
+  if (input.disabled) throw new Error(`RailsJsdom: ${input.outerHTML.slice(0, 120)} is disabled`)
+  if (files.length > 1 && !input.multiple) throw new Error("RailsJsdom: the file field does not allow multiple files")
+  const window = input.ownerDocument.defaultView
+  const list = internal(input.files)
+  list.length = 0
+  for (const file of files) list.push(internal(new window.File([Buffer.from(file.base64, "base64")], file.name, { type: file.type })))
+  changed(input)
+}
+
+function internal(object) {
+  const symbol = Object.getOwnPropertySymbols(object).find(candidate => candidate.description === "impl")
+  if (!symbol) throw new Error("RailsJsdom: attach_file does not work with this jsdom version")
+  return object[symbol]
+}
+
+function handleFor(element) {
+  if (!page.ids.has(element)) {
+    page.nextHandle += 1
+    page.ids.set(element, page.nextHandle)
+    page.handles.set(page.nextHandle, element)
+  }
+  return page.ids.get(element)
+}
+
+function elementFor(handle) {
+  const element = page && page.handles.get(handle)
+  if (!element || !element.isConnected) throw new Error("RailsJsdom: the element is no longer on the page")
+  return element
+}
+
+function describe(element) {
+  return {
+    handle: handleFor(element),
+    tag: element.localName,
+    text: normalize(visibleText(element)),
+    all_text: normalize(element.textContent),
+    visible: isVisible(element),
+    value: "value" in element ? String(element.value) : null,
+    checked: Boolean(element.checked),
+    selected: Boolean(element.selected),
+    disabled: Boolean(element.disabled),
+    type: element.localName === "input" ? element.type : element.localName,
+    attributes: Object.fromEntries([...element.attributes].map(attribute => [attribute.name, attribute.value]))
+  }
+}
+
+function query({ strategy, locator, scope }) {
+  if (!page) throw new Error("RailsJsdom: visit a page or mount a partial first")
+  return candidates(scopeRoot(scope), strategy, locator).map(describe)
+}
+
+function candidates(root, strategy, locator) {
+  const kind = QUERY_KINDS[strategy]
+  if (locator === null) return [...root.querySelectorAll(kind)]
+  if (strategy === "css") return [...root.querySelectorAll(locator)]
+  const search = strategy === "field" ? byField : byClickable
+  return search(root, locator).filter(element => element.matches(kind))
+}
+
+const ELEMENT_ACTIONS = {
+  click: element => click(element),
+  hover: element => hover(element),
+  double_click: element => doubleClick(element),
+  right_click: element => rightClick(element),
+  set: (element, message) => setValue(element, message.value),
+  select_option: element => chooseOption(element, true),
+  unselect_option: element => chooseOption(element, false),
+  send_keys: (element, message) => sendKeys(element, message.keys)
+}
+
+function elementAction(message) {
+  const element = elementFor(message.handle)
+  if (!ELEMENT_ACTIONS[message.action]) throw new Error(`RailsJsdom: unknown element action ${message.action}`)
+  return ELEMENT_ACTIONS[message.action](element, message)
+}
+
+function sendKeys(element, keys) {
+  if (element) element.focus()
+  for (const entry of keys) {
+    const modifiers = modifierFlags(entry.modifiers || [])
+    for (const key of pressedKeys(entry)) press(key, modifiers)
+  }
+}
+
+function modifierFlags(names) {
+  return Object.fromEntries(names.map(name => {
+    if (!MODIFIERS[name]) throw new Error(`RailsJsdom: unknown modifier key ${name}`)
+    return [MODIFIERS[name], true]
+  }))
+}
+
+function pressedKeys(entry) {
+  if (entry.text !== undefined) return [...entry.text]
+  if (KEYS[entry.key]) return [KEYS[entry.key]]
+  throw new Error(`RailsJsdom: unknown key ${entry.key}`)
+}
+
+function keyCode(key) {
+  if (/^[a-z]$/i.test(key)) return `Key${key.toUpperCase()}`
+  if (/^[0-9]$/.test(key)) return `Digit${key}`
+  return key === " " ? "Space" : key
+}
+
+function press(key, modifiers) {
+  const window = page.window
+  const target = window.document.activeElement
+  const options = { key, code: keyCode(key), bubbles: true, cancelable: true, composed: true, view: window, ...modifiers }
+  const proceed = target.dispatchEvent(new window.KeyboardEvent("keydown", options))
+  if (proceed && (key.length > 1 || target.dispatchEvent(new window.KeyboardEvent("keypress", options)))) keyAction(target, key, modifiers)
+  target.dispatchEvent(new window.KeyboardEvent("keyup", options))
+}
+
+function keyAction(target, key, modifiers) {
+  if (key === "Tab") return moveFocus(target, modifiers.shiftKey)
+  if (key === "Enter") return pressEnter(target)
+  if (key === " " && target.matches(PRESSABLE)) return click(target)
+  if (target.matches(STEPPABLE) && ["ArrowUp", "ArrowRight", "ArrowDown", "ArrowLeft", "Home", "End"].includes(key)) return step(target, key)
+  if (target.matches(`${FILLABLE}`)) return editText(target, key, modifiers)
+  return null
+}
+
+function editText(target, key, modifiers) {
+  if (target.disabled || target.readOnly) return null
+  const before = target.value
+  const after = editedValue(before, key, modifiers)
+  if (after === before) return null
+  target.value = after
+  if (!page.edited.has(target)) page.edited.set(target, before)
+  const deleting = key === "Backspace"
+  return target.dispatchEvent(new target.ownerDocument.defaultView.InputEvent("input", { bubbles: true, inputType: deleting ? "deleteContentBackward" : "insertText", data: deleting ? null : key }))
+}
+
+function editedValue(value, key, modifiers) {
+  if (key === "Backspace") return value.slice(0, -1)
+  return typesCharacter(key, modifiers) ? value + key : value
+}
+
+function typesCharacter(key, modifiers) {
+  return key.length === 1 && !modifiers.ctrlKey && !modifiers.metaKey && !modifiers.altKey
+}
+
+function pressEnter(target) {
+  if (target.localName === "textarea") return editText(target, "\n", {})
+  if (target.matches(`a[href], ${KINDS.button}`)) return click(target)
+  const form = target.form
+  if (!form || !target.matches(FILLABLE)) return null
+  const submitter = form.querySelector(`button:not([type]), button[type=submit], input[type=submit], input[type=image]`)
+  return submitter ? click(submitter) : form.requestSubmit()
+}
+
+function step(target, key) {
+  if (key === "Home") target.value = target.min || "0"
+  else if (key === "End") target.value = target.max || "100"
+  else if (["ArrowUp", "ArrowRight"].includes(key)) target.stepUp()
+  else target.stepDown()
+  changed(target)
+}
+
+function moveFocus(from, backwards) {
+  if (page.edited.has(from) && page.edited.get(from) !== from.value) from.dispatchEvent(new from.ownerDocument.defaultView.Event("change", { bubbles: true }))
+  page.edited.delete(from)
+  const next = nextFocus(tabOrder(from.ownerDocument), from, backwards)
+  if (next) next.focus()
+}
+
+function tabOrder(document) {
+  const focusable = [...document.querySelectorAll(FOCUSABLE)].filter(element => !element.disabled && element.tabIndex >= 0 && isVisible(element))
+  const positive = focusable.filter(element => element.tabIndex > 0).sort((a, b) => a.tabIndex - b.tabIndex)
+  return [...positive, ...focusable.filter(element => element.tabIndex === 0)]
+}
+
+function nextFocus(ordered, from, backwards) {
+  const index = ordered.indexOf(from)
+  if (index === -1) return backwards ? ordered[ordered.length - 1] : ordered[0]
+  const step = backwards ? -1 : 1
+  return ordered[(index + step + ordered.length) % ordered.length]
+}
+
+function selectOption(message) {
+  const root = scopeRoot(message.scope)
+  const selects = message.from === null ? [...root.querySelectorAll("select")] : [find({ ...message, locator: message.from }, byField, "select")]
+  const options = selects.flatMap(select => [...select.options])
+  const exact = options.filter(option => normalize(option.textContent) === message.option)
+  const option = pick(exact.length > 0 ? exact : options.filter(option => normalize(option.textContent).includes(message.option)), `option ${JSON.stringify(message.option)}`, message.match)
+  chooseOption(option, message.selected)
+}
+
+function mouse(element, type, options = {}) {
+  const window = element.ownerDocument.defaultView
+  const Event = type.startsWith("pointer") ? window.PointerEvent : window.MouseEvent
+  element.dispatchEvent(new Event(type, { bubbles: !type.endsWith("enter"), cancelable: true, composed: true, view: window, ...options }))
+}
+
+function hover(element) {
+  for (const type of ["pointerover", "pointerenter", "mouseover", "mouseenter", "pointermove", "mousemove"]) mouse(element, type)
+}
+
+function doubleClick(element) {
+  click(element)
+  click(element)
+  mouse(element, "dblclick", { detail: 2 })
+}
+
+function rightClick(element) {
+  for (const type of ["mousedown", "mouseup", "contextmenu"]) mouse(element, type, { button: 2, buttons: 2 })
+}
+
+function isVisible(element) {
+  for (let node = element; node; node = node.parentElement) {
+    if (node.matches(config.hidden)) return false
+    if (node.parentElement?.localName === "details" && !node.parentElement.open && node.localName !== "summary") return false
+  }
+  return true
+}
+
+function visibleText(node) {
+  if (node.nodeType === 3) return node.data
+  if (node.nodeType !== 1 || node.matches(config.hidden)) return ""
+  const children = node.localName === "details" && !node.open ? [...node.children].filter(child => child.localName === "summary") : [...node.childNodes]
+  const text = children.map(visibleText).join("")
+  return INLINE_ELEMENTS.has(node.localName) ? text : ` ${text} `
+}
+
+function streams() {
+  if (!page) return []
+  return [...page.window.document.querySelectorAll(STREAM_SOURCES)].map(source => source.getAttribute("signed-stream-name"))
+}
+
+function deliver(messages) {
+  for (const message of messages) page.window.Turbo.renderStreamMessage(message)
+  return null
+}
+
+function snapshot(scope) {
+  if (!page) throw new Error("RailsJsdom: visit a page or mount a partial first")
+  const root = scopeRoot(scope)
+  const document = root.nodeType === 9
+  return { html: document ? page.dom.serialize() : root.outerHTML, text: normalize(visibleText(document ? root.body : root)), url: page.window.location.href, title: page.window.document.title }
+}
+
+module.exports = { start }