## 15 Obsolete features

### 15.1 Obsolete but conforming features

Features listed in this section will trigger warnings in conformance checkers.

Authors should not specify a `border` attribute on an `img` element. If the attribute is present, its value must be the string "`0`". CSS should be used instead.

Authors should not specify a `language` attribute on a `script` element. If the attribute is present, its value must be an ASCII case-insensitive match for the string "`JavaScript`" and either the `type` attribute must be omitted or its value must be an ASCII case-insensitive match for the string "`text/javascript`". The attribute should be entirely omitted instead (with the value "`JavaScript`", it has no effect), or replaced with use of the `type` attribute.

Authors should not specify the `name` attribute on `a` elements. If the attribute is present, its value must not be the empty string and must neither be equal to the value of any of the IDs in the element's home subtree other than the element's own ID, if any, nor be equal to the value of any of the other `name` attributes on `a` elements in the element's home subtree. If this attribute is present and the element has an ID, then the attribute's value must be equal to the element's ID. In earlier versions of the language, this attribute was intended as a way to specify possible targets for fragment identifiers in URLs. The `id` attribute should be used instead.

Authors should not, but may despite requirements to the contrary elsewhere in this specification, specify the `maxlength` and `size` attributes on `input` elements whose `type` attributes are in the Number state. One valid reason for using these attributes regardless is to help legacy user agents that do not support `input` elements with `type="number"` to still render the text field with a useful width.

In the HTML syntax, specifying a DOCTYPE that is an obsolete permitted DOCTYPE will also trigger a warning.

#### 15.1.1 Warnings for obsolete but conforming features

To ease the transition from HTML4 Transitional documents to the language defined in this specification, and to discourage certain features that are only allowed in very few circumstances, conformance checkers must warn the user when the following features are used in a document. These are generally old obsolete features that have no effect, and are allowed only to distinguish between likely mistakes (regular conformance errors) and mere vestigial markup or unusual and discouraged practices (these warnings).

The following features must be categorised as described above:

- The presence of an obsolete permitted DOCTYPE in an HTML document.

- The presence of a `border` attribute on an `img` element if its value is the string "`0`".

- The presence of a `language` attribute on a `script` element if its value is an ASCII case-insensitive match for the string "`JavaScript`" and if there is no `type` attribute or there is and its value is an ASCII case-insensitive match for the string "`text/javascript`".

- The presence of a `name` attribute on an `a` element, if its value is not the empty string.

- The presence of a `maxlength` attribute on an `input` element whose `type` attribute is in the Number state.

- The presence of a `size` attribute on an `input` element whose `type` attribute is in the Number state.

Conformance checkers must distinguish between pages that have no conformance errors and have none of these obsolete features, and pages that have no conformance errors but do have some of these obsolete features.

For example, a validator could report some pages as "Valid HTML" and others as "Valid HTML with warnings".

### 15.2 Non-conforming features

Elements in the following list are entirely obsolete, and must not be used by authors:

`applet`

  Use `embed` or `object` instead.

`acronym`

  Use `abbr` instead.

`bgsound`

  Use `audio` instead.

`dir`

  Use `ul` instead.

`frame`
`frameset`
`noframes`

  Either use `iframe` and CSS instead, or use server-side includes to generate complete pages with the various invariant parts merged in.

`isindex`

  Use an explicit `form` and text field combination instead.

`listing`

  Use `pre` and `code` instead.

`nextid`

  Use GUIDs instead.

`noembed`

  Use `object` instead of `embed` when fallback is necessary.

`plaintext`

  Use the "`text/plain`" MIME type instead.

`rb`

  Providing the ruby base directly inside the `ruby` element is sufficient; the `rb` element is unnecessary. Omit it altogether.

`strike`

  Use `del` instead if the element is marking an edit, otherwise use `s` instead.

`xmp`

  Use `pre` and `code` instead, and escape "`<`" and "`&`" characters as "`&lt;`" and "`&amp;`" respectively.

`basefont`
`big`
`blink`
`center`
`font`
`marquee`
`multicol`
`nobr`
`spacer`
`tt`

  Use appropriate elements or CSS instead.

  Where the `tt` element would have been used for marking up keyboard input, consider the `kbd` element; for variables, consider the `var` element; for computer code, consider the `code` element; and for computer output, consider the `samp` element.

  Similarly, if the `big` element is being used to denote a heading, consider using the `h1` element; if it is being used for marking up important passages, consider the `strong` element; and if it is being used for highlighting text for reference purposes, consider the `mark` element.

  See also the text-level semantics usage summary for more suggestions with examples.

The following attributes are obsolete (though the elements are still part of the language), and must not be used by authors:

`charset` on `a` elements
`charset` on `link` elements

  Use an HTTP Content-Type header on the linked resource instead.

`coords` on `a` elements
`shape` on `a` elements

  Use `area` instead of `a` for image maps.

`methods` on `a` elements
`methods` on `link` elements

  Use the HTTP OPTIONS feature instead.

`name` on `a` elements (except as noted in the previous section)
`name` on `embed` elements
`name` on `img` elements
`name` on `option` elements

  Use the `id` attribute instead.

