WebDriver BiDi

当一个并行运行的算法 algorithm 等待一组 事件 events 和 resume id 时：

1. 暂停 algorithm 的执行。

2. 断言：等待 队列不包含 resume id。

3. 将等待 队列[resume id] 设置为（events, algorithm）。

要用给定的 name、 id 和 parameters 来恢复：

1. 如果等待队列不 包含 id，则返回。

2. 令（events, algorithm）为等待队列[id]

3. 对 events 中的每个 event：

   1. 如果 event 等于 name：

      1. 从等待队列中移除 id。

      2. 从 algorithm 被暂停的 位置恢复运行其中的步骤，并将 name 和 parameters 作为 等待的结果传入。

         我们是否应该有类似微任务的东西，以 确保它在事件循环上的任何其他任务之前 运行？

注：此算法允许访问给定navigable 的 WebDriver 配置，方式是依次检查 navigables、然后是 user contexts，最后是 global 中的值。 如果配置未设置，则返回 unset。

要获取 WebDriver 配置 configuration 对于 navigable navigable 的 WebDriver 配置值：

1. 令 top-level traversable 为 navigable 的顶级 traversable。

2. 如果 configuration 的navigables 包含 top-level traversable：

   1. 令 navigable configuration value 为 configuration 的 navigables[top-level traversable]。

   2. 如果 navigable configuration value 不是 unset，则返回 navigable configuration value。

3. 令 user context 为 navigable 的关联用户 上下文。

4. 如果 configuration 的user contexts 包含 user context：

   1. 令 user context configuration value 为 configuration 的 user contexts[user context]。

   2. 如果 user context configuration value 不是 unset，则返回 user context configuration value。

5. 返回 configuration 的 global。

注：这是一个用于按 target 存储 WebDriver 配置的通用算法，target 可以是 navigable、用户上下文，或者如果 target 为 null 或被省略，则全局存储。

要将 WebDriver 配置 configuration 的 值 value 存储到可选 target 中， 其中 target 是一个navigable、 一个用户上下文，或在未提供时为 null：

1. 如果 target 为 null，则将 configuration 的 global 设置为 value。

2. 如果 target 是一个用户上下文，则将 configuration 的 user contexts[target] 设置为 value。

3. 如果 target 是一个navigable，则将 configuration 的 navigables[target] 设置为 value。

注：此通用算法将 WebDriver 配置的值 存储在 global、user contexts 或 navigables 中，具体取决于 command parameters 中是否存在 "userContexts" 和 "contexts"。这些 参数 是互斥的。如果两者都未提供，则配置会全局存储。

要针对给定的 command parameters 存储 WebDriver 配置 WebDriver 配置 configuration 的 值 value：

1. 如果 command parameters 包含 "userContexts"，且 command parameters 包含 "contexts"，则返回带有错误 代码 invalid argument 的错误。

2. 令 affected navigables 为空集合。

3. 如果 command parameters 包含 "contexts"：

   1. 令 navigables 为尝试用 command parameters["contexts"] 通过 id 获取有效顶级 traversables 的结果。

   2. 对于 navigables 中的每个 navigable：

      1. 将 navigable 追加到 affected navigables。

      2. 将 configuration 的 value 存储到 navigable 中。

4. 否则，如果 command parameters 包含 "userContexts"：

   1. 令 user contexts 为尝试用 command parameters["userContexts"] 获取有效用户上下文的结果。

   2. 对于 user contexts 中的每个 user context：

      1. 对于所有其 关联用户上下文为 user context 的顶级 traversable列表中的每个 top-level traversable：

         1. 将 top-level traversable 追加 到 affected navigables。

      2. 将 configuration 的 value 存储到 user context 中。

5. 否则：

   1. 对于所有顶级 traversable中的每个 top-level traversable，将 top-level traversable 追加 到 affected navigables。

   2. 存储 configuration 的 value。

6. 返回 affected navigables。

Command = {
  id: js-uint,
  CommandData,
  Extensible,
}

CommandData = (
  BrowserCommand //
  BrowsingContextCommand //
  EmulationCommand //
  InputCommand //
  NetworkCommand //
  ScriptCommand //
  SessionCommand //
  StorageCommand //
  WebExtensionCommand
)

EmptyParams = {
   Extensible
}

Message = (
  CommandResponse /
  ErrorResponse /
  Event
)

CommandResponse = {
  type: "success",
  id: js-uint,
  result: ResultData,
  Extensible
}

ErrorResponse = {
  type: "error",
  id: js-uint / null,
  error: ErrorCode,
  message: text,
  ? stacktrace: text,
  Extensible
}

ResultData = (
  BrowserResult /
  BrowsingContextResult /
  EmulationResult /
  InputResult /
  NetworkResult /
  ScriptResult /
  SessionResult /
  StorageResult /
  WebExtensionResult
)

EmptyResult = {
  Extensible
}

Event = {
  type: "event",
  EventData,
  Extensible
}

EventData = (
  BrowsingContextEvent //
  InputEvent //
  LogEvent //
  NetworkEvent //
  ScriptEvent
)

Extensible = (*text => any)

js-int = -9007199254740991..9007199254740991
js-uint = 0..9007199254740991

活动 BiDi 会话列表由以下步骤给出：

1. 令 BiDi sessions 为一个新的列表。

2. 对于活动会话中的每个 session：

   1. 如果 session 是一个 BiDi 会话，则将 session 追加到 BiDi sessions。

3. 返回 BiDi sessions。

ErrorCode = "invalid argument" /
            "invalid selector" /
            "invalid session id" /
            "invalid web extension" /
            "move target out of bounds" /
            "no such alert" /
            "no such network collector" /
            "no such element" /
            "no such frame" /
            "no such handle" /
            "no such history entry" /
            "no such intercept" /
            "no such network data" /
            "no such node" /
            "no such request" /
            "no such screencast" /
            "no such script" /
            "no such storage partition" /
            "no such user context" /
            "no such web extension" /
            "session not created" /
            "unable to capture screen" /
            "unable to close browser" /
            "unable to set cookie" /
            "unable to set file input" /
            "unavailable network data" /
            "underspecified storage partition" /
            "unknown command" /
            "unknown error" /
            "unsupported operation"

给定 event name 和 navigables，启用了某个事件的会话 集合为：

1. 令 sessions 为一个新的集合。

2. 对于活动 BiDi 会话中的每个 session：

   1. 如果对于 session、event name 和 navigables，事件 已启用， 则将 session 追加到 sessions。

3. 返回 sessions。

要在给定 session、 event name 和 navigables 的情况下判断某个事件 是否已启用：

注：navigables 是一个集合，因为共享 worker 可以关联 多个上下文。

1. 令 top-level traversables 为使用 navigables 调用获取顶级 traversable 的结果。

2. 对于 session 的订阅中的每个 subscription：

   1. 如果 subscription 的事件名称不包含 event name，则继续。

   2. 如果 subscription 是全局的，则返回 true。

   3. 如果用户上下文 id不为空：

      1. 对于 top-level traversables 中的每个 navigable：

         1. 如果 subscription 的用户上下文 id包含 navigable 的关联用户上下文的 用户上下文 id， 则返回 true。

   4. 否则：

      1. 令 subscription top-level traversables 为用 subscription 的顶级 traversable id 调用通过 id 获取 navigables 的结果。

      2. 如果 top-level traversables 与 subscription top-level traversables 的交集不是空，则返回 true。

3. 返回 false。

给定 event name 和 session，启用了某个事件的顶级 traversable 集合 为：

1. 令 result 为一个新的集合。

2. 对于 session 的订阅中的每个 subscription：

   1. 如果 subscription 的事件名称不 包含 event name， 则继续。

   2. 如果 subscription 是全局的：

      1. 对于远端的顶级 traversable中的每个 traversable：

         1. 将 traversable 追加到 result。

      2. 中断。

   3. 否则，如果用户上下文 id不为空：

      1. 对于远端的顶级 traversable中的每个 traversable：

         1. 如果 subscription 的用户上下文 id包含 traversable 的关联用户上下文的 用户上下文 id，则将 traversable 追加到 result。

   4. 否则：

      1. 令 top-level traversables 为用 subscription 的顶级 traversable id 调用通过 id 获取 navigables 的结果。

      2. 将 top-level traversables 中的每一项追加到 result。

3. 返回 result。

要在给定 name 的情况下获得一组 事件名称：

1. 令 events 为空集合。

2. 如果 name 包含 U+002E（句点）：

   1. 如果 name 是某个事件的事件名称，则将 name 追加到 events 并返回带有数据 events 的成功。

   2. 返回一个带有错误代码 invalid argument 的错误

3. 否则，将 name 解释为表示某个模块中的所有事件。 如果 name 不是模块名称，则返回一个错误，其 错误代码为 invalid argument。

4. 将名称为 name 的模块中每个事件的事件 名称 追加到 events。

5. 返回带有数据 events 的成功。

要在给定会话 session 的情况下，构造 WebSocket 资源名称：

1. 如果 session 为 null，返回 "/session"

2. 返回将字符串 "/session/" 与 session 的会话 ID 连接起来的结果。

要在给定WebSocket 监听器 listener 和会话 session 的情况下，构造 WebSocket URL：

1. 令 resource name 为以 session 调用构造 WebSocket 资源名称 的结果。

2. 返回一个WebSocket URI，其构造方式为：将 host 设置为 listener 的主机，port 设置为 listener 的 端口，path 设置为 resource name；如果 listener 的安全标志已设置，则遵循 wss-URI 构造，否则遵循 ws-URL 构造。

要在给定 resource name 的情况下，获取 WebSocket 资源的会话 ID：

1. 如果 resource name 不是以字节字符串 "/session/" 开头，则返回 null。

2. 令 session id 为 resource name 中跟在 "/session/" 前缀之后的字节。

3. 如果 session id 不是 UUID 的字符串表示，则返回 null。

4. 返回 session id。

要在给定会话 session 的情况下，开始监听 WebSocket 连接：

1. 如果远端想要重用活跃监听器中的某个现有WebSocket 监听器，则令 listener 为该 监听器。否则，令 listener 为一个新的WebSocket 监听器，其具有 由实现定义的主机、端口、 安全 标志，以及一个空的WebSocket 资源列表。

2. 令 resource name 为以 session 调用构造 WebSocket 资源名称 的结果。

