HTML
现行标准 — 最后更新 2024年10月1日
现行标准 — 最后更新 2024年10月1日
a元素
em元素
strong元素small元素s元素
cite元素q元素
dfn元素
abbr元素ruby元素rt元素
rp元素
data元素time元素code元素var元素samp元素kbd元素sub和sup元素i元素
b元素
u元素
mark元素bdi元素bdo元素span元素br元素
wbr元素a 和 area 元素创建的链接a 和 area 元素的 APIalternate"author"bookmark"canonical"dns-prefetch"expect"external"help"icon"license"manifest"modulepreload"nofollow"noopener"noreferrer"opener"pingback"preconnect"prefetch"preload"privacy-policy"search"stylesheet"tag"terms-of-service"picture 元素source
元素img
元素source、img 和 link 元素的共同属性
iframe
元素embed
元素object
元素video
元素audio
元素track
元素TrackEvent 接口map
元素area
元素form
元素label
元素input
元素
type 属性的状态
type=hidden)type=text) 状态和搜索状态
(type=search)type=tel)type=url)type=email)type=password)type=date)type=month)type=week)type=time)type=datetime-local)type=number)type=range)type=color)type=checkbox)type=radio)type=file)type=submit)type=image)type=reset)type=button)input 元素属性
input 元素 APIbutton 元素select 元素datalist 元素optgroup 元素option 元素textarea 元素output 元素progress 元素meter
元素fieldset 元素legend 元素script 元素
noscript 元素template 元素
slot
元素canvas 元素
Path2D 对象ImageBitmap 渲染上下文
OffscreenCanvas 接口
canvas 元素的安全性Window、WindowProxy 和 Location 对象的安全基础设施
Window
对象
WindowProxy 外来对象
Location 接口
History 接口NotRestoredReasons 接口X-Frame-Options` 头部Refresh`
头部WindowOrWorkerGlobalScope 混合接口button 元素details 和 summary 元素input
元素作为文本输入小部件input 元素作为特定领域的小部件input 元素作为范围控制input 元素作为颜色选择器input 元素作为复选框和单选按钮小部件input 元素作为文件上传控件input 元素作为按钮marquee 元素meter 元素progress 元素select 元素textarea 元素该规范定义了网页平台的大部分内容，详细程度很高。它在网页平台规范堆栈中的位置相对于其他规范可以总结如下：
本节为非规范性内容。
简而言之：是的。
更详细地说：“HTML5”这一术语广泛用作现代网页技术的流行词，其中许多（尽管并非全部）是由 WHATWG 开发的。本文档即为其中之一；其他文档可在 WHATWG 标准概览 中找到。
本节为非规范性内容。
HTML 是万维网的核心标记语言。最初，HTML 主要被设计为一种用于语义描述科学文档的语言。然而，它的总体设计使得它在随后的几年中被适应为描述其他多种文档类型甚至应用程序的语言。
本节为非规范性内容。
本规范旨在为使用本规范中定义的特性的文档和脚本的作者、操作使用本规范中定义特性的页面的工具的实现者，以及希望确认文档或实现是否符合本规范要求的个人提供参考。
本文件可能不适合没有至少基础了解网络技术的读者，因为在某些地方，它牺牲了清晰性以追求精确性，牺牲了简洁性以求完整性。更易于接近的教程和创作指南可以为读者提供更温和的入门介绍。
特别是，对于本规范中一些更技术性的部分，了解 DOM 的基础知识是必要的。理解 Web IDL、HTTP、XML、Unicode、字符编码、JavaScript 和 CSS 在某些地方也会有所帮助，但不是必须的。
本节为非规范性内容。
本规范的范围限于提供一个语义级别的标记语言和相关的语义级别脚本 API，用于创建从静态文档到动态应用的可访问网页。
本规范的范围不包括提供媒体特定的呈现定制机制（尽管规范末尾包括了默认的网页浏览器渲染规则，并且提供了若干与 CSS 相关的钩子机制）。
本规范的范围也不包括描述整个操作系统。特别是，硬件配置软件、图像处理工具以及用户预期在高端工作站上日常使用的应用程序均不在范围之内。就应用程序而言，本规范特别针对那些预期用户偶尔使用的应用程序，或定期但在不同地点使用的应用程序，并且对 CPU 的要求较低。这类应用程序的例子包括在线购物系统、搜索系统、游戏（尤其是多人在线游戏）、公共电话簿或地址簿、通信软件（电子邮件客户端、即时消息客户端、讨论软件）、文档编辑软件等。
本节为非规范性内容。
在其最初的五年（1990-1995），HTML经历了若干次修订和扩展，最初由CERN主办，之后转到IETF。
随着W3C的成立，HTML的开发再次发生了变化。1995年第一次尝试扩展HTML的HTML 3.0未能成功，随后出现了更为务实的HTML 3.2，完成于1997年。同年晚些时候，HTML4紧随其后。
次年，W3C会员决定停止对HTML的演进，转而开始开发基于XML的等效语言，称为XHTML。这个工作从HTML4在XML中的重新表述，即XHTML 1.0开始，这没有增加新功能，只是新的序列化，并于2000年完成。在XHTML 1.0之后，W3C的重点转向使其他工作组更容易扩展XHTML，名为XHTML模块化。与此同时，W3C还致力于一种与早期HTML和XHTML语言不兼容的新语言，称为XHTML2。
在1998年停止HTML演进的同时，浏览器供应商开发的HTML API部分被指定并发布，称为DOM Level 1（1998年）和DOM Level 2 Core及DOM Level 2 HTML（从2000年开始，直至2003年）。这些努力逐渐减弱，2004年发布了一些DOM Level 3规范，但工作组在所有Level 3草案完成之前就关闭了。
2003年，XForms的发布引发了对HTML自身演进的重新关注，这种技术被定位为下一代网页表单。这种兴趣源于XML作为网页技术的部署被局限于完全新技术（如RSS和后来的Atom），而不是作为现有技术（如HTML）的替代品。
一个概念验证显示扩展HTML4表单以提供XForms 1.0引入的许多功能，而无需浏览器实现与现有HTML网页不兼容的渲染引擎，是这种重新关注的第一个结果。在这一早期阶段，尽管草案已经公开，并且正在从各方征求意见，规范仅由Opera Software拥有版权。
在2004年的W3C研讨会上，HTML演进应该重新开放的想法得到了测试，一些HTML5工作的基本原则（如下所述）以及早期草案提案（仅涉及表单相关功能）由Mozilla和Opera联合向W3C提出。该提案因与之前选择的网页演进方向相冲突而被拒绝；W3C工作人员和会员投票决定继续开发基于XML的替代品。
不久之后，Apple、Mozilla和Opera共同宣布他们打算在一个名为WHATWG的新平台下继续工作。创建了一个公开的邮件列表，草案转移到WHATWG网站。版权随后被修改为由三家供应商共同拥有，并允许重新使用规范。
WHATWG基于几个核心原则，特别是技术需要向后兼容，规范和实现需要匹配，即使这意味着更改规范而不是实现，并且规范需要详细到实现可以实现完全的互操作性，而不必相互逆向工程。
特别是，后一个要求需要HTML5规范的范围包括之前在三个独立文档中规定的内容：HTML4、XHTML1和DOM2 HTML。这也意味着包含比之前考虑的更多细节。
2006年，W3C表示有兴趣参与HTML5的开发，2007年成立了一个工作组，与WHATWG合作开发HTML5规范。Apple、Mozilla和Opera允许W3C在W3C版权下发布规范，同时在WHATWG网站上保留一个具有较少限制的版本。
随后，两个小组一起工作了几年。然而，2011年，两个小组得出结论，他们的目标不同：W3C希望发布“完成”的“HTML5”版本，而WHATWG希望继续在HTML的Living Standard上工作，持续维护规范，而不是将其冻结在存在已知问题的状态，并根据需要添加新功能以发展平台。
2019年，WHATWG和W3C 签署了协议，共同协作开发一个单一版本的HTML，即本文档。
本节为非规范性内容。
必须承认，HTML的许多方面乍一看似乎是毫无意义和不一致的。
HTML及其支持的DOM API，以及许多支持技术，已经由一系列不同优先级的人们在数十年的时间里开发完成，在很多情况下，这些人彼此之间并不知道对方的存在。
因此，特性来源于多个来源，并且设计方式并不总是特别一致。此外，由于网页的独特特性，实施错误往往成为事实上的标准，甚至现在是法定标准，因为内容通常会在修复这些错误之前以依赖它们的方式被无意中编写。
尽管如此，仍然努力坚持某些设计目标。这些目标将在接下来的几个小节中进行描述。
本节为非规范性内容。
为了避免将多线程的复杂性暴露给网页作者，HTML和DOM API的设计使得脚本无法检测到其他脚本的同时执行。即使在工作线程中，设计的意图也是使实现行为可以被认为是完全串行化所有脚本在所有全局上下文中的执行。
这一通用设计原则的例外是JavaScript SharedArrayBuffer
类。使用 SharedArrayBuffer
对象，实际上可以观察到其他代理中的脚本同时执行。此外，由于JavaScript内存模型，存在一些情况不仅不能通过序列化的脚本执行来表示，而且不能通过序列化的语句执行来表示这些脚本中的内容。
本节为非规范性内容。
本规范与许多其他规范进行交互并依赖于它们。在某些情况下，不幸的是，冲突的需求导致本规范违反了这些其他规范的要求。每当发生这种情况时，违规行为都会被标注为“故意违反”，并说明违反的原因。
本节为非规范性内容。
HTML 提供了多种扩展机制，可以安全地添加语义：
作者可以使用 class
属性来扩展元素，实际上创建自己的元素，同时使用最适用的现有“真实” HTML 元素，以便浏览器和其他不知晓扩展的工具仍能较好地支持它。这就是微格式使用的方法。
作者可以通过 data-*=""
属性包含供客户端脚本或服务器端站点脚本处理的数据。这些属性保证不会被浏览器触及，允许脚本在 HTML 元素上包含数据，然后脚本可以查找和处理这些数据。
作者可以使用 <meta name="" content="">
机制包含页面范围的元数据。
作者可以使用 rel=""
机制通过注册 预定义链接类型的扩展
来注释链接的具体含义。这也被微格式使用。
作者可以使用 <script type="">
机制和自定义类型嵌入原始数据，供内联或服务器端脚本进一步处理。
作者可以使用 JavaScript 原型机制扩展 API。这被脚本库广泛使用。
作者可以使用微数据功能（itemscope="" 和
itemprop=""
属性）嵌入嵌套的名称-值对数据，以便与其他应用程序和网站共享。
作者可以定义、共享和使用 自定义元素 来扩展 HTML 的词汇。有效自定义元素名称 的要求确保了向前兼容性（因为未来不会在 HTML、SVG 或 MathML 中添加包含连字符的本地名称的元素）。
本节为非规范性内容。
本规范定义了一种用于描述文档和应用程序的抽象语言，以及一些用于与使用该语言的资源的内存表示进行交互的 API。
这种内存中的表示称为“DOM HTML”，简称“DOM”。
有多种具体语法可以用于传输使用该抽象语言的资源，其中两种在本规范中有定义。
第一种具体语法是 HTML 语法。这是建议大多数作者使用的格式。它与大多数传统网页浏览器兼容。如果文档以 text/html MIME
类型 传输，那么它将被网页浏览器作为 HTML 文档处理。本规范定义了最新的 HTML 语法，简称“HTML”。
第二种具体语法是 XML。当文档以 XML MIME 类型（例如 application/xhtml+xml）传输时，它将被网页浏览器视为
XML 文档，由 XML 处理器进行解析。作者需要注意 XML 和 HTML 的处理方式不同；特别是，即使是小的语法错误也会导致标记为 XML 的文档无法完全呈现，而在 HTML 语法中这些错误会被忽略。
HTML 的 XML 语法以前被称为“XHTML”，但本规范不使用该术语（其中一个原因是，MathML 和 SVG 的 HTML 语法中没有使用该术语）。
DOM、HTML 语法和 XML 语法无法完全表示相同的内容。例如，HTML 语法无法表示命名空间，但 DOM 和 XML 语法支持。类似地，使用 noscript
特性的文档可以使用 HTML 语法表示，但无法使用 DOM 或 XML 语法表示。包含字符串 "-->" 的注释只能在 DOM 中表示，而不能在 HTML 和 XML 语法中表示。
本节为非规范性内容。
本规范分为以下主要部分：
EventSource
的服务器推送事件流机制，以及一种名为 Web Sockets 的双向全双工套接字协议。此外，还有一些附录，列出了 过时的特性 和 IANA 注意事项，以及几个索引。
阅读本规范的方法与其他规范类似。首先，应该全面阅读多次。然后，至少要反向阅读一次。接着，可以通过从目录中随机挑选章节并跟踪所有交叉引用来进行阅读。
如下面的合规要求部分所述，本规范描述了多种合规类别的合规标准。特别是，有些合规要求适用于 生产者，例如作者及其创建的文档，还有些合规要求适用于 消费者，例如网页浏览器。它们可以通过要求的内容来区分：对生产者的要求说明了允许的内容，而对消费者的要求则说明了软件应该如何行动。
例如，“foo 属性的值必须是一个 有效整数”是对生产者的要求，因为它规定了允许的值；相比之下，“foo 属性的值必须按照
解析整数的规则
进行解析”的要求是对消费者的要求，因为它描述了如何处理内容。
对生产者的要求对消费者没有任何影响。
继续上述示例，一个声明特定属性值受限于 有效整数 的要求明确地 不 意味着对消费者的要求。可能消费者实际上被要求将属性视为不透明字符串，完全不受值是否符合要求的影响。也可能（如上例所示），消费者被要求使用特定规则解析值，定义如何处理无效（在此情况下为非数字）值。
这是一个定义、要求或解释。
这是一个备注。
这是一个示例。
这是一个未解决的问题。
这是一个警告。
[Exposed =Window ]
interface Example {
// 这是一个IDL定义
};variable = object.method([optionalArgument])
这是一个描述接口使用的注释。
/* 这是一个CSS片段 */ 术语的定义实例标记为 这样。该术语的使用标记为 这样 或 这样。
元素、属性或API的定义实例标记为 这样。对该元素、属性或API的引用标记为 这样。
其他代码片段标记为 这样。
变量标记为 这样。
在算法中，同步部分中的步骤标记为 ⌛。
在某些情况下，要求以带有条件和对应要求的列表形式给出。在这种情况下，适用于条件的要求始终是紧跟在条件后的第一组要求，即使对于这些要求有多个条件组。这样的情况呈现如下：
本节非规范性。
一个基本的HTML文档如下所示：
<!DOCTYPE html>
< html lang = "en" >
< head >
< title > Sample page</ title >
</ head >
< body >
< h1 > Sample page</ h1 >
< p > This is a < a href = "demo.html" > simple</ a > sample.</ p >
<!-- this is a comment -->
</ body >
</ html > HTML文档由元素和文本构成的树状结构组成。每个元素在源代码中由一个开始标签（如“<body>”）和一个结束标签（如“</body>”）表示。
（在某些情况下，某些开始标签和结束标签可以省略，由其他标签隐含。）
标签必须嵌套在一起，确保所有元素完全包含在彼此之内，不可重叠：
<p>This is <em>very <strong>wrong</em>!</strong></p><p>This <em>is <strong>correct</strong>.</em></p>本规范定义了一组可以在HTML中使用的元素，以及有关元素嵌套方式的规则。
元素可以具有属性，这些属性控制元素的功能。在下面的示例中，有一个超链接，
使用了a元素及其href属性：
<a href="demo.html">simple</a>属性放在开始标签内，由一个名称和一个值组成，中间用"="字符分隔。
如果属性值不包含ASCII 空白字符或任何" ' ` =
< 或>，则属性值可以保持未加引号。否则，属性值必须使用单引号或双引号括起来。如果值为空字符串，则可以省略值和"="字符。
<!-- empty attributes -->
< input name = address disabled >
< input name = address disabled = "" >
<!-- attributes with a value -->
< input name = address maxlength = 200 >
< input name = address maxlength = '200' >
< input name = address maxlength = "200" > HTML 用户代理（例如，网页浏览器）会解析这些标记，将其转换为 DOM（文档对象模型）树。DOM 树是文档的内存中的表示。
DOM 树包含几种类型的节点，特别是一个DocumentType节点，Element节点，Text节点，Comment节点，以及在某些情况下的ProcessingInstruction节点。
本节顶部的标记片段将被转换为以下 DOM 树：
这个树的 文档元素 是 html
元素，这是在 HTML 文档中始终出现在该位置的元素。它包含两个元素，
head
和 body，
以及它们之间的一个 文本
节点。
在 DOM 树中，文本
节点比最初预期的要多，因为源代码中包含了许多空格（在这里表示为“␣”）和换行符（“⏎”），这些最终都会成为 文本
节点。然而，由于历史原因，并非所有的空格和换行符在原始标记中都会出现在 DOM 中。特别是，head
起始标签之前的所有空白会被静默丢弃，
而 body
结束标签之后的所有空白则会被放置在 body
元素的末尾。
head
元素包含一个 title
元素，它本身包含一个
文本
节点，文本内容为 "Sample page"。类似地，body
元素
包含一个 h1
元素，一个 p
元素，以及一个注释。
这个 DOM 树可以通过页面中的脚本进行操作。脚本（通常是 JavaScript）是可以嵌入的程序，使用 script
元素或使用 事件处理程序内容属性 嵌入。例如，这里是一个表单和一个脚本，该脚本将表单的 output
元素的值设置为 "Hello World"：
< form name = "main" >
Result: < output name = "result" ></ output >
< script >
document. forms. main. elements. result. value = 'Hello World' ;
</ script >
</ form > DOM 树中的每个元素由一个对象表示，这些对象具有 API 以便进行操作。例如，链接（例如上面树中的 a
元素）可以通过几种方式更改其 "href"
属性：
var a = document. links[ 0 ]; // obtain the first link in the document
a. href = 'sample.html' ; // change the destination URL of the link
a. protocol = 'https' ; // change just the scheme part of the URL
a. setAttribute( 'href' , 'https://example.com/' ); // change the content attribute directly 由于 DOM 树是用于表示 HTML 文档的方式，尤其是在交互式实现（如网页浏览器）中处理和呈现文档时，本规范大多以 DOM 树的术语来描述，而不是上面描述的标记。
HTML 文档代表了一个与媒体无关的互动内容描述。HTML 文档可能会被渲染到屏幕上，或者通过语音合成器，或者在盲文显示器上。为了精确控制渲染方式，作者可以使用样式语言，如 CSS。
在以下示例中，页面使用 CSS 被设置为黄底蓝字。
<!DOCTYPE html>
< html lang = "en" >
< head >
< title > Sample styled page</ title >
< style >
body { background : navy ; color : yellow ; }
</ style >
</ head >
< body >
< h1 > Sample styled page</ h1 >
< p > This page is just a demo.</ p >
</ body >
</ html > 有关如何使用 HTML 的更多详细信息，建议作者查阅教程和指南。虽然本规范中包含的一些示例可能也会有所帮助，但新手作者需注意，本规范为了必要性，以一种可能难以理解的细节水平定义了语言。
本节为非规范性内容。
当 HTML 被用于创建交互式网站时，需要注意避免引入漏洞，通过这些漏洞攻击者可以破坏网站自身或用户的安全。
对这一问题的全面研究超出了本文档的范围，强烈建议作者更详细地研究这一问题。然而，本节尝试提供对 HTML 应用开发中一些常见陷阱的快速介绍。
网络的安全模型基于“来源”概念，相应地，许多对网络的潜在攻击涉及跨源操作。 [ORIGIN]
在接受不可信的输入时，例如用户生成的内容如文本评论、URL 参数中的值、来自第三方网站的消息等，必须在使用之前对数据进行验证，并在显示时正确转义。否则，恶意用户可能会执行各种攻击，从可能无害的提供虚假用户信息（如负年龄），到严重的情况，例如每当用户查看包含信息的页面时运行脚本，可能在过程中传播攻击，到灾难性的情况，例如删除服务器中的所有数据。
在编写验证用户输入的过滤器时，必须确保过滤器始终基于白名单，允许已知安全的构造，拒绝所有其他输入。基于黑名单的过滤器，仅拒绝已知的恶意输入而允许其他所有输入是不安全的，因为并不是所有的恶意内容都是已知的（例如，可能是未来发明的）。
例如，假设一个页面查看其 URL 的查询字符串来确定要显示的内容，然后网站将用户重定向到该页面以显示消息，如下所示：
< ul >
< li >< a href = "message.cgi?say=Hello" > Say Hello</ a >
< li >< a href = "message.cgi?say=Welcome" > Say Welcome</ a >
< li >< a href = "message.cgi?say=Kittens" > Say Kittens</ a >
</ ul > 如果消息只是显示给用户而没有转义，恶意攻击者可能会构造一个包含脚本元素的 URL：
https://example.com/message.cgi?say=%3Cscript%3Ealert%28%27Oh%20no%21%27%29%3C/script%3E
如果攻击者成功地说服受害用户访问此页面，攻击者选择的脚本将在页面上运行。这样的脚本可以执行任何数量的恶意操作，仅受网站提供的功能的限制：例如，如果网站是电子商务商店，这样的脚本可能导致用户在不知情的情况下进行任意多的购买。
这被称为跨站脚本攻击。
有许多构造可以用来尝试欺骗网站执行代码。以下是一些作者在编写白名单过滤器时被鼓励考虑的：
img
这样的看似无害的元素时，必须对任何提供的属性进行白名单过滤。如果允许所有属性，那么攻击者可以例如使用 onload
属性来运行任意脚本。javascript:"，但用户代理可以实现（并且确实在历史上实现过）其他方案。
base
元素意味着页面中的任何带有相对链接的 script
元素都可能被劫持，同样地，任何表单提交都可能被重定向到一个恶意网站。如果网站允许用户进行具有用户特定副作用的表单提交，例如在论坛上以用户的名义发布消息、进行购买或申请护照，则必须验证请求是否确实由用户自愿发出，而不是由其他网站欺骗用户无意中发出请求。
这个问题存在是因为 HTML 表单可以提交到其他来源。
网站可以通过填充带有用户特定的隐藏令牌的表单，或通过检查 `Origin`
头来防止此类攻击。
提供用户执行他们可能不愿意执行的操作的接口的页面需要设计得足够谨慎，以避免用户被欺骗以激活该接口。
一种用户可能被欺骗的方法是，如果恶意网站将受害网站放在一个小的 iframe
中，然后通过让用户玩反应游戏来说服用户点击。例如，一旦用户开始玩游戏，恶意网站可以快速将 iframe 定位到鼠标指针下方，正当用户准备点击时，从而欺骗用户点击受害网站的界面。
为了避免这种情况，建议不期望在框架中使用的站点仅在检测到它们不在框架中时启用其接口（例如，通过将 window
对象与 top
属性的值进行比较）。
本节为非规范性内容。
HTML 中的脚本具有“执行完成”语义，这意味着浏览器通常会在执行其他操作之前运行脚本，例如触发更多事件或继续解析文档。
另一方面，HTML 文件的解析是增量进行的，这意味着解析器可以在任何点暂停以运行脚本。这通常是有益的，但这也意味着作者需要小心，以避免在事件可能已被触发后才挂钩事件处理程序。
有两种可靠的方法可以做到这一点：使用 事件处理程序内容属性，或者在同一个脚本中创建元素并添加事件处理程序。后一种方法是安全的，因为如前所述，脚本会在进一步事件触发之前完成执行。
这种情况可能会在 img
元素和 load
事件中体现。该事件可能会在元素被解析后立即触发，特别是当图像已经被缓存时（这种情况很常见）。
在这里，作者在一个 img
元素上使用 onload
处理程序来捕捉 load
事件：
<img src="games.png" alt="Games" onload="gamesLogoHasLoaded(event)">如果元素是由脚本添加的，只要在同一个脚本中添加事件处理程序，事件仍然不会丢失：
< script >
var img = new Image();
img. src = 'games.png' ;
img. alt = 'Games' ;
img. onload = gamesLogoHasLoaded;
// img.addEventListener('load', gamesLogoHasLoaded, false); // would work also
</ script > 然而，如果作者先创建了 img
元素，然后在一个单独的脚本中添加事件监听器，就有可能在事件触发之间丢失 load
事件：
<!-- Do not use this style, it has a race condition! -->
< img id = "games" src = "games.png" alt = "Games" >
<!-- the 'load' event might fire here while the parser is taking a
break, in which case you will not see it! -->
< script >
var img = document. getElementById( 'games' );
img. onload = gamesLogoHasLoaded; // might never fire!
</ script > 本节为非规范性内容。
建议作者使用合规检查器（也称为 验证器）来捕捉常见错误。WHATWG 维护了一个此类工具的列表：https://whatwg.org/validator/
本节为非规范性内容。
与之前版本的 HTML 规范不同，本规范详细定义了无效文档和有效文档的处理要求。
然而，即使无效内容的处理在大多数情况下是明确的，文档的合规要求仍然很重要：实际上，互操作性（即所有实现以可靠和相同或等效的方式处理特定内容）并不是文档合规要求的唯一目标。本节详细说明了仍然区分符合规范的文档和有错误的文档的一些常见原因。
本节为非规范性内容。
以前版本的 HTML 中大多数表现性特性现在已不再允许。表现性标记通常存在一些问题：
虽然可以以提供给辅助技术（AT）用户可接受体验的方式使用表现性标记（例如，使用 ARIA），但这样做比使用语义上合适的标记要困难得多。此外，即使使用这些技术，也无法帮助非 AT 用户，如文本模式浏览器用户，使页面变得可访问。
另一方面，使用与媒体无关的标记可以提供一种简单的方法，使文档能够以更适合更多用户（例如文本浏览器用户）的方式编写。
维护风格无关的站点要容易得多。例如，更改整个站点中使用 <font color=""> 的颜色需要对整个站点进行更改，而对基于 CSS 的站点进行类似更改只需更改一个文件。
表现性标记往往更加冗余，因此导致文档大小更大。
由于这些原因，表现性标记在这一版本的 HTML 中已被移除。这一变化并不令人惊讶；HTML4 很多年前已弃用了表现性标记，并提供了一种模式（HTML4 Transitional）来帮助作者摆脱表现性标记；随后，XHTML 1.1 进一步将这些特性完全废弃。
HTML 中唯一剩余的表现性标记特性是 style 属性和 style
元素。style
属性在生产环境中使用有些不被推荐，但在快速原型制作（其规则可以随后直接移入单独的样式表）和在特定情况下提供特殊样式时（在这种情况下使用单独的样式表可能不方便）是有用的。类似地，style
元素在聚合或页面特定样式中可能很有用，但一般来说，当样式适用于多个页面时，外部样式表可能更为方便。
还值得注意的是，一些以前被认为是表现性的元素在本规范中被重新定义为与媒体无关：b、i、hr、s、small 和
u。
本节为非规范性内容。
HTML 的语法被约束以避免各种问题。
某些无效的语法构造在解析时，会生成非常不直观的 DOM 树。
为了使用户代理在受控环境中使用而无需实现更奇异和复杂的错误处理规则，允许用户代理在遇到 解析错误 时失败。
一些错误处理行为，例如上面提到的 <table><hr>... 示例，不兼容流式用户代理（即以单次传递处理 HTML
文件的用户代理，不存储状态）。为了避免与这些用户代理的互操作性问题，任何导致这种行为的语法都被视为无效。
当基于 XML 的用户代理连接到 HTML 解析器时，可能会出现违反 XML 强制的某些不变性（例如，元素或属性名称从不包含多个冒号）的情况。这需要解析器将 HTML DOM 强制转换为与 XML 兼容的 infoset。大多数需要这种处理的语法构造被视为无效。（包含两个连续连字符或以连字符结尾的注释是 HTML 语法中允许的例外。）
某些语法构造可能导致性能显著下降。为了防止使用这些构造，通常会将其标记为不符合规范。
例如，以下标记导致性能下降，因为所有未闭合的 i
元素必须在每个段落中重建，从而导致每个段落中的元素逐渐增多：
< p >< i > She dreamt.
< p >< i > She dreamt that she ate breakfast.
< p >< i > Then lunch.
< p >< i > And finally dinner.这个片段生成的 DOM 将是：
有些语法构造由于历史原因，较为脆弱。为了减少用户偶然遇到此类问题的数量，这些构造被设为不符合规范。
例如，某些命名字符引用在属性中的解析即使在省略了结束分号的情况下也会发生。可以安全地包含一个紧跟着非命名字符引用字母的与号，但如果字母被更改为一个确实形成命名字符引用的字符串，它们将被解释为该字符。
在以下片段中，属性的值是 "?bill&ted"：
< a href = "?bill&ted" > Bill and Ted</ a > 然而，在以下片段中，属性的值实际上是 "?art©"，而不是预期的
"?art©"，因为即使没有最终的分号，"©" 也会被处理为 "©"，从而被解释为
"©"：
< a href = "?art©" > Art and Copy</ a > 为避免此问题，所有命名字符引用必须以分号结束，且未以分号结束的命名字符引用将被标记为错误。
因此，上述情况的正确表示方式如下：
< a href = "?bill&ted" > Bill and Ted</ a > <!-- &ted is ok, since it's not a named character reference --> < a href = "?art&copy" > Art and Copy</ a > <!-- the & has to be escaped, since © is a named character reference --> 某些语法构造已知会在旧版用户代理中引发特别微妙或严重的问题，因此被标记为不符合规范，以帮助作者避免这些问题。
例如，这就是为什么 U+0060 GRAVE ACCENT 字符（`）不允许出现在未加引号的属性中。在某些旧版用户代理中，它有时被当作引号字符处理。
某些限制纯粹是为了避免已知的安全问题。
例如，限制使用 UTF-7 的规定纯粹是为了避免作者受到利用 UTF-7 的已知跨站脚本攻击的威胁。 [UTF7]
作者意图非常不明确的标记通常被标记为不符合规范。尽早纠正这些错误可以使后续维护更容易。
当用户犯简单的打字错误时，如果能够及早捕捉到错误，这将有助于节省作者大量的调试时间。因此，本规范通常将使用与规范中定义的名称不匹配的元素名称、属性名称等视为错误。
例如，如果作者输入了 <capton> 而不是 <caption>，这将被标记为错误，作者可以立即纠正这个打字错误。
为了允许将来扩展语言语法，某些原本无害的特性被禁止。
例如，结束标签中的“属性”目前被忽略，但它们是无效的，以防将来对语言进行修改时，使用该语法特性而不与已经部署的（并且有效的！）内容冲突。
一些作者发现，总是引用所有属性并始终包括所有可选标签的做法是有帮助的，他们更倾向于从这种习惯中获得的一致性，而不是利用HTML语法的灵活性所带来的微小好处。为了帮助这些作者，符合性检查工具可以提供一种操作模式，其中强制执行这些约定。
本节是非规范性的。
除了语言的语法之外，本规范还对如何指定元素和属性进行限制。这些限制存在的原因类似：
为了避免误用具有明确意义的元素，定义了内容模型以限制元素在这种嵌套不太可能有价值的情况下的嵌套方式。
同样，为了引起作者对元素使用错误的注意，明确的语义矛盾也被视为符合性错误。
例如，在下面的片段中，语义是不合理的：分隔符不能同时是单元格，单选按钮也不能是进度条。
< hr role = "cell" > < input type = radio role = progressbar > 另一个例子是ul
元素的内容模型限制，该模型只允许li
元素作为子元素。列表按定义仅由零个或多个列表项组成，因此如果一个ul
元素包含除li
元素以外的内容，就不清楚其含义了。
某些元素具有默认样式或行为，这使得某些组合可能会导致混淆。如果这些问题可以通过使用没有这些问题的等效替代方案来避免，则混淆的组合将不被允许。
例如，div
元素作为块盒显示，而span
元素作为行内盒显示。在一个
块盒中放置一个
行内盒是不必要的混淆；因为无论是仅嵌套div
元素，还是仅嵌套span
元素，或者在div
元素中嵌套span
元素，都可以达到相同的目的。因此，div
元素嵌套在span元素中是被禁止的。
另一个例子是交互内容
不能嵌套。例如，button
元素不能包含textarea
元素。这是因为这种嵌套交互元素的默认行为对用户来说会非常混乱。相反，这些元素可以并排放置。
有时，一些东西被禁止是因为允许它会导致作者的混淆。
例如，将disabled
属性设置为false是禁止的，因为尽管看起来是表示元素是启用的，但实际上表示元素是禁用的（对于实现来说，重要的是属性的存在，而不是其值）。
某些符合性错误简化了作者需要学习的语言。
例如，area
元素的shape
属性，尽管在实践中circ
和circle
值作为同义词接受，但禁止使用circ
值，以简化教程和其他学习工具。允许两者没有任何好处，但会在教授语言时引起额外的混淆。
某些元素以有些古怪的方式解析（通常是历史原因），其内容模型限制旨在避免作者暴露于这些问题。
某些错误旨在帮助防止难以调试的脚本问题。
例如，这就是为什么具有相同值的两个id
属性是非规范的。重复的ID会导致选择错误的元素，有时会导致难以确定原因的灾难性效果。
某些构造被禁止是因为它们在历史上已导致了大量的创作时间浪费，通过鼓励作者避免犯这些错误，可以在未来的工作中节省时间。
例如，一个script
元素的src
属性会导致元素的内容被忽略。然而，这并不明显，特别是当元素的内容看起来像可执行脚本时——这会导致作者花费大量时间尝试调试内联脚本，而没有意识到它没有执行。为了减少这个问题，本规范使在存在src
属性时，在script
元素中包含可执行脚本为非规范。这意味着验证其文档的作者不太可能在这种错误上浪费时间。
有些作者喜欢编写可以同时作为XML和HTML解释并具有类似结果的文件。尽管这种做法在一般情况下由于涉及的各种微妙复杂性（尤其是涉及脚本、样式或任何形式的自动化序列化）而不鼓励，但本规范有一些限制旨在至少在某种程度上缓解这些困难。这使得作者在HTML和XML语法之间迁移时可以更轻松地使用此过渡步骤。
例如，围绕lang
和xml:lang
属性的规则相对复杂，旨在保持两者同步。
另一个例子是HTML序列化中xmlns属性值的限制，旨在确保无论是作为HTML还是XML处理，符合规范的文档中的元素最终都会位于相同的命名空间中。
与旨在允许将来修订语言的新语法的语法限制一样，对元素的内容模型和属性值的某些限制旨在允许HTML词汇的未来扩展。
例如，限制以U+005F下划线字符（_）开头的target
属性的值仅限于特定的预定义值，以便将来可以引入新的预定义值，而不会与作者定义的值冲突。
某些限制旨在支持其他规范的限制。
例如，要求使用媒体查询列表的属性仅使用有效的媒体查询列表，加强了遵循该规范的符合性规则的重要性。
本节是非规范性的。
以下文档可能对本规范的读者感兴趣。
本架构规范为规范的作者、软件开发人员和内容开发人员提供了一个共同的参考，用于在万维网上进行可互操作的文本处理，基于Unicode标准和ISO/IEC 10646共同定义的通用字符集。涉及的主题包括“字符”、“编码”和“字符串”的使用术语、参考处理模型、字符编码的选择和标识、字符转义和字符串索引。
由于Unicode包含了大量字符并结合了世界上各种书写系统，不正确的使用可能会使程序或系统面临潜在的安全攻击。这在越来越多的产品国际化时尤为重要。本文件描述了程序员、系统分析员、标准开发人员和用户应考虑的一些安全问题，并提供了具体的建议以降低问题的风险。
网页内容无障碍指南 (WCAG) 涵盖了一系列使网页内容更具可访问性的建议。遵循这些指南将使内容对更多有残疾的人更易访问，包括盲人和低视力者、聋人和听力损失者、学习障碍者、认知限制者、行动不便者、言语障碍者、光敏感者及其组合。遵循这些指南通常也会使您的网页内容对一般用户更易用。
本规范提供了设计更易于残障人士使用的网页内容创作工具的指南。符合这些指南的创作工具将通过为残障作者提供可访问的用户界面以及通过启用、支持和促进所有作者创作可访问的网页内容来促进无障碍。
本文件提供了设计用户代理的指南，以降低残障人士在网页无障碍方面的障碍。用户代理包括浏览器和其他类型的检索和呈现网页内容的软件。符合这些指南的用户代理将通过其自身的用户界面和其他内部功能（包括与其他技术（尤其是辅助技术）通信的能力）促进无障碍。此外，所有用户，不仅仅是残障用户，都会发现符合这些指南的用户代理更易用。
本规范依赖于 Infra。[INFRA]
本规范提到HTML和XML属性以及IDL属性时，通常在同一上下文中使用。当不清楚所指为何时，HTML和XML属性被称为内容属性，而IDL接口中定义的那些则被称为IDL属性。同样，"属性"一词既用于JavaScript对象属性，也用于CSS属性。当这些术语有歧义时，会分别限定为对象属性和CSS属性。
通常，当规范说明某个功能适用于HTML语法 或XML语法时，它也包括另一种语法。当某个功能仅适用于两种语言中的一种时，会明确指出它不适用于另一种格式，例如“对于HTML，...（这不适用于XML）”。
本规范使用术语文档来指代任何使用HTML的情况，从短的静态文档到带有丰富多媒体的长篇文章或报告，以及完全成熟的交互式应用程序。该术语用于指代Document
对象及其后代DOM树，以及根据上下文使用HTML语法或XML语法的序列化字节流。
在DOM结构的上下文中，术语HTML文档和XML文档按照DOM中的定义使用，特指Document对象可能处于的两种不同模式。[DOM]（此类用法总是超链接到其定义。）
在字节流的上下文中，术语HTML文档指的是标记为text/html的资源，术语XML文档指的是标记为XML MIME类型的资源。
为了简化，术语如显示、呈现和可见有时可能用于指代文档呈现给用户的方式。这些术语并不意味着特指视觉媒介；它们必须被视为在其他媒介中具有等效的应用。
按照定义并行执行步骤，意味着这些步骤在标准中的其他逻辑（例如，事件循环）同时运行。该标准未定义实现这一目标的精确机制，无论是时间共享协作多任务处理、纤程、线程、进程、使用不同的超线程、核心、CPU、机器等。相比之下，立即运行的操作必须中断当前正在运行的任务，自己运行，然后恢复之前正在运行的任务。
有关编写利用并行处理规范的指南，请参见其他规范中的事件循环处理。
为了避免不同并行算法在操作相同数据时产生竞争条件，可以使用并行队列。
并行队列表示必须按顺序运行的一系列算法步骤。
要将步骤加入队列到并行队列，加入算法步骤到并行队列的算法队列。
要启动一个新的并行队列，请运行以下步骤：
并行运行的步骤本身可以并行运行其他步骤。例如，在并行队列内并行运行一系列步骤可能是有用的。
设想一个标准定义的nameList（一个列表），以及一个方法将name添加到nameList，除非nameList已经 包含name，在这种情况下，它将拒绝。
以下解决方案存在竞态条件：
按以下步骤并行运行：
返回p。
以上两个调用可以同时运行，这意味着在步骤 2.1 中name不在nameList中，但在步骤 2.3 运行之前，它 可能被添加，这意味着name最终在nameList中出现了两次。
并行队列解决了这个问题。标准将让nameListQueue作为 启动一个新并行队列的结果，然后：
将以下步骤加入队列到nameListQueue：
返回p。
这些步骤现在会排队，竞态得以避免。
本规范使用术语支持的来指用户代理是否具有能够解码外部资源语义的实现。当实现能够处理某种格式或类型的外部资源而不会忽略资源的关键方面时，该格式或类型被称为支持的。特定资源是否支持的可能取决于资源格式中使用的功能。
例如，如果可以解码并渲染PNG图像的像素数据，即使实现不知道图像还包含动画数据，该图像也被认为是支持的格式。
如果使用的压缩格式不支持，即使实现可以从文件的元数据中确定电影的尺寸，MPEG-4视频文件也不会被认为是支持的格式。
某些规范（特别是HTTP规范）所指的表示在本规范中被称为资源。[HTTP]
资源的关键子资源是指资源需要可用以便被正确处理的那些资源。哪些资源被认为是关键资源由定义资源格式的规范规定。
对于CSS样式表，我们在此暂时定义它们的关键子资源是通过@import规则导入的其他样式表，包括由其他导入的样式表间接导入的样式表。
此定义尚未完全互操作；此外，一些用户代理似乎将背景图像或网页字体等资源视为关键子资源。理想情况下，CSS工作组将定义这一点；请参见w3c/csswg-drafts issue #1088以跟踪此方面的进展。
为了简化从HTML到XML的迁移，符合本规范的用户代理将在DOM和CSS的目的下，将HTML中的元素放置在http://www.w3.org/1999/xhtml命名空间中。术语"HTML元素"指的是该命名空间中的任何元素，即使是在XML文档中。
除非另有说明，本规范中定义或提到的所有元素都在HTML命名空间
("http://www.w3.org/1999/xhtml")中，且本规范中定义或提到的所有属性都没有命名空间。
术语元素类型用于指具有给定本地名称和命名空间的元素集。例如，button元素是具有元素类型button的元素，这意味着它们具有本地名称"button"，并且（如上所述隐含）在HTML命名空间中。
如果属性名称与XML中定义的Name生产匹配，并且不包含U+003A冒号字符(:)，则称这些属性名称为XML兼容。[XML]
当声明某个元素或属性被忽略，或被视为其他值，或处理为其他内容时，这仅指节点在DOM中处理的情况。在这种情况下，用户代理不得更改DOM。
只有当内容属性的新值与其先前的值不同，才说内容属性改变了值；将属性设置为它已经具有的值不会改变它。
当术语空用于属性值、文本节点或字符串时，表示文本的长度为零（即，不包含控制字符或U+0020空格）。
HTML 元素可以具有特定的 HTML 元素插入步骤、HTML 元素连接后步骤 和 HTML 元素移除步骤，这些步骤都是根据元素的 本地名称 定义的。
HTML标准的插入步骤，给定insertedNode，定义如下：
如果insertedNode是一个元素，并且其命名空间是HTML 命名空间，并且本标准为insertedNode的本地名称定义了HTML 元素插入步骤，则运行相应的HTML 元素插入步骤，给定insertedNode。
如果insertedNode是一个不在打开元素栈中的HTML解析器的Element，则处理内部资源链接，给定insertedNode的节点文档。
连接后的步骤对于 HTML 标准，给定 insertedNode，定义如下：
如果 insertedNode 是一个元素，并且其 命名空间是 HTML 命名空间，且本标准为 insertedNode 的 本地名称定义了HTML 元素连接后的步骤，则在给定 insertedNode 的情况下运行相应的 HTML 元素连接后的步骤。
HTML标准的移除步骤，给定removedNode和oldParent，定义如下：
令document为removedNode的节点文档。
如果document的聚焦区域是removedNode，则将document的聚焦区域设置为document的视口，并将document的相关全局对象的导航API的正在进行导航期间焦点更改设置为false。
如果removedNode是其命名空间为 HTML命名空间的元素，并且本标准为removedNode的本地名称定义了HTML元素移除步骤，则运行对应的HTML元素移除步骤，给定removedNode和oldParent。
如果removedNode的弹出框属性不在无弹出框状态，则运行隐藏弹出框算法，给定removedNode、false、false和false。
当插入步骤以某个节点作为参数调用时，并且该节点现在在文档树中，则称该节点已插入文档。类似地，当移除步骤以某个节点作为参数调用时，并且该节点现在不再在文档树中，则称该节点已从文档中移除。
当插入步骤以某个节点作为参数调用时，并且该节点现在已连接，则该节点变为连接状态。类似地，当移除步骤以某个节点作为参数调用时，并且该节点现在不再已连接，则该节点变为断开状态。
当某个节点已连接且其包含阴影根的浏览上下文非空时，该节点是浏览上下文连接的。当插入步骤以某个节点作为参数调用时，并且该节点现在浏览上下文连接的，则该节点变为浏览上下文连接的。当移除步骤以某个节点作为参数调用时，并且该节点现在不再浏览上下文连接的，或当其包含阴影根的浏览上下文变为空时，该节点变为浏览上下文断开的。
构造 "一个 Foo 对象"，其中 Foo 实际上是一个接口，有时被用于代替更准确的 "实现接口 Foo 的对象"。
当IDL属性的值被检索（例如通过作者脚本）时，称该属性正在获取值，当为其赋予新值时，称其正在设置值。
如果某个DOM对象被称为实时的，则该对象上的属性和方法必须操作实际的底层数据，而不是数据的快照。
术语插件是指由用户代理使用的一组实现定义的内容处理程序，这些处理程序可以参与用户代理对文档对象的渲染，但既不作为文档的子导航，也不会向文档的DOM引入任何节点对象。
通常，这些内容处理程序由第三方提供，但用户代理也可以将内置的内容处理程序指定为插件。
用户代理不得将类型text/plain和application/octet-stream视为已注册的插件。
插件的一个例子是当用户导航到PDF文件时，在导航器中实例化的PDF查看器。无论PDF查看器组件的实现方与用户代理的实现方是否相同，这都算作插件。然而，与用户代理分开的启动的PDF查看器应用程序（而不是使用相同的界面）不符合插件的定义。
本规范未定义与插件交互的机制，因为这被认为是用户代理和平台特定的。一些用户代理可能选择支持诸如Netscape插件API之类的插件机制；其他可能使用远程内容转换器或内置支持某些类型。事实上，本规范并不要求用户代理支持插件。[NPAPI]
浏览器在与外部内容（例如插件）交互时应格外小心。当第三方软件与用户代理本身具有相同的权限运行时，第三方软件中的漏洞变得与用户代理中的漏洞一样危险。
由于不同用户拥有不同的插件集提供了一个跟踪向量，增加了唯一识别用户的可能性，建议用户代理为每个用户支持完全相同的插件集。
字符编码，或在不产生歧义的情况下仅称为编码，是一种在字节流和Unicode字符串之间转换的定义方式，如编码中定义的那样。一个编码具有一个编码名称和一个或多个编码标签，在编码标准中被称为编码的名称和标签。[ENCODING]
本规范描述了与实现者相关的用户代理和与作者及创作工具实现者相关的文档的合规标准。
合规文档是指符合所有文档合规标准的文档。为了便于阅读，这些合规要求中的一些被表述为对作者的合规要求；这些要求隐含为对文档的要求：根据定义，所有文档都假定由某个作者创建。（在某些情况下，作者本身可能是用户代理——此类用户代理需要遵守下面解释的额外规则。）
例如，如果某个要求规定“作者不得使用foobar元素”，则意味着文档中不允许包含名为foobar的元素。
文档合规要求与实现合规要求之间没有隐含关系。用户代理不得自由处理不合规的文档；无论输入文档是否合规，本规范描述的处理模型都适用于实现。
用户代理分为几类（重叠），具有不同的合规要求。
支持XML语法的Web浏览器必须按本规范描述的方式处理XML文档中HTML命名空间中的元素和属性，以便用户可以与之交互，除非这些元素的语义已被其他规范覆盖。
一个合规的Web浏览器在XML文档中发现script元素时，会执行该元素中包含的脚本。然而，如果该元素在用XSLT表示的转换中被找到（假设用户代理也支持XSLT），则处理器会将script元素视为转换的一部分的透明元素。
支持HTML语法的Web浏览器必须按本规范描述的方式处理带有HTML MIME类型标签的文档，以便用户可以与之交互。
支持脚本的用户代理还必须是本规范中IDL片段的合规实现，如Web IDL中所述。[WEBIDL]
除非明确说明，覆盖HTML元素语义的规范不会覆盖表示这些元素的DOM对象的要求。例如，上述示例中的script元素仍将实现HTMLScriptElement接口。
纯粹为了呈现非交互式版本的HTML和XML文档的用户代理必须遵守与Web浏览器相同的合规标准，只是它们不需要遵守有关用户交互的要求。
非交互式呈现用户代理的典型例子是打印机（静态用户代理）和投影显示器（动态用户代理）。大多数静态非交互式呈现用户代理预计也会选择不支持脚本。
一个非交互但动态的呈现用户代理仍会执行脚本，允许表单动态提交等等。然而，由于用户无法与文档交互，“焦点”概念无关紧要，用户代理不需要支持任何与焦点相关的DOM API。
用户代理，无论是交互式的还是非交互式的，都可以（可能作为用户选项）被指定为支持本规范定义的建议默认渲染。
这不是强制性的。特别是，即使实现了建议的默认渲染的用户代理，也鼓励提供设置，以覆盖此默认设置，从而改善用户体验，例如改变颜色对比度，使用不同的焦点样式，或以其他方式使体验对用户更具可访问性和可用性。
指定为支持建议默认渲染的用户代理在指定时，必须实现渲染部分定义的用户代理应当实现的规则。
不支持脚本的实现（或完全禁用其脚本功能的实现）不需要支持本规范中提到的事件和DOM接口。对于以事件模型或DOM为基础定义的规范部分，此类用户代理仍必须表现得好像支持事件和DOM一样。
脚本可以构成应用程序的一个组成部分。不支持脚本的Web浏览器或禁用脚本的Web浏览器可能无法完全传达作者的意图。
合规检查器必须验证文档是否符合本规范描述的适用合规标准。自动化合规检查器不需要检测需要解释作者意图的错误（例如，虽然如果blockquote元素的内容不是引用，文档就不合规，但没有人工判断输入的合规检查器不必检查blockquote元素是否只包含引用材料）。
合规检查器必须在没有浏览上下文的情况下（意味着不运行脚本，解析器的脚本标志被禁用）检查输入文档的合规性，还应检查在有浏览上下文并且脚本执行时输入文档的合规性，并且脚本在执行期间不会导致除瞬态状态外的非合规状态。（这是一个“应当”而不是“必须”要求，因为它已被证明是不可能的。[COMPUTABLE]）
术语“HTML验证器”可以用来指代符合本规范适用要求的合规检查器。
XML DTD无法表达本规范的所有合规要求。因此，验证XML处理器和DTD不能构成合规检查器。此外，由于本规范定义的两种创作格式都不是SGML的应用程序，因此验证SGML系统也不能构成合规检查器。
换句话说，有三种类型的合规标准：
合规检查器必须检查前两类错误。简单的基于DTD的验证器只能检查第一类错误，因此根据本规范不构成合规检查器。
为了渲 染文档或检查其合规性之外的目的处理HTML和XML文档的应用程序和工具，应根据其处理的文档的语义行事。
创作工具和标记生成器必须生成合规文档。适用于作者的合规标准在适当时也适用于创作工具。
创作工具不受严格使用元素只用于其指定目的的要求的限制，但仅限于创作工具尚无法确定作者意图的情况。然而，创作工具不得自动滥用元素或鼓励其用户这样做。
例如，使用address元素标记任意联系信息是不合规的；该元素只能用于标记其最近的article或body元素祖先的联系信息。然而，由于创作工具可能无法区分，创作工具对此要求免除。这并不意味着创作工具可以将address元素用于任何斜体文本块（例如）；这仅意味着创作工具不必验证用户在插入article元素的联系信息工具时，用户确实在插入联系信息而不是插入其他内容。
在合规检查方面，编辑器必须输出符合与合规检查器将验证的程度相同的文档。
当使用创作工具编辑不合规文档时，它可以在编辑过程中未编辑的文档部分保留合规错误（即编辑工具可以原样保存错误内容）。然而，如果错误被这样保留，创作工具不得声称输出是合规的。
创作工具预计分为两大类：基于结构或语义数据的工具和基于所见即所得的媒体特定编辑工具（WYSIWYG）。
前者是创作HTML工具的首选机制，因为源信息中的结构可以用于在HTML元素和属性的选择上做出明智的选择。
然而，所见即所得工具也是合法的。所见即所得工具应使用它们知道合适的元素，并且不应使用它们不知道合适的元素。这在某些极端情况下可能意味着将流元素的使用限制在少数几个元素，如div，b，i和span，并广泛使用style属性。
无论是所见即所得还是其他类型的创作工具，都应尽最大努力使用户能够创建结构良好、语义丰富、与媒体无关的内容。
为了与现有内容和先前规范兼容，本规范描述了两种创作格式：一种基于XML，另一种使用自定义格式，受到SGML的启发（称为HTML语法）。实现必须至少支持这两种格式中的一种，尽管鼓励支持两者。
一些合规要求表述为对元素、属性、方法或对象的要求。这些要求分为两类：描述内容模型限制的要求和描述实现行为的要求。前者是对文档和创作工具的要求。后者是对用户代理的要求。同样，一些合规要求表述为对作者的要求；这些要求应解释为对作者生成的文档的合规要求。（换句话说，本规范不区分对作者的合规标准和对文档的合规标准。）
本规范依赖于几个其他的基础规范。
以下术语在基础结构（Infra）中定义：[INFRA]
Unicode字符集用于表示文本数据，Encoding定义了与字符编码相关的要求。 [UNICODE]
本规范引入了 基于这些规范中定义的术语，如前所述。
以下术语在Encoding中定义：[ENCODING]
支持HTML的XML语法的实现必须支持某个版本的XML及其对应的命名空间规范，因为该语法使用带有命名空间的XML序列化。[XML] [XMLNS]
在不运行脚本、不评估CSS或XPath表达式，或不将结果DOM暴露给任意内容的情况下执行内容操作的数据挖掘工具和其他用户代理，可以通过仅断言其DOM节点类似物在某些命名空间中来“支持命名空间”，而无需实际暴露命名空间字符串。
在HTML语法中，命名空间前缀和命名空间声明与XML中的效果不同。例如，冒号在HTML元素名称中没有特殊含义。
在XML命名空间中名称为space的属性由可扩展标记语言
(XML)定义。[XML]
本规范还引用了与XML文档关联样式表中定义的<?xml-stylesheet?>处理指令。[XMLSSPI]
本规范还非规范性地提及了XSLTProcessor接口及其transformToFragment()和transformToDocument()方法。[XSLTP]
以下术语在URL中定义：[URL]
application/x-www-form-urlencoded
formatapplication/x-www-form-urlencoded
serializer本规范还引用了多个方案和协议：
about:方案
[ABOUT]
blob:方案
[FILEAPI]
data:方案
[RFC2397]
http:方案
[HTTP]
https:方案
[HTTP]
mailto:方案
[MAILTO]
sms:方案
[SMS]
urn:方案
[URN]
媒体片段语法在媒体片段URI中定义。[MEDIAFRAG]
以下术语在HTTP规范中定义：[HTTP]
Accept` 头部Accept-Language`
头部Cache-Control`
头部Content-Disposition` 头部Content-Language`
头部Content-Range`
头部Last-Modified`
头部Range` 头部Referer` 头部以下术语在HTTP State Management Mechanism中定义：[COOKIES]
以下术语在Web Linking中定义：[WEBLINK]
以下术语在Structured Field Values for HTTP中定义：[STRUCTURED-FIELDS]
以下术语在MIME Sniffing中定义：[MIMESNIFF]
以下术语在Fetch中定义：[FETCH]
about:blankUser-Agent`值
Origin`头部Cross-Origin-Resource-Policy`头部
RequestCredentials枚举
RequestDestination枚举
fetch()方法以下术语在Referrer Policy中定义：[REFERRERPOLICY]
Referrer-Policy`HTTP头
Referrer-Policy`头解析引用者政策算法
no-referrer`，`no-referrer-when-downgrade`，`origin-when-cross-origin`，`unsafe-url`引用者政策
以下术语在Mixed Content中定义：[MIX]
以下术语在Subresource Integrity中定义：[SRI]
Paint Timing 中定义了以下术语：[PAINTTIMING]
Navigation Timing 中定义了以下术语：[NAVIGATIONTIMING]
NavigationTimingType
及其 "navigate",
"reload",
和 "back_forward"
值。Resource Timing 中定义了以下术语： [RESOURCETIMING]
Performance Timeline 中定义了以下术语： [PERFORMANCETIMELINE]
Long Animation Frames 中定义了以下术语： [LONGANIMATIONFRAMES]
Long Tasks 中定义了以下术语： [LONGTASKS]
本规范中的 IDL 片段必须按照 Web IDL 的要求进行解释，以符合 IDL 片段的要求。 [WEBIDL]
以下术语在 Web IDL 中定义：
[Global][LegacyFactoryFunction]
[LegacyLenientThis][LegacyNullToEmptyString]
[LegacyOverrideBuiltIns]
[LegacyTreatNonObjectAsNull]
[LegacyUnenumerableNamedProperties]
[LegacyUnforgeable]Web IDL 还定义了以下在本规范的 Web IDL 片段中使用的类型：
ArrayBufferArrayBufferView
boolean
DOMStringdouble
Functionlongobject
Promise
Uint8ClampedArray
unrestricted double
unsigned longUSVStringVoidFunction本规范中术语 throw 的使用定义见 Web
IDL。DOMException 类型和以下异常名称由 Web
IDL 定义，并由本规范使用：
IndexSizeError"HierarchyRequestError"
InvalidCharacterError"
NoModificationAllowedError"
NotFoundError"NotSupportedError"InvalidStateError"SyntaxError"InvalidAccessError"
SecurityError"NetworkError"AbortError"QuotaExceededError"
DataCloneError"EncodingError"NotAllowedError"当本规范要求用户代理创建一个表示特定时间（可能是特殊值 NaN）的 Date 对象 时，该时间的毫秒部分（如果有）必须截断为整数，新创建的
Date
对象的时间值必须表示截断后的时间。
例如，给定 2000 年 1 月 1 日 01:00 UTC 后 23045 微秒的时间，即 2000-01-01T00:00:00.023045Z 的时间，则表示该时间的新创建的
Date
对象将表示与表示 2000-01-01T00:00:00.023Z 的对象相同的时间，提前 45 微秒。如果给定的时间是 NaN，则结果是表示时间值为 NaN 的 Date
对象（表示该对象不代表特定的时间点）。
本规范描述的某些语言部分仅支持 JavaScript 作为底层脚本语言。[JAVASCRIPT]
术语“JavaScript”用来指代 ECMA-262，而不是正式术语 ECMAScript，因为 JavaScript 这个术语更广为人知。
以下术语在 JavaScript 规范中定义，并在本规范中使用：
Atomics 对象
Atomics.waitAsync 对象Date 类FinalizationRegistry
类RegExp 类
SharedArrayBuffer 类
SyntaxError
类TypeError
类RangeError
类WeakRef 类
eval() 函数WeakRef.prototype.deref()
函数import()
import.metatypeof
运算符delete 运算符
支持 JavaScript 的用户代理还必须实现 动态代码品牌检查 提案。以下术语在那里定义，并在本规范中使用： [JSDYNAMICCODEBRANDCHECKS]
支持 JavaScript 的用户代理还必须实现 ECMAScript 国际化 API。[JSINTL]
支持 JavaScript 的用户代理还必须实现 导入属性 提案。以下术语在那里定义，并在本规范中使用： [JSIMPORTATTRIBUTES]
支持 JavaScript 的用户代理还必须实现 JSON 模块 提案。以下术语在那里定义，并在本规范中使用： [JSJSONMODULES]
支持 JavaScript 的用户代理还必须实现 可调整大小的 ArrayBuffer 和可增长的 SharedArrayBuffer 提案。以下术语在那里定义，并在本规范中使用： [JSRESIZABLEBUFFERS]
支持 JavaScript 的用户代理还必须实现 Temporal 提案。以下术语在那里定义，并在本规范中使用： [JSTEMPORAL]
以下术语在 WebAssembly JavaScript Interface 中定义：[WASMJS]
文档对象模型 (DOM) 是文档及其内容的表示——一种模型。DOM 不仅仅是一个 API；HTML 实现的符合性标准在本规范中以对 DOM 的操作来定义。[DOM]
实现必须支持 DOM 和在 UI Events 中定义的事件，因为本规范是根据 DOM 定义的，并且一些功能被定义为对 DOM 接口的扩展。[DOM] [UIEVENTS]
特别地，以下功能在 DOM 中定义：[DOM]
Attr 接口CharacterData 接口Comment 接口DOMImplementation
接口Document 接口及其 doctype 属性DocumentOrShadowRoot 接口
DocumentFragment
接口DocumentType 接口ChildNode 接口Element
接口attachShadow() 方法。
Node 接口NodeList 接口ProcessingInstruction
接口ShadowRoot 接口Text 接口Range 接口
HTMLCollection 接口，其
length 属性，以及其 item() 和 namedItem() 方法
DOMTokenList 接口及其 value 属性和 supports
操作createDocument()
方法createHTMLDocument()
方法createElement() 方法
createElementNS()
方法getElementById()
方法getElementsByClassName()
方法append() 方法
appendChild() 方法cloneNode() 方法importNode() 方法preventDefault() 方法
id
属性setAttribute() 方法
textContent 属性slotchange
事件CharacterData
节点及其 replace data
算法Event 接口
Event 和派生接口的构造行为
EventTarget 接口EventInit 字典类型type
属性currentTarget 属性bubbles 属性cancelable 属性composed 属性isTrusted 属性
initEvent() 方法addEventListener()
方法EventListener 回调接口
DocumentNode
及其使用的 cloning
steps 概念is valueMutationObserver 接口及 mutation
observers 的一般概念AbortController 及其 signalAbortSignal以下功能在 UI Events 中定义：[UI EVENTS]
MouseEvent 接口MouseEvent
接口的 relatedTarget
属性MouseEventInit 字典类型
FocusEvent 接口FocusEvent
接口的 relatedTarget
属性UIEvent 接口UIEvent
接口的 view 属性auxclick 事件beforeinput 事件click 事件contextmenu 事件dblclick 事件input 事件mousedown 事件mouseenter 事件mouseleave 事件mousemove 事件mouseout 事件mouseover 事件mouseup 事件wheel 事件keydown 事件keypress 事件keyup 事件以下功能在 Touch Events 中定义：[TOUCH]
Touch
接口touchend 事件以下功能在 Pointer Events 中定义：[POINTEREVENTS]
PointerEvent
接口PointerEvent
接口的 pointerType
属性pointerdown 事件
pointerup 事件pointercancel
事件以下事件在 Clipboard API and events 中定义：[CLIPBOARD-APIS]
本规范有时使用术语 name 来指代事件的 type；例如，“一个名为
click 的事件”或“如果事件名称是 keypress”。术语“name”和“type”对于事件是同义的。
以下功能在 DOM Parsing and Serialization 中定义：[DOMPARSING]
以下功能在 Selection API 中定义：[SELECTION]
鼓励用户代理实现 execCommand 中描述的功能。[EXECCOMMAND]
以下功能在 Fullscreen API 中定义：[FULLSCREEN]
requestFullscreen()
fullscreenchange
High Resolution Time 提供了以下功能：[HRT]
本规范使用 File API 中定义的以下功能：[FILEAPI]
Blob 接口及其
type 属性
File 接口及其
name 和
lastModified 属性
FileList 接口Blob
的
快照状态 概念
本规范使用 Indexed Database API 定义的 清理 Indexed Database 事务。 [INDEXEDDB]
以下术语在 Media Source Extensions 中定义： [MEDIASOURCE]
以下术语在 Media Capture and Streams 中定义： [MEDIASTREAM]
MediaStream
接口以下术语在 Reporting 中定义：[REPORTING]
以下功能和术语在 XMLHttpRequest 中定义： [XHR]
XMLHttpRequest 接口及其 responseXML 属性
ProgressEvent 接口及其
lengthComputable、loaded 和 total 属性
FormData 接口及其关联的
条目列表
以下功能在 Battery Status API 中定义：[BATTERY]
getBattery()
方法实现必须支持 Media Queries。其中定义了 <media-condition> 特性。[MQ]
虽然本规范的实现不要求完全支持 CSS（尽管我们鼓励支持，尤其是对 web 浏览器而言），但有些特性是根据特定的 CSS 要求定义的。
当本规范要求按照特定的 CSS 语法解析某些内容时，必须遵循 CSS Syntax 中相关的算法，包括错误处理规则。[CSSSYNTAX]
例如，用户代理在意外发现样式表末尾时，需要关闭所有未闭合的结构。因此，当解析字符串
"rgb(0,0,0"（缺少闭合括号）作为颜色值时，根据此错误处理规则，闭合括号是隐含的，并且会得到一个值（颜色为 '黑色'）。然而，类似的结构
"rgb(0,0,"（既缺少括号又缺少 "蓝色" 值）不能被解析，因为闭合未闭合的结构不会得到一个有效的值。
以下术语和特性在 Cascading Style Sheets（CSS）中定义：[CSS]
基本版本的'display'属性在CSS中定义，并且该属性由其他CSS模块扩展。[CSS] [CSSRUBY] [CSSTABLE]
以下术语和功能在CSS Box Model中定义：[CSSBOX]
以下功能在CSS逻辑属性中定义：[CSSLOGICAL]
以下术语和功能在CSS颜色中定义：[CSSCOLOR]
以下术语在CSS Images中定义：[CSSIMAGES]
术语paint source在CSS Images Level 4中定义，用于定义某些HTML元素与CSS 'element()'函数的交互。[CSSIMAGES4]
以下功能在CSS Backgrounds and Borders中定义：[CSSBG]
CSS Backgrounds and Borders还定义了以下边框属性：[CSSBG]
以下功能在CSS Box Alignment中定义：[CSSALIGN]
以下术语和功能在CSS Display中定义：[CSSDISPLAY]
以下功能在CSS Flexible Box Layout中定义：[CSSFLEXBOX]
以下术语和功能在CSS Fonts中定义：[CSSFONTS]
以下功能在CSS Grid Layout中定义：[CSSGRID]
以下术语在CSS Inline Layout中定义：[CSSINLINE]
以下术语和功能在CSS Box Sizing中定义：[CSSSIZING]
以下功能在CSS Lists and Counters中定义：[CSSLISTS]
以下功能在CSS Overflow中定义：[CSSOVERFLOW]
以下术语和功能在CSS Positioned Layout中定义：[CSSPOSITION]
以下功能在CSS Multi-column Layout中定义：[CSSMULTICOL]
'ruby-base'值的'display'属性在CSS Ruby Layout中定义。[CSSRUBY]
以下功能在CSS Table中定义：[CSSTABLE]
以下功能在CSS Text中定义：[CSSTEXT]
以下功能在CSS Writing Modes中定义：[CSSWM]
以下功能在CSS Basic User Interface中定义：[CSSUI]
更新动画并发送事件算法在Web Animations中定义。[WEBANIMATIONS]
支持脚本的实现必须支持CSS对象模型。以下功能和术语在CSSOM规范中定义：[CSSOM] [CSSOMVIEW]
Screen接口LinkStyle接口CSSStyleDeclaration接口
styleIDL属性
cssText的CSSStyleDeclaration属性
StyleSheet接口CSSStyleSheet接口
CSSStyleSheet
CSSStyleSheet的规则
resize事件scroll事件
scrollend事件
以下功能和术语在CSS Syntax中定义：[CSSSYNTAX]
以下术语在Selectors中定义：[SELECTORS]
以下功能在CSS Values and Units中定义：[CSSVALUES]
以下功能在CSS View Transitions中定义：[CSSVIEWTRANSITIONS]
术语style attribute在CSS Style Attributes中定义。[CSSATTR]
以下术语在CSS Cascading and Inheritance中定义：[CSSCASCADE]
CanvasRenderingContext2D对象对字体的使用依赖于CSSFonts和Font
Loading规范中描述的功能，特别是FontFace对象和字体来源概念。[CSSFONTS] [CSSFONTLOAD]
以下接口和术语在Geometry Interfaces中定义：[GEOMETRY]
DOMMatrix接口及相关的m11元素、m12元素、m21元素、m22元素、m41元素和m42元素DOMMatrix2DInit和DOMMatrixInit字典
DOMMatrix和从2D字典创建DOMMatrix算法，用于DOMMatrix2DInit或DOMMatrixInit
DOMPointInit字典及相关的x和y成员以下术语在CSS Scoping中定义：[CSSSCOPING]
以下术语和功能在CSS Color Adjustment中定义：[CSSCOLORADJUST]
以下术语在CSS Pseudo-Elements中定义：[CSSPSEUDO]
以下术语在CSS Containment中定义：[CSSCONTAIN]
以下术语在Intersection Observer中定义：[INTERSECTIONOBSERVER]
以下术语在Resize Observer中定义：[RESIZEOBSERVER]
以下接口在WebGL规范中定义：[WEBGL]
以下接口在WebGPU中定义：[WEBGPU]
实现可能支持将WebVTT作为字幕、说明、元数据等的文本轨格式，用于媒体资源。[WEBVTT]
本规范中使用的以下术语在WebVTT中定义：
role属性在Accessible Rich
Internet Applications（ARIA）中定义，如下角色也是：[ARIA]
此外，以下aria-*内容属性在ARIA中定义：[ARIA]
最后，以下术语在ARIA中定义：[ARIA]
以下术语在Content Security Policy中定义：[CSP]
report-uri directiveframe-ancestors
directivesandbox
directiveSecurityPolicyViolationEvent接口
securitypolicyviolation事件
以下术语在Service Workers中定义：[SW]
以下算法在Secure Contexts中定义：[SECURE-CONTEXTS]
以下术语在Permissions Policy中定义：[PERMISSIONSPOLICY]
以下功能在Payment Request API中定义：[PAYMENTREQUEST]
虽然本规范不要求全面支持MathML（尽管至少鼓励网页浏览器支持），某些功能依赖于实现MathML的一小部分。[MATHML]
以下功能在Mathematical Markup Language（MathML）中定义：
虽然本规范不要求全面支持SVG（尽管至少鼓励网页浏览器支持），但某些功能依赖于实现SVG的部分内容。
实现SVG的用户代理必须实现SVG 2规范，而不是任何早期版本。
以下功能在SVG 2规范中定义：[SVG]
SVGElement接口
SVGImageElement接口
SVGScriptElement接口
SVGSVGElement接口
a元素desc元素foreignObject元素image元素script元素svg元素title元素use元素text-rendering属性以下功能在Filter Effects中定义：[FILTERS]
以下功能在Compositing and Blending中定义：[COMPOSITE]
以下功能在Cooperative Scheduling of Background Tasks中定义：[REQUESTIDLECALLBACK]
以下术语在Screen Orientation中定义：[SCREENORIENTATION]
以下术语在Storage中定义：[STORAGE]
以下功能在Web App Manifest中定义：[MANIFEST]
以下术语在WebAssembly JavaScript 接口：ESM 集成中定义：[WASMESM]
以下功能在WebCodecs中定义：[WEBCODECS]
以下术语在WebDriver中定义：[WEBDRIVER]
以下术语在WebDriver BiDi中定义：[WEBDRIVERBIDI]
以下术语在Web Cryptography API中定义： [WEBCRYPTO]
以下术语在WebSockets中定义：[WEBSOCKETS]
以下术语在WebTransport中定义：[WEBTRANSPORT]
以下术语在Web Authentication: An API for accessing Public Key Credentials中定义：[WEBAUTHN]
以下术语在Credential Management中定义：[CREDMAN]
以下术语在Console中定义：[CONSOLE]
以下术语在Web Locks API中定义：[WEBLOCKS]
本规范使用在Trusted Types中定义的以下功能： [TRUSTED-TYPES]
本规范并不要求支持任何特定的网络协议、样式表语言、脚本语言或超出上述列表中要求的任何 DOM 规范。然而，本规范描述的语言倾向于使用 CSS 作为样式语言，JavaScript 作为脚本语言，以及 HTTP 作为网络协议，并且多个功能假定这些语言和协议正在使用。
实现 HTTP 协议的用户代理必须同时实现HTTP State Management Mechanism（Cookies）。[HTTP] [COOKIES]
本规范可能在各自的章节中对字符编码、图像格式、音频格式和视频格式有某些额外要求。
强烈不建议对本规范进行厂商特定的专有用户代理扩展。文档不得使用此类扩展，因为这样做会降低互操作性并分裂用户群体，导致只有特定用户代理的用户才能访问相关内容。
所有扩展必须定义为使用扩展既不矛盾也不导致规范中定义的功能不合格。
例如，尽管强烈不建议这样做，但实现可以向控件添加一个新的 IDL 属性 "typeTime"，该属性返回用户选择当前控件值所花费的时间。另一方面，定义一个出现在表单的 elements
数组中的新控件将违反上述要求，因为它将违反本规范中给出的 elements
的定义。
当需要对本规范进行中立扩展时，可以相应地更新本规范，或者可以编写一个扩展规范来覆盖本规范中的要求。当某人将本规范应用于其活动时，决定认可此类扩展规范的要求时，它将成为本规范符合性要求目的的 适用规范。
有人可以编写一个规范，定义任何任意字节流都是合格的，然后声称他们的随机垃圾是合格的。然而，这并不意味着他们的随机垃圾实际上对所有人的目的都是合格的：如果其他人决定该规范不适用于他们的工作，那么他们可以很合法地说上述随机垃圾只是垃圾，根本不合格。就符合性而言，特定社区中的重要问题是该社区 同意 适用的是什么。
用户代理必须将不理解的元素和属性视为语义中性；将它们留在 DOM 中（对于 DOM 处理器），并根据 CSS 进行样式设置（对于 CSS 处理器），但不从中推断任何意义。
当某个功能的支持被禁用时（例如作为减轻安全问题的紧急措施，或为开发提供帮助，或出于性能原因），用户代理必须表现得好像他们完全不支持该功能，并且该功能未在本规范中提及。例如，如果通过 Web IDL 接口中的属性访问某个特定功能，该属性本身将从实现该接口的对象中省略——将属性留在对象上但使其返回 null 或抛出异常是不足够的。
在根据本规范描述的方式解析或创建的 HTML 文档上操作的 XPath 1.0
实现（例如，作为 document.evaluate() API 的一部分）必须表现得好像已对 XPath 1.0 规范应用了以下编辑。
首先，删除以下段落：
节点测试中的 QName 使用表达式上下文中的命名空间声明扩展为 扩展名称。这与在开始和结束标签中为元素类型名称进行扩展的方式相同，只是未使用
xmlns声明的默认命名空间：如果 QName 没有前缀，则命名空间 URI 为 null（这与属性名称的扩展方式相同）。如果 QName 有一个前缀，但在表达式上下文中没有命名空间声明，则这是一个错误。
然后，将其替换为以下内容：
节点测试中的 QName 使用表达式上下文中的命名空间声明扩展为扩展名称。如果 QName 有前缀，则该前缀必须在表达式上下文中有命名空间声明，并且相应的命名空间 URI 是与该前缀关联的命名空间 URI。如果 QName 有一个前缀，但在表达式上下文中没有命名空间声明，则这是一个错误。
如果 QName 没有前缀并且轴的主要节点类型是元素，则使用默认元素命名空间。否则，如果 QName 没有前缀，则命名空间 URI 为 null。默认元素命名空间是 XPath 表达式上下文的成员。在通过 DOM3 XPath API 执行 XPath 表达式时，默认元素命名空间的值按以下方式确定：
- 如果上下文节点来自 HTML DOM，则默认元素命名空间为 "http://www.w3.org/1999/xhtml"。
- 否则，默认元素命名空间 URI 为 null。
这相当于将 XPath 2.0 的默认元素命名空间功能添加到 XPath 1.0 中，并将 HTML 命名空间用作 HTML 文档的默认元素命名空间。这样做的目的是希望实现能够与遗留 HTML 内容兼容，同时支持本规范引入的有关 HTML 元素使用的命名空间的更改，并希望使用 XPath 1.0 而不是 XPath 2.0。
此更改是 XPath 1.0 规范的故意违反，目的是希望实现能够与遗留内容兼容，同时支持本规范引入的有关 HTML 元素使用的命名空间的更改。[XPATH10]
当输出方法为 "html"（无论是显式还是通过 XSLT 1.0 中的默认规则）时，将输出到 DOM 的 XSLT 1.0 处理器受以下影响：
如果转换程序输出的元素没有命名空间，则处理器在构造相应的 DOM 元素节点之前，必须将该元素的命名空间更改为HTML 命名空间，将元素的本地名称转换为 ASCII 小写，并将元素上的任何非命名空间属性的名称转换为 ASCII 小写。
此要求是 XSLT 1.0 规范的故意违反，因为本规范更改了 HTML 的命名空间和大小写规则，否则这将与基于 DOM 的 XSLT 转换不兼容。（序列化输出的处理器不受影响。）[XSLT10]
本规范未明确说明 XSLT 处理如何与HTML
解析器基础结构交互（例如，XSLT 处理器是否表现为将任何元素放入打开元素堆栈）。然而，XSLT 处理器在成功完成时必须停止解析，并且在中止时必须首先将当前文档的准备状态更新为
"interactive"，然后更新为 "complete"。
本规范未规定 XSLT 如何与导航算法、如何适应事件循环以及如何处理错误页面（例如，是否用 XSLT 错误替换增量 XSLT 输出，或内联呈现等）。
在 script 元素部分中以及在 template 元素部分中，还对 XSLT 和 HTML 以及 XSLT、XPath 和 HTML 的交互进行了额外的非规范性注释。
Headers/Permissions-Policy/document-domain
仅在一个引擎中支持。
本文档定义了以下策略控制的功能：
Headers/Feature-Policy/autoplay
Headers/Permissions-Policy/autoplay
仅在一个引擎中支持。
HTML 中有很多地方接受特定的数据类型，例如日期或数字。本节描述了这些格式内容的符合性标准以及如何解析它们。
强烈建议实现者仔细检查可能考虑使用的任何第三方库，以实现以下描述的语法解析。例如，日期库可能会实现与本规范要求不同的错误处理行为，因为描述类似于本规范中使用的日期语法的规范中通常未定义错误处理行为，因此实现往往在如何处理错误方面存在很大差异。
下面描述的一些微解析器遵循一种模式，即具有一个保存解析字符串的 input 变量，以及一个指向 input 中下一个要解析的字符的 position 变量。
有许多属性是 布尔属性。元素上存在布尔属性表示真值，而不存在该属性表示假值。
如果该属性存在，其值必须是空字符串或与属性规范名称进行 ASCII 大小写不敏感 匹配的值，且没有前导或尾随空格。
布尔属性上不允许使用值 "true" 和 "false"。要表示假值，必须完全省略该属性。
以下是一个已选中且禁用的复选框示例。checked
和 disabled
属性是布尔属性。
< label >< input type = checkbox checked name = cheese disabled > Cheese</ label > 这也可以等效地写成这样：
< label >< input type = checkbox checked = checked name = cheese disabled = disabled > Cheese</ label > 你也可以混合使用样式；以下内容仍然等效：
< label >< input type = 'checkbox' checked name = cheese disabled = "" > Cheese</ label > 一些属性称为枚举属性，它们取一组有限的状态。此类属性的状态通过将属性值、每个属性规范中给出的关键字/状态映射集和属性规范中可能给出的两种特殊状态结合起来得出。这些特殊状态是无效值默认值和缺失值默认值。
多个关键字可以映射到同一状态。
空字符串可以是有效的关键字。注意，缺失值默认值仅在属性缺失时适用，而不是当它以空字符串值存在时。
要确定属性的状态，请使用以下步骤：
如果未指定该属性：
如果属性的值与为该属性定义的关键字之一进行ASCII大小写不敏感匹配，则返回该关键字表示的状态。
不返回任何状态。
出于编写符合性目的，如果指定了枚举属性，则属性的值必须与该属性的一个合规关键字进行ASCII大小写不敏感匹配，且没有前导或尾随空格。
出于反射目的，有任何关键字映射到的状态被称为具有规范关键字。其确定方式如下：
如果只有一个关键字映射到给定状态，则为该关键字。
如果只有一个合规关键字映射到给定状态，则为该合规关键字。
否则，该状态的规范关键字将在属性规范中明确给出。
如果一个字符串由一个或多个ASCII数字组成，并且可以选择以U+002D连字符-字符（-）为前缀，则该字符串是有效整数。
没有U+002D连字符-前缀的有效整数表示由该数字字符串表示的十进制数。有U+002D连字符-前缀的有效整数表示由跟随U+002D连字符-的数字字符串表示的十进制数，从零减去。
解析整数的规则如下所示。当调用时，必须按给定顺序执行步骤，在返回值的第一个步骤中中止。该算法将返回一个整数或一个错误。
令input为正在解析的字符串。
令position为input中的指针，最初指向字符串的开头。
令sign的值为“positive”。
跳过ASCII空白字符在input中给定position。
如果position超过input的末尾，则返回错误。
如果position指示的字符（第一个字符）是U+002D连字符-字符（-）：
否则，如果position指示的字符（第一个字符）是U+002B加号字符（+）：
+”被忽略，但它不符合规范。）如果position指示的字符不是ASCII数字，则返回错误。
收集一系列代码点，这些代码点是input中给定position的ASCII数字，并将结果序列解释为十进制整数。令value为该整数。
如果sign为“positive”，则返回value，否则返回从零减去value的结果。
如果一个字符串由一个或多个ASCII数字组成，则该字符串是有效非负整数。
一个有效非负整数表示由该数字字符串表示的十进制数。
解析非负整数的规则如下所示。当调用时，必须按给定顺序执行步骤，在返回值的第一个步骤中中止。该算法将返回零、正整数或错误。
令input为正在解析的字符串。
令value为使用解析整数的规则解析input的结果。
如果value是一个错误，则返回错误。
如果value小于零，则返回错误。
返回value。
如果一个字符串包含以下内容，则该字符串是有效浮点数：
可选的U+002D HYPHEN-MINUS字符（-）。
以下两项之一或两项，按给定顺序：
可选的：
U+0065拉丁小写字母E字符（e）或U+0045拉丁大写字母E字符（E）。
可选的U+002D HYPHEN-MINUS字符（-）或U+002B PLUS SIGN字符（+）。
一系列一个或多个ASCII数字。
一个有效浮点数表示通过将有效数字乘以10的指数次方获得的数，其中有效数字是第一个数，解释为十进制（包括小数点和小数点后的数字，如果有的话，并解释为负数，如果整个字符串以U+002D HYPHEN-MINUS字符（-）开头并且该数字不为零），其中指数是E之后的数字，如果有的话（如果在E和数字之间有U+002D HYPHEN-MINUS字符（-）并且该数字不为零，则解释为负数，或者如果在E和数字之间有U+002B PLUS SIGN字符（+），则忽略该字符）。如果没有E，则指数视为零。
无穷大和非数字（NaN）值不是有效浮点数。
有效浮点数的概念通常仅用于限制作者允许的内容，而用户代理要求使用以下解析浮点数值的规则（例如，max属性的progress元素）。但是，在某些情况下，用户代理要求包括检查字符串是否为有效浮点数（例如，值清理算法的数字状态的input元素，或解析srcset属性的算法）。
作为浮点数的最佳表示是运行ToString(n)获得的字符串。抽象操作ToString不是唯一确定的。当存在多个可能的字符串可以从ToString获得特定值时，用户代理必须始终返回该值的相同字符串（尽管它可能与其他用户代理使用的值不同）。
解析浮点数值的规则如下所示。该算法必须在返回值的第一个步骤中中止。该算法将返回数字或错误。
令input为正在解析的字符串。
令position为指向input的指针，最初指向字符串的开头。
令value的值为1。
令divisor的值为1。
令exponent的值为1。
跳过ASCII空白，在input中给定position。
如果position超过input的末尾，则返回错误。
如果position指示的字符是U+002D HYPHEN-MINUS字符（-）：
否则，如果position指示的字符（第一个字符）是U+002B PLUS SIGN字符（+）：
+”被忽略，但不符合规范。）如果position指示的字符是U+002E FULL STOP（.），并且不是input中的最后一个字符，并且position指示的字符后的字符是ASCII数字，则 将value设为零并跳转到标记为fraction的步骤。
如果position指示的字符不是ASCII数字，则返回错误。
收集一系列代码点，这些代码点是ASCII数字，从input中给定position，并将结果序列解释为十进制整数。将value乘以该整数。
Fraction：如果position指示的字符是U+002E FULL STOP（.），请运行这些子步骤：
将position前移到下一个字符。
如果position超过input的末尾，或者position指示的字符不是ASCII数字，U+0065拉丁小写字母E（e），或U+0045拉丁大写字母E（E），则跳转到标记为conversion的步骤。
如果position指示的字符是U+0065拉丁小写字母E字符（e）或U+0045拉丁大写字母E字符（E），则跳过这些子步骤的其余部分。
Fraction loop：将divisor乘以10。
将position前移到下一个字符。
如果position超过input的末尾，则跳转到标记为conversion的步骤。
如果position指示的字符是ASCII数字，则跳回这些子步骤中标记为fraction loop的步骤。
如果position指示的字符是U+0065（e）或U+0045（E），则：
将position前移到下一个字符。
如果position超过input的末尾，则跳转到标记为conversion的步骤。
如果position指示的字符是U+002D HYPHEN-MINUS字符（-）：
如果position超过input的末尾，则跳转到标记为conversion的步骤。
否则，如果position指示的字符是U+002B PLUS SIGN字符（+）：
如果position超过input的末尾，则跳转到标记为conversion的步骤。
如果position指示的字符不是ASCII数字，则跳转到标记为conversion的步骤。
收集一系列代码点，这些代码点是ASCII数字，从input中给定position，并将结果序列解释为十进制整数。将exponent乘以该整数。
将value乘以10的exponent次方。
Conversion：令S为一组有限的IEEE 754双精度浮点值，除了-0，但增加了两个特殊值：21024和-21024。
令rounded-value为S中最接近value的数，如果有两个同样接近的值，则选择有效数字为偶数的数。（这两个特殊值21024和-21024被视为具有偶数有效数字）。
如果rounded-value是21024或-21024，则返回错误。
返回rounded-value。
解析尺寸值的规则如下所示。调用时，必须按给定顺序执行这些步骤，在返回值的第一个步骤中中止。该算法将返回大于或等于0.0的数字或失败；如果返回数字，则进一步分类为百分比或长度。
令input为正在解析的字符串。
令position为input的位置变量，最初指向input的开头。
跳过ASCII空白，在input中给定position。
如果position超过input的末尾或input中position处的代码点不是ASCII数字，则返回失败。
收集一系列代码点，这些代码点是ASCII数字，从input中给定position，并将结果序列解释为十进制整数。令value为该数字。
如果position超过input的末尾，则返回value作为长度。
如果input中position处的代码点是U+002E (.)，则：
返回带有value、input和position的当前尺寸值。
给定value、input和position，确定当前尺寸值如下：
如果position超过input的末尾，则返回value作为长度。
如果input中position处的代码点是U+0025 (%)，则返回value作为百分比。
返回value作为长度。
解析非零尺寸值的规则如下所示。调用时，必须按给定顺序执行这些步骤，在返回值的第一个步骤中中止。该算法将返回大于0.0的数字或错误；如果返回数字，则进一步分类为百分比或长度。
令input为正在解析的字符串。
令value为使用解析尺寸值的规则解析input的结果。
如果value是错误，则返回错误。
如果value为零，则返回错误。
如果value是百分比，则返回value作为百分比。
返回value作为长度。
一个有效的浮点数列表是由U+002C逗号字符分隔的多个有效的浮点数，不包含其他字符（例如没有ASCII空白字符）。此外，还可能对可以给出的浮点数的数量或允许的值范围有限制。
解析浮点数列表的规则如下：
令input为正在解析的字符串。
令position为input中的一个指针，初始指向字符串的开始。
令numbers为一个初始为空的浮点数列表。该列表将是此算法的结果。
收集一系列代码点，这些代码点是input中的ASCII空白字符、U+002C逗号或U+003B分号字符，位置由position指示。此操作会跳过任何前导分隔符。
当position未越过input的末尾时：
收集一系列代码点，这些代码点不是ASCII空白字符、U+002C逗号、U+003B分号、ASCII数字、U+002E句号或U+002D连字符，位置由position指示。这会跳过前导的无效字符。
收集一系列代码点，这些代码点不是ASCII空白字符、U+002C逗号或U+003B分号字符，位置由position指示，并将结果命名为unparsed number。
使用解析浮点数值的规则解析unparsed number，得到number。
如果number是错误，则将number设为零。
将number附加到numbers中。
收集一系列代码点，这些代码点是input中的ASCII空白字符、U+002C逗号或U+003B分号字符，位置由position指示。这会跳过分隔符。
返回numbers。
解析维度列表的规则如下。这些规则返回零个或多个由一个数字和一个单位组成的对，其中单位可以是百分比、相对或绝对。
令raw input为正在解析的字符串。
如果raw input的最后一个字符是U+002C逗号字符(,)，则移除该字符。
按逗号分割字符串raw input。令raw tokens为结果的标记列表。
令result为一个空的数字/单位对列表。
对于raw tokens中的每个标记，运行以下子步骤：
令input为该标记。
令position为input中的一个指针，初始指向字符串的开始。
令value为数字0。
令unit为绝对。
如果position已超出input的末尾，则将unit设为相对并跳至最后一个子步骤。
如果position处的字符是ASCII数字，则收集一系列代码点，这些代码点是input中的ASCII数字，将结果解释为一个以十进制表示的整数，并将value增加该整数。
如果position处的字符是U+002E（.），则：
跳过ASCII空白字符，在input中的position。
如果position处的字符是U+0025百分号字符(%)，则将unit设为百分比。
否则，如果position处的字符是U+002A星号字符(*)，则将unit设为相对。
将一个由value给定的数字和unit给定的单位组成的条目添加到result中。
返回列表result。
在以下算法中，年份year的月份month中的天数为：如果month是1、3、5、7、8、10或12，则为31；如果month是4、6、9或11，则为30；如果month是2且year是能被400整除的数，或year是能被4整除但不能被100整除的数，则为29；否则为28。这考虑到了格里高利历中的闰年。[GREGORIAN]
当在本节定义的日期和时间语法中使用ASCII数字时，它们表示十进制的数字。
虽然此处描述的格式旨在作为相应ISO8601格式的子集，但本规范对解析规则的定义比ISO8601更详细。因此，建议实现者在使用任何日期解析库来实现以下描述的解析规则之前仔细检查这些库；ISO8601库可能不会以完全相同的方式解析日期和时间。[ISO8601]
本规范所指的前置格里高利历指的是现代格里高利历，向前推算到1年。前置格里高利历中的日期，有时明确称为前置格里高利日期，即使用该历法描述的日期，即使该历法在当时（或地点）尚未使用。[GREGORIAN]
在本规范中使用格里高利历作为线格式是由于参与决策的人员的文化偏见而做出的任意选择。另请参阅讨论日期、时间和数字格式的部分（作者部分）、有关表单控件本地化的实现注释，以及time元素。
月份由一个特定的前置格里高利日期组成，没有时区信息，并且日期信息仅限于年份和月份。[GREGORIAN]
如果字符串包含以下顺序的组件，则表示一个年份year和月份month的有效月份字符串：
解析月份字符串的规则如下。这将返回一个年份和月份，或不返回任何内容。如果在任何时候算法指示“失败”，则意味着算法在该点中止并返回无。
令input为要解析的字符串。
令position为指向input的指针，最初指向字符串的开始。
解析月份组件以获得year和month。如果返回为空，则失败。
如果position不在input的结尾之外，则失败。
返回year和month。
解析月份组件的规则如下，给定一个input字符串和一个position。这将返回一个年份和月份，或不返回任何内容。如果在任何时候算法指示“失败”，则意味着算法在该点中止并返回无。
收集一系列码点，这些码点是input中的ASCII数字，根据position。如果收集的序列长度不足四个字符，则失败。否则，将结果序列解释为十进制整数。将该数值作为year。
如果year不是大于零的数值，则失败。
如果position超出input的结尾或position处的字符不是U+002D连字符，则失败。否则，将position前移一个字符。
收集一系列码点，这些码点是input中的ASCII数字，根据position。如果收集的序列长度不正好是两个字符，则失败。否则，将结果序列解释为十进制整数。将该数值作为month。
如果month不是范围在1 ≤ month ≤ 12之间的数值，则失败。
返回year和month。
日期由一个特定的前置格里高利日期组成，没有时区信息，由年、月和日组成。[GREGORIAN]
如果字符串包含以下顺序的组件，则表示一个年份year、月份month和日期day的有效日期字符串：
解析日期字符串的规则如下。这将返回一个日期，或不返回任何内容。如果在任何时候算法指示“失败”，则意味着算法在该点中止并返回无。
令input为要解析的字符串。
令position为指向input的指针，最初指向字符串的开始。
解析日期组件以获得year、month和day。如果返回为空，则失败。
如果position不在input的结尾之外，则失败。
令date为具有year、month和day的日期。
返回date。
解析日期组件的规则如下，给定一个input字符串和一个position。这将返回一个年份、月份和日期，或不返回任何内容。如果在任何时候算法指示“失败”，则意味着算法在该点中止并返回无。
解析月份组件以获得year和month。如果返回为空，则失败。
令maxday为该年该月的天数。
如果position超出input的结尾或position处的字符不是U+002D HYPHEN-MINUS字符，则失败。否则，将position前移一个字符。
收集一系列码点，这些码点是input中的ASCII数字，根据position。如果收集的序列长度不正好是两个字符，则失败。否则，将结果序列解释为十进制整数。将该数值作为day。
如果day不是范围在1 ≤ day ≤ maxday之间的数值，则失败。
返回year、month和day。
无年份的日期由一个公历月份和该月份中的一天组成，但没有关联的年份信息。[GREGORIAN]
如果字符串包含以下顺序的组件，则表示一个月份month和日期day的有效无年份日期字符串：
换句话说，如果month是“02”，表示二月，那么日期可以是29日，就像该年份是闰年一样。
解析无年份日期字符串的规则如下。这将返回一个月份和日期，或不返回任何内容。如果在任何时候算法指示“失败”，则意味着算法在该点中止并返回无。
令input为要解析的字符串。
令position为指向input的指针，最初指向字符串的开始。
解析无年份日期组件以获得month和day。如果返回为空，则失败。
如果position不在input的结尾之外，则失败。
返回month和day。
解析无年份日期组件的规则如下，给定一个input字符串和一个position。这将返回一个月份和日期，或不返回任何内容。如果在任何时候算法指示“失败”，则意味着算法在该点中止并返回无。
收集一系列码点，这些码点是input中的U+002D HYPHEN-MINUS字符(-)，根据position。如果收集的序列长度不正好是零个或两个字符，则失败。
收集一系列码点，这些码点是input中的ASCII数字，根据position。如果收集的序列长度不正好是两个字符，则失败。否则，将结果序列解释为十进制整数。将该数值作为month。
如果month不是范围在1 ≤ month ≤ 12之间的数值，则失败。
令maxday为该月份的天数，以任意闰年（例如4或2000年）为准。
如果position超出input的结尾或position处的字符不是U+002D HYPHEN-MINUS字符，则失败。否则，将position前移一个字符。
收集一系列码点，这些码点是input中的ASCII数字，根据position。如果收集的序列长度不正好是两个字符，则失败。否则，将结果序列解释为十进制整数。将该数值作为day。
如果day不是范围在1 ≤ day ≤ maxday之间的数值，则失败。
返回month和day。
时间由具体的时间组成，不包含时区信息，包括小时、分钟、秒和秒的小数部分。
如果字符串包含以下顺序的组件，则表示一个小时hour、分钟minute和秒second的有效时间字符串：
秒second组件不能为60或61；无法表示闰秒。
解析时间字符串的规则如下。这将返回一个时间或不返回任何内容。如果在任何时候算法指示“失败”，则意味着算法在该点中止并返回无。
令input为要解析的字符串。
令position为指向input的指针，最初指向字符串的开始。
解析时间组件以获得hour、minute和second。如果返回为空，则失败。
如果position不在input的结尾之外，则失败。
令time为具有小时hour、分钟minute和秒second的时间。
返回time。
解析时间组件的规则如下，给定一个input字符串和一个position。这将返回一个小时、分钟和秒，或不返回任何内容。如果在任何时候算法指示“失败”，则意味着算法在该点中止并返回无。
收集一系列码点，这些码点是input中的ASCII数字，根据position。如果收集的序列长度不正好是两个字符，则失败。否则，将结果序列解释为十进制整数。将该数值作为hour。
如果hour不是范围在0 ≤ hour ≤ 23之间的数值，则失败。
如果position超出input的结尾或position处的字符不是U+003A COLON字符，则失败。否则，将position前移一个字符。
收集一系列码点，这些码点是input中的ASCII数字，根据position。如果收集的序列长度不正好是两个字符，则失败。否则，将结果序列解释为十进制整数。将该数值作为minute。
如果minute不是范围在0 ≤ minute ≤ 59之间的数值，则失败。
令second为0。
如果position不在input的结尾之外且position处的字符是U+003A COLON字符(:)，则：
将position前移至input中的下一个字符。
如果position超出input的结尾，或在input的最后一个字符，或如果position开始的两个字符都不是ASCII数字，则失败。
收集一系列码点，这些码点是input中的ASCII数字或U+002E FULL STOP字符。根据position。如果收集的序列长度为三字符，或如果它长于三字符并且第三个字符不是U+002E FULL STOP字符，或如果它包含多个U+002E FULL STOP字符，则失败。否则，将结果序列解释为十进制数（可能包含小数部分）。将second设置为该数值。
如果second不是范围在0 ≤ second < 60之间的数值，则失败。
返回hour、minute和second。
本地日期和时间由一个特定的前置格里高利日期（包括年份、月份和日期）和一个时间（包括小时、分钟、秒和秒的小数部分）组成，但不包含时区信息。[GREGORIAN]
如果字符串包含以下顺序的组件，则表示日期和时间的有效本地日期和时间字符串：
如果字符串包含以下顺序的组件，则表示日期和时间的有效规范化本地日期和时间字符串：
解析本地日期和时间字符串的规则如下。这将返回一个日期和时间，或不返回任何内容。如果在任何时候算法指示“失败”，则意味着算法在该点中止并返回无。
令input为要解析的字符串。
令position为指向input的指针，最初指向字符串的开始。
解析日期组件以获得year、month和day。如果返回为空，则失败。
如果position超出input的结尾或position处的字符既不是U+0054拉丁大写字母T字符（T）也不是U+0020空格字符，则失败。否则，将position前移一个字符。
解析时间组件以获得hour、minute和second。如果返回为空，则失败。
如果position不在input的结尾之外，则失败。
令date为具有年份year、月份month和日期day的日期。
令time为具有小时hour、分钟minute和秒second的时间。
返回date和time。
时区偏移由若干小时和分钟组成。
如果字符串符合以下任意一种情况，则表示一个有效的时区偏移字符串：
一个U+005A拉丁大写字母Z字符（Z），仅在时区为UTC时允许
或者，以下顺序的组件：
此格式允许时区偏移范围为-23:59到+23:59。目前，实际时区的偏移范围为-12:00到+14:00，且偏移的分钟部分通常为00、30或45。然而，由于时区是政治因素的产物，可能会发生变化。
有关使用时区偏移表示历史时间的详细信息，请参阅全局日期和时间部分中的使用说明和示例。
解析时区偏移字符串的规则如下。这将返回一个时区偏移，或者不返回任何内容。如果在任何时候算法指示“失败”，则意味着算法在该点中止并返回无。
令input为要解析的字符串。
令position为指向input的指针，最初指向字符串的开始。
解析时区偏移组件以获得timezonehours和timezoneminutes。如果返回无，则失败。
如果position未超出input的结尾，则失败。
返回与UTC相差timezonehours小时和timezoneminutes分钟的时区偏移。
解析时区偏移组件的规则如下，给定一个input字符串和一个position。这将返回时区小时和分钟，或者不返回任何内容。如果在任何时候算法指示“失败”，则意味着算法在该点中止并返回无。
如果position处的字符为U+005A拉丁大写字母Z字符（Z），则：
令timezonehours为0。
令timezoneminutes为0。
将position前移到input中的下一个字符。
否则，如果position处的字符是U+002B加号（+）或U+002D连字符（-），则：
如果position处的字符是U+002B加号（+），则令sign为“positive”。否则，它是U+002D连字符（-）；令sign为“negative”。
将position前移到input中的下一个字符。
如果s恰好为两个字符长，则：
将s解释为十进制整数。令该数为timezonehours。
如果position超出input的结尾或position处的字符不是U+003A冒号字符，则失败。否则，将position前移一个字符。
收集从position开始的input中ASCII数字序列。如果收集的序列不恰好为两个字符长，则失败。否则，将结果序列解释为十进制整数。令该数为timezoneminutes。
如果s恰好为四个字符长，则：
将s的前两个字符解释为十进制整数。令该数为timezonehours。
将s的后两个字符解释为十进制整数。令该数为timezoneminutes。
否则，失败。
否则 ，失败。
返回timezonehours和timezoneminutes。
全球日期和时间包括一个特定的 前置格里高利日期，包括年份、月份和日期，以及时间，包括小时、分钟、秒和秒的小数部分，用时区偏移量表示，包括一个带符号的小时数和分钟数。 [GREGORIAN]
如果一个字符串包含以下顺序的组件，则表示一个日期、时间和时区偏移量，它是一个有效的全球日期和时间字符串：
在20世纪中期UTC形成之前的日期中的时间必须用UT1（在0°经度的当代地球太阳时间）表示和解释，而不是UTC（以SI秒计时的UT1的近似）。在时区形成之前的时间必须用显式时区的UT1时间表示和解释，这些时区近似于当代格林威治伦敦所在地时间和适当本地时间之间的差异。
以下是一些用有效全球日期和时间字符串书写的日期示例。
0037-12-13 00:00Z"1979-10-14T12:00:00.001-04:00"8592-01-01T02:09+02:09"这些日期有几个显著之处：
T"被替换为一个空格，它必须是一个单一的空格字符。字符串"2001-12-21 12:00Z"（组件之间有两个空格）不会被成功解析。
解析全球日期和时间字符串的规则如下。这将返回UTC时间，以及用于回溯或显示目的的相关时区偏移信息，或什么也不返回。如果算法中任何一点指出它"失败"，这意味着它在该点中止并返回什么也没有。
让input成为被解析的字符串。
让position成为input中的一个指针，最初指向字符串的开始。
解析日期组件以获得year、month和day。如果没有返回值，则失败。
如果position超出input的末尾或position处的字符既不是U+0054拉丁大写字母T字符（T），也不是U+0020空格字符，则失败。否则，将position向前移动一个字符。
解析时间组件以获得hour、minute和second。如果没有返回值，则失败。
如果position超出input的末尾，则失败。
解析时区偏移组件以获得timezonehours和timezoneminutes。如果没有返回值，则失败。
如果position不超出input的末尾，则失败。
让time成为year年、month月、day日、hour时、minute分、second秒的时间，减去timezonehours小时和timezoneminutes分钟。这个时间点是UTC时区的时间点。
让timezone成为比UTC快timezonehours小时和timezoneminutes分钟的时区偏移量。
返回time和timezone。
周由一个周年编号和一个周编号组成，表示一个从星期一开始的七天周期。在该日历系统中，每个周年有52或53个这样的七天周期，如下所定义。1969年12月29日（1969-12-29）格里高利日期的星期一被定义为1970年周年的第1周。连续的周按顺序编号。周年编号为1的前一周是前一个周年的最后一周，反之亦然。[GREGORIAN]
如果一个周年编号year对应于一个在前置格里高利日历中以星期四（1月1日）为第一天的年份，或一个在前置格里高利日历中以星期三（1月1日）为第一天且year是400的倍数或4的倍数但不是100的倍数的年份，则该周年编号year有53周。所有其他周年编号都有52周。
一个有53周的周年最后一天的周编号为53；一个有52周的周年最后一天的周编号为52。
一个特定日期的周年编号可能与包含该日期的年份在前置格里高利日历中的编号不同。周年y的第一周是包含格里高利年y的第一个星期四的那一周。
对于现代用途，这里定义的周等同于ISO 8601中定义的ISO周。[ISO8601]
如果一个字符串包含以下顺序的组件，则表示一个周年编号year和周week，它是一个有效的周字符串：
解析周字符串的规则如下。这将返回一个周年编号和周编号，或者返回空值。如果在任何时候算法指示"失败"，这意味着它在该点中止并返回空值。
令input为被解析的字符串。
令position为input中的指针，最初指向字符串的开头。
收集一系列代码点，这些代码点是ASCII数字，从position处的input中收集。如果收集到的序列不超过四个字符，则失败。否则，将结果序列解释为十进制整数。令该数为year。
如果year不是大于零的数字，则失败。
如果position超出input的末尾或position处的字符不是U+002D连字符，则失败。否则，将position向前移动一个字符。
如果position超出input的末尾或position处的字符不是U+0057拉丁大写字母W字符，则失败。否则，将position向前移动一个字符。
收集一系列代码点，这些代码点是ASCII数字，从position处的input中收集。如果收集到的序列不是恰好两个字符，则失败。否则，将结果序列解释为十进制整数。令该数为week。
令maxweek为年份year的最后一天的周编号。
如果week不是1 ≤ week ≤ maxweek范围内的数字，则失败。
如果position未超出input的末尾，则失败。
返回周年编号year和周编号week。
持续时间由若干秒组成。
由于月份和秒不可比较（一个月不是一个精确的秒数，而是一个其精确长度取决于从何时开始测量的时间段），本规范中定义的持续时间不能包括月份（或等同于十二个月的年份）。只能描述特定秒数的持续时间。
如果字符串符合以下任一形式，则表示持续时间t，且该字符串为有效持续时间字符串：
一个U+0050拉丁大写字母P字符，后跟以下子组件之一或多个，按给定顺序，其中天数、小时、分钟和秒数对应于t中的相同秒数：
一个或多个ASCII数字，后跟一个U+0044拉丁大写字母D字符，表示天数。
一个U+0054拉丁大写字母T字符，后跟以下子组件之一或多个，按给定顺序：
这与本规范中定义的其他一些日期和时间相关的微语法一样，基于ISO 8601定义的格式之一。[ISO8601]
一个或多个持续时间时间组件，每个组件具有不同的持续时间时间组件刻度，顺序不限；表示的秒数总和等于t中的秒数。
持续时间时间组件是一个字符串，由以下组件组成：
零个或多个ASCII空白字符。
一个或多个ASCII数字，表示若干时间单位，按指定的持续时间时间组件刻度（见下文）缩放，以表示若干秒。
如果指定的持续时间时间组件刻度为1（即单位为秒），则可选地，一个U+002E全停止符（.），后跟一个、两个或三个ASCII数字，表示秒的小数部分。
零个或多个ASCII空白字符。
以下字符之一，表示时间单位的持续时间时间组件刻度：
零个或多个ASCII空白字符。
这不是基于ISO 8601中的任何格式。它旨在成为ISO 8601持续时间格式的更易于理解的替代方案。
解析持续时间字符串的规则如下。这将返回一个持续时间或返回空值。如果在任何时候算法指示"失败"，这意味着它在该点中止并返回空值。
令input为被解析的字符串。
令position为input中的指针，最初指向字符串的开头。
令months、seconds和component count均为零。
令M-disambiguator为minutes。
此标志的另一个值为months。它用于消除ISO8601持续时间中"M"单位的歧义，这些持续时间使用相同的单位表示月份和分钟。月份不允许，但解析为了未来的兼 容性，并避免误解在其他上下文中有效的ISO8601持续时间。
跳过ASCII空白字符在input中给定position。
如果position超出input的末尾，则失败。
如果input中position指向的字符是U+0050拉丁大写字母P字符，则将position前进到下一个字符，将M-disambiguator设置为months，并跳过ASCII空白字符在input中给定position。
当条件为真时，执行以下操作：
令units未定义。它将被赋值为以下值之一：years、months、weeks、days、hours、minutes和seconds。
令next character未定义。它用于处理input中的字符。
如果position超出input的末尾，则中断。
如果input中position指向的字符是U+0054拉丁大写字母T字符，则将position前进到下一个字符，将M-disambiguator设置为minutes，跳过ASCII空白字符在input中给定position，并继续。
将next character设置为input中position指向的字符。
如果next character是U+002E全停止符（.），则令N等于零。（不要前进position。稍后会处理这一点。）
否则，如果next character是ASCII数字，则收集一系列代码点，这些代码点是ASCII数字，从position处的input中收集，将结果序列解释为十进制整数，并将N设置为该数。
否则，next character不是数字的一部分；失败。
如果position超出input的末尾，则失败。
将next character设置为input中position指向的字符，并将position前进到下一个字符。（如果next character之前是U+002E全停止符（.），这次仍将是该字符。）
如果next character是U+002E（.），则：
如果s是空字符串，则失败。
令length为s中的字符数。
令fraction为将s解释为十进制整数，然后将该数除以10length的结果。
将N增加fraction。
跳过ASCII空白字符在input中给定position。
如果position超出input的末尾，则失败。
将next character设置为input中position指向的字符，并将position前进到下一个字符。
如果next character既不是U+0053拉丁大写字母S字符，也不是U+0073拉丁小写字母s字符，则失败。
将units设置为seconds。
否则：
如果next character是ASCII空白字符，则跳过ASCII空白字符在input中给定position，将next character设置为input中position指向的字符，并将position前进到下一个字符。
如果next character是U+0059拉丁大写字母Y字符或U+0079拉丁小写字母y字符，将units设置为years，并将M-disambiguator设置为months。
如果next character是U+004D拉丁大写字母M字符或U+006D拉丁 小写字母m字符，并且M-disambiguator是months，则将units设置为months。
如果next character是U+0057拉丁大写字母W字符或U+0077拉丁小写字母w字符，将units设置为weeks，并将M-disambiguator设置为minutes。
如果next character是U+0044拉丁大写字母D字符或U+0064拉丁小写字母d字符，将units设置为days，并将M-disambiguator设置为minutes。
如果next character是U+0048拉丁大写字母H字符或U+0068拉丁小写字母h字符，将units设置为hours，并将M-disambiguator设置为minutes。
如果next character是U+004D拉丁大写字母M字符或U+006D拉丁小写字母m字符，并且M-disambiguator是minutes，则将units设置为minutes。
如果next character是U+0053拉丁大写字母S字符或U+0073拉丁小写字母s字符，将units设置为seconds，并将M-disambiguator设置为minutes。
否则，如果next character不是上述任何一个字符，则失败。
增加component count。
令multiplier为1。
如果units是years，则将multiplier乘以12，并将units设置为months。
如果units是months，则将N和multiplier的乘积加到months中。
否则：
如果units是weeks，则将multiplier乘以7，并将units设置为days。
如果units是days，则将multiplier乘以24，并将units设置为hours。
如果units是hours，则将multiplier乘以60，并将units设置为minutes。
如果units是minutes，则将multiplier乘以60，并将units设置为seconds。
最终，units现在是seconds。将N和multiplier的乘积加到seconds中。
跳过ASCII空白字符在input中给定position。
如果component count为零，则失败。
如果months不为零，则失败。
返回由seconds秒组成的持续时间。
如果字符串也是以下之一，则该字符串是一个有效的包含可选时间的日期字符串：
解析日期或时间字符串的规则如下。该算法将返回一个日期、一个时间、一个全球日期和时间，或什么都不返回。如果在任何时候算法说它“失败”，这意味着它在该点中止并返回什么都没有。
令input为正在解析的字符串。
令position为input中的指针，最初指向字符串的开头。
将start position设置为与position相同的位置。
将date present和time present标志设置为true。
解析日期组件以获取year、month和day。如果解析失败，则将date present标志设置为false。
如果date present为true，并且position没有超出input的末尾，并且position处的字符是U+0054拉丁大写字母T字符（T）或U+0020空格字符，则将position前进到input中的下一个字符。
否则，如果date present为true，并且position超出input的末尾或position处的字符既不是U+0054拉丁大写字母T字符（T）也不是U+0020空格字符，则将time present设置为false。
否则，如果date present为false，将position设置回与start position相同的位置。
如果time present标志为true，则解析时间组件以获取hour、minute和second。如果解析失败，则失败。
如果date present和time present标志都为true，但position超出input的末尾，则失败。
如果date present和time present标志都为true，解析时区偏移组件以获取timezonehours和timezoneminutes。如果解析失败，则失败。
如果position没有超出input的末尾，则失败。
如果date present标志为true且time present标志为false，则令date为具有year、month和day的日期，并返回date。
否则，如果time present标志为true且date present标志为false，则令time为具有hour、minute和second的时间，并返回time。
否则，令time为年year、月month、日day、小时hour、分钟minute、秒second的时间减去timezonehours小时和timezoneminutes分钟，该时间点为UTC时区的时间点；令timezone为距离UTC的timezonehours小时和timezoneminutes分钟；并返回time和timezone。
一个简单颜色由三个范围在0到255（含）之间的8位数字组成，分别代表颜色的红色、绿色和蓝色分量，在'srgb'颜色空间中。
如果字符串长度正好为七个字符，且第一个字符是U+0023号码符号字符（#），并且剩下的六个字符都是ASCII十六进制数字，那么该字符串是有效的简单颜色，其中前两个数字代表红色分量，中间两个数字代表绿色分量，最后两个数字代表蓝色分量，采用十六进制表示。
如果一个字符串是有效的简单颜色且不使用范围在U+0041拉丁大写字母A到U+0046拉丁大写字母F之间的任何字符，则该字符串是有效的小写简单颜色。
解析简单颜色值的规则如下。在调用时，必须按给定顺序执行这些步骤，在第一个返回值的步骤处中止。该算法将返回一个简单颜色或错误。
令input为正在解析的字符串。
如果input长度不是正好七个字符，则返回错误。
如果input的第一个字符不是U+0023号码符号字符（#），则返回错误。
如果input的最后六个字符不是全部为ASCII十六进制数字，则返回错误。
令result为一个简单颜色。
将第二个和第三个字符解释为十六进制数字，并将结果作为result的红色分量。
将第四个和第五个字符解释为十六进制数字，并将结果作为result的绿色分量。
将第六个和第七个字符解释为十六进制数字，并将结果作为result的蓝色分量。
返回result。
给定一个简单颜色，序列化简单颜色值的规则如下：
令result为一个由单个U+0023号码符号字符（#）组成的字符串。
将红色、绿色和蓝色分量依次转换为两位十六进制数字，使用ASCII小写十六进制数字，必要时进行零填充，并按红色、绿色、蓝色的顺序将这些数字附加到result。
返回result，它将是一个有效的小写简单颜色。
一些过时的遗留属性以更复杂的方式解析颜色，使用解析遗留颜色值的规则，如下算法所示。在调用时，必须按给定顺序执行这些步骤，在第一个返回值的步骤处中止。该算法将返回一个简单颜色或错误。
令input为正在解析的字符串。
如果input为空字符串，则返回错误。
如果input与字符串"transparent"进行ASCII大小写不敏感匹配，则返回错误。
如果input与其中一个命名颜色进行ASCII大小写不敏感匹配，则返回与该关键字对应的简单颜色。[CSSCOLOR]
CSS2系统颜色不被识别。
如果input的代码点长度为四，并且input的第一个字符是U+0023（#），并且input的最后三个字符都是ASCII十六进制数字，则：
令result为一个简单颜色。
将input的第二个字符解释为十六进制数字；令result的红色分量为结果数字乘以 17。
将input的第三个字符解释为十六进制数字；令result的绿色分量为结果数字乘以17。
将input的第四个字符解释为十六进制数字；令result的蓝色分量为结果数字乘以17。
返回result。
将input中所有代码点大于U+FFFF的字符（即任何不在基本多语言平面中的字符）替换为两个字符的字符串"00"。
如果input的代码点长度大于128，则截断input，只保留前128个字符。
如果input的第一个字符是U+0023号码符号字符（#），则将其移除。
将input中任何不是ASCII十六进制数字的字符替换为U+0030数字零字符（0）。
当input的代码点长度为零或不是三的倍数时，将U+0030数字零字符（0）附加到input。
将input拆分为三个相等代码点长度的字符串，以获得三个组件。令length为所有这些组件的代码点长度（input的代码点长度的三分之一）。
如果length大于8，则删除每个组件中前length-8个字符，并将length设置为8。
当length大于两个并且每个组件的第一个字符是U+0030数字零字符（0）时，移除该字符并减少length。
如果length仍大于两个，则截断每个组件，只保留每个组件的前两个字符。
令result为一个简单颜色。
将第一个组件解释为十六进制数字；令result的红色分量为结果数字。
将第二个组件解释为十六进制数字；令result的绿色分量为结果数字。
将第三个组件解释为十六进制数字；令result的蓝色分量为结果数字。
返回result。
2D图形上下文有一个单独的颜色语法，也处理不透明度。
一个 空格分隔的标记集 是一个包含零个或多个单词（称为标记）的字符串，这些单词由一个或多个 ASCII 空白字符 分隔，其中单词由一个或多个字符组成，这些字符都不是 ASCII 空白字符。
一个包含 空格分隔的标记集 的字符串可以有前导或尾随的 ASCII 空白字符。
一个 无序的唯一空格分隔标记集 是一个 空格分隔的标记集，其中的标记没有重复。
一个 有序的唯一空格分隔标记集 是一个 空格分隔的标记集，其中的标记没有重复，但标记的顺序是有意义的。
空格分隔的标记集 有时具有定义的允许值集合。当定义了允许值集合时，标记必须全部来自该允许值列表；其他值不符合规范。如果没有提供这样的允许值集合，则所有值都是符合规范的。
如何比较 空格分隔的标记集 中的标记（例如，区分大小写或不区分大小写）是按集合来定义的。
一个 逗号分隔的标记集 是一个包含零个或多个标记的字符串，每个标记之间用一个 U+002C 逗号字符（,）分隔，其中标记由零个或多个字符组成，既不以 ASCII 空白字符 开头或结尾，也不包含任何 U+002C 逗号字符（,），并且可以选择性地被 ASCII 空白字符 包围。
例如，字符串 " a ,b,,d d " 由四个标记组成："a"，"b"，空字符串和
"d d"。每个标记周围的前导和尾随空白字符不计入标记的一部分，并且空字符串可以是一个标记。
逗号分隔的标记集 有时对有效标记的构成有进一步的限制。当定义了这些限制时，标记必须全部符合这些限制；其他值是不符合规范的。如果没有规定这样的限制，则所有值都是符合规范的。
一个 有效的哈希名称引用 到一个类型为 type 的元素，是一个包含 U+0023 数字符号字符 (#) 后跟一个与同一个
树 中类型为
type 的元素的 name 属性值完全匹配的字符串。
给定上下文节点 scope，解析类型为 type 的元素的哈希名称引用的 规则 如下：
如果被解析的字符串不包含 U+0023 数字符号字符，或者如果字符串中的第一个这样的字符是字符串中的最后一个字符，则返回 null。
让 s 成为从被解析字符串中第一个 U+0023 数字符号字符之后的字符到字符串末尾的字符串。
返回 scope 的 树 中按 树顺序 排列的第一个类型为
type 且其 id 或
name 属性的值为 s 的元素，如果没有这样的元素，则返回 null。
尽管在解析时会考虑 id
属性，但它们不会用于确定一个值是否为 有效的 哈希名称引用。也就是说，基于 id
引用元素的哈希名称引用是一个一致性错误（除非该元素也有一个具有相同值的 name 属性）。
如果字符串符合 Media Queries 的 <media-query-list> 生成规则，则该字符串是一个 有效的媒体查询列表。
[MQ]
如果字符串为空字符串、仅包含 ASCII 空白字符，或是一个根据 Media Queries 中定义的符合用户环境的媒体查询列表，则该字符串 符合用户环境。[MQ]
一个 唯一内部值 是一个可序列化、按值可比较且从不暴露给脚本的值。
要创建一个 新的唯一内部值，返回一个从未被此算法返回过的 唯一内部值。
如果字符串是一个 有效的 URL 字符串 且不是空字符串，则该字符串是一个 有效的非空 URL。
如果字符串在去除前导和尾随的 ASCII 空白字符 后是一个 有效的 URL 字符串，则该字符串是一个 有效的可能被空格包围的 URL。
如果字符串在去除前导和尾随的 ASCII 空白字符 后是一个 有效的非空 URL，则该字符串是一个 有效的非空 URL 可能被空格包围。
本规范将 URL about:legacy-compat 定义为一个保留的但不可解析的 about:
URL，用于在需要与 XML 工具兼容时在 DOCTYPE
中使用的 HTML 文档。[ABOUT]
本规范将 URL about:html-kind 定义为一个保留的但不可解析的 about:
URL，用作媒体轨道类型的标识符。[ABOUT]
本规范将 URL about:srcdoc 定义为一个保留的但不可解析的 about:
URL，用作 URL 的 iframe srcdoc 文档。[ABOUT]
备用基础 URL 是 文档 对象
document 的
URL
记录，通过执行以下步骤获得：
如果 document 是 一个
iframe srcdoc 文档，则：
断言：document 的 about 基础 URL 非空。
返回 document 的 about 基础 URL。
如果 document 的 URL 匹配
about:blank 并且 document 的 about 基础 URL 非空，则返回 document 的 about 基础 URL。
返回 document 的 URL。
文档基础 URL 是 文档 对象的
URL
记录，通过执行以下步骤获得：
URL 匹配 about:blank 如果其 方案 是 "about"，其 路径 包含单个字符串 "blank"，其 用户名 和 密码 是空字符串，且其 主机 为 null。
这样的 URL 的 查询 和 片段 可以是非空的。例如，通过 解析 "about:blank?foo#bar" 创建的 URL 记录 匹配
about:blank。
URL 匹配 about:srcdoc 如果其 方案 是 "about"，其 路径 包含单个字符串 "srcdoc"，其 查询 为 null，其 用户名 和 密码 是空字符串，且其 主机 为 null。
确保 匹配
about:srcdoc 的原因是因为不可能创建 一个 iframe srcdoc 文档 其 URL 具有非空的 查询，而与 文档 的 URL 匹配 about:blank 不同。换句话说，所有 URL 只有在其 片段 上有所不同，才会 匹配 about:srcdoc。
解析 URL 是将一个字符串转换为其表示的 URL 记录 的过程。虽然这个过程在 URL 中有定义，但 HTML 标准定义了几个封装器来抽象基础 URL 和编码。[URL]
大多数新的 API 应该使用 解析 URL。较旧的 API 和 HTML 元素可能需要使用 编码解析 URL。当需要自定义基础 URL 或不希望使用基础 URL 时，URL 解析器 也可以直接使用。
要 解析 URL，给定一个字符串 url，相对于 文档 对象或 环境设置对象 environment，执行以下步骤。这些步骤返回失败或一个 URL。
让 baseURL 为 environment 的 基础 URL，如果 environment 是一个 文档 对象；否则为
environment 的 API 基础
URL。
返回应用于 url 的 URL 解析器 的结果，使用 baseURL。
要 编码解析 URL，给定一个字符串 url，相对于一个
文档 对象或 环境设置对象 environment，执行以下步骤。这些步骤返回失败或一个 URL。
让 encoding 为 UTF-8。
如果 environment 是一个 文档 对象，则将
encoding 设置为 environment 的 字符编码。
否则，如果 environment 的 相关全局对象 是一个 Window 对象，将 encoding
设置为 environment 的 相关全局对象 的 关联
Document 的 字符编码。
让 baseURL 为 environment 的 基础 URL，如果 environment 是一个 文档 对象；否则为
environment 的 API 基础
URL。
返回应用于 url 的 URL 解析器 的结果，使用 baseURL 和 encoding。
要 编码解析并序列化 URL，给定一个字符串 url，相对于一个 文档 对象或 环境设置对象 environment，执行以下步骤。这些步骤返回失败或一个字符串。
当文档的 文档基础 URL 更改时，该文档中的所有元素 都会 受到基础 URL 更改的影响。
以下是 基础 URL 更改步骤，当元素 受到基础 URL 更改的影响（如 DOM 定义的）时执行：
如果超链接标识的 URL 正显示给用户，或者任何从该 URL 派生的数据影响了显示，则
href
属性的值应该 重新解析，相对于元素的 节点文档，并且 UI 应适当更新。
例如，CSS :link/:visited
伪类
可能已经受到影响。
如果超链接具有 ping 属性
并且其 URL(s) 正显示给用户，则 ping
属性的标记应该 重新解析，相对于元素的 节点文档，并且 UI 应适当更新。
q、
blockquote、
ins，
或
del
元素，且具有 cite 属性
如果 URL 标识的 cite 属性正在显示给用户，或者任何从该 URL 派生的数据影响了显示，
则 cite 属性的值应该 重新解析，相对于元素的 节点文档，并且 UI 应适当更新。
该元素不会直接受到影响。
例如，更改基础 URL 不会影响 img
元素显示的图像，尽管从脚本中对 src
IDL 属性的后续访问将返回一个新的 绝对
URL，可能不再对应于正在显示的图像。
一个 响应 如果其 类型 为
"basic"、"cors" 或
"default"，则称为 CORS-同源。
[FETCH]
一个 响应 如果其 类型 为 "opaque"
或 "opaqueredirect"，则称为 CORS-跨源。
一个 响应 的 不安全响应 是其 内部响应，如果有的话，否则就是该 响应 本身。
要 创建一个潜在的 CORS 请求，给定一个 url、 destination、corsAttributeState 和一个可选的 同源回退标志，执行以下步骤：
如果 corsAttributeState 为 无
CORS，则让 mode 为 "no-cors"，否则为
"cors"。
如果 同源回退标志 被设置且 mode 为 "no-cors"，则将 mode 设置为
"same-origin"。
让 credentialsMode 为 "include"。
如果 corsAttributeState 为 匿名，则将 credentialsMode 设置为
"same-origin"。
让 request 为一个新的 请求，其 URL 为 url，目的地 为 destination， 模式 为 mode，凭证模式 为 credentialsMode，且 使用 URL 凭证标志 被设置。
资源的 内容类型元数据 必须以与 MIME Sniffing 要求一致的方式获取和解释。 [MIMESNIFF]
资源的 计算 MIME 类型 必须以与 MIME Sniffing 要求一致的方式确定。[MIMESNIFF]
对于 图像的嗅探规则、区分资源是文本还是二进制的规则 和 音频和视频的嗅探规则 也在 MIME Sniffing 中定义。这些规则返回一个 MIME 类型 作为结果。[MIMESNIFF]
务必严格遵守 MIME Sniffing 中的规则。当用户代理使用不同于服务器预期的内容类型检测启发式方法时，可能会发生安全问题。更多详细信息，请参见 MIME Sniffing。 [MIMESNIFF]
meta
元素中提取字符编码
给定一个字符串 s，从 meta 元素中提取字符编码的 算法 如下。它要么返回一个字符编码，要么返回无结果。
设 position 为指向 s 的指针，初始时指向字符串的开始。
循环: 找到 position 之后的 s 中前七个字符中与单词 "charset" 的 ASCII
不区分大小写 匹配的第一个字符。如果没有找到这样的匹配，返回无结果。
跳过紧跟在单词 "charset" 之后的任何 ASCII
空白字符（可能没有）。
如果下一个字符不是 U+003D 等号 (=)，则将 position 移动到指向该下一个字符之前，并返回到标记为 循环 的步骤。
跳过紧跟在等号之后的任何 ASCII 空白字符（可能没有）。
处理下一个字符如下：
该算法与 HTTP 规范中的那些算法不同（例如，HTTP 不允许使用单引号，并且要求支持一个不被该算法支持的反斜杠转义机制）。虽然该算法用于历史上与 HTTP 相关的上下文中，但实现所支持的语法已经有一段时间偏离。[HTTP]
在所有当前引擎中均受支持。
CORS 设置属性 是一个 枚举属性， 具有以下关键字和状态：
| 关键字 | 状态 | 简要描述 |
|---|---|---|
anonymous
|
匿名 | 对元素的请求 将其
模式 设置为
"cors"，并将其
凭证模式 设置为 "same-origin"。
|
| (空字符串) | ||
use-credentials
|
使用凭证 | 对元素的请求 将其 模式 设置为
"cors"，并将其 凭证模式 设置为 "include"。
|
该属性的 缺失值默认值 是 无
CORS 状态，其 无效值默认值 是 匿名 状态。为了 反射 的目的，规范关键字 为
匿名 状态是 anonymous
关键字。
大多数受 CORS 设置属性 管辖的请求将通过 创建潜在 CORS 请求 算法进行。
对于更现代的功能，其中请求的 模式 始终为
"cors"，某些 CORS
设置属性 已被重新定义为具有略有不同的含义，其中它们仅影响 请求 的 凭证模式。为了进行此转换，我们定义 CORS 设置属性凭证模式 为通过切换属性状态来确定：
same-origin"include"引荐政策属性 是一个 枚举属性。每个 引荐政策， 包括空字符串，都是该属性的关键字，对应一个同名的状态。
该属性的 缺失值默认值 和 无效值默认值 都是空字符串状态。
这些状态对各种 fetch 请求 的处理模型的影响在本规范中有更详细的定义，包括 Fetch 和 Referrer Policy。[FETCH] [REFERRERPOLICY]
几个信号可以影响用于给定 fetch 请求 的处理模型；引荐政策属性 只是其中之一。通常，这些信号的处理顺序为：
首先，存在一个 noreferrer
链接类型；
然后是 引荐政策属性 的值；
最后是 `Referrer-Policy`
HTTP 头部。
所有当前引擎都支持。
nonce 内容
属性表示一个加密 nonce（“仅使用一次的数字”），可以由 内容安全策略 用来决定是否允许给定的 fetch 请求继续进行。其值为文本。[CSP]
具有 nonce 内容属性的元素
确保加密 nonce 只暴露给脚本（而非通过 CSS 属性选择器等侧信道）。它通过从内容属性中获取值，将其移动到一个名为 [[CryptographicNonce]] 的内部插槽中，通过 HTMLOrSVGElement
接口混合来暴露给脚本，并将内容属性设置为空字符串。除非另有说明，插槽的值为空字符串。
element.nonce
返回 element 的加密 nonce 的值。如果没有使用 setter，这将是原始的 nonce
内容属性中的值。
element.nonce = value
更新 element 的加密 nonce 值。
nonce IDL 属性必须在获取时返回该元素的 [[CryptographicNonce]] 的值；在设置时，将该元素的 [[CryptographicNonce]] 设置为给定的值。
注意，nonce
IDL 属性的 setter 不会更新对应的内容属性。这以及当一个元素 变为浏览上下文连接 时将 nonce
内容属性设置为空字符串，是为了防止通过容易读取内容属性的机制（如选择器）泄露 nonce 值。了解更多信息请参见 问题
#2369，该行为在此处被引入。
如果 element
不 包含 HTMLOrSVGElement，
则返回。
如果 localName 不是 nonce 或
namespace 不为 null，则返回。
如果 value 为 null，则将 element 的 [[CryptographicNonce]] 设置为空字符串。
否则，将 element 的 [[CryptographicNonce]] 设置为 value。
每当一个元素 包含 HTMLOrSVGElement
变为浏览上下文连接 时，用户代理必须对 element 执行以下步骤：
令 CSP list 为 element 的 shadow-including root 的 策略容器 的 CSP list。
如果 CSP list 包含一个头部传递的内容安全策略，并且
element 具有一个 nonce 内容
属性 attr，其值不是空字符串，则：
令 nonce 为 element 的 [[CryptographicNonce]]。
将 element 的 [[CryptographicNonce]] 设置为 nonce。
如果 element 的 [[CryptographicNonce]] 没有恢复，那么在此时它将是空字符串。
对于 包含 HTMLOrSVGElement
的元素，克隆步骤必须将副本上的 [[CryptographicNonce]]
插槽设置为元素被克隆时插槽的值。
所有当前引擎都支持。
一个 延迟加载属性 是一个 枚举属性， 具有以下关键字和状态：
| 关键字 | 状态 | 简要描述 |
|---|---|---|
lazy
|
延迟 | 用于在满足某些条件之前推迟获取资源。 |
eager
|
立即 | 用于立即获取资源；默认状态。 |
该属性指示用户代理立即获取资源，或根据属性的当前状态，在满足与元素相关的一些条件之后再获取资源。
该属性的 缺失值默认值 和 无效值默认值 都是 立即 状态。
对于给定的元素 element，将延迟加载元素步骤 如下：
如果 脚本功能被禁用，则返回 false。
这是一个反跟踪措施，因为如果用户代理在脚本功能被禁用时仍支持延迟加载，那么一个网站可以通过在页面的标记中战略性地放置图像，以便服务器可以跟踪请求的图像数量及其时间，从而在整个会话中跟踪用户的大致滚动位置。
返回 false。
每个 img
和 iframe
元素都有相关的 延迟加载恢复步骤，最初为 null。
对于那些 将延迟加载 的 img
和 iframe
元素，这些步骤会在 延迟加载交叉观察器 的回调中运行，或当其 延迟加载属性 设置为 立即 状态时。这会导致元素继续加载。
每个 文档 都有一个
延迟加载交叉观察器，最初设置为 null，但可以设置为一个 IntersectionObserver
实例。
要 开始交叉观察一个延迟加载元素 element，执行以下步骤：
将 doc 设为 element 的 节点文档。
如果 doc 的 延迟加载交叉观察器 为 null，
将其设置为一个新的 IntersectionObserver
实例，初始化如下：
意图是使用 IntersectionObserver
构造函数的原始值。然而，我们被迫使用本规范中的 JavaScript 暴露构造函数，直到 Intersection Observer
为规范中的使用提供低级钩子。请参见跟踪此问题的 bug w3c/IntersectionObserver#464。[INTERSECTIONOBSERVER]
callback 是这些步骤，参数为 entries 和 observer：
对于 entries 中的每个 entry 使用一种不会触发开发者可修改数组访问器或 迭代钩子的方法进行迭代：
将 resumptionSteps 设为 null。
如果 entry.isIntersecting
为 true，则将 resumptionSteps 设为 entry.target
的
延迟加载恢复步骤。
如果 resumptionSteps 为 null，则返回。
停止
交叉观察延迟加载元素 对于 entry.target。
调用 resumptionSteps。
意图是使用 isIntersecting
和 target
的原始值。请参见 w3c/IntersectionObserver#464。
[INTERSECTIONOBSERVER]
options 是一个 IntersectionObserverInit
字典，具有以下字典成员：«[ "scrollMargin" → 延迟加载滚动边距 ]»
这允许在图像尚未 — 但即将 — 与视口交叉时进行获取。
延迟加载滚动边距建议意味着值的动态变化，但 IntersectionObserver
API 不支持更改滚动边距。参见问题 w3c/IntersectionObserver#428。
调用 doc 的 延迟加载交叉观察器 的 observe
方法，以 element 作为参数。
意图是使用 observe
方法的原始值。参见 w3c/IntersectionObserver#464。
[INTERSECTIONOBSERVER]
要 停止交叉观察延迟加载元素 element，执行以下步骤：
将 doc 设为 element 的 节点文档。
调用 doc 的 延迟加载交叉观察器 的 unobserve
方法，以 element 作为参数。
意图是使用 unobserve
方法的原始值。参见 w3c/IntersectionObserver#464。
[INTERSECTIONOBSERVER]
延迟加载滚动边距 是一个
实现定义 的值，但有以下建议供参考：
设置一个最小值，以便在正常使用模式下，大多数情况下，资源会在它们进入视口之前加载。
典型的滚动速度：对于具有较快典型滚动速度的设备，增加该值。
当前滚动速度或惯性：用户代理可以尝试预测滚动将在哪个位置停止，并相应调整该值。
网络质量：对于慢速或高延迟连接，增加该值。
用户偏好可能会影响该值。
为了 保护隐私，延迟加载滚动边距 不应泄露额外的信息。例如，当前设备的典型滚动速度可能不够精确，以免引入新的指纹识别向量。
阻塞属性 明确表示在获取外部资源时应阻止某些操作。这些操作可以被阻止的由 可能的阻塞令牌 表示，这些令牌以字符串形式列于下表：
| 可能的阻塞令牌 | 描述 |
|---|---|
"render"
|
该元素是 可能阻塞渲染 的。 |
将来可能会有更多的 可能的阻塞令牌。
一个 阻塞属性 必须具有一个值，该值是一个 唯一的以空格分隔的令牌无序集合，每个令牌都是 可能的阻塞令牌。一个 支持的令牌 是 可能的阻塞令牌。任何元素最多只能有一个 阻塞属性。
阻塞令牌集 是针对一个元素 el 的以下步骤的结果：
让 value 为 el 的 阻塞属性 的值，如果不存在这样的属性，则为 空字符串。
将 value 转换为 ASCII 小写。
让 rawTokens 为 按 ASCII 空白字符分割 value 的结果。
返回一个包含 rawTokens 中所有 可能的阻塞令牌 的集合。
一个元素如果其 阻塞令牌集
包含 "render"，
或者如果它是 隐式潜在渲染阻塞 的，这将在各个元素中定义。
默认情况下，元素不是 隐式潜在渲染阻塞 的。
获取优先级属性 是一个 枚举属性， 具有以下关键字和状态：
| 关键字 | 状态 | 简要描述 |
|---|---|---|
high
|
high | 表示相对于其他具有相同 目的地 的资源，这是一个高优先级的 获取 操作。 |
low
|
low | 表示相对于其他具有相同 目的地 的资源，这是一个低优先级的 获取 操作。 |
auto
|
auto | 表示自动确定相对于其他具有相同 目的地 的 获取 优先级。 |
该属性的 缺失值默认值 和 无效值默认值 都是 auto 状态。
反射的构建块如下：
反射目标 是一个元素或 ElementInternals
对象。通常从上下文中可以清楚地确定，并且通常与
反射 IDL 属性 的接口相同。当
反射目标是 ElementInternals
对象时，它总是与该接口相同。
反射 IDL 属性 是一个属性接口成员。
反射内容属性名称 是一个字符串。当 反射目标 是一个元素时，它表示一个内容属性的本地名称，其命名空间为
null。当 反射目标 是一个 ElementInternals
对象时，它表示 反射目标 的 目标元素 的 内部内容属性映射 的一个键。
反射 IDL 属性 可以被定义为 反射 反射内容属性名称 的 反射目标。通常，这意味着 IDL 属性的 getter 返回内容属性的当前值，setter 则将内容属性的值更改为给定值。
如果 反射目标
是一个元素，则
反射
IDL 属性 还可以声明
支持 ElementInternals。这意味着 ElementInternals
接口也有一个 反射 IDL 属性，具有相同的标识符，并且该 反射
IDL 属性 反射
相同的 反射内容属性名称。
该 fooBar
IDL 属性必须 反射
foobar
内容属性，并且 支持
ElementInternals。
反射目标 具有以下关联算法：
对于一个 反射目标，如果它是一个元素 element，这些算法定义如下：
返回 element。
令 attribute 为运行 按命名空间和本地名称获取属性 的结果， 传入 null、反射内容属性名称 和 element。
如果 attribute 为 null，则返回 null。
返回 attribute 的 值。
按命名空间和本地名称删除属性， 传入 null、反射内容属性名称 和 element。
对于一个 反射目标，如果它是一个 ElementInternals
对象 elementInternals，这些算法定义如下：
返回 elementInternals 的 目标元素。
这会导致 ElementInternals
对象出现一些冗余的数据结构，因为其 目标元素 的 内部内容属性映射
不能直接操作，因此反射只发生在单向。这种方法尽管如此，仍被选择以减少定义在 反射目标 之间共享的 IDL 属性的错误，并从通用 API 语义中受益。
类型为 DOMString
或
DOMString?
的 IDL 属性如果 反射 枚举
内容属性，则可以
限制为仅已知值。
根据下面的处理模型，这些将导致这些 IDL 属性的 getter 仅返回这些枚举属性的关键字，或者空字符串或 null。
如果一个 反射的 IDL 属性 的
类型为 DOMString：
getter 的步骤是：
让 attributeDefinition 成为 element 的内容属性的属性定义，该属性的命名空间为 null，局部名称为 反射内容属性名称。
如果 attributeDefinition 表示它是一个 枚举属性 并且 反射的 IDL 属性 被定义为 仅限于已知值：
如果 contentAttributeValue 为 null，则返回空字符串。
返回 contentAttributeValue。
如果一个 反射的 IDL 属性 的类型是
DOMString?：
getter 的步骤是：
setter 的步骤是：
如果一个 反射的 IDL 属性 的类型是 USVString：
getter 的步骤是：
让 attributeDefinition 成为 element 的内容属性的属性定义，该属性的命名空间为 null，局部名称为 反射内容属性名称。
如果 attributeDefinition 表示它包含一个 URL：
如果 contentAttributeValue 为 null，则返回空字符串。
让 urlString 成为对 contentAttributeValue 进行 编码-解析和序列化 URL 的结果，基于 element 的 节点文档。
如果 urlString 不是失败，则返回 urlString。
返回 contentAttributeValue，转换为标量值字符串。
如果一个 反射的 IDL 属性 的类型是 boolean：
getter 的步骤是：
setter 的步骤是：
这对应于 布尔内容属性 的规则。
If a 反射的 IDL 属性 的类型是 long，
可选地 限制为非负数 并且可选地具有 默认值
defaultValue：
getter 的步骤是：
如果 contentAttributeValue 不为 null：
让 parsedValue 成为 整数解析 contentAttributeValue 的结果，如果 反射的 IDL 属性 不是 限制为非负数；否则是 非负整数解析 contentAttributeValue 的结果。
如果 parsedValue 不是错误且在 long
范围内，则返回 parsedValue。
如果 反射的 IDL 属性 具有 默认值，则返回 defaultValue。
如果 反射的 IDL 属性 是 限制为非负数，则返回 −1。
返回 0。
setter 的步骤是：
如果 反射的 IDL 属性 是 限制为非负数
且给定的值为负，则抛出一个
"IndexSizeError" DOMException。
如果一个 反射的 IDL 属性 的类型是 unsigned long，
可选地 限制为仅正数、限制为仅正数（带回退），或 夹紧到范围 [clampedMin，clampedMax]，并且可选地具有 默认值
defaultValue：
getter 的步骤是：
让 minimum 为 0。
如果 反射的 IDL 属性 是 仅限正数 或 仅限正数（带回退），则将 minimum 设置为 1。
如果 反射的 IDL 属性 是 夹紧到范围，则将 minimum 设置为 clampedMin。
让 maximum 为 2147483647，如果 反射的 IDL 属性 不是 夹紧到范围；否则为 clampedMax。
如果 contentAttributeValue 不为 null：
让 parsedValue 成为 非负整数解析 contentAttributeValue 的结果。
如果 parsedValue 不是错误且在范围 minimum 到 maximum（包含）内，则返回 parsedValue。
如果 parsedValue 不是错误且 反射的 IDL 属性 是 夹紧到范围：
如果 parsedValue 小于 minimum，则返回 minimum。
返回 maximum。
如果 反射的 IDL 属性 具有 默认值，则返回 defaultValue。
返回 minimum。
setter 的步骤是：
如果 反射的 IDL 属性 是 仅限正数
且给定值为 0，则抛出一个
"IndexSizeError" DOMException。
让 minimum 为 0。
如果 反射的 IDL 属性 是 仅限正数 或 仅限正数（带回退），则将 minimum 设置为 1。
让 newValue 为 minimum。
如果 反射的 IDL 属性 具有 默认值，则将 newValue 设置为 defaultValue。
如果给定值在范围 minimum 到 2147483647（包含）内，则将 newValue 设置为该值。
夹紧到范围 对 setter 步骤没有影响。
如果一个 反射的 IDL 属性 的类型是 double，
可选地 限制为仅正数，并且可选地具有 默认值 defaultValue：
getter 的步骤是：
如果 contentAttributeValue 不为 null：
让 parsedValue 成为 浮点数解析 contentAttributeValue 的结果。
如果 parsedValue 不是错误且大于 0，则返回 parsedValue。
如果 parsedValue 不是错误且 反射的 IDL 属性 不是 仅限正数，则返回 parsedValue。
如果 反射的 IDL 属性 具有 默认值，则返回 defaultValue。
返回 0。
setter 的步骤是：
如果 反射的 IDL 属性 是 仅限正数 且给定值不大于 0，则返回。
值 Infinity 和 Not-a-Number (NaN) 在设置时会抛出异常，如 Web IDL 中定义。[WEBIDL]
如果一个 反射的 IDL 属性 的类型是 DOMTokenList，
那么它的 getter 步骤是返回一个 DOMTokenList
对象，其关联的元素是 this，关联属性的本地名称是 反射的内容属性名称。规范作者不能使用 支持
ElementInternals 来处理此类型的 IDL 属性。
如果一个 反射的 IDL 属性 的类型是
T?，
其中 T 是 Element
或从 Element
继承的接口，则 attr 是 反射的内容属性名称：
其 反射目标 有一个 显式设置的 attr-element，这是一个对元素的弱引用或 null。初始值为 null。
其 反射目标 reflectedTarget 有一个 获取 attr-关联元素 算法，执行以下步骤：
让 element 成为运行 reflectedTarget 的 获取元素 的结果。
让 contentAttributeValue 成为运行 reflectedTarget 的 获取内容属性 的结果。
如果 reflectedTarget 的 显式设置的 attr-element 不为 null：
如果reflectedTarget的显式设置的attr-元素是任何element的后代，并且在element的包括影子的祖先中的任何一个，则返回reflectedTarget的显式设置的attr-元素。
返回 null。
否则，如果 contentAttributeValue 不为 null，则返回第一个符合以下标准的元素 candidate，按 树序 排序：
如果没有这样的元素，则返回 null。
返回 null。
getter 的步骤是返回运行 this 的 获取 attr-关联元素 的结果。
setter 的步骤是：
如果给定值为 null，则：
将 this 的 显式设置的 attr-element 设置为 null。
返回。
将 this 的 显式设置的 attr-element 设置为对给定值的弱引用。
仅对于元素 反射目标：以下 属性更改步骤，给定 element、localName、oldValue、value 和 namespace，用于同步内容属性和 IDL 属性：
如果 localName 不是 attr 或 namespace 不为 null，则返回。
将 element 的 显式设置的 attr-element 设置为 null。
反射的 IDL 属性 这种类型的属性强烈建议其标识符以
"Element" 结尾，以保持一致性。
如果一个 反射的 IDL 属性 的类型是
FrozenArray<T>?，其中 T 是 Element
或一个继承自 Element
的接口，那么对于 attr 作为 反射的内容属性名称：
其 反射目标
有一个 缓存的 attr-关联元素对象，它是一个
FrozenArray<T>?。最初为 null。
其 反射目标 reflectedTarget 有一个 获取 attr-关联元素 算法，执行以下步骤：
让 elements 成为一个空的 列表。
让 element 成为运行 reflectedTarget 的 获取元素 的结果。
如果 reflectedTarget 的 显式设置的 attr-元素 不为 null：
对于 attrElement 在 reflectedTarget 的 显式设置的 attr-元素 中：
否则：
让 contentAttributeValue 成为运行 reflectedTarget 的 获取内容属性 的结果。
如果 contentAttributeValue 为 null，则返回 null。
让 tokens 为 contentAttributeValue，按 ASCII 空白拆分。
对于 id 的 tokens：
返回 elements。
getter 步骤是：
让 elements 成为运行 this 的 获取 attr-关联元素 的结果。
如果 elements 的内容等于 this 的 缓存的 attr-关联元素 的内容，则返回 this 的 缓存的 attr-关联元素对象。
让 elementsAsFrozenArray 为 elements，转换 为 FrozenArray<T>?。
将 this 的 缓存的 attr-关联元素 设置为 elements。
将 this 的 缓存的 attr-关联元素对象 设置为 elementsAsFrozenArray。
返回 elementsAsFrozenArray。
这个额外的缓存层是必要的，以保持不变量 element.reflectedElements === element.reflectedElements。
setter 步骤是：
仅对于元素 反射目标：以下 属性更改步骤，给定 element、localName、oldValue、value 和 namespace，用于在内容属性和 IDL 属性之间同步：
如果 localName 不是 attr 或 namespace 不为 null，则返回。
将 element 的 显式 设置的 attr-元素 设置为 null。
反射的 IDL 属性 强烈建议其标识符以
"Elements" 结尾，以保持一致性。
反射 主要是通过给开发者提供通过 反射的 IDL 属性 类型访问内容属性，以改善开发者的使用体验。网页平台的最终事实来源是内容属性本身。也就是说，规范作者不能使用 反射的 IDL 属性 的 getter 或 setter 步骤，而应使用内容属性的存在和值。（或其上的抽象，如 枚举属性 的状态。）
两个重要的例外是 反射的 IDL 属性 其类型是以下之一：
对于这些情况，规范作者必须使用 反射目标的 获取 attr-关联元素 和 获取 attr-关联元素 的步骤。内容属性的存在和值不应使用，因为它们不能完全与 反射的 IDL 属性 同步。
反射目标的 显式设置的 attr-元素、 显式设置的 attr-元素、 缓存的 attr-关联元素 和 缓存的 attr-关联元素对象 应被视为内部实现细节，而不应基于它们进行构建。
HTMLFormControlsCollection
和 HTMLOptionsCollection
接口是从
HTMLCollection
接口派生的
集合。HTMLAllCollection
接口是一个集合，但不是这样派生的。
HTMLAllCollection
接口HTMLAllCollection
接口用于遗留的 document.all
属性。它的操作类似于 HTMLCollection；主要区别在于它允许各种不同的（滥用）方法返回一些内容，并且它可以作为函数调用，而不是属性访问。
所有 HTMLAllCollection
对象都根植于 Document，并具有匹配所有元素的过滤器，因此
由集合表示 的元素 HTMLAllCollection
对象由根 Document
的所有后代元素组成。
实现 HTMLAllCollection
接口的对象是 遗留平台对象，具有附加的 [[Call]] 内部方法，如下面部分所述。它们还具有 [[IsHTMLDDA]] 内部槽。
实现 HTMLAllCollection
接口的对象有几个不寻常的行为，因为它们具有 [[IsHTMLDDA]] 内部槽：
JavaScript 中的 ToBoolean 抽象操作在给定实现
HTMLAllCollection
接口的对象时返回 false。
当给定实现 HTMLAllCollection
接口的对象时，IsLooselyEqual 抽象操作与 undefined 和 null
值比较时返回 true。 (使用 IsStrictlyEqual 抽象操作的比较以及与字符串或对象等其他值的 IsLooselyEqual 比较不受影响。)
在 JavaScript 中对实现 HTMLAllCollection
接口的对象应用 typeof
运算符时，返回字符串 "undefined"。
这些特殊行为是为了兼容两类遗留内容：一类是使用 document.all
存在来检测遗留用户代理的内容，另一类仅支持这些遗留用户代理并在不测试其存在的情况下使用 document.all
对象的内容。[JAVASCRIPT]
[Exposed =Window ,
LegacyUnenumerableNamedProperties ]
interface HTMLAllCollection {
readonly attribute unsigned long length ;
getter Element (unsigned long index );
getter (HTMLCollection or Element )? namedItem (DOMString name );
(HTMLCollection or Element )? item (optional DOMString nameOrIndex );
// Note: HTMLAllCollection objects have a custom [[Call]] internal method and an [[IsHTMLDDA]] internal slot.
};对象的 支持的属性索引 定义与 HTMLCollection
对象相同。
支持的属性名称 由所有元素的 id
属性的非空值组成，这些元素 由集合表示，以及所有 “全部”命名元素 的 name 属性的非空值，这些元素 由集合表示，按 树顺序，忽略后续的重复项，如果一个元素同时提供
id
和 name 且它们不同且都不是早期条目的重复项，则 id 在 name 之前。
length 的 getter 步骤是返回 由集合表示 的节点数。
索引属性 getter 必须返回通过给定传递的索引 获取“全部”索引的元素 的结果 this。
namedItem(name) 方法步骤是返回 获取“全部”命名的元素 的结果 this 给定 name。
item(nameOrIndex) 方法步骤是：
如果未提供 nameOrIndex，则返回 null。
返回 获取“全部”索引或命名的元素 的结果 this 给定 nameOrIndex。
以下元素是 “全部”命名元素：a，button，embed，form，frame，frameset，iframe，img，input，map，meta，object，select，以及textarea
从 HTMLAllCollection
collection 中 获取“全部”索引的元素 给定索引 index，返回
collection 中的第 index 个元素，如果没有这样的 index 个元素，则返回 null。
从 HTMLAllCollection
collection 中 获取“全部”命名的元素 给定名称 name，执行以下步骤：
如果 name 是空字符串，则返回 null。
让 subCollection 成为一个 HTMLCollection
对象，它以与 collection 相同的 Document
为根，其过滤器仅匹配以下任一元素：
如果 subCollection 中只有一个元素，则返回该元素。
否则，如果 subCollection 为空，则返回 null。
否则，返回 subCollection。
从 HTMLAllCollection
collection 中 获取“全部”索引或命名的元素 给定 nameOrIndex：
如果 nameOrIndex，转换 为 JavaScript 字符串值，是一个 数组索引属性名称，则返回通过给定 nameOrIndex 表示的数字从 collection 获取“全部”索引的元素 的结果。
返回通过给定 nameOrIndex 从 collection 获取“all”命名的元素 的结果。
如果 argumentsList 的 大小 为零，或者 argumentsList[0] 是 undefined，则返回 null。
将从此 HTMLAllCollection
中 获取“全部”索引或命名的元素 的结果赋值给 result，给定
nameOrIndex。
返回将 result 转换 为 ECMAScript 值的结果。
忽略 thisArgument，因此诸如 Function.prototype.call.call(document.all, null, "x")
的代码仍将搜索元素。（document.all.call 不存在，因为 document.all 不继承自 Function.prototype。）
HTMLFormControlsCollection
接口HTMLFormControlsCollection
接口用于 集合 中
form
元素中的 列出元素。
Support in all current engines.
Support in all current engines.
[Exposed =Window ]
interface HTMLFormControlsCollection : HTMLCollection {
// inherits length and item()
getter (RadioNodeList or Element )? namedItem (DOMString name ); // shadows inherited namedItem()
};
[Exposed =Window ]
interface RadioNodeList : NodeList {
attribute DOMString value ;
};collection.length
返回 collection 中的元素数量。
element = collection.item(index)
element = collection[index]返回 collection 中索引为 index 的项。项按 树顺序 排序。
element = collection.namedItem(name)
HTMLFormControlsCollection/namedItem
Support in all current engines.
radioNodeList = collection.namedItem(name)
element = collection[name]radioNodeList = collection[name]从 collection 返回 ID 或 name
为 name 的项。
如果有多个匹配的项，则返回包含所有这些元素的 RadioNodeList
对象。
radioNodeList.value
返回 radioNodeList 所代表的第一个选中的单选按钮的值。
radioNodeList.value = value
选择第一个值为 value 的 radioNodeList 所代表的单选按钮。
The 支持的属性名称 由所有非空值组成
id
和 name
属性的所有元素由集合表示，按树顺序，忽略后续的重复项，其中id
的元素优先于其name
如果它们同时贡献，它们彼此不同，并且都不是先前条目的重复项。
namedItem(name) 方法必须按照以下算法操作：
id
属性或 name
属性等于 name，则返回该节点并停止算法。id
属性或 name
属性等于 name，则返回 null 并停止算法。RadioNodeList
对象，表示 动态 查看 HTMLFormControlsCollection
对象的视图，进一步过滤，使得 RadioNodeList
对象中的唯一节点是那些具有 id
属性或 name
属性等于 name 的节点。RadioNodeList
对象中的节点必须按 树顺序 排序。RadioNodeList
对象。RadioNodeList
接口的成员从 NodeList
接口继承，必须像在 NodeList
对象上一样表现。
Support in all current engines.
value
IDL 属性在 RadioNodeList
对象上，获取时必须返回通过运行以下步骤返回的值：
让 element 成为由 RadioNodeList
对象表示的第一个元素，在 树顺序 中是一个 input
元素，其 type
属性处于 单选按钮 状态并且其 已选中
状态为真。否则，让其为 null。
如果 element 为 null，则返回空字符串。
如果 element 是一个没有 value
属性的元素，则返回字符串 "on"。
否则，返回 element 的 value
属性的值。
在设置时，value
IDL 属性必须运行以下步骤：
如果新值为字符串 "on"：让 element 成为由 RadioNodeList
对象表示的第一个元素，在 树顺序 中是一个 input
元素，其 type
属性处于 单选按钮 状态并且其 value
内容属性不存在，或存在且等于新值，如果有。如果不存在这样的元素，则让 element 为 null。
否则：让 element 成为由 RadioNodeList
对象表示的第一个元素，在 树顺序 中是一个 input
元素，其 type
属性处于 单选按钮 状态并且其 value
内容属性存在并等于新值，如果有。如果不存在这样的元素，则让 element 为 null。
如果 element 不为 null，则将其 已选中 状态设置为真。
HTMLOptionsCollection
接口支持所有当前引擎。
HTMLOptionsCollection
接口用于 集合 的 option
元素。它总是根植于一个 select
元素，并具有操作该元素后代的属性和方法。
[Exposed =Window ]
interface HTMLOptionsCollection : HTMLCollection {
// inherits item(), namedItem()
[CEReactions ] attribute unsigned long length ; // shadows inherited length
[CEReactions ] setter undefined (unsigned long index , HTMLOptionElement ? option );
[CEReactions ] undefined add ((HTMLOptionElement or HTMLOptGroupElement ) element , optional (HTMLElement or long )? before = null );
[CEReactions ] undefined remove (long index );
attribute long selectedIndex ;
};collection.length
返回 collection 中的元素数量。
collection.length = value
当设置为小于现有长度的值时，截断 collection 对应容器中的 option
元素数量。
当设置为大于现有长度的值时，如果该值小于或等于100000，则向 collection 对应容器中添加新的空白 option
元素。
element = collection.item(index)
element = collection[index]返回 collection 中索引为 index 的项。项目按 树顺序 排列。
collection[index] = element当 index 大于 collection 中的项目数量时，在相应容器中添加新的空白 option
元素。
当设置为 null 时，从 collection 中移除索引为 index 的项。
当设置为 option
元素时，在 collection 中的索引为 index 的位置添加或替换该元素。
element = collection.namedItem(name)
element = collection[name]返回 collection 中具有 ID 或 name
为 name 的项。
如果有多个匹配项，则返回第一个匹配项。
collection.add(element[, before])
在 before 指定的节点前插入 element。
before 参数可以是一个数字，在这种情况下，element 插入到该编号的项之前；也可以是 collection 中的一个元素，在这种情况下，element 插入到该元素之前。
如果 before 被省略、为空或为超出范围的数字 ，则 element 将添加到列表末尾。
如果 element 是要插入的元素的祖先，则抛出 "HierarchyRequestError" DOMException。
collection.remove(index)
从 collection 中移除索引为 index 的项。
collection.selectedIndex
返回第一个被选中项的索引（如果有），否则返回 -1。
collection.selectedIndex = index
将选项更改为 collection 中索引为 index 的 option
元素。
对象的 支持的属性索引如 HTMLCollection
对象中定义。
length 的获取步骤是返回 collection 表示的节点数。
length
的设置步骤为：
令 current 为 collection 表示的节点数。
如果给定值大于 current，则：
如果给定值小于 current，则：
令 n 为 current - value。
从其父节点中移除集合中的最后 n 个节点。
设置 length
永远不会移除或添加任何 optgroup
元素，也不会向现有的 optgroup
元素中添加新的子节点（尽管它可以从中移除子节点）。
The 支持的属性名称 由所有非空值组成
id
和 name
属性的所有元素由集合表示，按树顺序，忽略后续的重复项，其中id
的元素优先于其name
如果它们同时贡献，它们彼此不同，并且都不是先前条目的重复项。
当用户代理要 设置新索引属性的值或 设置现有索引属性的值时，必须运行以下算法：
如果 value 为 null，则调用 remove
方法，将 index 作为参数，并返回。
令 length 为 collection 表示的节点数。
令 n 为 index 减去 length。
如果 n 大于零，则 附加 一个由
n-1 个新的没有属性和子节点的 option
元素组成的 DocumentFragment
到 select
元素上。
如果 n 大于或等于零，则 附加
value 到 select
元素。否则，替换
集合中的第 index 个元素为 value。
add(element, before) 方法必须按以下算法操作：
如果 element 是 select
元素的祖先，则抛出 "HierarchyRequestError" DOMException。
如果 before 是一个元素，但该元素不是 select
元素的后代，则抛出 "NotFoundError" DOMException。
如果 element 和 before 是同一个元素，则返回。
如果 before 是一个节点，则令 reference 为该节点。否则，如果 before 是一个整数，并且集合中存在第 before 个节点，则令 reference 为该节点。否则，令 reference 为 null。
如果 reference 不为 null，则令 parent 为 reference 的父节点。否则，令 parent 为 select
元素。
预插入 element 到 parent 节点中，在 reference 之前。
remove(index) 方法必须按以下算法操作：
如果 collection 表示的节点数 为零，则返回。
如果 index 不是大于等于 0 且小于 collection 表示的节点数 的数字，则返回。
令 element 为集合中的第 index 个元素。
从其父节点中移除 element。
selectedIndex IDL 属性必须像 select
元素上的同名属性一样操作，该 HTMLOptionsCollection
根植于该元素上。
DOMStringList
接口所有当前引擎支持。
DOMStringList
接口是一种不时髦的复古方式，用于表示字符串列表。
[Exposed =(Window ,Worker )]
interface DOMStringList {
readonly attribute unsigned long length ;
getter DOMString ? item (unsigned long index );
boolean contains (DOMString string );
};新 API 必须使用 sequence<DOMString> 或等效的方式，而不是 DOMStringList。
strings.length
返回 strings 中的字符串数量。
strings[index]strings.item(index)
返回 strings 中索引为 index 的字符串。
strings.contains(string)
如果 strings 包含 string，则返回 true，否则返回 false。
每个 DOMStringList
对象都有一个关联的 列表。
DOMStringList
接口 支持索引属性。支持的属性索引是 此的关联列表的 索引。
所有当前引擎支持。
所有当前引擎支持。
item(index) 方法步骤是返回 此关联列表中的第 index 项，或者如果 index 加一大于 此关联列表的 大小，则返回 null。
所有当前引擎支持。
contains(string) 方法步骤是如果 此关联列表 包含 string，则返回
true，否则返回 false。
为了支持在不同realm边界之间传递JavaScript对象，包括平台对象，本规范定义了以下用于序列化和反序列化对象的基础设施，包括在某些情况下传输底层数据而不是复制数据。总体而言，这种序列化/反序列化过程被称为“结构化克隆”，尽管大多数API执行的是单独的序列化和反序列化步骤。（显著的例外是structuredClone()方法。）
本节使用了JavaScript规范中的术语和排版约定。[JAVASCRIPT]
/developer.mozilla.org/en-US/docs/Glossary/Serializable_object
可序列化对象支持以独立于任何特定realm的方式进行序列化和稍后反序列化。这使得它们可以存储在磁盘上并稍后恢复，或跨代理甚至代理集群边界进行克隆。
并非所有对象都是可序列化对象，而且并非所有可序列化对象的所有方面在序列化时都会被保留。
平台对象可以是可序列化对象，如果它们的主要接口带有[Serializable]IDL扩展属性。这些接口还必须定义以下算法：
一组步骤，将value中的数据序列化为serialized的字段。序列化到serialized中的结果数据必须独立于任何realm。
如果序列化不可能，这些步骤可能会抛出异常。
这些步骤可能执行子序列化以序列化嵌套的数据结构。它们不应直接调用StructuredSerialize，因为这样做会遗漏重要的memory参数。
如果forStorage参数与算法无关，应在引入这些步骤时省略提及。
一组步骤，将serialized中的数据反序列化，适当设置value。value将是所涉及的平台对象类型的新创建实例，其内部数据未设置；设置这些数据是这些步骤的任务。
如果反序列化不可能，这些步骤可能会抛出异常。
这些步骤可能执行子反序列化以反序列化嵌套的数据结构。它们不应直接调用StructuredDeserialize，因为这样做会遗漏重要的targetRealm和memory参数。
定义单个平台对象的数据在这些步骤中如何被序列化和反序列化是个体平台对象定义的责任。通常这些步骤是非常对称的。
[Serializable]扩展属性不得带有任何参数，并且只能出现在接口上。在一个接口上不得出现超过一次。
对于给定的平台对象，只有对象的主要接口在（反）序列化过程中被考虑。因此，如果在定义接口时涉及继承，每个继承链中的[Serializable]注释接口需要定义独立的序列化步骤和反序列化步骤，包括考虑任何可能来自继承接口的重要数据。
假设我们定义了一个平台对象Person，它关联了两部分数据：
一个名称值，它是一个字符串；和
一个最好朋友值，它可以是另一个Person实例或null。
然后我们可以通过将Person接口注释为[Serializable]扩展属性，并定义以下配套算法，使Person实例成为可序列化对象：
JavaScript规范中定义的对象由StructuredSerialize抽象操作直接处理。
最初，本规范定义了“可克隆对象”的概念，可以从一个realm克隆到另一个realm。然而，为了更好地指定某些更复杂情况的行为，模型被更新为使序列化和反序列化显式化。
可转移对象支持在代理之间转移。转移实际上是重新创建对象，同时共享对底层数据的引用，然后分离被转移的对象。这对于转移昂贵资源的所有权非常有用。并非所有对象都是可转移对象，而且并非所有可转移对象的所有方面在转移时都会被保留。
转移是不可逆且非幂等的操作。一旦对象被转移，它不能再被转移，甚至不能再被使用。
平台对象可以是可转移对象，如果它们的主要接口带有[Transferable]IDL扩展属性。这些接口还必须定义以下算法：
一组步骤，将value中的数据转移到dataHolder的字段中。保存在dataHolder中的结果数据必须独立于任何realm。
如果转移不可能，这些步骤可能会抛出异常。
一组步骤，接收dataHolder中的数据，适当设置value。value将是所涉及的平台对象类型的新创建实例，其内部数据未设置；设置这些数据是这些步骤的任务。
如果无法接收转移，这些步骤可能会抛出异常。
定义单个平台对象的数据在这些步骤中如何被转移是个体平台对象定义的责任。通常这些步骤是非常对称的。
[Transferable]扩展属性不得带有任何参数，并且只能出现在接口上。在一个接口上不得出现超过一次。
对于给定的平台对象，只有对象的主要接口在转移过程中被考虑。因此，如果在定义接口时涉及继承，每个继承链中的[Transferable]注释接口需要定义独立的转移步骤和接收转移步骤，包括考虑任何可能来自继承接口的重要数据。
作为可转移对象的平台对象具有一个[[Detached]]内部槽。这用于确保一旦平台对象被转移，它不能再次被转移。
JavaScript规范中定义的对象由StructuredSerializeWithTransfer抽象操作直接处理。
StructuredSerializeInternal 抽象操作以一个 JavaScript 值 value 为输入，将其序列化为一个独立于 realm 的形式，这里表示为一个 记录。这种序列化形式包含所有必要的信息，以便以后在不同的 realm 中反序列化为一个新的 JavaScript 值。
此过程可能会抛出异常，例如尝试序列化不可序列化的对象时。
如果未提供 memory，则让 memory 成为空的 map。
memory map 的目的是避免对象被序列化两次。这最终保留了图中的循环和重复对象的身份。
如果 memory[value] 存在，则返回 memory[value]。
让 deep 为 false。
如果 Type(value) 是 Undefined、Null、Boolean、Number、BigInt 或 String，则返回 { [[Type]]: "primitive", [[Value]]: value }。
如果 Type(value) 是 Symbol，则抛出
"DataCloneError" DOMException。
让 serialized 成为一个未初始化的值。
如果 value 有 [[BooleanData]] 内部槽，则将 serialized 设置为 { [[Type]]: "Boolean", [[BooleanData]]: value.[[BooleanData]] }。
否则，如果 value 有 [[NumberData]] 内部槽，则将 serialized 设置为 { [[Type]]: "Number", [[NumberData]]: value.[[NumberData]] }。
否则，如果 value 有 [[BigIntData]] 内部槽，则将 serialized 设置为 { [[Type]]: "BigInt", [[BigIntData]]: value.[[BigIntData]] }。
否则，如果 value 有 [[StringData]] 内部槽，则将 serialized 设置为 { [[Type]]: "String", [[StringData]]: value.[[StringData]] }。
否则，如果 value 有 [[DateValue]] 内部槽，则将 serialized 设置为 { [[Type]]: "Date", [[DateValue]]: value.[[DateValue]] }。
否则，如果 value 有 [[RegExpMatcher]] 内部槽，则将 serialized 设置为 { [[Type]]: "RegExp", [[RegExpMatcher]]: value.[[RegExpMatcher]], [[OriginalSource]]: value.[[OriginalSource]], [[OriginalFlags]]: value.[[OriginalFlags]] }。
否则，如果 value 有 [[ArrayBufferData]] 内部槽，则：
如果 IsSharedArrayBuffer(value) 是 true，则：
如果 当前设置对象 的 跨域隔离能力 为
false，则抛出 "DataCloneError" DOMException。
此检查仅在序列化时需要（反序列化时不需要），因为 跨域隔离能力
不能随时间改变，且 SharedArrayBuffer
不能离开一个 agent 集群。
如果 forStorage 为 true，则抛出 "DataCloneError" DOMException。
如果 value 有 [[ArrayBufferMaxByteLength]] 内部槽，则将 serialized 设置为 { [[Type]]: "GrowableSharedArrayBuffer", [[ArrayBufferData]]: value.[[ArrayBufferData]], [[ArrayBufferByteLengthData]]: value.[[ArrayBufferByteLengthData]], [[ArrayBufferMaxByteLength]]: value.[[ArrayBufferMaxByteLength]], [[AgentCluster]]: 周围 agent 的 agent 集群 }。
否则，将 serialized 设置为 { [[Type]]: "SharedArrayBuffer", [[ArrayBufferData]]: value.[[ArrayBufferData]], [[ArrayBufferByteLength]]: value.[[ArrayBufferByteLength]], [[AgentCluster]]: 周围 agent 的 agent 集群 }。
否则：
如果 IsDetachedBuffer(value) 是
true，则抛出 "DataCloneError" DOMException。
让 size 为 value.[[ArrayBufferByteLength]]。
让 dataCopy 成为 ? CreateByteDataBlock(size)。
在分配失败时，这可能会抛出 RangeError
异常。
执行 CopyDataBlockBytes(dataCopy, 0, value.[[ArrayBufferData]], 0, size)。
如果 value 有 [[ArrayBufferMaxByteLength]] 内部槽，则将 serialized 设置为 { [[Type]]: "ResizableArrayBuffer", [[ArrayBufferData]]: dataCopy, [[ArrayBufferByteLength]]: size, [[ArrayBufferMaxByteLength]]: value.[[ArrayBufferMaxByteLength]] }。
否则，将 serialized 设置为 { [[Type]]: "ArrayBuffer", [[ArrayBufferData]]: dataCopy, [[ArrayBufferByteLength]]: size }。
否则，如果 value 有 [[ViewedArrayBuffer]] 内部槽，则：
如果 IsArrayBufferViewOutOfBounds(value) 是
true，则抛出 "DataCloneError" DOMException。
让 buffer 成为 value 的 [[ViewedArrayBuffer]] 内部槽的值。
让 bufferSerialized 成为 ? StructuredSerializeInternal(buffer, forStorage, memory)。
断言：bufferSerialized.[[Type]] 是 "ArrayBuffer"、"ResizableArrayBuffer"、"SharedArrayBuffer" 或 "GrowableSharedArrayBuffer"。
如果 value 有 [[DataView]] 内部槽，则将 serialized 设置为 { [[Type]]: "ArrayBufferView", [[Constructor]]: "DataView", [[ArrayBufferSerialized]]: bufferSerialized, [[ByteLength]]: value.[[ByteLength]], [[ByteOffset]]: value.[[ByteOffset]] }。
否则：
断言：value 有 [[TypedArrayName]] 内部槽。
将 serialized 设置为 { [[Type]]: "ArrayBufferView", [[Constructor]]: value.[[TypedArrayName]], [[ArrayBufferSerialized]]: bufferSerialized, [[ByteLength]]: value.[[ByteLength]], [[ByteOffset]]: value.[[ByteOffset]], [[ArrayLength]]: value.[[ArrayLength]] }。
否则，如果 value 有 [[MapData]] 内部槽，则：
将 serialized 设置为 { [[Type]]: "Map", [[MapData]]: 一个新的空 列表 }。
将 deep 设置为 true。
否则，如果 value 有 [[SetData]] 内部槽，则：
将 serialized 设置为 { [[Type]]: "Set", [[SetData]]: 一个新的空 列表 }。
将 deep 设置为 true。
否则，如果 value 有 [[ErrorData]] 内部槽且 value 不是 平台对象，则：
让 name 成为 ? 获取(value, "name")。
如果 name 不是 "Error"、"EvalError"、"RangeError"、"ReferenceError"、"SyntaxError"、"TypeError" 或 "URIError" 之一，则将 name 设置为 "Error"。
让 valueMessageDesc 成为 ? value.[[GetOwnProperty]]("message")。
如果 IsDataDescriptor(valueMessageDesc) 为 false，则将 message 设置为 undefined；否则，将 message 设置为 ? ToString(valueMessageDesc.[[Value]])。
将 serialized 设置为 { [[Type]]: "Error", [[Name]]: name, [[Message]]: message }。
用户代理应将尚未指定的任何有趣的附带数据的序列化表示附加到 serialized，特别是 stack 属性。
请参见 Error Stacks 提案，了解关于指定此数据的进行中的工作。[JSERRORSTACKS]
否则，如果 value 是一个数组异类对象，则：
让 valueLenDescriptor 成为 ? OrdinaryGetOwnProperty(value, "length")。
让 valueLen 成为 valueLenDescriptor.[[Value]]。
将 serialized 设置为 { [[Type]]: "Array", [[Length]]: valueLen, [[Properties]]: 一个新的空 列表 }。
将 deep 设置为 true。
否则，如果 value 是一个 平台对象，且是一个 可序列化对象：
如果 value 有一个值为 true 的 [[Detached]] 内部槽，则抛出 "DataCloneError" DOMException。
让 typeString 成为 主接口 的标识符。
将 serialized 设置为 { [[Type]]: typeString }。
将 deep 设置为 true。
否则，如果 value 是一个 平台对象，则抛出 "DataCloneError" DOMException。
否则，如果 IsCallable(value) 为 true，则抛出 "DataCloneError" DOMException。
否则，如果 value 有任何内部槽，除 [[Prototype]]、[[Extensible]] 或 [[PrivateElements]] 外，则抛出 "DataCloneError" DOMException。
例如，一个 [[PromiseState]] 或 [[WeakMapData]] 内部槽。
否则，如果 value 是一个异类对象，且 value 不是与任何 realm 关联的 %Object.prototype% 内在对象，则抛出 "DataCloneError" DOMException。
例如，一个代理对象。
否则：
将 serialized 设置为 { [[Type]]: "Object", [[Properties]]: 一个新的空 列表 }。
将 deep 设置为 true。
%Object.prototype% 将通过此步骤和后续步骤进行处理。最终结果是忽略其异类性，并且在反序列化后结果将是一个空对象（不是一个 不可变原型异类对象）。
设置 memory[value] 为 serialized。
如果 deep 为 true，则：
如果 value 有 [[MapData]] 内部槽，则：
让 copiedList 成为一个新的空 列表。
对于每个 记录 { [[Key]], [[Value]] } entry 在 copiedList 中：
让 serializedKey 成为 ? StructuredSerializeInternal(entry.[[Key]], forStorage, memory)。
让 serializedValue 成为 ? StructuredSerializeInternal(entry.[[Value]], forStorage, memory)。
将 { [[Key]]: serializedKey, [[Value]]: serializedValue } 附加 到 serialized.[[MapData]]。
否则，如果 value 有 [[SetData]] 内部槽，则：
否则，如果 value 是一个 平台对象，且是一个 可序列化对象，则为 value 的 主接口 执行 序列化步骤，给定 value、serialized 和 forStorage。
序列化步骤 可能需要执行 子序列化。这是一个以值 subValue 为输入的操作，并返回 StructuredSerializeInternal(subValue, forStorage, memory)。（换句话说，一个 子序列化 是 StructuredSerializeInternal 在此次调用中的特化。）
否则，对于 ! EnumerableOwnProperties(value, key) 中的每个 key：
如果 ! HasOwnProperty(value, key) 为 true，则：
让 inputValue 成为 ? value.[[Get]](key, value)。
让 outputValue 成为 ? StructuredSerializeInternal(inputValue, forStorage, memory)。
将 { [[Key]]: key, [[Value]]: outputValue } 附加 到 serialized.[[Properties]]。
返回 serialized。
需要注意的是，记录由StructuredSerializeInternal生成的可能包含指向其他记录的“指针”，这些指针会创建循环引用。例如，当我们将以下 JavaScript 对象传递给StructuredSerializeInternal时：
const o = {};
o. myself = o; 它会生成以下结果：
{
[[Type]]: "Object",
[[Properties]]: «
{
[[Key]]: "myself",
[[Value]]: <a pointer to this whole structure>
}
»
}
返回 ? StructuredSerializeInternal(value, false)。
返回 ? StructuredSerializeInternal(value, true)。
结构化反序列化抽象操作接受一个记录serialized作为输入，该记录之前由结构化序列化或存储用结构化序列化生成，并将其反序列化为在targetRealm中创建的新JavaScript值。
此过程可能会抛出异常，例如在尝试为新对象（尤其是ArrayBuffer对象）分配内存时。
如果未提供memory，则将memory设为空的映射。
memory映射的目的是避免对象的两次反序列化。这最终保留了图中循环和重复对象的身份。
如果memory[serialized] 存在，则返回memory[serialized]。
将deep设为false。
将value设为未初始化的值。
如果serialized.[[Type]]是"primitive"，则将value设为serialized.[[Value]]。
否则，如果serialized.[[Type]]是"Boolean"，则将value设为在targetRealm中新的Boolean对象，其[[BooleanData]]内部槽值为serialized.[[BooleanData]]。
否则，如果serialized.[[Type]]是"Number"，则将value设为在targetRealm中新的Number对象，其[[NumberData]]内部槽值为serialized.[[NumberData]]。
否则，如果serialized.[[Type]]是"BigInt"，则将value设为在targetRealm中新的BigInt对象，其[[BigIntData]]内部槽值为serialized.[[BigIntData]]。
否则，如果serialized.[[Type]]是"String"，则将value设为在targetRealm中新的String对象，其[[StringData]]内部槽值为serialized.[[StringData]]。
否则，如果serialized.[[Type]]是"Date"，则将value设为在targetRealm中新的Date对象，其[[DateValue]]内部槽值为serialized.[[DateValue]]。
否则，如果serialized.[[Type]]是"RegExp"，则将value设为在targetRealm中新的RegExp对象，其[[RegExpMatcher]]内部槽值为serialized.[[RegExpMatcher]]，其[[OriginalSource]]内部槽值为serialized.[[OriginalSource]]，其[[OriginalFlags]]内部槽值为serialized.[[OriginalFlags]]。
否则，如果serialized.[[Type]]是"SharedArrayBuffer"，则：
如果targetRealm对应的代理集群不是serialized.[[AgentCluster]]，则抛出"DataCloneError" DOMException。
否则，将value设为在targetRealm中新的SharedArrayBuffer对象，其[[ArrayBufferData]]内部槽值为serialized.[[ArrayBufferData]]，其[[ArrayBufferByteLength]]内部槽值为serialized.[[ArrayBufferByteLength]]。
否则，如果serialized.[[Type]]是"GrowableSharedArrayBuffer"，则：
如果targetRealm对应的代理集群不是serialized.[[AgentCluster]]，则抛出"DataCloneError" DOMException。
否则，将value设为在targetRealm中新的SharedArrayBuffer对象，其[[ArrayBufferData]]内部槽值为serialized.[[ArrayBufferData]]，其[[ArrayBufferByteLengthData]]内部槽值为serialized.[[ArrayBufferByteLengthData]]，其[[ArrayBufferMaxByteLength]]内部槽值为serialized.[[ArrayBufferMaxByteLength]]。
否则，如果serialized.[[Type]]是"ArrayBuffer"，则将value设为在targetRealm中新的ArrayBuffer对象，其[[ArrayBufferData]]内部槽值为serialized.[[ArrayBufferData]]，其[[ArrayBufferByteLength]]内部槽值为serialized.[[ArrayBufferByteLength]]。
如果这抛出了异常，捕获它，然后抛出"DataCloneError" DOMException。
如果没有足够的内存可用来创建这样的ArrayBuffer对象，此步骤可能会抛出异常。
否则，如果serialized.[[Type]]是"ResizableArrayBuffer"，则将value设为在targetRealm中新的ArrayBuffer对象，其[[ArrayBufferData]]内部槽值为serialized.[[ArrayBufferData]]，其[[ArrayBufferByteLength]]内部槽值为serialized.[[ArrayBufferByteLength]]，其[[ArrayBufferMaxByteLength]]内部槽值为serialized.[[ArrayBufferMaxByteLength]]。
如果这抛出了异常，捕获它，然后抛出"DataCloneError" DOMException。
如果没有足够的内存可用来创建这样的ArrayBuffer对象，此步骤可能会抛出异常。
否则，如果serialized.[[Type]]是"ArrayBufferView"，则：
让deserializedArrayBuffer为? 结构化反序列化(serialized.[[ArrayBufferSerialized]], targetRealm, memory)。
如果serialized.[[Constructor]]是"DataView"，则将value设为在targetRealm中新的DataView对象，其[[ViewedArrayBuffer]]内部槽值为deserializedArrayBuffer，其[[ByteLength]]内部槽值为serialized.[[ByteLength]]，其[[ByteOffset]]内部槽值为serialized.[[ByteOffset]]。
否则，将value设为在targetRealm中新的类型数组对象，使用serialized.[[Constructor]]给定的构造函数，其[[ViewedArrayBuffer]]内部槽值为deserializedArrayBuffer，其[[TypedArrayName]]内部槽值为serialized.[[Constructor]]，其[[ByteLength]]内部槽值为serialized.[[ByteLength]]，其[[ByteOffset]]内部槽值为serialized.[[ByteOffset]]，其[[ArrayLength]]内部槽值为serialized.[[ArrayLength]]。
否则，如果serialized.[[Type]]是"Map"，则：
将value设为在targetRealm中新的Map对象，其[[MapData]]内部槽值为新的空列表。
将deep设为true。
否则，如果serialized.[[Type]]是"Set"，则：
将value设为在targetRealm中新的Set对象，其[[SetData]]内部槽值为新的空列表。
将deep设为true。
否则，如果serialized.[[Type]]是"Array"，则：
让outputProto为targetRealm.[[Intrinsics]].[[%Array.prototype%]]。
将value设为! 数组创建(serialized.[[Length]], outputProto)。
将deep设为true。
否则，如果serialized.[[Type]]是"Object"，则：
将value设为在targetRealm中的新对象。
将deep设为true。
否则，如果serialized.[[Type]]是"Error"，则：
让prototype为%Error.prototype%。
如果serialized.[[Name]]是"EvalError"，则将prototype设为%EvalError.prototype%。
如果serialized.[[Name]]是"RangeError"，则将prototype设为%RangeError.prototype%。
如果serialized.[[Name]]是"ReferenceError"，则将prototype设为%ReferenceError.prototype%。
如果serialized.[[Name]]是"SyntaxError"，则将prototype设为%SyntaxError.prototype%。
如果serialized.[[Name]]是"TypeError"，则将prototype设为%TypeError.prototype%。
如果serialized.[[Name]]是"URIError"，则将prototype设为%URIError.prototype%。
让 message为serialized.[[Message]]。
将value设为普通对象创建(prototype，«[[ErrorData]]»)。
让messageDesc为属性描述符{[[Value]]: message, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: true}。
如果message不为undefined，则执行! 普通定义自有属性(value, "message",
messageDesc)。
任何附加到serialized上的有趣的附加数据都应该被反序列化并附加到value上。
否则：
让interfaceName为serialized.[[Type]]。
如果interfaceName标识的接口在targetRealm中不是暴露的，则抛出"DataCloneError" DOMException。
将value设为在targetRealm中创建的由interfaceName标识的接口的新实例。
将deep设为true。
设置 memory[serialized]为value。
如果deep为true，则：
如果serialized.[[Type]]是"Map"，则：
否则，如果serialized.[[Type]]是"Set"，则：
否则，如果serialized.[[Type]]是"Array"或"Object"，则：
否则：
返回value。
让 memory 为一个空的map。
除了 StructuredSerializeInternal 正常使用外，在这个算法中 memory 还用于确保 StructuredSerializeInternal 忽略 transferList 中的项目，并让我们自己处理。
对于每个 transferable 的 transferList：
如果 transferable 既没有 [[ArrayBufferData]] 内部槽也没有[[Detached]] 内部槽，则抛出 "DataCloneError" DOMException。
如果 transferable 具有 [[ArrayBufferData]] 内部槽且 IsSharedArrayBuffer(transferable) 为真，则抛出 "DataCloneError" DOMException。
如果 memory[transferable] 存在，则抛出 "DataCloneError" DOMException。
设置 memory[transferable] 为 {[[Type]]: 未初始化的值}。
transferable 尚未传输，因为传输有副作用，并且 StructuredSerializeInternal 需要先能够抛出。
让 serialized 为 ? StructuredSerializeInternal(value, false, memory)。
让 transferDataHolders 为一个新的空的 List。
对于每个 transferable 的 transferList：
如果 transferable 具有 [[ArrayBufferData]] 内部槽且 IsDetachedBuffer(transferable) 为真，则抛出 "DataCloneError" DOMException。
如果 transferable 具有 [[Detached]] 内部槽且 transferable.[[Detached]]
为真，则抛出 "DataCloneError" DOMException。
让 dataHolder 为 memory[transferable]。
如果 transferable 具有 [[ArrayBufferData]] 内部槽，则：
如果 transferable 具有 [[ArrayBufferMaxByteLength]] 内部槽，则：
将 dataHolder.[[Type]] 设为 "ResizableArrayBuffer"。
将 dataHolder.[[ArrayBufferData]] 设为 transferable.[[ArrayBufferData]]。
将 dataHolder.[[ArrayBufferByteLength]] 设为 transferable.[[ArrayBufferByteLength]]。
将 dataHolder.[[ArrayBufferMaxByteLength]] 设为 transferable.[[ArrayBufferMaxByteLength]]。
否则：
将 dataHolder.[[Type]] 设为 "ArrayBuffer"。
将 data Holder.[[ArrayBufferData]] 设为 transferable.[[ArrayBufferData]]。
将 dataHolder.[[ArrayBufferByteLength]] 设为 transferable.[[ArrayBufferByteLength]]。
执行 ? DetachArrayBuffer(transferable)。
规范可以使用 [[ArrayBufferDetachKey]] 内部槽来防止 ArrayBuffer
被分离。例如，这在 WebAssembly JavaScript Interface 中使用。[WASMJS]
否则：
追加 dataHolder 到 transferDataHolders。
返回 { [[Serialized]]: serialized, [[TransferDataHolders]]: transferDataHolders }。
让 memory 为一个空的map。
类似于 StructuredSerializeWithTransfer，除了正常被 StructuredDeserialize 使用外，在这个算法中 memory 还用于确保 StructuredDeserialize 忽略 serializeWithTransferResult.[[TransferDataHolders]] 中的项目，让我们自己进行处理。
让 transferredValues 为一个新的空的List。
对于每个 transferDataHolder 的 serializeWithTransferResult.[[TransferDataHolders]]：
让 value 为一个未初始化的值。
如果 transferDataHolder.[[Type]] 是 "ArrayBuffer"，则将 value 设为在 targetRealm 中创建的新 ArrayBuffer 对象，其 [[ArrayBufferData]] 内部槽值为 transferDataHolder.[[ArrayBufferData]]，且 [[ArrayBufferByteLength]] 内部槽值为 transferDataHolder.[[ArrayBufferByteLength]]。
在原始内存仍可访问的情况下，这一步骤不太可能抛出异常，因为不需要分配新的内存：[[ArrayBufferData]] 占用的内存只是被转移到新的 ArrayBuffer 中。这可能在源和目标领域在同一进程中时为真。
否则，如果 transferDataHolder.[[Type]] 是 "ResizableArrayBuffer"，则将 value 设为在 targetRealm 中创建的新 ArrayBuffer 对象，其 [[ArrayBufferData]] 内部槽值为 transferDataHolder.[[ArrayBufferData]]，[[ArrayBufferByteLength]] 内部槽值为 transferDataHolder.[[ArrayBufferByteLength]]，以及 [[ArrayBufferMaxByteLength]] 内部槽值为 transferDataHolder.[[ArrayBufferMaxByteLength]]。
与前一步相同，这一步骤也不太可能抛出异常。
否则：
让 interfaceName 为 transferDataHolder.[[Type]]。
如果由 interfaceName 标识的接口在 targetRealm 中不可用，则抛出 "DataCloneError"
DOMException。
将 value 设为在 targetRealm 中创建的由 interfaceName 标识的接口的新实例。
执行适当的接收转移步骤，针对由 interfaceName 标识的接口，给定 transferDataHolder 和 value。
设置 memory[transferDataHolder] 为 value。
追加 value 到 transferredValues。
让 deserialized 为 ? StructuredDeserialize(serializeWithTransferResult.[[Serialized]], targetRealm, memory)。
返回 { [[Deserialized]]: deserialized, [[TransferredValues]]: transferredValues }。
其他规范可以使用此处定义的抽象操作。以下提供了一些关于每个抽象操作通常何时有用的指导，并附有示例。
将一个值克隆到另一个realm，使用一个传输列表，但目标realm事先未知。在这种情况下，可以立即执行序列化步骤，而反序列化步骤则延迟到目标realm变得已知时再进行。
messagePort.postMessage()
使用这对抽象操作，因为直到MessagePort
已被发送后，目标realm才会变得已知。
创建一个给定值的realm独立快照，可以保存无限期的时间，然后在以后重新成为JavaScript值，可能多次。
StructuredSerializeForStorage
可用于预期要以持久方式存储序列化结果，而不是在realm之间传递。它在尝试序列化SharedArrayBuffer对象时会抛出异常，因为存储共享内存没有意义。同样，当给定一个具有自定义序列化步骤的平台对象时，forStorage参数为true时，它可能抛出异常或具有不同的行为。
history.pushState()
和 history.replaceState()
使用StructuredSerializeForStorage
作用于作者提供的状态对象，将它们作为序列化状态存储在相应的会话历史条目中。然后，StructuredDeserialize
被用来让history.state
属性返回原始状态对象的克隆。
broadcastChannel.postMessage()
在其输入上使用StructuredSerialize，然后对结果多次使用StructuredDeserialize，以便为每个广播目的地产生一个新的克隆。请注意，在多目的地情况下，传输是不合适的。
任何用于将JavaScript值持久化到文件系统的API也会在其输入上使用StructuredSerializeForStorage，并在其输出上使用StructuredDeserialize。
一般来说，调用点可能会传递Web IDL值而不是JavaScript值；这应该理解为在调用这些算法之前执行隐式转换为JavaScript值。
那些不是因为作者代码同步调用用户代理方法而调用的调用点，必须在调用StructuredSerialize、StructuredSerializeForStorage 或 StructuredSerializeWithTransfer抽象操作之前，做好适当的准备运行脚本和准备运行回调。这是必要的，因为序列化过程可以在其最终深度序列化步骤中调用作者定义的访问器，而这些访问器可能会调用依赖于正确设置entry和incumbent概念的操作。
window.postMessage()
在其参数上执行StructuredSerializeWithTransfer，但要小心立即在其算法的同步部分内执行。因此，它可以使用这些算法，而不需要准备运行脚本和准备运行回调。
相比之下，一个假设的API，使用