`rev` on `a` elements
`rev` on `link` elements

  Use the `rel` attribute instead, with an opposite term. (For example, instead of `rev="made"`, use `rel="author"`.)

`urn` on `a` elements
`urn` on `link` elements

  Specify the preferred persistent identifier using the `href` attribute instead.

`accept` on `form` elements

  Use the `accept` attribute directly on the `input` elements instead.

`nohref` on `area` elements

  Omitting the `href` attribute is sufficient; the `nohref` attribute is unnecessary. Omit it altogether.

`profile` on `head` elements

  When used for declaring which `meta` terms are used in the document, unnecessary; omit it altogether, and register the names.

  When used for triggering specific user agent behaviours: use a `link` element instead.

`version` on `html` elements

  Unnecessary. Omit it altogether.

`ismap` on `input` elements

  Unnecessary. Omit it altogether. All `input` elements with a `type` attribute in the Image Button state are processed as server-side image maps.

`usemap` on `input` elements

  Use `img` instead of `input` for image maps.

`longdesc` on `iframe` elements
`longdesc` on `img` elements

  Use a regular `a` element to link to the description, or (in the case of images) use an image map to provide a link from the image to the image's description.

`lowsrc` on `img` elements

  Use a progressive JPEG image (given in the `src` attribute), instead of using two separate images.

`target` on `link` elements

  Unnecessary. Omit it altogether.

`scheme` on `meta` elements

  Use only one scheme per field, or make the scheme declaration part of the value.

`archive` on `object` elements
`classid` on `object` elements
`code` on `object` elements
`codebase` on `object` elements
`codetype` on `object` elements

  Use the `data` and `type` attributes to invoke plugins. To set parameters with these names in particular, the `param` element can be used.

`declare` on `object` elements

  Repeat the `object` element completely each time the resource is to be reused.

`standby` on `object` elements

  Optimise the linked resource so that it loads quickly or, at least, incrementally.

`type` on `param` elements
`valuetype` on `param` elements

  Use the `name` and `value` attributes without declaring value types.

`language` on `script` elements (except as noted in the previous section)

  Use the `type` attribute instead.

`event` on `script` elements
`for` on `script` elements

  Use DOM Events mechanisms to register event listeners. [DOM]

`media` on `source` elements

  Use script to select the media resource(s) to use.

`datapagesize` on `table` elements

  Unnecessary. Omit it altogether.

`summary` on `table` elements

  Use one of the techniques for describing tables given in the `table` section instead.

`abbr` on `td` elements

  Use text that begins in an unambiguous and terse manner, and include any more elaborate text after that. The `title` attribute can also be useful in including more detailed text, so that the cell's contents can be made terse. If it's a heading, use `th` (which has an `abbr` attribute).

`axis` on `td` and `th` elements

  Use the `scope` attribute on the relevant `th`.

`scope` on `td` elements

  Use `th` elements for heading cells.

`datasrc` on `a`, `applet`, `button`, `div`, `frame`, `iframe`, `img`, `input`, `label`, `legend`, `marquee`, `object`, `option`, `select`, `span`, `table`, and `textarea` elements
`datafld` on `a`, `applet`, `button`, `div`, `fieldset`, `frame`, `iframe`, `img`, `input`, `label`, `legend`, `marquee`, `object`, `param`, `select`, `span`, and `textarea` elements
`dataformatas` on `button`, `div`, `input`, `label`, `legend`, `marquee`, `object`, `option`, `select`, `span`, and `table` elements

  Use script and a mechanism such as `XMLHttpRequest` to populate the page dynamically. [XHR]