3. 将 resource name 追加到 listener 的WebSocket 资源列表。

4. 将 listener 追加到远端的活跃监听器。

5. 返回 listener。

要在给定 WebSocket 连接 connection、类型 type 和数据 data 的情况下处理 传入消息：

1. 如果 type 不是text，则在给定 connection、 null 和invalid argument 的情况下发送错误响应，最后 返回。

2. 断言：data 是一个标量值字符串，因为 WebSocket 处理 UTF-8 编码数据中的错误否则已经 会使 WebSocket 连接失败。

   似乎没有内容 定义 UTF-8 错误使用什么状态码。

3. 如果存在一个BiDi 会话与连接关联 connection， 则令 session 为该会话。否则，如果 connection 在未与会话关联的 WebSocket 连接中，则令 session 为 null。否则，返回。

4. 令 parsed 为在给定 data 的情况下将 JSON 解析为 Infra 值的结果。如果这抛出异常，则在给定 connection、 null 和invalid argument 的情况下发送错误响应，并 最后返回。

5. 如果 session 非 null 且不在活动会话中，则返回。

6. 将 parsed 与 远端定义匹配。 如果这产生 匹配：

   1. 令 matched 为表示匹配数据的映射。

   2. 断言：matched 包含 "id"、"method" 和 "params"。

   3. 令 command id 为 matched["id"]。

   4. 令 method 为 matched["method"]

   5. 令 command 为命令名称为 method 的命令。

   6. 如果 session 为 null 且 command 不是静态命令，则 在给定 connection、command id 和invalid session id 的情况下发送错误响应，并返回。

   7. 并行运行以下步骤：

      1. 令 result 为对于 command，在给定 session 和命令参数 matched["params"] 的情况下运行远端步骤所得的结果

      2. 如果 result 是一个错误，则在给定 connection、command id 和 result 的错误代码的情况下发送 错误响应，并最后 返回。

      3. 令 value 为 result 的数据。

      4. 断言：value 与结果类型的定义匹配， 该结果类型对应于命令 名称为 method 的命令。

      5. 如果 method 是 "session.new"，则令 session 为 活动会话列表中的条目，其会话 ID等于 value 的 "sessionId" 属性；将 connection 追加 到 session 的会话 WebSocket 连接，并 从未与会话关联的 WebSocket 连接中移除 connection。

      6. 令 response 为一个新的映射，它与 CommandResponse 产生式匹配，该产生式在 本地端定义 中，其 id 字段设置为 command id，value 字段设置为 value。

      7. 令 serialized 为在给定 response 的情况下将 infra 值序列化为 JSON 字节的结果。

      8. 在 connection 上发送 WebSocket 消息，该消息由 serialized 组成。

7. 否则：

   1. 令 command id 为 null。

   2. 如果 parsed 是一个映射， 且 parsed["id"] 存在并且是一个 大于或等于零的整数，则将 command id 设置为该整数。

   3. 令 error code 为invalid argument。

   4. 如果 parsed 是一个映射， 且 parsed["method"] 存在并且是一个 字符串，但 parsed["method"] 不在所有命令名称的集合中，则将 error code 设置为unknown command。

   5. 在给定 connection、command id 和 error code 的情况下发送错误响应。

要在给定设置对象 settings 的情况下获取相关 navigables：

1. 令 related navigables 为空集合。

2. 如果 settings 的相关全局对象是一个 Window：

   1. 令 navigable 为相关全局对象的关联 Document的节点 navigable。

   2. 如果 navigable 非 null，则将 navigable 追加到 related navigables。

3. 否则，如果 settings 所指定的全局对象是一个 WorkerGlobalScope， 则对于该全局对象的 所有者集合中的每个 owner：

   1. 令 navigable 为 null。

   2. 如果 owner 是一个Document，则将 navigable 设置为 owner 的 节点 navigable。

   3. 如果 navigable 非 null，则将 navigable 追加到 related navigables。

4. 返回 related navigables。

要在给定一个 context id navigable ids 的列表的情况下通过 id 获取 navigables：

1. 令 result 为空集合。

2. 对于 navigable ids 中的每个 navigable id：

   1. 如果存在 id 为 navigable id 的navigable，则令 navigable 为该 navigable，否则为 null。

   2. 如果 navigable 非 null，则将 navigable 追加到 result。

3. 返回 result。

要在给定navigables navigables 的列表的情况下获取 顶级 traversables：

1. 令 result 为空集合。

2. 对于 navigables 中的每个 navigable：

   1. 将 navigable 的追加顶级 traversable到 result。

3. 返回 result。

要在给定 context id navigable ids 的列表的情况下通过 id 获取有效 navigables：

1. 令 result 为空集合。

2. 对于 navigable ids 中的每个 navigable id：

   1. 令 navigable 为尝试用 navigable id 获取 navigable的结果。

   2. 将 navigable 追加到 result。

3. 返回带有数据 result 的成功。

要在给定 context id navigable ids 的列表的情况下通过 id 获取有效顶级 traversables：

1. 令 result 为空集合。

2. 对于 navigable ids 中的每个 navigable id：

   1. 令 navigable 为尝试用 navigable id 获取 navigable的结果。

   2. 如果 navigable 不是顶级 traversable，则返回带有错误代码 invalid argument 的错误。

   3. 将 navigable 追加到 result。

3. 返回带有数据 result 的成功。

要在给定 session 和 body 的情况下发出事件：

1. 断言：body 与 Event 产生式匹配。

2. 令 serialized 为在给定 body 的情况下将 infra 值序列化为 JSON 字节的结果。

3. 对于 session 的会话 WebSocket 连接中的每个 connection：

   1. 在 connection 上发送 WebSocket 消息，该消息由 serialized 组成。

要在给定 WebSocket 连接 connection、command id 和 error code 的情况下发送错误 响应：

1. 令 error data 为一个新的映射，与 本地端定义中的 ErrorResponse 产生式匹配， 其中 id 字段 设置为 command id，error 字段设置为 error code， message 字段设置为一个实现定义的字符串， 包含对所发生错误的人类可读定义，并且 stacktrace 字段可选地设置为一个实现定义的 字符串，包含错误发生时活动栈帧的栈跟踪报告。

2. 令 response 为在给定 error data 的情况下将 infra 值序列化为 JSON 字节 的结果。

   注：command id 可以为 null，在 这种情况下，id 字段也会 被设置为 null，而不会从 response 中省略。

3. 在 connection 上发送 WebSocket 消息，该消息由 response 组成。

要在给定 WebSocket 连接 connection 的情况下处理连接 关闭：

1. 如果存在一个BiDi 会话与连接关联 connection：

   1. 令 session 为与连接关联 connection 的 BiDi 会话。

   2. 从 session 的会话 WebSocket 连接中移除 connection。

2. 否则，如果未与会话关联的 WebSocket 连接 包含 connection，则从该集合中移除 connection。

注： 这不会结束任何会话。

需要挂接到 会话结束，以允许 UA 在需要时关闭 监听器。

要在给定 session 的情况下关闭 WebSocket 连接：

1. 对于 session 的会话 WebSocket 连接中的每个 connection：

   1. 使用 connection 开始 WebSocket 关闭握手。

      注：这将导致 对 connection 运行处理连接关闭中的步骤， 这些步骤将清理与 connection 关联的资源。

本规范定义的 WebDriver 新会话算法， 其参数为 session、capabilities 和 flags，如下：

1. 如果 flags 包含 "bidi"，则返回。

2. 令 webSocketUrl 为从 capabilities 获取名为 "webSocketUrl" 的属性的结果。

3. 如果 webSocketUrl 是 undefined，则返回。

4. 断言：webSocketUrl 为 true。

5. 令 listener 为在给定 session 的情况下开始监听 WebSocket 连接的结果。

6. 将 webSocketUrl 设置为用 listener 和 session 构造 WebSocket URL的结果。

7. 在 capabilities 上设置名为 "webSocketUrl" 的属性为 webSocketUrl。

8. 将 session 的 BiDi 标志设置为 true。

9. 将 "bidi" 追加到 flags。

实现还应允许客户端建立一个 不是 HTTP 会话的 BiDi 会话。在这种情况下，WebSocket 服务器的 URL 通过带外方式传达。允许这样做的实现支持 仅 BiDi 会话。当这样的实现准备好接受 启动 WebDriver 会话的请求时，它必须：

1. 在给定 null 的情况下开始监听 WebSocket 连接。

要在给定 name 和 navigable 的情况下获取或 创建沙盒 realm：

1. 如果 name 为空字符串，则返回带有 错误代码 invalid argument 的错误。

2. 令 window 为 navigable 的活动窗口。

3. 如果沙盒映射不 包含 window，则将沙盒映射[window] 设置为新的映射。

4. 令 sandboxes 为沙盒映射[window]。

5. 如果 sandboxes 不包含 name，则将 sandboxes[name] 设置为用 navigable 调用创建沙盒 realm的结果。

6. 返回带有数据 sandboxes[name] 的成功。

要用 window 创建沙盒 realm：

定义 沙盒 realm 的创建。这将返回一个 SandboxWindowProxy， 其包装 window。

要在给定 target realm 的情况下获取沙盒 名称：

1. 令 realms maps 为获取沙盒映射的值所得的结果。

2. 对于 realms maps 中的每个 realms map：

   1. 对于 realms map 中的每个 name → realm：

      1. 如果 realm 是 target realm，则返回 name。

3. 返回 null。

要获取解包装的 object：

1. 只要 object 是 SandboxProxy 或 SandboxWindowProxy， 就将 object 设置为它的 被包装对象。

2. 返回 object。

要移除 用户上下文订阅：

1. 对于活动会话中的每个 session：

   1. 令 subscriptions to remove 为一个集合。

   2. 对于 session 的订阅中的每个 subscription：

      1. 如果 subscription 的用户上下文 id 包含 navigable 的关联用户上下文的用户上下文 id；

         1. 从 subscription 的用户上下文 id中移除 navigable 的关联用户上下文的 用户上下文 id。

         2. 如果 subscription 的用户上下文 id 为空：

            1. 将 subscription 追加到 subscriptions to remove。

   3. 从 session 的订阅中移除 subscriptions to remove。

要在给定 user context id 的情况下获取用户上下文：

1. 对于用户上下文集合中的每个 user context：

2. 如果 user context 的用户上下文 id等于 user context id：

   1. 返回 user context。