`alink` on `body` elements
`bgcolor` on `body` elements
`bottommargin` on `body` elements
`leftmargin` on `body` elements
`link` on `body` elements
`marginheight` on `body` elements
`marginwidth` on `body` elements
`rightmargin` on `body` elements
`text` on `body` elements
`margintop` on `body` elements
`vlink` on `body` elements
`clear` on `br` elements
`align` on `caption` elements
`align` on `col` elements
`char` on `col` elements
`charoff` on `col` elements
`valign` on `col` elements
`width` on `col` elements
`align` on `div` elements
`compact` on `dl` elements
`align` on `embed` elements
`hspace` on `embed` elements
`vspace` on `embed` elements
`align` on `hr` elements
`color` on `hr` elements
`noshade` on `hr` elements
`size` on `hr` elements
`width` on `hr` elements
`align` on `h1`—`h6` elements
`align` on `iframe` elements
`allowtransparency` on `iframe` elements
`frameborder` on `iframe` elements
`hspace` on `iframe` elements
`marginheight` on `iframe` elements
`marginwidth` on `iframe` elements
`scrolling` on `iframe` elements
`vspace` on `iframe` elements
`align` on `input` elements
`border` on `input` elements
`hspace` on `input` elements
`vspace` on `input` elements
`align` on `img` elements
`border` on `img` elements (except as noted in the previous section)
`hspace` on `img` elements
`vspace` on `img` elements
`align` on `legend` elements
`type` on `li` elements
`compact` on `menu` elements
`align` on `object` elements
`border` on `object` elements
`hspace` on `object` elements
`vspace` on `object` elements
`compact` on `ol` elements
`align` on `p` elements
`width` on `pre` elements
`align` on `table` elements
`bgcolor` on `table` elements
`border` on `table` elements
`bordercolor` on `table` elements
`cellpadding` on `table` elements
`cellspacing` on `table` elements
`frame` on `table` elements
`height` on `table` elements
`hspace` on `table` elements
`rules` on `table` elements
`vspace` on `table` elements
`width` on `table` elements
`align` on `tbody`, `thead`, and `tfoot` elements
`char` on `tbody`, `thead`, and `tfoot` elements
`charoff` on `tbody`, `thead`, and `tfoot` elements
`valign` on `tbody`, `thead`, and `tfoot` elements
`align` on `td` and `th` elements
`bgcolor` on `td` and `th` elements
`char` on `td` and `th` elements
`charoff` on `td` and `th` elements
`height` on `td` and `th` elements
`nowrap` on `td` and `th` elements
`valign` on `td` and `th` elements
`width` on `td` and `th` elements
`align` on `tr` elements
`bgcolor` on `tr` elements
`char` on `tr` elements
`charoff` on `tr` elements
`height` on `tr` elements
`valign` on `tr` elements
`compact` on `ul` elements
`type` on `ul` elements
`background` on `body`, `table`, `thead`, `tbody`, `tfoot`, `tr`, `td`, and `th` elements

  Use CSS instead.

### 15.3 Requirements for implementations

#### 15.3.1 The `applet` element

The `applet` element is a Java-specific variant of the `embed` element. The `applet` element is now obsoleted so that all extension frameworks (Java, .NET, Flash, etc) are handled in a consistent manner.

When the element matches any of the following conditions, it represents its contents:

- The element is still in the stack of open elements of an HTML parser or XML parser.
- The element is not in a `Document`.
- The element's node document is not fully active.
- The element's node document's active sandboxing flag set has its sandboxed plugins browsing context flag set.
- The element has an ancestor media element.
- The element has an ancestor `object` element that is not showing its fallback content.
- No Java Language runtime plugin is available.
- A Java runtime plugin is available but it is disabled.

Otherwise, the user agent should instantiate a Java Language runtime plugin, and should pass the names and values of all the attributes on the element, in the order they were added to the element, with the attributes added by the parser being ordered in source order, and then a parameter named "PARAM" whose value is null, and then all the names and values of parameters given by `param` elements that are children of the `applet` element, in tree order, to the plugin used. If the plugin supports a scriptable interface, the `HTMLAppletElement` object representing the element should expose that interface. The `applet` element represents the plugin.

The `applet` element is unaffected by the CSS 'display' property. The Java Language runtime is instantiated even if the element is hidden with a 'display:none' CSS style.

The `applet` element must implement the `HTMLAppletElement` interface.

    interface HTMLAppletElement : HTMLElement {
      attribute DOMString align;
      attribute DOMString alt;
      attribute DOMString archive;
      attribute DOMString code;
      attribute DOMString codeBase;
      attribute DOMString height;
      attribute unsigned long hspace;
      attribute DOMString name;
      attribute DOMString _object; // the underscore is not part of the identifier
      attribute unsigned long vspace;
      attribute DOMString width;
    };

The `align`, `alt`, `archive`, `code`, `height`, `hspace`, `name`, `object`, `vspace`, and `width` IDL attributes must reflect the respective content attributes of the same name. For the purposes of reflection, the `applet` element's `object` content attribute is defined as containing a URL.

The `codeBase` IDL attribute must reflect the `codebase` content attribute, which for the purposes of reflection is defined as containing a URL.

#### 15.3.2 The `marquee` element

The `marquee` element is a presentational element that animates content. CSS transitions and animations are a more appropriate mechanism. [CSSANIMATIONS] [CSSTRANSITIONS]

The task source for tasks mentioned in this section is the DOM manipulation task source.

The `marquee` element must implement the `HTMLMarqueeElement` interface.

    interface HTMLMarqueeElement : HTMLElement {
      attribute DOMString behavior;
      attribute DOMString bgColor;
      attribute DOMString direction;
      attribute DOMString height;
      attribute unsigned long hspace;
      attribute long loop;
      attribute unsigned long scrollAmount;
      attribute unsigned long scrollDelay;
      attribute boolean trueSpeed;
      attribute unsigned long vspace;
      attribute DOMString width;

      attribute EventHandler onbounce;
      attribute EventHandler onfinish;
      attribute EventHandler onstart;

      void start();
      void stop();
    };

A `marquee` element can be turned on or turned off. When it is created, it is turned on.

When the `start()` method is called, the `marquee` element must be turned on.

When the `stop()` method is called, the `marquee` element must be turned off.

When a `marquee` element is created, the user agent must queue a task to fire a simple event named `start` at the element.

The `behavior` content attribute on `marquee` elements is an enumerated attribute with the following keywords (all non-conforming):

Keyword | State
--- | ---
`scroll` | scroll
`slide` | slide
`alternate` | alternate

The missing value default is the scroll state.

The `direction` content attribute on `marquee` elements is an enumerated attribute with the following keywords (all non-conforming):

Keyword | State
--- | ---
`left` | left
`right` | right
`up` | up
`down` | down

The missing value default is the left state.

The `truespeed` content attribute on `marquee` elements is a boolean attribute.

A `marquee` element has a marquee scroll interval, which is obtained as follows:

1. If the element has a `scrolldelay` attribute, and parsing its value using the rules for parsing non-negative integers does not return an error, then let delay be the parsed value. Otherwise, let delay be 85.

2. If the element does not have a `truespeed` attribute, and the delay value is less than 60, then let delay be 60 instead.

3. The marquee scroll interval is delay, interpreted in milliseconds.

A `marquee` element has a marquee scroll distance, which, if the element has a `scrollamount` attribute, and parsing its value using the rules for parsing non-negative integers does not return an error, is the parsed value interpreted in CSS pixels, and otherwise is 6 CSS pixels.

A `marquee` element has a marquee loop count, which, if the element has a `loop` attribute, and parsing its value using the rules for parsing integers does not return an error or a number less than 1, is the parsed value, and otherwise is −1.

The `loop` IDL attribute, on getting, must return the element's marquee loop count; and on setting, if the new value is different than the element's marquee loop count and either greater than zero or equal to −1, must set the element's `loop` content attribute (adding it if necessary) to the valid integer that represents the new value. (Other values are ignored.)

A `marquee` element also has a marquee current loop index, which is zero when the element is created.

The rendering layer will occasionally increment the marquee current loop index, which must cause the following steps to be run:

1. If the marquee loop count is −1, then abort these steps.

2. Increment the marquee current loop index by one.

3. If the marquee current loop index is now equal to or greater than the element's marquee loop count, turn off the `marquee` element and queue a task to fire a simple event named `finish` at the `marquee` element.

   Otherwise, if the `behavior` attribute is in the alternate state, then queue a task to fire a simple event named `bounce` at the `marquee` element.

   Otherwise, queue a task to fire a simple event named `start` at the `marquee` element.

The following are the event handlers (and their corresponding event handler event types) that must be supported, as event handler content attributes and event handler IDL attributes, by `marquee` elements:

Event handler | Event handler event type
--- | ---
`onbounce` | `bounce`
`onfinish` | `finish`
`onstart` | `start`

The `behavior`, `direction`, `height`, `hspace`, `vspace`, and `width` IDL attributes must reflect the respective content attributes of the same name.

The `bgColor` IDL attribute must reflect the `bgcolor` content attribute.

The `scrollAmount` IDL attribute must reflect the `scrollamount` content attribute. The default value is 6.

The `scrollDelay` IDL attribute must reflect the `scrolldelay` content attribute. The default value is 85.

The `trueSpeed` IDL attribute must reflect the `truespeed` content attribute.

#### 15.3.3 Frames

The `frameset` element acts as the body element in documents that use frames.

The `frameset` element must implement the `HTMLFrameSetElement` interface.

    interface HTMLFrameSetElement : HTMLElement {
      attribute DOMString cols;
      attribute DOMString rows;
    };
    HTMLFrameSetElement implements WindowEventHandlers;

The `cols` and `rows` IDL attributes of the `frameset` element must reflect the respective content attributes of the same name.

The `frameset` element exposes as event handler content attributes a number of the event handlers of the `Window` object. It also mirrors their event handler IDL attributes.

The `onblur`, `onerror`, `onfocus`, `onload`, `onresize`, and `onscroll` event handlers of the `Window` object, exposed on the `frameset` element, replace the generic event handlers with the same names normally supported by HTML elements.

The `frame` element defines a nested browsing context similar to the `iframe` element, but rendered within a `frameset` element.

A `frame` element is said to be an active `frame` element when it is in a `Document`.

When a `frame` element is created as an active `frame` element, or becomes an active `frame` element after not having been one, the user agent must create a nested browsing context, and then process the `frame` attributes for the first time.

When a `frame` element stops being an active `frame` element, the user agent must discard the nested browsing context.

Whenever a `frame` element with a nested browsing context has its `src` attribute set, changed, or removed, the user agent must process the `frame` attributes.

When the user agent is to process the `frame` attributes, it must run the first appropriate steps from the following list:

If the element has no `src` attribute specified, and the user agent is processing the `frame`'s attributes for the first time

  Queue a task to fire a simple event named `load` at the `frame` element.

Otherwise

  1. If the value of the `src` attribute is the empty string, let url be the string "`about:blank`".

     Otherwise, resolve the value of the `src` attribute, relative to the `frame` element.

     If that is not successful, then let url be the string "`about:blank`". Otherwise, let url be the resulting absolute URL.

  2. Navigate the element's child browsing context to url.

Any navigation required of the user agent in the process the `frame` attributes algorithm must be completed as an explicit self-navigation override and with the `frame` element's node document's browsing context as the source browsing context.