3. 返回 null。

要在给定 user context ids 的情况下获取有效用户 上下文：

1. 令 result 为空集合。

2. 对于 user context ids 中的每个 user context id：

   1. 将 user context 设置为用 user context id 调用获取用户上下文的结果。

   2. 如果 user context 为 null，则返回带有 错误代码 no such user context 的错误。

   3. 将 user context 追加到 result。

3. 返回 result。

SessionCommand = (
  session.End //
  session.New //
  session.Status //
  session.Subscribe //
  session.Unsubscribe
)

SessionResult = (
  session.EndResult /
  session.NewResult /
  session.StatusResult /
  session.SubscribeResult /
  session.UnsubscribeResult
)

要在给定 session 的情况下结束会话：

1. 从活动会话中移除 session。

2. 如果活动会话为空，则将 webdriver-active 标志 设置为 false。

要在给定 session 的情况下清理 会话：

1. 使用 session 关闭 WebSocket 连接。

2. 对于用户上下文集合中的每个 user context：

   1. 移除 session 的 用户上下文到接受不安全证书覆盖映射[user context]。

   2. 移除 session 的 用户上下文到代理配置映射[user context]。

3. 对于 session 的已阻塞请求映射中的每个 request id →（request、phase、response）：

   1. 使用 "continue request"、request id 和（response、"incomplete"）恢复。

4. 对于 session 的网络收集器中的每个 collector：

   1. 令 collector id 为 collector 的收集器。

   2. 对于已收集的网络 数据中的每个 collected data，使用 collected data 和 collector id 从数据中移除收集器。

5. 对于 session 的 屏幕录制映射中的每个 screencast recording：

   1. 给定 screencast recording，停止屏幕录制。

   2. 从屏幕录制映射中移除 screencast recording。

6. 如果活动会话为空，则清理远端状态。

7. 执行任何特定于实现的清理步骤。

要清理远端 状态。

1. 清空发送请求前映射。

2. 将默认缓存行为设置为 "default"。

3. 清空navigable 缓存行为映射。

4. 执行实现定义的步骤，以启用当前远端配置中通常启用的任何 特定于实现的资源缓存。

session.CapabilitiesRequest = {
  ? alwaysMatch: session.CapabilityRequest,
  ? firstMatch: [*session.CapabilityRequest]
}

session.CapabilityRequest = {
  ? acceptInsecureCerts: bool,
  ? browserName: text,
  ? browserVersion: text,
  ? platformName: text,
  ? proxy: session.ProxyConfiguration,
  ? unhandledPromptBehavior: session.UserPromptHandler,
  Extensible
}

"webSocketUrl" 能力的额外能力反序列化 算法，参数为 value，如下：

1. 如果 value 不是 boolean，则返回带有代码 invalid argument 的错误。

2. 返回带有数据 value 的成功。

"webSocketUrl" 能力的匹配能力序列化 算法， 参数为 value，如下：

1. 如果 value 为 false，则返回带有数据 null 的成功。

2. 返回带有数据 true 的成功。

session.ProxyConfiguration = {
   session.AutodetectProxyConfiguration //
   session.DirectProxyConfiguration //
   session.ManualProxyConfiguration //
   session.PacProxyConfiguration //
   session.SystemProxyConfiguration
}

session.AutodetectProxyConfiguration = (
   proxyType: "autodetect",
   Extensible
)

session.DirectProxyConfiguration = (
   proxyType: "direct",
   Extensible
)

session.ManualProxyConfiguration = (
   proxyType: "manual",
   ? httpProxy: text,
   ? sslProxy: text,
   ? session.SocksProxyConfiguration,
   ? noProxy: [*text],
   Extensible
)

session.SocksProxyConfiguration = (
   socksProxy: text,
   socksVersion: 0..255,
)

session.PacProxyConfiguration = (
   proxyType: "pac",
   proxyAutoconfigUrl: text,
   Extensible
)

session.SystemProxyConfiguration = (
   proxyType: "system",
   Extensible
)

session.UserPromptHandler = {
  ? alert: session.UserPromptHandlerType,
  ? beforeUnload: session.UserPromptHandlerType,
  ? confirm: session.UserPromptHandlerType,
  ? default: session.UserPromptHandlerType,
  ? file: session.UserPromptHandlerType,
  ? prompt: session.UserPromptHandlerType,
}

session.UserPromptHandlerType = "accept" / "dismiss" / "ignore";

session.Subscription = text

session.SubscribeParameters = {
  events: [+text],
  ? contexts: [+browsingContext.BrowsingContext],
  ? userContexts: [+browser.UserContext],
}

session.UnsubscribeByIDRequest = {
  subscriptions: [+session.Subscription],
}

session.UnsubscribeByAttributesRequest = {
  events: [+text],
}

给定 session 和 command parameters 时，远端步骤为：

1. 令 body 为一个具有以下属性的新映射：

   "ready"

   远端的就绪状态。

   "message"

   一个实现定义的字符串，用于解释远端的 就绪状态。

2. 返回带有数据 body 的成功

给定 session 和 command parameters 时，远端步骤为：

1. 如果 session 不是 null，则返回一个错误，错误 代码为 session not created。

2. 如果实现因任何原因无法启动新会话，则返回 一个错误，错误代码为 session not created。

3. 令 flags 为一个包含 "bidi" 的集合。

4. 令 capabilities json 为使用 command parameters 和 flags 尝试处理能力 所得的结果。

5. 令 capabilities 为用 capabilities json 调用将 JSON 派生的 JavaScript 值转换为 Infra 值的结果。

6. 令 session 为使用 capabilities 和 flags 尝试创建会话所得的结果。

7. 将 session 的 BiDi 标志设置为 true。

   注：此会话的连接将由调用者设置为当前连接。

8. 令 body 为一个新的映射， 它与 session.NewResult 产生式匹配， 其 sessionId 字段设置为 session 的会话 ID，并且 capabilities 字段设置为 capabilities。

9. 返回带有数据 body 的成功。

给定 session 和 command parameters 时，远端步骤为：

1. 使用 session 结束会话。

2. 返回带有数据 null 的成功，并并行运行以下 步骤：

   1. 等到发送 WebSocket 消息步骤已使用 对此命令的 响应被调用。

      这 是相当不精确的语言，但希望意图很清楚： 在开始关闭连接之前，我们要先发送命令响应。

   2. 使用 session 清理会话。

给定 session 和 command parameters 时，远端步骤为：

1. 令 event names 为空集合。

2. 对于 command parameters["events"] 中的每个条目 name，令 event names 为 event names 与尝试用 name 获得一组 事件名称的结果的并集。

3. 令 input user context ids 为用 command parameters[userContexts] 创建集合所得的结果。

4. 令 input context ids 为用 command parameters[contexts] 创建集合所得的结果。

5. 如果 input user context ids 非空且 input context ids 非空， 则返回带有错误 代码 invalid argument 的错误。

6. 令 subscription navigables 为一个集合。

7. 令 top-level traversable context ids 为一个集合。

8. 如果 input context ids 非空：

   1. 令 navigables 为尝试用 input context ids 通过 id 获取有效 navigables的结果。

   2. 将 subscription navigables 设置为用 navigables 调用获取 顶级 traversables的结果。

   3. 对于 subscription navigables 中的每个 navigable：

      1. 将 navigable 的navigable id 追加到 top-level traversable context ids。

9. 否则，如果 input user context ids 非空：

   1. 对于 input user context ids 中的每个 user context id：

      1. 令 user context 为用 user context id 调用获取用户上下文的结果。

      2. 如果 user context 为 null，则返回带有错误代码 no such user context 的错误。

      3. 对于所有其关联用户上下文为 user context 的顶级 traversable列表中的每个 top-level traversable：

         1. 将 top-level traversable 追加到 subscription navigables。

10. 否则，将 subscription navigables 设置为远端中所有 顶级 traversable组成的集合。

11. 令 subscription 为一个订阅，其 订阅 id设置为 UUID 的字符串表示， 事件名称设置为 event names， 顶级 traversable id设置为 top-level traversable context ids，并且 用户上下文 id设置为 input user context ids。

12. 令 subscribe step events 为一个新的映射。

13. 对于 event names 中的每个 event name：

    1. 如果事件（其事件 名称为 event name）没有定义远端订阅步骤， 则继续；

    2. 令 existing navigables 为使用 session 和 event name 调用启用了某个事件的顶级 traversable 集合的结果。

    3. 将 subscribe step events[event name] 设置为 subscription navigables 与 existing navigables 的差集。

14. 将 subscription 追加到 session 的订阅。

15. 将 subscription 的订阅 id追加到 session 的已知订阅 id。

16. 使用以下小于算法，按升序排序 subscribe step events；给定两个键为 event name one 和 event name two 的条目：

    1. 令 event one 为名称为 event name one 的事件

    2. 令 event two 为名称为 event name two 的事件

    3. 如果 event one 的订阅 优先级小于 event two 的订阅优先级，则返回 true，否则返回 false。

17. 如果 subscription 是全局的，则令 include global 为 true， 否则令 include global 为 false。

18. 对于 subscribe step events 中的每个 event name → navigables：

    1. 对事件（其事件 名称为 event name）运行远端订阅步骤，给定 session、navigables 和 include global。

19. 令 body 为一个新的映射， 它与 session.SubscribeResult 产生式匹配， 其 subscription 字段设置为 subscription 的订阅 id。

20. 返回带有数据 body 的成功。

给定 session 和 command parameters 时，远端步骤为：

1. 如果 command parameters 不包含 "subscriptions"：

   注：该条件意味着 command parameters 与 session.UnsubscribeByAttributesRequest 产生式匹配。

   1. 令 event names 为空集合。

   2. 对于 command parameters["events"] 中的每个条目 name， 令 event names 为 event names 与尝试用 name 获得 一组事件名称所得结果的并集。

   3. 令 new subscriptions 为一个列表。

   4. 令 matched events 为一个集合。

   5. 对于 session 的订阅中的每个 subscription：

      1. 如果 subscription 的 事件名称与 event names 的交集是一个空集合：

         1. 将 subscription 追加到 new subscriptions。

         2. 继续。

      2. 如果 subscription 不是全局的：

         1. 将 subscription 追加到 new subscriptions。

         2. 继续。

      3. 令 subscription event names 为 subscription 的事件名称的克隆。

      4. 对于 event names 中的每个 event name：

         1. 如果 subscription event names 包含 event name：

            1. 将 event name 追加到 matched events。

            2. 从 subscription event names 中移除 event name。

      5. 如果 subscription event names 非空：

         1. 令 cloned subscription 为一个订阅，其 订阅 id设置 为 subscription 的订阅 id， 事件名称设置为一个新的 集合，其中包含 subscription event names。

         2. 将 cloned subscription 追加到 new subscriptions。

   6. 如果 matched events 不等于 event names，则返回带有 错误代码 invalid argument 的错误。

   7. 将 session 的订阅设置为 new subscriptions。