Furthermore, if the active document of the element's child browsing context before such a navigation was not completely loaded at the time of the new navigation, then the navigation must be completed with replacement enabled.

Similarly, if the child browsing context's session history contained only one `Document` when the process the `frame` attributes algorithm was invoked, and that was the `about:blank` `Document` created when the child browsing context was created, then any navigation required of the user agent in that algorithm must be completed with replacement enabled.

When a `Document` in a `frame` is marked as completely loaded, the user agent must queue a task to fire a simple event named `load` at the `frame` element.

The task source for the tasks above is the DOM manipulation task source.

When a `frame` element's nested browsing context's active document is not ready for post-load tasks, and when anything is delaying the load event of the `frame` element's browsing context's active document, and when the `frame` element's browsing context is in the delaying `load` events mode, the `frame` must delay the load event of its document.

When the browsing context is created, if a `name` attribute is present, the browsing context name must be set to the value of this attribute; otherwise, the browsing context name must be set to the empty string.

Whenever the `name` attribute is set, the nested browsing context's name must be changed to the new value. If the attribute is removed, the browsing context name must be set to the empty string.

The `frame` element must implement the `HTMLFrameElement` interface.

    interface HTMLFrameElement : HTMLElement {
      attribute DOMString name;
      attribute DOMString scrolling;
      attribute DOMString src;
      attribute DOMString frameBorder;
      attribute DOMString longDesc;
      attribute boolean noResize;
      readonly attribute Document? contentDocument;
      readonly attribute WindowProxy? contentWindow;

      [TreatNullAs=EmptyString] attribute DOMString marginHeight;
      [TreatNullAs=EmptyString] attribute DOMString marginWidth;
    };

The `name`, `scrolling`, and `src` IDL attributes of the `frame` element must reflect the respective content attributes of the same name. For the purposes of reflection, the `frame` element's `src` content attribute is defined as containing a URL.

The `frameBorder` IDL attribute of the `frame` element must reflect the element's `frameborder` content attribute.

The `longDesc` IDL attribute of the `frame` element must reflect the element's `longdesc` content attribute, which for the purposes of reflection is defined as containing a URL.

The `noResize` IDL attribute of the `frame` element must reflect the element's `noresize` content attribute.

The `contentDocument` IDL attribute of the `frame` element must return the `Document` object of the active document of the `frame` element's nested browsing context, if any and if its effective script origin is the same origin as the effective script origin specified by the incumbent settings object, or null otherwise.

The `contentWindow` IDL attribute must return the `WindowProxy` object of the `frame` element's nested browsing context.

The `marginHeight` IDL attribute of the `frame` element must reflect the element's `marginheight` content attribute.

The `marginWidth` IDL attribute of the `frame` element must reflect the element's `marginwidth` content attribute.

#### 15.3.4 Other elements, attributes and APIs

User agents must treat `acronym` elements in a manner equivalent to `abbr` elements in terms of semantics and for purposes of rendering.

    partial interface HTMLAnchorElement {
      attribute DOMString coords;
      attribute DOMString charset;
      attribute DOMString name;
      attribute DOMString rev;
      attribute DOMString shape;
    };

The `coords`, `charset`, `name`, `rev`, and `shape` IDL attributes of the `a` element must reflect the respective content attributes of the same name.

    partial interface HTMLAreaElement {
      attribute boolean noHref;
    };

The `noHref` IDL attribute of the `area` element must reflect the element's `nohref` content attribute.

    partial interface HTMLBodyElement {
      [TreatNullAs=EmptyString] attribute DOMString text;
      [TreatNullAs=EmptyString] attribute DOMString link;
      [TreatNullAs=EmptyString] attribute DOMString vLink;
      [TreatNullAs=EmptyString] attribute DOMString aLink;
      [TreatNullAs=EmptyString] attribute DOMString bgColor;
                       attribute DOMString background;
    };

The `text` IDL attribute of the `body` element must reflect the element's `text` content attribute.

The `link` IDL attribute of the `body` element must reflect the element's `link` content attribute.

The `aLink` IDL attribute of the `body` element must reflect the element's `alink` content attribute.

The `vLink` IDL attribute of the `body` element must reflect the element's `vlink` content attribute.

The `bgColor` IDL attribute of the `body` element must reflect the element's `bgcolor` content attribute.

The `background` IDL attribute of the `body` element must reflect the element's `background` content attribute. (The `background` content is not defined to contain a URL, despite rules regarding its handling in the rendering section above.)

    partial interface HTMLBRElement {
      attribute DOMString clear;
    };

The `clear` IDL attribute of the `br` element must reflect the content attribute of the same name.

    partial interface HTMLTableCaptionElement {
      attribute DOMString align;
    };

The `align` IDL attribute of the `caption` element must reflect the content attribute of the same name.

    partial interface HTMLTableColElement {
      attribute DOMString align;
      attribute DOMString ch;
      attribute DOMString chOff;
      attribute DOMString vAlign;
      attribute DOMString width;
    };

The `align` and `width` IDL attributes of the `col` element must reflect the respective content attributes of the same name.

The `ch` IDL attribute of the `col` element must reflect the element's `char` content attribute.

The `chOff` IDL attribute of the `col` element must reflect the element's `charoff` content attribute.

The `vAlign` IDL attribute of the `col` element must reflect the element's `valign` content attribute.

User agents must treat `dir` elements in a manner equivalent to `ul` elements in terms of semantics and for purposes of rendering.

The `dir` element must implement the `HTMLDirectoryElement` interface.

    interface HTMLDirectoryElement : HTMLElement {
      attribute boolean compact;
    };

The `compact` IDL attribute of the `dir` element must reflect the content attribute of the same name.

    partial interface HTMLDivElement {
      attribute DOMString align;
    };

The `align` IDL attribute of the `div` element must reflect the content attribute of the same name.

    partial interface HTMLDListElement {
      attribute boolean compact;
    };

The `compact` IDL attribute of the `dl` element must reflect the content attribute of the same name.

    partial interface HTMLEmbedElement {
      attribute DOMString align;
      attribute DOMString name;
    };

The `name` and `align` IDL attributes of the `embed` element must reflect the respective content attributes of the same name.

The `font` element must implement the `HTMLFontElement` interface.

    interface HTMLFontElement : HTMLElement {
      [TreatNullAs=EmptyString] attribute DOMString color;
                       attribute DOMString face;
                       attribute DOMString size;
    };

The `color`, `face`, and `size` IDL attributes of the `font` element must reflect the respective content attributes of the same name.

    partial interface HTMLHeadingElement {
      attribute DOMString align;
    };

The `align` IDL attribute of the `h1`–`h6` elements must reflect the content attribute of the same name.

The `profile` IDL attribute on `head` elements (with the `HTMLHeadElement` interface) is intentionally omitted. Unless so required by another applicable specification, implementations would therefore not support this attribute. (It is mentioned here as it was defined in a previous version of the DOM specifications.)

    partial interface HTMLHRElement {
      attribute DOMString align;
      attribute DOMString color;
      attribute boolean noShade;
      attribute DOMString size;
      attribute DOMString width;
    };

The `align`, `color`, `size`, and `width` IDL attributes of the `hr` element must reflect the respective content attributes of the same name.

The `noShade` IDL attribute of the `hr` element must reflect the element's `noshade` content attribute.

    partial interface HTMLHtmlElement {
      attribute DOMString version;
    };

The `version` IDL attribute of the `html` element must reflect the content attribute of the same name.

    partial interface HTMLIFrameElement {
      attribute DOMString align;
      attribute DOMString scrolling;
      attribute DOMString frameBorder;
      attribute DOMString longDesc;

      [TreatNullAs=EmptyString] attribute DOMString marginHeight;
      [TreatNullAs=EmptyString] attribute DOMString marginWidth;
    };

The `align` and `scrolling` IDL attributes of the `iframe` element must reflect the respective content attributes of the same name.

The `frameBorder` IDL attribute of the `iframe` element must reflect the element's `frameborder` content attribute.

The `longDesc` IDL attribute of the `iframe` element must reflect the element's `longdesc` content attribute, which for the purposes of reflection is defined as containing a URL.

The `marginHeight` IDL attribute of the `iframe` element must reflect the element's `marginheight` content attribute.

The `marginWidth` IDL attribute of the `iframe` element must reflect the element's `marginwidth` content attribute.

    partial interface HTMLImageElement {
      attribute DOMString name;
      attribute DOMString lowsrc;
      attribute DOMString align;
      attribute unsigned long hspace;
      attribute unsigned long vspace;
      attribute DOMString longDesc;

      [TreatNullAs=EmptyString] attribute DOMString border;
    };

The `name`, `align`, `border`, `hspace`, and `vspace` IDL attributes of the `img` element must reflect the respective content attributes of the same name.

The `longDesc` IDL attribute of the `img` element must reflect the element's `longdesc` content attribute, which for the purposes of reflection is defined as containing a URL.

The `lowsrc` IDL attribute of the `img` element must reflect the element's `lowsrc` content attribute, which for the purposes of reflection is defined as containing a URL.

    partial interface HTMLInputElement {
      attribute DOMString align;
      attribute DOMString useMap;
    };

The `align` IDL attribute of the `input` element must reflect the content attribute of the same name.

The `useMap` IDL attribute of the `input` element must reflect the element's `usemap` content attribute.

    partial interface HTMLLegendElement {
      attribute DOMString align;
    };

The `align` IDL attribute of the `legend` element must reflect the content attribute of the same name.

    partial interface HTMLLIElement {
      attribute DOMString type;
    };

The `type` IDL attribute of the `li` element must reflect the content attribute of the same name.

    partial interface HTMLLinkElement {
      attribute DOMString charset;
      attribute DOMString rev;
      attribute DOMString target;
    };

The `charset`, `rev`, and `target` IDL attributes of the `link` element must reflect the respective content attributes of the same name.

User agents must treat `listing` elements in a manner equivalent to `pre` elements in terms of semantics and for purposes of rendering.

    partial interface HTMLMenuElement {
      attribute boolean compact;
    };