2. 否则：

   1. 令 subscriptions 为用 command parameters[subscriptions] 创建 集合所得的结果。

   2. 令 unknown subscription ids 为 subscriptions 与 session 的已知订阅 id之间的差集。

   3. 如果 unknown subscription ids 非空：

      1. 返回带有错误代码 invalid argument 的错误。

   4. 令 subscriptions to remove 为空集合。

   5. 对于 session 的订阅中的每个 subscription：

      1. 如果 subscriptions 包含 subscription 的订阅 id：

         1. 将 subscription 追加到 subscriptions to remove。

   6. 将 session 的已知订阅 id设置为 session 的已知订阅 id与 subscriptions之间的差集。

   7. 从 session 的订阅中移除 subscriptions to remove 中的每一项。

3. 返回带有数据 null 的成功。

BrowserCommand = (
  browser.Close //
  browser.CreateUserContext //
  browser.GetClientWindows //
  browser.GetUserContexts //
  browser.RemoveUserContext //
  browser.SetClientWindowState //
  browser.SetDownloadBehavior
)

BrowserResult = (
  browser.CloseResult /
  browser.CreateUserContextResult /
  browser.GetClientWindowsResult /
  browser.GetUserContextsResult /
  browser.RemoveUserContextResult /
  browser.SetClientWindowStateResult /
  browser.SetDownloadBehaviorResult
)

要在给定 window 的情况下获取 客户端窗口状态：

1. 令 documents 为空列表。

2. 令 visible documents 为空列表。

3. 对于每个顶级 traversable traversable：

   1. 如果 traversable 的客户端窗口不是 window，则 继续。

   2. 令 document 为 traversable 的活动文档。

   3. 将 document 追加到 documents。

   4. 如果 document 的可见性状态为 "visible"， 则将 document 追加到 visible documents。

4. 对于 visible documents 中的每个 document：

   1. 如果 document 的全屏元素不是 null，则返回 "fullscreen"。

5. 如果 visible documents 为空但 documents 不是 空，或者如果 window 以其他方式处于特定于 OS 的 最小化状态，则返回 "minimized"。

   注：这通常但不一定意味着 window 的宽度和高度等于 0。

6. 如果 window 处于特定于 OS 的最大化状态，则返回 "maximized"。

   注：这通常但不一定意味着 window 的宽度等于Web 暴露屏幕区域的宽度，并且 window 的高度等于 Web 暴露屏幕区域的高度。

7. 返回 "normal"。

要在给定 window 和 state 的情况下设置 客户端窗口状态：

1. 令 current state 为使用 window 获取客户端窗口状态的结果。

2. 如果 current state 是 "fullscreen"、"maximized" 或 "minimized"，且等于 state，则返回带有数据 null 的成功。

3. 在以下条件及其关联步骤列表中，运行第一个关联条件为 true 的步骤集：

   "fullscreen"

   如果不支持全屏，则返回带有错误代码 unsupported operation 的错误。

   "normal"

   如果对于 window 不支持还原客户端窗口， 则返回带有 错误代码 unsupported operation 的错误。

   "maximize"

   如果对于 window 不支持最大化客户端窗口， 则返回带有 错误代码 unsupported operation 的错误。

   "minimize"

   如果对于 window 不支持最小化客户端窗口， 则返回带有 错误代码 unsupported operation 的错误。

4. 令 documents 为空列表。

5. 对于每个顶级 traversable traversable：

   1. 如果 traversable 的关联客户端窗口不是 window，则 继续。

   2. 令 document 为 traversable 的活动文档。

   3. 将 document 追加到 documents。

6. 如果 documents 为空，则返回 带有错误 代码 no such client window 的错误。

7. 如果 current state 是 "fullscreen"：

   1. 对于 documents 中的每个 document：

      1. 使用 document 完全退出全屏。

         注：对于窗口中并非全屏的 文档，这是无操作。

8. 如果 current state 是 "maximized" 或 "minimized"：

   1. 还原客户端窗口 window。

9. 根据 state 的值进行切换：

   "fullscreen"

   1. 对于 documents 中的每个 document：

      1. 如果 document 的可见性状态为 "visible"， 则使用 document 的document element使元素全屏。

      2. 中断。

   "maximize"

   1. 最大化客户端窗口 window。

   "minimize"

   1. 最小化客户端窗口 window。

10. 返回带有数据 null 的成功。

browser.ClientWindow = text;

browser.ClientWindowInfo = {
  active: bool,
  clientWindow: browser.ClientWindow,
  height: js-uint,
  state: "fullscreen" / "maximized" / "minimized" / "normal",
  width: js-uint,
  x: js-int,
  y: js-int,
}

要在给定 client window 的情况下获取客户端 窗口信息：

1. 令 client window id 为 client window 的客户端窗口 id。

2. 令 state 为使用 client window 调用获取客户端窗口状态的结果。

3. 如果 client window 能够接收从操作系统传送来的键盘输入， 则令 active 为 true，否则令 active 为 false。

   注：这可能意味着某个顶级 traversable（其客户端窗口是 client window）具有系统焦点，也可能意味着浏览器自身的 用户界面当前具有焦点。

4. 令 client window info 为一个映射， 它与 browser.ClientWindowsInfo 产生式匹配，其 clientWindow 字段设置为 client window id，state 字段设置为 state，x 字段设置为 client window 的 x 坐标，y 字段设置为 client window 的y 坐标，width 字段设置 为 client window 的宽度，height 字段 设置为 client window 的高度，且 active 字段设置为 active。

5. 返回 client window info

browser.UserContext = text;

browser.UserContextInfo = {
  userContext: browser.UserContext
}

给定 session 和 command parameters 时，远端步骤为：

1. 使用 session 结束会话。

2. 如果活动会话不是空，实现可以 返回带有错误 代码 unable to close browser 的错误，然后 并行运行以下步骤：

   1. 等到发送 WebSocket 消息步骤已使用 对此命令的 响应被调用。

   2. 使用 session 清理会话。

   注：当浏览器具有多个自动化 会话时的行为目前未指定。可能是任何会话都可以关闭 浏览器，也可能只有最后一个打开的会话才能实际关闭浏览器， 或者只有第一个启动的会话可以。此行为可能会在本规范的未来版本中 完全指定。

3. 对于活动会话中的每个 active session：

   1. 结束 会话 active session。

   2. 使用 active session 清理会话

4. 返回带有数据 null 的成功，并并行运行以下步骤。

   1. 等到发送 WebSocket 消息步骤已使用 对此命令的 响应被调用。

   2. 使用 session 清理会话。

   3. 在不提示卸载的情况下关闭任何顶级 traversable。

   4. 执行实现定义的步骤，以清理与自动化控制下的远端关联的资源。

      注：例如，这可能包括 干净地关闭与自动化控制下的浏览器关联的任何 OS 级 进程、移除临时 状态（例如远端在自动化控制期间创建的用户配置文件数据）， 或关闭WebSocket 监听器。由于 浏览器和操作系统之间存在差异，无法在这里详细 指定本地端可依赖的精确不变式。

给定 session 和 command parameters 时，远端步骤为：

1. 令 user context 为一个新的用户上下文。

2. 如果 command parameters 包含 "acceptInsecureCerts"：

   注：如果设置了 "acceptInsecureCerts"， 它会覆盖 接受不安全 TLS 标志的行为。

   1. 令 acceptInsecureCerts 为 command parameters["acceptInsecureCerts"]：

   2. 如果 acceptInsecureCerts 为 true，且端点节点不支持 接受不安全 TLS 连接，则返回带有 错误代码 unsupported operation 的错误。

   3. 将 session 的 用户上下文到接受不安全证书覆盖映射[user context] 设置为 acceptInsecureCerts。

3. 如果 command parameters 包含 "unhandledPromptBehavior"， 则将未处理提示行为覆盖 映射[user context] 设置为 command parameters["unhandledPromptBehavior"]。

4. 如果 command parameters 包含 "proxy"：

   1. 令 proxy configuration 为 command parameters["proxy"]。

   2. 如果远端无法按用户 上下文配置代理设置， 或无法用 proxy configuration 配置代理，则返回带有 错误代码 unsupported operation 的错误。

   3. 将 session 的 用户上下文到代理 配置映射[user context] 设置为 proxy configuration。

5. 将 user context 追加到用户上下文集合。

6. 令 user context info 为一个映射， 它与 browser.UserContextInfo 产生式匹配，其 userContext 字段设置为 user context 的用户上下文 id。

7. 返回带有数据 user context info 的成功。

远端步骤为：

1. 令 client window ids 为空集合。

2. 令 client windows 为空列表。

3. 对于每个顶级 traversable traversable：

   1. 令 client window 为 traversable 的关联客户端 窗口

   2. 令 client window id 为 client window 的客户端窗口 id。

   3. 如果 client window ids 包含 client window id，则继续。

   4. 将 client window id 追加到 client window ids。

   5. 令 client window info 为使用 client window 调用获取 客户端窗口信息的结果。

   6. 将 client window info 追加到 client windows。

4. 令 result 为一个映射， 它与 browser.GetClientWindowsResult 产生式匹配，其 clientWindows 字段设置为 client windows。

5. 返回带有数据 result 的成功。

远端步骤为：

1. 令 user contexts 为空列表。

2. 对于用户上下文集合中的每个 user context：

   1. 令 user context info 为一个映射， 它与 browser.UserContextInfo 产生式匹配，其 userContext 字段设置为 user context 的用户 上下文 id。

   2. 将 user context info 追加到 user contexts。

3. 令 result 为一个映射， 它与 browser.GetUserContextsResult 产生式匹配，其 userContexts 字段设置为 user contexts。

4. 返回带有数据 result 的成功。

给定 command parameters 时，远端步骤为：

1. 令 user context id 为 command parameters["userContext"]。

2. 如果 user context id 是 "default"，则返回带有错误代码 invalid argument 的错误。

3. 将 user context 设置为用 user context id 调用获取用户上下文的结果。

4. 如果 user context 为 null，则返回带有错误代码 no such user context 的错误。

5. 对于每个顶级 traversable navigable：

   1. 如果 navigable 的关联用户上下文是 user context：

      1. 在不提示卸载的情况下关闭 navigable。

6. 从用户上下文集合中移除 user context。

7. 返回带有数据 null 的成功。

给定 session 和 command parameters 时，远端步骤为：

1. 如果实现完全不支持设置客户端窗口状态， 则返回带有错误 代码 unsupported operation 的错误。

2. 如果存在一个客户端 窗口，其客户端窗口 id 为 command parameters["clientWindow"]，则令 client window 为该客户端窗口。 否则返回带有错误 代码 no such client window 的错误。

3. 尝试使用 client window 和 command parameters["state"] 设置客户端窗口状态。

4. 如果 command parameters["state"] 是 "normal"：

   1. 如果 command parameters 包含 "x"，并且 实现支持定位客户端窗口，则将 client window 的x 坐标设置为尽可能接近 command parameters["x"] 的值。

   2. 如果 command parameters 包含 "y"，并且 实现支持定位客户端窗口，则将 client window 的y 坐标设置为尽可能接近 command parameters["y"] 的值。

   3. 如果 command parameters 包含 "width"，并且 实现支持调整客户端窗口大小，则将 client window 的宽度设置为尽可能接近 command parameters["width"] 的值。

   4. 如果 command parameters 包含 "width"，并且 实现支持调整客户端窗口大小，则将 client window 的宽度设置为尽可能接近 command parameters["width"] 的值。

5. 令 client window info 为使用 client window 调用获取客户端窗口信息的结果。

6. 返回带有数据 client window info 的成功。

注：为简单起见，这里将所有客户端窗口 操作都建模为 同步。因此，返回的客户端窗口尺寸预期是 窗口达到其新状态之后的尺寸。

要在给定 navigable 的情况下获取下载 行为：

1. 令 user context 为 navigable 的关联用户 上下文。

2. 如果下载 行为的user context download behavior 包含 user context，则返回下载行为的 user context download behavior[user context]。

3. 返回下载 行为的default download behavior。

给定 session 和 command parameters 时，远端步骤为：

1. 如果 command parameters["downloadBehavior"] 为 null，则令 download behavior 为 null。

2. 否则：

   1. 如果 command parameters["downloadBehavior"]["type"] 是 "allowed"，则令 allowed 为 true，否则令 allowed 为 false。

   2. 如果 command parameters["downloadBehavior"] 包含 "destinationFolder"，则令 destinationFolder 为 command parameters["downloadBehavior"]["destinationFolder"]， 否则令 destinationFolder 为 null。

   3. 令 download behavior 为一个下载 行为结构体，其 allowed 设置为 allowed， 且 destinationFolder 设置 为 destinationFolder。

3. 如果实现不支持所需的 download behavior，则返回 带有错误 代码 unsupported operation 的错误。

4. 如果 command parameters 的 userContexts 字段存在：

   1. 令 user contexts 为尝试用 command parameters["userContexts"] 获取有效用户上下文 所得的结果。

   2. 对于 user contexts 中的每个 user context：

      1. 如果 download behavior 为 null，则从下载行为的 user context download behavior中移除 user context。

      2. 否则，将下载 行为的 user context download behavior[user context] 设置为 download behavior。

5. 否则，将下载行为的default download behavior设置为 download behavior。

6. 返回带有数据 null 的成功。

BrowsingContextCommand = (
  browsingContext.Activate //
  browsingContext.CaptureScreenshot //
  browsingContext.Close //
  browsingContext.Create //
  browsingContext.GetTree //
  browsingContext.HandleUserPrompt //
  browsingContext.LocateNodes //
  browsingContext.Navigate //
  browsingContext.Print //
  browsingContext.Reload //
  browsingContext.SetBypassCSP //
  browsingContext.SetViewport //
  browsingContext.StartScreencast //
  browsingContext.StopScreencast //
  browsingContext.TraverseHistory
)

BrowsingContextResult = (
  browsingContext.ActivateResult /
  browsingContext.CaptureScreenshotResult /
  browsingContext.CloseResult /
  browsingContext.CreateResult /
  browsingContext.GetTreeResult /
  browsingContext.HandleUserPromptResult /
  browsingContext.LocateNodesResult /
  browsingContext.NavigateResult /
  browsingContext.PrintResult /
  browsingContext.ReloadResult /
  browsingContext.SetBypassCSPResult /
  browsingContext.SetViewportResult /
  browsingContext.StartScreencastResult /
  browsingContext.StopScreencastResult /
  browsingContext.TraverseHistoryResult
)

BrowsingContextEvent = (
  browsingContext.ContextCreated //
  browsingContext.ContextDestroyed //
  browsingContext.DomContentLoaded //
  browsingContext.DownloadEnd //
  browsingContext.DownloadWillBegin //
  browsingContext.FragmentNavigated //
  browsingContext.HistoryUpdated //
  browsingContext.Load //
  browsingContext.NavigationAborted //
  browsingContext.NavigationCommitted //
  browsingContext.NavigationFailed //
  browsingContext.NavigationStarted //
  browsingContext.UserPromptClosed //
  browsingContext.UserPromptOpened
)

要在给定屏幕录制 recording 和 mime type 的情况下，启动屏幕录制：

1. 并行运行以下步骤：

   1. 开始使用 mime type 对 recording 的stream进行编码， 生成连续的编码数据块，作为字节 序列。 当 recording 的state 为 "recording" 时， 以实现定义的间隔生成一个新块。

   2. 对于为 recording 生成的每个块 bytes，运行以下 步骤：

      1. 将 bytes 追加到 recording 的path处的文件。 如果失败：

         1. 将 recording 的writeError 设为一个 描述写入失败的实现定义字符串。

         2. 给定 recording，停止屏幕录制。

要在给定屏幕录制 recording 的情况下，停止屏幕录制：

1. 如果 recording 的state 不是 "recording"，则 返回。

2. 将 recording 的state 设为 "stopping"。

3. 停止为 recording 生成新块，刷新任何剩余的已编码 数据作为最后一个块（按启动屏幕录制中的方式处理）， 停止从 recording 的stream 捕获，并 释放其 视频轨道以及（如果存在）其 音频轨道，然后将 recording 的 state 设为 "stopped"。

4. 等待，直到 recording 的state 为 "stopped"。

browsingContext.BrowsingContext = text;

要在给定 navigable id 的情况下获取 navigable：

1. 如果 navigable id 为 null，则返回带有数据 null 的成功。

2. 如果不存在navigable id 为 navigable id 的 navigable，则返回 带有错误 代码 no such frame 的错误

3. 令 navigable 为 id 为 navigable id 的navigable。

4. 返回带有数据 navigable 的成功。

browsingContext.InfoList = [*browsingContext.Info]

browsingContext.Info = {
  children: browsingContext.InfoList / null,
  clientWindow: browser.ClientWindow,
  context: browsingContext.BrowsingContext,
  originalOpener: browsingContext.BrowsingContext / null,
  url: text,
  userContext: browser.UserContext,
  ? parent: browsingContext.BrowsingContext / null,
}

要在给定 navigable 的情况下获取子 navigable：

TODO：使其按文档顺序返回列表

1. 令 child navigables 为一个集合， 包含所有作为 navigable 的子 navigable的 navigable。

2. 返回 child navigables。

要在给定 navigable、 max depth 和 include parent id 的情况下获取 navigable 信息：

1. 令 navigable id 为 navigable 的navigable id。

2. 令 parent navigable 为 navigable 的父级。

3. 如果 parent navigable 非 null，则令 parent id 为 parent navigable 的navigable id。否则令 parent id 为 null。

4. 令 document 为 navigable 的活动文档。

5. 令 url 为在给定 document 的URL的情况下运行 URL 序列化器所得的结果。

   注：这包括 URL 的片段组成部分。

6. 令 child infos 为 null。

7. 如果 max depth 为 null，或 max depth 大于 0：

   1. 令 child navigables 为给定 navigable 时调用获取子 navigable的结果。

   2. 如果 max depth 非 null，则令 child depth 为 max depth - 1， 否则为 null。

   3. 将 child infos 设置为空列表。

   4. 对于 child navigables 中的每个 child navigable：

      1. 令 info 为给定 child navigable、child depth 和 false 时调用获取 navigable 信息的结果。

      2. 将 info 追加到 child infos

8. 令 user context 为 navigable 的关联用户 上下文。

9. 如果 navigable 的original opener 非 null， 则令 opener id 为 navigable 的 original opener的navigable id， 否则为 null。

10. 令 top-level traversable 为 navigable 的顶级 traversable。

11. 令 client window id 为 top-level traversable 的关联客户端窗口的客户端窗口 id。

12. 令 navigable info 为一个映射， 它与 browsingContext.Info 产生式匹配，其中 context 字段设置为 navigable id；如果 include parent id 为 true，则 parent 字段设置为 parent id，否则不设置； url 字段设置为 url；userContext 字段设置 为 user context 的用户上下文 id；originalOpener 字段 设置为 opener id；children 字段设置为 child infos；且 clientWindow 字段设置为 client window id。

13. 返回 navigable info。

要在给定 navigable、request、wait condition， 以及可选的 history handling（默认值："default"）和 ignore cache（默认值：false）的情况下 等待导航：

1. 令 navigation id 为一个基于真正随机数或 伪随机数的 UUID 的字符串表示。

2. 用资源 request 导航 navigable， 并使用 navigable 的活动文档作为来源 Document， 导航时使用 navigation id navigation id 和 历史处理行为 history handling。如果 ignore cache 为 true， 则该导航不得从 HTTP 缓存加载资源。

   准确 指定 ignore cache 标志如何工作。这需要 考虑是否只有资源的首次加载会绕过缓存 （即这是否类似于最初清除缓存然后像 通常一样继续），或者不是由 HTML 解析器直接加载的资源 （例如由脚本或样式表发起的加载）是否也会绕过缓存。

3. 令（event received、navigation status）为在给定 «"navigation started", "navigation failed", "fragment navigated"» 和 navigation id 的情况下进行 await 的结果。