The `compact` IDL attribute of the `menu` element must reflect the content attribute of the same name.

    partial interface HTMLMetaElement {
      attribute DOMString scheme;
    };

User agents may treat the `scheme` content attribute on the `meta` element as an extension of the element's `name` content attribute when processing a `meta` element with a `name` attribute whose value is one that the user agent recognizes as supporting the `scheme` attribute.

User agents are encouraged to ignore the `scheme` attribute and instead process the value given to the metadata name as if it had been specified for each expected value of the `scheme` attribute.

For example, if the user agent acts on `meta` elements with `name` attributes having the value "eGMS.subject.keyword", and knows that the `scheme` attribute is used with this metadata name, then it could take the `scheme` attribute into account, acting as if it was an extension of the `name` attribute. Thus the following two `meta` elements could be treated as two elements giving values for two different metadata names, one consisting of a combination of "eGMS.subject.keyword" and "LGCL", and the other consisting of a combination of "eGMS.subject.keyword" and "ORLY":

    <!-- this markup is invalid -->
    <meta name="eGMS.subject.keyword" scheme="LGCL" content="Abandoned vehicles">
    <meta name="eGMS.subject.keyword" scheme="ORLY" content="Mah car: kthxbye">

The suggested processing of this markup, however, would be equivalent to the following:

    <meta name="eGMS.subject.keyword" content="Abandoned vehicles">
    <meta name="eGMS.subject.keyword" content="Mah car: kthxbye">

The `scheme` IDL attribute of the `meta` element must reflect the content attribute of the same name.

    partial interface HTMLObjectElement {
      attribute DOMString align;
      attribute DOMString archive;
      attribute DOMString code;
      attribute boolean declare;
      attribute unsigned long hspace;
      attribute DOMString standby;
      attribute unsigned long vspace;
      attribute DOMString codeBase;
      attribute DOMString codeType;

      [TreatNullAs=EmptyString] attribute DOMString border;
    };

The `align`, `archive`, `border`, `code`, `declare`, `hspace`, `standby`, and `vspace` IDL attributes of the `object` element must reflect the respective content attributes of the same name.

The `codeBase` IDL attribute of the `object` element must reflect the element's `codebase` content attribute, which for the purposes of reflection is defined as containing a URL.

The `codeType` IDL attribute of the `object` element must reflect the element's `codetype` content attribute.

    partial interface HTMLOListElement {
      attribute boolean compact;
    };

The `compact` IDL attribute of the `ol` element must reflect the content attribute of the same name.

    partial interface HTMLParagraphElement {
      attribute DOMString align;
    };

The `align` IDL attribute of the `p` element must reflect the content attribute of the same name.

    partial interface HTMLParamElement {
      attribute DOMString type;
      attribute DOMString valueType;
    };

The `type` IDL attribute of the `param` element must reflect the content attribute of the same name.

The `valueType` IDL attribute of the `param` element must reflect the element's `valuetype` content attribute.

User agents must treat `plaintext` elements in a manner equivalent to `pre` elements in terms of semantics and for purposes of rendering. (The parser has special behaviour for this element, though.)

    partial interface HTMLPreElement {
      attribute long width;
    };

The `width` IDL attribute of the `pre` element must reflect the content attribute of the same name.

    partial interface HTMLScriptElement {
      attribute DOMString event;
      attribute DOMString htmlFor;
    };

The `event` and `htmlFor` IDL attributes of the `script` element must return the empty string on getting, and do nothing on setting.

    partial interface HTMLTableElement {
      attribute DOMString align;
      attribute DOMString border;
      attribute DOMString frame;
      attribute DOMString rules;
      attribute DOMString summary;
      attribute DOMString width;

      [TreatNullAs=EmptyString] attribute DOMString bgColor;
      [TreatNullAs=EmptyString] attribute DOMString cellPadding;
      [TreatNullAs=EmptyString] attribute DOMString cellSpacing;
    };

The `align`, `border`, `frame`, `summary`, `rules`, and `width`, IDL attributes of the `table` element must reflect the respective content attributes of the same name.

The `bgColor` IDL attribute of the `table` element must reflect the element's `bgcolor` content attribute.

The `cellPadding` IDL attribute of the `table` element must reflect the element's `cellpadding` content attribute.

The `cellSpacing` IDL attribute of the `table` element must reflect the element's `cellspacing` content attribute.

    partial interface HTMLTableSectionElement {
      attribute DOMString align;
      attribute DOMString ch;
      attribute DOMString chOff;
      attribute DOMString vAlign;
    };

The `align` IDL attribute of the `tbody`, `thead`, and `tfoot` elements must reflect the content attribute of the same name.

The `ch` IDL attribute of the `tbody`, `thead`, and `tfoot` elements must reflect the elements' `char` content attributes.

The `chOff` IDL attribute of the `tbody`, `thead`, and `tfoot` elements must reflect the elements' `charoff` content attributes.