4. 断言：navigation status 的id 是 navigation id。

5. 如果 navigation status 的status 是 "complete"：

   1. 令 body 为一个映射， 它与 browsingContext.NavigateResult 产生式匹配，其中 navigation 字段设置为 navigation id，且 url 字段设置为在给定 navigation status 的url时运行 URL 序列化器所得的结果。

   2. 返回带有数据 body 的成功。

   注：如果导航仅导致片段 改变，就是这种情况。

6. 如果 navigation status 的status 是 "canceled"， 则返回带有错误 代码 unknown error 的错误。

   TODO：这是在这里处理错误的正确方式吗？

7. 断言：navigation status 的status 是 "pending"，并且 navigation id 不是 null。

8. 如果 wait condition 是 "committed"，则令 event name 为 "committed"。

9. 否则，如果 wait condition 是 "interactive"，则令 event name 为 "domContentLoaded"。

10. 否则，令 event name 为 "load"。

11. 令（event received、status）为在给定 «event name, "download started", "navigation aborted", "navigation failed"» 和 navigation id 的情况下进行 await 的结果。

12. 如果 event received 是 "navigation failed"， 则返回带有错误 代码 unknown error 的错误。

    我们在这里用 错误暴露了足够多关于失败内容和原因的信息吗？ 我们想要什么错误代码？本地端是否会解析实现定义的字符串 来弄清楚实际出了什么问题，从而造成问题？

13. 令 body 为一个映射， 它与 browsingContext.NavigateResult 产生式匹配，其中 navigation 字段设置为 status 的 id，且 url 字段设置为在给定 status 的 url 时运行 URL 序列化器所得的结果。

14. 返回带有数据 body 的成功。

browsingContext.Locator = (
   browsingContext.AccessibilityLocator /
   browsingContext.CssLocator /
   browsingContext.ContextLocator /
   browsingContext.InnerTextLocator /
   browsingContext.XPathLocator
)

browsingContext.AccessibilityLocator = {
   type: "accessibility",
   value: {
    ? name: text,
    ? role: text,
   }
}

browsingContext.CssLocator = {
   type: "css",
   value: text
}

browsingContext.ContextLocator = {
  type: "context",
  value: {
    context: browsingContext.BrowsingContext,
  }
}

browsingContext.InnerTextLocator = {
   type: "innerText",
   value: text,
   ? ignoreCase: bool
   ? matchType: "full" / "partial",
   ? maxDepth: js-uint,
}

browsingContext.XPathLocator = {
   type: "xpath",
   value: text
}

browsingContext.Navigation = text;

browsingContext.Download = text;

browsingContext.BaseNavigationInfo = (
  context: browsingContext.BrowsingContext,
  navigation: browsingContext.Navigation / null,
  timestamp: js-uint,
  url: text,
  ? userContext: browser.UserContext,
)

browsingContext.NavigationInfo = {
  browsingContext.BaseNavigationInfo
}

要在给定navigable navigable 和 导航状态 navigation status 的情况下 获取 导航信息：

1. 令 navigable id 为 navigable 的navigable id。

2. 令 navigation id 为 navigation status 的id。

3. 令 timestamp 为表示当前 UTC 日期和 时间的时间值。

4. 令 url 为 navigation status 的url。

5. 令 user context id 为 navigable 的关联用户上下文的用户上下文 id。

6. 返回一个与 browsingContext.NavigationInfo 产生式匹配的映射，其中 context 字段设置为 navigable id， navigation 字段设置为 navigation id， timestamp 字段设置为 timestamp，url 字段设置为在给定 url 的情况下运行 URL 序列化器所得的结果，且 userContext 字段设置为 user context id。

browsingContext.ReadinessState = "none" / "interactive" / "complete"

browsingContext.UserPromptType = "alert" / "beforeunload" / "confirm" / "prompt";

给定 command parameters 时，远端步骤为：

1. 令 navigable id 为 command parameters["context"] 字段的值。

2. 令 navigable 为使用 navigable id 尝试获取 navigable的结果。

3. 如果 navigable 不是顶级 traversable，则返回带有错误 代码 invalid argument 的错误。

4. 返回使用 navigable 调用激活 navigable的结果。

要在给定 navigable 的情况下激活 navigable：

1. 运行特定于实现的步骤，使 navigable 的系统可见性状态变为visible。如果这不可能，则返回带有错误代码 unsupported operation 的错误。

   注：这可能会产生副作用，使当前 visible 的navigable变为hidden。

   注：这可能会通过导致窗口取消最小化， 或通过与改变系统可见性状态相关的其他副作用，来改变底层 OS 状态。

2. 运行特定于实现的步骤，在 navigable 未聚焦时将系统焦点设置到 navigable 上。

   注：除非其他规范强制要求，否则这不会改变文档的聚焦区域。

3. 返回带有数据 null 的成功。

要在给定 rect 的情况下规范化矩形：

注：这确保所得矩形具有 正的宽度尺寸和 高度尺寸。

1. 令 x 为 rect 的x 坐标。

2. 令 y 为 rect 的y 坐标。

3. 令 width 为 rect 的宽度尺寸。

4. 令 height 为 rect 的高度尺寸。

5. 如果 width 小于 0，则将 x 设置为 x + width，然后 将 width 设置为 -width。

6. 如果 height 小于 0，则将 y 设置为 y + height，然后 将 height 设置为 -height。

7. 返回一个新的 DOMRectReadOnly， 其x 坐标为 x，y 坐标 为 y，宽度尺寸为 width，且高度尺寸为 height。

要在给定 rect1 和 rect2 的情况下求矩形 交集

1. 令 rect1 为用 rect1 调用规范化矩形的结果。

2. 令 rect2 为用 rect2 调用规范化矩形的结果。

3. 令 x1_0 为 rect1 的x 坐标。

4. 令 x2_0 为 rect2 的x 坐标。

5. 令 x1_1 为 rect1 的x 坐标加上 rect1 的宽度尺寸。

6. 令 x2_1 为 rect2 的x 坐标加上 rect2 的宽度尺寸。

7. 令 x_0 为 «x1_0, x2_0» 的最大元素。

8. 令 x_1 为 «x1_1, x2_1» 的最小元素。

9. 令 y1_0 为 rect1 的y 坐标。

10. 令 y2_0 为 rect2 的y 坐标。

11. 令 y1_1 为 rect1 的y 坐标加上 rect1 的高度尺寸。

12. 令 y2_1 为 rect2 的y 坐标加上 rect2 的高度尺寸。

13. 令 y_0 为 «y1_0, y2_0» 的最大元素。

14. 令 y_1 为 «y1_1, y2_1» 的最小元素。

15. 如果 x_1 小于 x_0，则令 width 为 0。否则令 width 为 x_1 - x_0。

16. 如果 y_1 小于 y_0，则令 height 为 0。否则令 height 为 y_1 - y_0。

17. 返回一个新的 DOMRectReadOnly， 其x 坐标为 x_0，y 坐标 为 y_0，宽度尺寸为 width，且高度尺寸为 height。

要在给定 document 和 rect 的情况下将 document 渲染到 canvas：

1. 令 ratio 为在给定 document 的默认视图的情况下确定 device pixel ratio所得的结果。

2. 令 paint width 为 rect 的宽度尺寸乘以 ratio， 四舍五入到最接近的整数，使其与 rect 在设备像素中的宽度 相匹配。

3. 令 paint height 为 rect 的高度尺寸乘以 ratio， 四舍五入到最接近的整数，使其与 rect 在设备像素中的高度 相匹配。

4. 令 canvas 为新的 HTMLCanvasElement， 其 width 为 paint width，height 为 paint height。

5. 令 canvas context 为用 canvas 和 null 运行 2D 上下文创建算法 所得的结果。

6. 将 canvas 的上下文模式设置为2D。

7. 完成特定于实现的步骤，其等价于将 framebuffer 中表示 document 被 rect 覆盖区域的区域绘制到 canvas context，使 framebuffer 中的每个像素对应于 canvas context 中的一个像素，其中视口坐标中的（rect 的x 坐标，rect 的y 坐标）对应于 canvas context 中的 (0,0)，而（rect 的 x 坐标 + rect 的宽度尺寸，rect 的 y 坐标 + rect 的高度尺寸）对应于（paint width，paint height）。

8. 返回 canvas。

要在给定 canvas 和 format 的情况下将 canvas 编码为 Base64：

1. 如果 format 不是 null，则令 type 为 format 的 type 字段，且令 quality 为 format 的 quality 字段。

2. 否则，令 type 为 "image/png"，并令 quality 为undefined。

3. 令 file 为 canvas 在给定 type 和 quality 的情况下的位图作为文件的序列化。

4. 令 encoded string 为 file 的forgiving-base64 编码。

5. 返回带有数据 encoded string 的成功。

要在给定 document 和 origin 的情况下获取 origin 矩形：

1. 如果 origin 是 "viewport"：

   1. 令 viewport 为 document 的视觉视口。

   2. 令 viewport rect 为一个 DOMRectReadOnly， 其x 坐标为 viewport 的page left，y 坐标为 viewport 的page top，宽度尺寸为 viewport width，且高度尺寸为 viewport height。

   3. 返回带有数据 viewport rect 的成功。

2. 断言：origin 是 "document"。

3. 令 document element 为 document 的document element。

4. 令 document rect 为一个 DOMRectReadOnly， 其x 坐标为 0，y 坐标为 0，宽度尺寸为 document element 的scroll height， 且高度尺寸为 document element 的scroll width。

5. 返回带有数据 document rect 的成功。

给定 command parameters 时，远端步骤为：

1. 令 navigable id 为 command parameters 的 context 字段的值。

2. 令 prompt unload 为 command parameters 的 promptUnload 字段的值。

3. 令 navigable 为用 navigable id 尝试获取 navigable 所得的结果。

4. 断言：navigable 不是 null。

5. 如果 navigable 不是顶级 traversable，则返回带有 错误代码 invalid argument 的错误。

6. 如果 prompt unload 为 true：

   1. 关闭 navigable。

7. 否则：

   1. 在不提示卸载的情况下关闭 navigable。

8. 返回带有数据 null 的成功。