The `vAlign` IDL attribute of the `tbody`, `thead`, and `tfoot` element must reflect the elements' `valign` content attributes.

    partial interface HTMLTableCellElement {
      attribute DOMString align;
      attribute DOMString axis;
      attribute DOMString height;
      attribute DOMString width;

      attribute DOMString ch;
      attribute DOMString chOff;
      attribute boolean noWrap;
      attribute DOMString vAlign;

      [TreatNullAs=EmptyString] attribute DOMString bgColor;
    };

The `align`, `axis`, `height`, and `width` IDL attributes of the `td` and `th` elements must reflect the respective content attributes of the same name.

The `ch` IDL attribute of the `td` and `th` elements must reflect the elements' `char` content attributes.

The `chOff` IDL attribute of the `td` and `th` elements must reflect the elements' `charoff` content attributes.

The `noWrap` IDL attribute of the `td` and `th` elements must reflect the elements' `nowrap` content attributes.

The `vAlign` IDL attribute of the `td` and `th` element must reflect the elements' `valign` content attributes.

The `bgColor` IDL attribute of the `td` and `th` elements must reflect the elements' `bgcolor` content attributes.

    partial interface HTMLTableDataCellElement {
      attribute DOMString abbr;
    };

The `abbr` IDL attribute of the `td` element must reflect the respective content attributes of the same name.

    partial interface HTMLTableRowElement {
      attribute DOMString align;
      attribute DOMString ch;
      attribute DOMString chOff;
      attribute DOMString vAlign;

      [TreatNullAs=EmptyString] attribute DOMString bgColor;
    };

The `align` IDL attribute of the `tr` element must reflect the content attribute of the same name.

The `ch` IDL attribute of the `tr` element must reflect the element's `char` content attribute.

The `chOff` IDL attribute of the `tr` element must reflect the element's `charoff` content attribute.

The `vAlign` IDL attribute of the `tr` element must reflect the element's `valign` content attribute.

The `bgColor` IDL attribute of the `tr` element must reflect the element's `bgcolor` content attribute.

    partial interface HTMLUListElement {
      attribute boolean compact;
      attribute DOMString type;
    };

The `compact` and `type` IDL attributes of the `ul` element must reflect the respective content attributes of the same name.

User agents must treat `xmp` elements in a manner equivalent to `pre` elements in terms of semantics and for purposes of rendering. (The parser has special behaviour for this element though.)

The `blink`, `bgsound`, `isindex`, `multicol`, `nextid`, `rb`, and `spacer` elements must use the `HTMLUnknownElement` interface.

    partial interface Document {
      [TreatNullAs=EmptyString] attribute DOMString fgColor;
      [TreatNullAs=EmptyString] attribute DOMString linkColor;
      [TreatNullAs=EmptyString] attribute DOMString vlinkColor;
      [TreatNullAs=EmptyString] attribute DOMString alinkColor;
      [TreatNullAs=EmptyString] attribute DOMString bgColor;

      readonly attribute HTMLCollection anchors;
      readonly attribute HTMLCollection applets;

      void clear();
      void captureEvents();
      void releaseEvents();

      readonly attribute HTMLAllCollection all;
    };

The attributes of the `Document` object listed in the first column of the following table must reflect the content attribute on the body element with the name given in the corresponding cell in the second column on the same row, if the body element is a `body` element (as opposed to a `frameset` element). When there is no body element or if it is a `frameset` element, the attributes must instead return the empty string on getting and do nothing on setting.

IDL attribute | Content attribute
--- | ---
`fgColor` | `text`
`linkColor` | `link`
`vlinkColor` | `vlink`
`alinkColor` | `alink`
`bgColor` | `bgcolor`

The `anchors` attribute must return an `HTMLCollection` rooted at the `Document` node, whose filter matches only `a` elements with `name` attributes.

The `applets` attribute must return an `HTMLCollection` rooted at the `Document` node, whose filter matches only `applet` elements.

The `clear()`, `captureEvents()`, and `releaseEvents()` methods must do nothing.

The `all` attribute must return an `HTMLAllCollection` rooted at the `Document` node, whose filter matches all elements.

The object returned for `all` has several unusual behaviours:

- The user agent must act as if the ToBoolean() operator in JavaScript converts the object returned for `all` to the false value.

- The user agent must act as if, for the purposes of the `==` and `!=` operators in JavaScript, the object returned for `all` compares as equal to the `undefined` and `null` values. (Comparisons using the `===` operator, and comparisons to other values such as strings or objects, are unaffected.)

- The user agent must act such that the `typeof` operator in JavaScript returns the string `undefined` when applied to the object returned for `all`.

These requirements are a willful violation of the JavaScript specification current at the time of writing (ECMAScript edition 5). The JavaScript specification requires that the ToBoolean() operator convert all objects to the true value, and does not have provisions for objects acting as if they were `undefined` for the purposes of certain operators. This violation is motivated by a desire for compatibility with two classes of legacy content: one that uses the presence of `document.all` as a way to detect legacy user agents, and one that only supports those legacy user agents and uses the `document.all` object without testing for its presence first. [ECMA262]

    partial interface Window {
      void captureEvents();
      void releaseEvents();
    };

The `captureEvents()` and `releaseEvents()` methods must do nothing.