关于关闭最后一个 顶级 traversable时的行为，目前有一个开放的 讨论。我们可以预期关闭浏览器、关闭会话，或将其留给实现决定。[w3c/webdriver-bidi Issue #170]

给定 command parameters 时，远端步骤为：

1. 令 type 为 command parameters 的 type 字段的值。

2. 令 reference navigable id 为 command parameters 的 referenceContext 字段的值（如果存在），否则为 null。

3. 如果 reference navigable id 不为 null，则令 reference navigable 为 尝试使用 reference navigable id 获取可导航的结果。否则令 reference navigable 为 null。

4. 如果 reference navigable 不为 null，且不是顶级可遍历， 则返回带有错误码 无效参数的错误。

5. 如果实现由于任何原因无法创建新的顶级可遍历，则返回带有错误 码 不支持的操作的错误。

6. 如果 reference navigable 为 null，则令 user context 为默认用户上下文，否则令其为 reference navigable 的关联用户 上下文。

7. 令 user context id 为 command parameters 的 userContext 字段的值（如果存在）， 否则为 null。

8. 如果 user context id 不为 null，则将 user context 设为 尝试使用 user context id 获取用户上下文的结果。

9. 如果 user context 为 null，则返回带有错误码 无此用户 上下文的错误。

10. 如果实现由于任何原因无法创建具有关联用户上下文 user context 的新顶级可遍历，则返回带有 错误 码 不支持的操作的错误。

11. 令 traversable 为尝试以 null 和空字符串运行创建新的顶级可遍历步骤， 并将新创建的顶级可遍历的关联用户上下文设为 user context 的结果。 新顶级可遍历会在哪个 OS 窗口中创建，取决于 type 和 reference navigable：

    • 如果 type 为 "tab"，且实现支持在同一 OS 窗口中存在多个顶级可遍历：

      • 新的顶级可遍历应复用 现有 OS 窗口（如果有）。

      • 如果 reference navigable 不为 null，则新的顶级可遍历应复用包含 reference navigable 的窗口（如果有）。如果 OS 窗口内的顶级可遍历具有确定的顺序， 则新的顶级可遍历应在该顺序中紧接在 reference navigable 的顶级可遍历之后。

    • 如果 type 为 "window"，且实现支持在不同 OS 窗口中存在多个顶级可遍历，则创建的 顶级可遍历应位于新的 OS 窗口中。

    • 否则，如何向用户呈现该顶级可遍历的细节由实现定义。

12. 如果 command parameters 的 background 字段的值为 false：

    1. 令 activate result 为使用新创建的可导航激活可导航的结果。

    2. 如果 activate result 是错误， 则返回 activate result。

    注：如果 background 为 true，则不要为创建的可导航调用聚焦步骤。

13. 令 body 为一个匹配 browsingContext.CreateResult 产生式的映射， 其中 context 字段设为 traversable 的可导航 ID， 且 userContext 属性设为 traversable 的 关联用户上下文的用户 上下文 ID。

14. 返回带有数据 body 的成功。

给定 session 和 command parameters 时，远端步骤为：

1. 令 root id 为 command parameters 的 root 字段的值， 如果存在的话；否则为 null。

2. 令 max depth 为 command parameters 的 maxDepth 字段的值，如果存在的话；否则为 null。

3. 令 navigables 为空列表。

4. 如果 root id 不是 null，则将给定 root id 时 尝试获取 navigable所得的结果追加到 navigables。 否则将所有顶级 traversable追加到 navigables。

5. 令 navigables infos 为空列表。

6. 对于 navigables 中的每个 navigable：

   1. 令 info 为给定 navigable、max depth 和 true 时调用获取 navigable 信息所得的结果。

   2. 将 info 追加到 navigables infos

7. 令 body 为一个与 browsingContext.GetTreeResult 产生式匹配的映射， 其中 contexts 字段设置为 navigables infos。

8. 返回带有数据 body 的成功。

给定 session 和 command parameters 时，远端步骤为：

1. 令 navigable id 为 command parameters 的 context 字段的值。

2. 令 navigable 为用 navigable id 尝试获取 navigable 所得的结果。

3. 令 accept 为 command parameters 的 accept 字段的值，如果存在的话；否则为 true。

4. 令 userText 为 command parameters 的 userText 字段的值，如果存在的话；否则为空字符串。

5. 如果 navigable 当前显示的是由调用 alert 产生的简单对话框，则 确认该提示。

   否则，如果 navigable 当前显示的是由调用 confirm 产生的简单对话框，则当 accept 为 true 时肯定响应， 或当 accept 为 false 时 否定响应。

   否则，如果 navigable 当前显示的是由调用 prompt 产生的简单对话框，则当 accept 为 true 时用字符串值 userText 响应，或当 accept 为 false 时中止。

   否则，如果 navigable 当前显示的是作为提示卸载步骤的一部分的提示，则当 accept 为 true 时确认该 导航，否则 拒绝该导航。

   否则，返回带有错误 代码 no such alert 的错误。

6. 返回带有数据 null 的成功。

要在给定 navigable、context nodes、 selector、maximum returned node count 和 session 的情况下使用 CSS 定位节点：

1. 令 returned nodes 为空列表。

2. 令 parse result 为给定 selector 时解析选择器所得的结果。

3. 如果 parse result 为 failure，则返回带有错误代码 invalid selector 的错误。

4. 对于 context nodes 中的每个 context node：

   1. 令 elements 为用 parse result 和 navigable 的活动文档的根，并使用 作用域根 context node， 针对树匹配选择器所得的结果。

   2. 对于 elements 中的每个 element：

      1. 将 element 追加到 returned nodes。

      2. 如果 maximum returned node count 不是 null，且 returned nodes 的大小等于 maximum returned node count， 则返回带有数据 returned nodes 的成功。

5. 返回带有数据 returned nodes 的成功。

要在给定 navigable 的情况下定位容器 元素：

1. 令 returned nodes 为空列表。

2. 如果 navigable 的容器不是 null， 则将 navigable 的容器追加到 returned nodes。

3. 返回 returned nodes。

要在给定 navigable、context nodes、 selector 和 maximum returned node count 的情况下使用 XPath 定位节点：

注：由于 XPath 规范处于无人维护状态，本算法被表述为像是在调用 XPath DOM API。 然而，应将其理解为等价于直接访问底层算法的规范内部调用， 而不经过 ECMAScript 运行时。

1. 令 returned nodes 为空列表。

2. 对于 context nodes 中的每个 context node：

   1. 令 evaluate result 为在 navigable 的 活动文档上调用 evaluate，并以 selector、context node、null、 ORDERED_NODE_SNAPSHOT_TYPE 和 null 作为实参所得的结果。如果这抛出一个 "SyntaxError" DOMException，则返回带有 错误代码 invalid selector 的错误； 否则，如果这抛出任何其他异常，则返回带有 错误代码 unknown error 的错误。

   2. 令 index 为 0。

   3. 令 length 为从 evaluate result 获取 snapshotLength 属性所得的结果。

   4. 当 index 小于 length 时，重复：

      1. 令 node 为以 evaluate result 作为 this、以 index 作为实参调用 snapshotItem所得的结果。

      2. 将 node 追加到 returned nodes。

      3. 如果 maximum returned node count 不是 null，且 returned nodes 的大小等于 maximum returned node count， 则返回带有数据 returned nodes 的成功。

      4. 将 index 设置为 index + 1。

3. 返回带有数据 returned nodes 的成功。

要在给定 context nodes、 selector、max depth、match type、ignore case 和 maximum returned node count 的情况下使用 inner text 定位节点：

1. 如果 selector 是空字符串，则返回带有错误代码 invalid selector 的错误。

2. 令 returned nodes 为空列表。

3. 如果 ignore case 为 false，则令 search text 为 selector。否则， 令 search text 为按 Unicode 默认大小写转换算法对 selector 执行 toUppercase所得的结果。

4. 对于 context nodes 中的每个 context node：

   1. 如果 context node 实现了 Document 或 DocumentFragment：

      注：遍历 document 或 document fragment 时，max depth 有意不减少，以使使用 document 和 document.documentElement 的搜索结果等价。

      1. 令 child nodes 为空列表。

      2. 对于 context node 的子节点中的每个节点 child。

         1. 将 child 追加到 child nodes。

      3. 用在给定 child nodes、selector、max depth、 match type、ignore case 和 maximum returned node count 的情况下尝试使用 inner text 定位节点 所得的结果扩展 returned nodes。

   2. 如果 context node 没有实现 HTMLElement， 则继续。

   3. 令 node inner text 为以 context node 作为 this 值调用 innerText getter 步骤所得的结果。

   4. 如果 ignore case 为 false，则令 node text 为 node inner text。否则， 令 node text 为按 Unicode 默认大小写转换算法对 node inner text 执行 toUppercase所得的结果。

   5. 如果 search text 是 node text 的码点子字符串， 则执行以下步骤：

      1. 令 child nodes 为空列表，并且 对于 context node 的 子节点中的每个节点 child：

         1. 将 child 追加到 child nodes。

      2. 如果 child nodes 的大小等于 0，或 max depth 等于 0， 则执行以下步骤：

         1. 如果 match type 是 "full" 且 node text 是 search text， 则将 context node 追加到 returned nodes。

         2. 否则，如果 match type 是 "partial"，则将 context node 追加到 returned nodes。

      3. 否则，执行以下步骤：

         1. 如果 max depth 为 null，则令 child max depth 为 null， 否则为 max depth - 1。

         2. 令 child node matches 为用 child nodes、selector、child max depth、match type、 ignore case 和 maximum returned node count 调用使用 inner text 定位节点所得的结果。

         3. 如果 child node matches 的大小等于 0 且 match type 是 "partial"，则将 context node 追加到 returned nodes。否则，用 child node matches 扩展 returned nodes。

5. 如果 maximum returned node count 不是 null，则移除 returned nodes 中索引大于或等于 maximum returned node count 的所有条目。

6. 返回带有数据 returned nodes 的成功。

要在给定 context nodes、selector、 maximum returned node count 和 returned nodes 的情况下使用无障碍属性收集节点：

1. 如果 returned nodes 为 null：

   1. 将 returned nodes 设置为空列表。

2. 对于 context nodes 中的每个 context node：

   1. 令 match 为 true。

   2. 如果 context node 实现了 Element：

      1. 如果 selector 包含 "role"：

         1. 令 role 为 context node 的计算角色。

         2. 如果 selector["role"] 不是 role：

            1. 将 match 设置为 false。

      2. 如果 selector 包含 "name"：

         1. 令 name 为 context node 的可访问名称。

         2. 如果 selector["name"] 不是 name：

            1. 将 match 设置为 false。

   3. 否则，将 match 设置为 false。

   4. 如果 match 为 true：

      1. 如果 maximum returned node count 不是 null，且 returned nodes 的大小等于 maximum returned node count， 则中断。

      2. 将 context node 追加到 returned nodes。

   5. 令 child nodes 为空列表，并且对于 context node 的 子节点中的每个节点 child：

      1. 如果 child 实现了 Element， 则将 child 追加到 child nodes。

   6. 尝试用 child nodes、selector、maximum returned node count 和 returned nodes 使用无障碍属性收集节点。

3. 返回 returned nodes。

要在给定 context nodes、selector 和 maximum returned node count 的情况下使用无障碍属性定位节点：

1. 如果 selector 不包含 "role"，且 selector 不包含 "name"，则返回 带有错误 代码 invalid selector 的错误。

2. 返回用 context nodes、selector、maximum returned node count 和 null 调用使用无障碍属性收集节点所得的结果。

给定 session 和 command parameters 时，远端步骤为：

1. 令 navigable id 为 command parameters["context"]。

2. 令 navigable 为用 navigable id 尝试获取 navigable 所得的结果。

3. 断言：navigable 不是 null。

4. 令 realm 为用 navigable 的navigable id 和 null 尝试从 navigable 获取 realm 所得的结果。

5. 令 locator 为 command parameters["locator"]。

6. 如果 command parameters 包含 "startNodes"，则令 start nodes parameter 为 command parameters["startNodes"]。 否则令 start nodes parameter 为 null。

7. 如果 command parameters 包含 "maxNodeCount"，则令 maximum returned node count 为 command parameters["maxNodeCount"]。 否则，令 maximum returned node count 为 null。

8. 令 context nodes 为空列表。

9. 如果 start nodes parameter 为 null，则将 navigable 的 活动文档追加到 context nodes。否则，对于 start nodes parameter 中的每个 serialized start node：

   1. 令 start node 为给定 serialized start node、realm 和 session 时 尝试反序列化共享引用所得的结果。

   2. 将 start node 追加到 context nodes。

10. 断言 context nodes 的大小大于 0。

11. 令 type 为 locator["type"]。

12. 在以下条件及其关联步骤列表中，运行第一个其关联条件为 true 的 步骤集合：

    type 是字符串 "css"

    1. 令 selector 为 locator["value"]。

    2. 令 result nodes 为给定 navigable、context nodes、selector 和 maximum returned nodes 时尝试使用 css 定位节点所得的结果。

    type 是字符串 "xpath"

    1. 令 selector 为 locator["value"]。

    2. 令 result nodes 为给定 navigable、context nodes、selector 和 maximum returned nodes 时尝试使用 xpath 定位节点所得的结果。

    type 是字符串 "innerText"

    1. 令 selector 为 locator["value"]。

    2. 如果 locator 包含 maxDepth，则令 max depth 为 locator["maxDepth"]。否则，令 max depth 为 null。

    3. 如果 locator 包含 ignoreCase，则令 ignore case 为 locator["ignoreCase"]。否则，令 ignore case 为 false。

    4. 如果 locator 包含 matchType，则令 match type 为 locator["matchType"]。否则，令 match type 为 "full"。

    5. 令 result nodes 为给定 context nodes、selector、max depth、 match type、ignore case 和 maximum returned node count 时 尝试使用 inner text 定位节点所得的结果。

    type 是字符串 "accessibility"

    1. 令 selector 为 locator["value"]。

    2. 令 result nodes 为给定 context nodes、selector 和 maximum returned node count 时使用无障碍属性定位节点所得的结果。

    type 是字符串 "context"

    1. 如果 start nodes parameter 不是 null， 则返回带有错误代码 "invalid argument" 的错误。

    2. 令 selector 为 locator["value"]。

    3. 令 context id 为 selector["context"]。

    4. 令 child navigable 为用 context id 尝试获取 navigable 所得的结果。

    5. 如果 child navigable 的父级不是 navigable， 则返回带有错误代码 "invalid argument" 的错误。

    6. 令 result nodes 为给定 child navigable 时定位容器元素所得的结果。

    7. 断言：对于 result nodes 中的每个 node， node 的节点 navigable是 navigable。

13. 断言：maximum returned node count 为 null，或 result nodes 的大小小于或等于 maximum returned node count。

14. 如果 command parameters 包含 "serializationOptions"， 则令 serialization options 为 command parameters["serializationOptions"]。 否则，令 serialization options 为一个与 script.SerializationOptions 产生式匹配、且各字段 设置为其默认值的映射。

15. 令 result ownership 为 "none"。

16. 令 serialized nodes 为空列表。

17. 对于 result nodes 中的每个 result node：

    1. 令 serialized node 为用 result node、serialization options、result ownership、一个新的映射作为 serialization internal map、realm 和 session 序列化为远程值所得的结果。

    2. 将 serialized node 追加到 serialized nodes。

18. 令 result 为一个与 browsingContext.LocateNodesResult 产生式匹配的映射， 其 nodes 字段设置为 serialized nodes。

19. 返回带有数据 result 的成功。

给定 session 和 command parameters 时，远端步骤为：

1. 令 navigable id 为 command parameters 的 context 字段的值。

2. 令 navigable 为用 navigable id 尝试获取 navigable 所得的结果。

3. 断言：navigable 不是 null。

4. 令 wait condition 为 "committed"。

5. 如果 command parameters 包含 wait 且 command parameters[wait] 不是 "none"， 则将 wait condition 设置为 command parameters[wait]。

6. 令 url 为 command parameters 的 url 字段的值。

7. 令 document 为 navigable 的活动文档。

8. 令 base 为 document 的基 URL。

9. 令 url record 为以 基 URL base 将 URL 解析器应用于 url所得的结果。

10. 如果 url record 为 failure，则返回带有错误代码 invalid argument 的错误。

11. 令 request 为一个新的 request，其 URL 为 url record。

12. 返回用 navigable、 request 和 wait condition 调用等待导航所得的结果。

带有 session 和 command parameters 的远程端步骤如下：

1. 令 navigable id 为 command parameters 的 context 字段的值。

2. 令 navigable 为尝试使用 navigable id 获取 可导航的结果。

3. 如果实现由于任何原因无法提供 navigable 的分页表示，则返回带有错误码 不支持的操作的错误。

4. 令 margin 为 command parameters 的 margin 字段的值（如果存在），否则为一个匹配 browsingContext.PrintMarginParameters 且字段设为 其默认值的映射。

5. 令 page size 为 command parameters 的 page 字段的值（如果存在），否则为一个匹配 browsingContext.PrintPageParameters 且字段设为 其默认值的映射。

注：最小页面尺寸为 1 点，按照绝对长度， 即 (2.54 / 72) cm。

1. 令 page ranges 为 command parameters 的 pageRanges 字段的值（如果存在）， 否则为空列表。

2. 令 document 为 navigable 的活动文档。

3. 在下一次为 document 调用运行动画帧回调 算法之后立即：

   这应当以某种更明确的方式 集成到更新渲染算法中。

   1. 令 pdf data 为采用 UA 特定步骤生成 document 的分页表示的结果，其中 CSS 媒体类型设为 print，编码为 PDF，并具有以下纸张设置：

      属性	值
      宽度，单位 cm	如果 command parameters["orientation"] 为 "portrait"，则为 page size["width"]，否则为 page size["height"]
      高度，单位 cm	如果 command parameters["orientation"] 为 "portrait"，则为 page size["height"]，否则为 page size["width"]
      上边距，单位 cm	margin["top"]
      下边距，单位 cm	margin["bottom"]
      左边距，单位 cm	margin["left"]
      右边距，单位 cm	margin["right"]

      此外，UA 应应用以下格式化提示：

      如果 command parameters["scale"] 不等于 1：

      按因子 command parameters["scale"] 缩放内容大小

      如果 command parameters["background"] 为 false：

      抑制背景图像输出

      如果 command parameters["shrinkToFit"] 为 true：

      调整内容大小以匹配页面宽度，覆盖内容中指定的任何页面 宽度

   2. 如果 page ranges 不是空， 则令 pages 为 尝试使用 page ranges 和 pdf data 中包含的页数解析页面范围的结果，然后从 pdf data 中移除 任何其从 1 开始的索引未包含在 pages 中的页面。

   3. 令 encoding result 为对 pdf data 调用Base64 编码的结果。

   4. 令 encoded data 为 encoding result 的数据。

   5. 令 body 为一个匹配 browsingContext.PrintResult 产生式的映射， 其中 data 字段设为 encoded data。

   6. 返回带有数据 body 的成功。

给定 command parameters 时，远端步骤为：

1. 令 navigable id 为 command parameters 的 context 字段的值。

2. 令 navigable 为用 navigable id 尝试获取 navigable 所得的结果。

3. 断言：navigable 不是 null。

4. 令 ignore cache 为 command parameters 的 ignoreCache 字段的值（如果存在），否则为 false。

5. 令 wait condition 为 "committed"。

6. 如果 command parameters 包含 wait 且 command parameters[wait] 不是 "none"， 则将 wait condition 设置为 command parameters[wait]。

7. 令 document 为 navigable 的活动文档。

8. 令 url 为 document 的URL。

9. 令 request 为一个新的 request，其 URL 为 url。

10. 返回用 navigable、 request、wait condition、历史处理 "reload" 和 ignore cache ignore cache 调用等待导航所得的结果。

给定 navigable navigable 时，WebDriver BiDi CSP 被绕过步骤为：

1. 令 top-level traversable 为 navigable 的顶级 traversable。

2. 令 bypass CSP enabled 为针对 top-level traversable 的 绕过 CSP 配置调用获取 WebDriver 配置值所得的结果。

3. 断言：bypass CSP enabled 是 true 或 unset。

4. 如果 bypass CSP enabled 是 unset，则返回 false。

5. 返回 true。

给定 command parameters 时，远端步骤为：

1. 令 bypass 为 command parameters["bypass"]。

2. 如果 bypass 为 null，则将 bypass 设置为 unset。

3. 尝试为 command parameters 存储 WebDriver 配置 绕过 CSP 配置 bypass。

4. 返回带有数据 null 的成功。