HTML 5.1

A script element has several associated pieces of state.

The first is a flag indicating whether or not the script block has been "already started"#already-startedReferenced in:4.12.1. The script element (2) (3) (4)4.12.1.4. Interaction of script elements and XSLT (2)8.2.5.4.4. The "in head" insertion mode8.2.5.4.8. The "text" insertion mode9.2. Parsing XHTML documents. Initially, script elements must have this flag unset (script blocks, when created, are not "already started"). The cloning steps for script elements must set the "already started" flag on the copy if it is set on the element being cloned.

The second is a flag indicating whether the element was "parser-inserted"#parser-insertedReferenced in:4.12.1. The script element (2) (3) (4) (5) (6) (7) (8) (9) (10)4.12.1.4. Interaction of script elements and XSLT (2) (3)8.2.5.4.4. The "in head" insertion mode9.2. Parsing XHTML documents. Initially, script elements must have this flag unset. It is set by the HTML parser and the XML parser on script elements they insert and affects the processing of those elements.

The third is a flag indicating whether the element will "non-blocking"#non-blockingReferenced in:4.12.1. The script element (2) (3) (4) (5) (6) (7) (8)8.2.5.4.4. The "in head" insertion mode9.2. Parsing XHTML documents. Initially, script elements must have this flag set. It is unset by the HTML parser and the XML parser on script elements they insert. In addition, whenever a script element whose "non-blocking" flag is set has an async content attribute added, the element’s "non-blocking" flag must be unset.

The fourth is a flag indicating whether or not the script block is "ready to be parser-executed"#ready-to-be-parser-executedReferenced in:4.12.1. The script element (2) (3)8.2.5.4.8. The "text" insertion mode (2)8.2.6. The end9.2. Parsing XHTML documents. Initially, script elements must have this flag unset (script blocks, when created, are not "ready to be parser-executed"). This flag is used only for elements that are also "parser-inserted", to let the parser know when to execute the script.

The last few pieces of state are the script block type, the script block character encoding, and the script block fallback character encoding. They are determined when the script is prepared, based on the attributes on the element at that time, and the script element’s node document.

When a script element that is not marked as being "parser-inserted" experiences one of the events listed in the following list, the user agent must immediately prepare the script element:

• The script element gets inserted into a document, at the time the node is inserted according to the DOM, after any other script elements inserted at the same time that are earlier in the Document in tree order.
• The script element is in a Document and a node or document fragment is inserted into the script element, after any script elements inserted at that time.
• The script element is in a Document and has a src attribute set where previously the element had no such attribute.

To prepare a script#prepare-a-scriptReferenced in:4.12.1. The script element (2) (3)4.12.1.4. Interaction of script elements and XSLT, the user agent must act as follows:

1. If the script element is marked as having "already started", then the user agent must abort these steps at this point. The script is not executed.

2. If the element has its "parser-inserted" flag set, then set was-parser-inserted to true and unset the element’s "parser-inserted" flag. Otherwise, set was-parser-inserted to false.

   This is done so that if parser-inserted script elements fail to run when the parser tries to run them, e.g., because they are empty or specify an unsupported scripting language, another script can later mutate them and cause them to run again.

3. If was-parser-inserted is true and the element does not have an async attribute, then set the element’s "non-blocking" flag to true.

   This is done so that if a parser-inserted script element fails to run when the parser tries to run it, but it is later executed after a script dynamically updates it, it will execute in a non-blocking fashion even if the async attribute isn’t set.

4. If the element has no src attribute, and its child nodes, if any, consist only of comment nodes and empty Text nodes, then the user agent must abort these steps at this point. The script is not executed.

5. If the element is not in a Document, then the user agent must abort these steps at this point. The script is not executed.

6. If either:

   • the script element has a type attribute and its value is the empty string, or
   • the script element has no type attribute but it has a language attribute and that attribute’s value is the empty string, or
   • the script element has neither a type attribute nor a language attribute, then

   ...let the script block’s type for this script element be "text/javascript".

   Otherwise, if the script element has a type attribute, let the script block’s type for this script element be the value of that attribute with any leading or trailing sequences of space characters removed.

   Otherwise, the element has a non-empty language attribute; let the script block’s type for this script element be the concatenation of the string "text/" followed by the value of the language attribute.

   The language attribute is never conforming, and is always ignored if there is a type attribute present.

7. If the user agent does not support the scripting language given by the script block’s type for this script element, then the user agent must abort these steps at this point. The script is not executed.

8. If was-parser-inserted is true, then flag the element as "parser-inserted" again, and set the element’s "non-blocking" flag to false.

9. The user agent must set the element’s "already started" flag.

   The state of the element at this moment is later used to determine the script source.

10. If the element is flagged as "parser-inserted", but the element’s node document is not the Document of the parser that created the element, then abort these steps.

11. If scripting is disabled for the script element, then the user agent must abort these steps at this point. The script is not executed.

    The definition of scripting is disabled means that, amongst others, the following scripts will not execute: scripts in XMLHttpRequest’s responseXML documents, scripts in DOMParser-created documents, scripts in documents created by XSLTProcessor’s transformToDocument feature, and scripts that are first inserted by a script into a Document that was created using the createDocument() API. [XHR] [DOMPARSING] [DOM]

12. If the script element has an event attribute and a for attribute, then run these substeps:

    1. Let for be the value of the for attribute.
    2. Let event be the value of the event attribute.
    3. Strip leading and trailing whitespace from event and for.
    4. If for is not an ASCII case-insensitive match for the string "window", then the user agent must abort these steps at this point. The script is not executed.
    5. If event is not an ASCII case-insensitive match for either the string "onload" or the string "onload()", then the user agent must abort these steps at this point. The script is not executed.

13. If the script element has a charset attribute, then let the script block’s character encoding for this script element be the result of getting an encoding from the value of the charset attribute.

    Otherwise, let the script block’s fallback character encoding for this script element be the same as the encoding of the document itself.

    Only one of these two pieces of state is set.

14. If the element has a src content attribute, run these substeps:

    1. Let src be the value of the element’s src attribute.
    2. If src is the empty string, queue a task to fire a simple event named error at the element, and abort these steps.
    3. Resolve src relative to the element.
    4. If the previous step failed, queue a task to fire a simple event named error at the element, and abort these steps.
    5. Let request be the result of creating a potential-CORS request given the resulting absolute URL and the current state of the element’s crossorigin content attribute.
    6. Set request’s client to the element’s node document’s Window object’s environment settings object and type to "script".
    7. Fetch request.

       The resource obtained in this fashion can be either CORS-same-origin or CORS-cross-origin. This only affects how error reporting happens.

       For performance reasons, user agents may start fetching the script (as defined above) as soon as the src attribute is set, instead, in the hope that the element will be inserted into the document (and that the crossorigin attribute won’t change value in the meantime). Either way, once the element is inserted into the document, the load must have started as described in this step. If the user agent performs such prefetching, but the element is never inserted in the document, or the src attribute is dynamically changed, or the crossorigin attribute is dynamically changed, then the user agent will not execute the script so obtained, and the fetching process will have been effectively wasted.

15. Then, the first of the following options that describes the situation must be followed:

    If the element has a src attribute, and the element has a defer attribute, and the element has been flagged as "parser-inserted", and the element does not have an async attribute

    The element must be added to the end of the list of scripts that will execute when the document has finished parsing#list-of-scripts-that-will-execute-when-the-document-has-finished-parsingReferenced in:8.2.6. The end (2) (3) (4) (5) associated with the Document of the parser that created the element.

    The task that the networking task source places on the task queue once fetching has completed must set the element’s "ready to be parser-executed" flag. The parser will handle executing the script.

    If the element has a src attribute, and the element has been flagged as "parser-inserted", and the element does not have an async attribute

    The element is the pending parsing-blocking script of the Document of the parser that created the element. (There can only be one such script per Document at a time.)

    The task that the networking task source places on the task queue once fetching has completed must set the element’s "ready to be parser-executed" flag. The parser will handle executing the script.

    If the element does not have a src attribute, and the element has been flagged as "parser-inserted", and either the parser that created the script is an XML parser or it’s an HTML parser whose script nesting level is not greater than one, and the Document of the HTML parser or XML parser that created the script element has a style sheet that is blocking scripts

    The element is the pending parsing-blocking script of the Document of the parser that created the element. (There can only be one such script per Document at a time.)

    Set the element’s "ready to be parser-executed" flag. The parser will handle executing the script.

    If the element has a src attribute, does not have an async attribute, and does not have the "non-blocking" flag set

    The element must be added to the end of the list of scripts that will execute in order as soon as possible#list-of-scripts-that-will-execute-in-order-as-soon-as-possibleReferenced in:4.12.1. The script element (2) (3) (4)8.2.6. The end associated with the node document of the script element at the time the prepare a script algorithm started.

    The task that the networking task source places on the task queue once fetching has completed must run the following steps:

    1. If the element is not now the first element in the list of scripts that will execute in order as soon as possible to which it was added above, then mark the element as ready but abort these steps without executing the script yet.
    2. Execution: Execute the script block corresponding to the first script element in this list of scripts that will execute in order as soon as possible.
    3. Remove the first element from this list of scripts that will execute in order as soon as possible.
    4. If this list of scripts that will execute in order as soon as possible is still not empty and the first entry has already been marked as ready, then jump back to the step labeled execution.

    If the element has a src attribute

    The element must be added to the set of scripts that will execute as soon as possible#set-of-scripts-that-will-execute-as-soon-as-possibleReferenced in:4.12.1. The script element8.2.6. The end of the node document of the script element at the time the prepare a script algorithm started.

    The task that the networking task source places on the task queue once fetching has completed must execute the script block and then remove the element from the set of scripts that will execute as soon as possible.

    Otherwise

    The user agent must immediately execute the script block, even if other scripts are already executing.

Fetching an external script must delay the load event of the element’s node document until the task that is queued by the networking task source once the resource has been fetched (defined above) has been run.

The pending parsing-blocking script#pending-parsing-blocking-scriptReferenced in:4.12.1. The script element (2) (3)7.3.2. Closing the input stream7.3.3. document.write()8.2.5.4.8. The "text" insertion mode (2) (3) (4)9.2. Parsing XHTML documents (2) (3) (4) of a Document is used by the Document’s parser(s).

If a script element that blocks a parser gets moved to another Document before it would normally have stopped blocking that parser, it nonetheless continues blocking that parser until the condition that causes it to be blocking the parser no longer applies (e.g., if the script is a pending parsing-blocking script because there was a style sheet that is blocking scripts when it was parsed, but then the script is moved to another Document before the style sheet loads, the script still blocks the parser until the style sheets are all loaded, at which time the script executes and the parser is unblocked).

When the user agent is required to execute a script block#execute-a-script-blockReferenced in:4.12.1. The script element (2) (3)8.2.5.4.8. The "text" insertion mode8.2.6. The end9.2. Parsing XHTML documents, it must run the following steps:

1. If the element is flagged as "parser-inserted", but the element’s node document is not the Document of the parser that created the element, then abort these steps.

2. Jump to the appropriate set of steps from the list below:

   If the load resulted in an error (for example a DNS error, or an HTTP 404 error)

   Executing the script block must just consist of firing a simple event named error at the element.

   If the load was successful

   Executing the script block must consist of running the following steps. For the purposes of these steps, the script is considered to be from an external file if, while the prepare a script algorithm above was running for this script, the script element had a src attribute specified.

   1. Initialize the script block’s source#is-later-usedReferenced in:4.12.1. The script element as follows:

      If the script is from an external file and the script block’s type is a text-based language

      The contents of that file, interpreted as a Unicode string, are the script source.

      To obtain the Unicode string, the user agent run the following steps:

      1. If the resource’s Content-Type metadata, if any, specifies a character encoding, and the user agent supports that encoding, then let character encoding be that encoding, and jump to the bottom step in this series of steps.
      2. If the algorithm above set the script block’s character encoding, then let character encoding be that encoding, and jump to the bottom step in this series of steps.
      3. Let character encoding be the script block’s fallback character encoding.

      4. If the specification for the script block’s type gives specific rules for decoding files in that format to Unicode, follow them, using character encoding as the character encoding specified by higher-level protocols, if necessary.

         Otherwise, decode the file to Unicode, using character encoding as the fallback encoding.

         The decode algorithm overrides character encoding if the file contains a BOM.

      If the script is from an external file and the script block’s type is an XML-based language

      The external file is the script source. When it is later executed, it must be interpreted in a manner consistent with the specification defining the language given by the script block’s type.

      If the script is inline and the script block’s type is a text-based language

      The value of the text IDL attribute at the time the element’s "already started" flag was last set is the script source.

      If the script is inline and the script block’s type is an XML-based language

      The child nodes of the script element at the time the element’s "already started" flag was last set are the script source.

   2. Fire a simple event named beforescriptexecute that bubbles and is cancelable at the script element.

      If the event is canceled, then abort these steps.

   3. If the script is from an external file, then increment the ignore-destructive-writes counter of the script element’s node document. Let neutralized doc be that Document.

   4. Let old script element be the value to which the script element’s node document’s currentScript object was most recently initialized.

   5. Initialize the script element’s node document’s currentScript object to the script element.

   6. Create a script, using the script block’s source, the URL from which the script was obtained, the script block’s type as the scripting language, and the environment settings object of the script element’s node document’s Window object.

      If the script came from a resource that was fetched in the steps above, and the resource was CORS-cross-origin, then pass the muted errors flag to the create a script algorithm as well.

      This is where the script is compiled and actually executed.

   7. Initialize the script element’s node document’s currentScript object to old script element.

   8. Decrement the ignore-destructive-writes counter of neutralized doc, if it was incremented in the earlier step.

   9. Fire a simple event named afterscriptexecute that bubbles (but is not cancelable) at the script element.

   10. If the script is from an external file, fire a simple event named load at the script element.

       Otherwise, the script is internal; queue a task to fire a simple event named load at the script element.

The IDL attributes src#dom-htmlscriptelement-srcReferenced in:4.12.1. The script element, type#dom-htmlscriptelement-typeReferenced in:4.12.1. The script element, charset#dom-htmlscriptelement-charsetReferenced in:4.12.1. The script element, and defer#dom-htmlscriptelement-deferReferenced in:4.12.1. The script element, must each reflect the respective content attributes of the same name.

The crossOrigin#dom-htmlscriptelement-crossoriginReferenced in:4.12.1. The script element IDL attribute must reflect the crossorigin content attribute.

The async#dom-htmlscriptelement-asyncReferenced in:4.12.1. The script element IDL attribute controls whether the element will execute in parallel or not. If the element’s "non-blocking" flag is set, then, on getting, the async IDL attribute must return true, and on setting, the "non-blocking" flag must first be unset, and then the content attribute must be removed if the IDL attribute’s new value is false, and must be set to the empty string if the IDL attribute’s new value is true. If the element’s "non-blocking" flag is not set, the IDL attribute must reflect the async content attribute.

The IDL attribute text#dom-htmlscriptelement-textReferenced in:4.12.1. The script element must return a concatenation of the contents of all the Text nodes that are children of the script element (ignoring any other nodes such as comments or elements), in tree order. On setting, it must act the same way as the textContent IDL attribute.

A user agent is said to support the scripting language#support-the-scripting-languageReferenced in:4.12.1. The script element if each component of the script block’s type is an ASCII case-insensitive match for the corresponding component in the MIME type string of a scripting language that the user agent implements.

User agents may support other MIME types for other languages, but must not support other MIME types for the languages in the list above. User agents are not required to support the languages listed above.

The following MIME types (with or without parameters) must not be interpreted as scripting languages:

• text/plain
• text/xml
• application/octet-stream
• application/xml

These types are explicitly listed here because they are poorly-defined types that are nonetheless likely to be used as formats for data blocks, and it would be problematic if they were suddenly to be interpreted as script by a user agent.

When examining types to determine if they represent supported languages, user agents must not ignore MIME parameters. Types are to be compared including all parameters.

For example, types that include the charset parameter will not be recognized as referencing any of the scripting languages listed above.

4.12.1.4. Interaction of script elements and XSLT

This section is non-normative.

This specification does not define how XSLT interacts with the script element. However, in the absence of another specification actually defining this, here are some guidelines for implementors, based on existing implementations:

• When an XSLT transformation program is triggered by an <?xml-stylesheet?> processing instruction and the browser implements a direct-to-DOM transformation, script elements created by the XSLT processor need to be marked "parser-inserted" and run in document order (modulo scripts marked defer or async), immediately, as the transformation is occurring.
• The XSLTProcessor.transformToDocument() method adds elements to a Document that is not in a browsing context, and, accordingly, any script elements they create need to have their "already started" flag set in the prepare a script algorithm and never get executed (scripting is disabled). Such script elements still need to be marked "parser-inserted", though, such that their async IDL attribute will return false in the absence of an async content attribute.
• The XSLTProcessor.transformToFragment() method needs to create a fragment that is equivalent to one built manually by creating the elements using document.createElementNS(). For instance, it needs to create script elements that aren’t "parser-inserted" and that don’t have their "already started" flag set, so that they will execute when the fragment is inserted into a document.

The main distinction between the first two cases and the last case is that the first two operate on Documents and the last operates on a fragment.

The noscript element has no other requirements. In particular, children of the noscript element are not exempt from §4.10.22 Form submission, scripting, and so forth, even when scripting is enabled for the element.

Each template element has an associated DocumentFragment object that is its template contents#template-contentsReferenced in:3.2.4. Content models4.12.3. The template element (2) (3) (4) (5) (6) (7) (8)4.12.3.1. Interaction of template elements with XSLT and XPath (2) (3)8.2.5.1. Creating and inserting nodes (2)8.2.7. Coercing an HTML DOM into an infoset8.3. Serializing HTML fragments9.2. Parsing XHTML documents9.3. Serializing XHTML fragments. When a template element is created, the user agent must run the following steps to establish the template contents:

1. Let doc be the template element’s node document’s appropriate template contents owner document.
2. Create a DocumentFragment object whose node document is doc.
3. Set the template element’s template contents to the newly created DocumentFragment object.

A Document doc’s appropriate template contents owner document#appropriate-template-contents-owner-documentReferenced in:4.12.3. The template element (2) is the Document returned by the following algorithm:

1. If doc is not a Document created by this algorithm, run these substeps:

   1. If doc does not yet have an associated inert template document#associated-inert-template-documentReferenced in:4.12.3. The template element (2) then run these substeps:

      1. Let new doc be a new Document (that does not have a browsing context). This is "a Document created by this algorithm" for the purposes of the step above.
      2. If doc is an HTML document, mark new doc as an HTML document also.
      3. Let doc’s associated inert template document be new doc.
   2. Set doc to doc’s associated inert template document.

   Each Document not created by this algorithm thus gets a single Document to act as its proxy for owning the template contents of all its template elements, so that they aren’t in a browsing context and thus remain inert (e.g., scripts do not run). Meanwhile, template elements inside Document objects that are created by this algorithm just reuse the same Document owner for their contents.

2. Return doc.

The adopting steps (with node and oldDocument as parameters) for template elements are the following:

1. Let doc be node’s node document’s appropriate template contents owner document.

   node’s node document is the Document object that node was just adopted into.

2. Adopt node’s template contents (a DocumentFragment object) into doc.

The content IDL attribute must return the template element’s template contents.

The cloning steps for a template element node being cloned to a copy copy must run the following steps:

1. If the clone children flag is not set in the calling clone algorithm, abort these steps.
2. Let copied contents be the result of cloning all the children of node’s template contents, with document set to copy’s template contents’s node document, and with the clone children flag set.
3. Append copied contents to copy’s template contents.

4.12.3.1. Interaction of template elements with XSLT and XPath

This section is non-normative.

This specification does not define how XSLT and XPath interact with the template element. However, in the absence of another specification actually defining this, here are some guidelines for implementors, which are intended to be consistent with other processing described in this specification:

• An XSLT processor based on an XML parser that acts as described in this specification needs to act as if template elements contain as descendants their template contents for the purposes of the transform.
• An XSLT processor that outputs a DOM needs to ensure that nodes that would go into a template element are instead placed into the element’s template contents.
• XPath evaluation using the XPath DOM API when applied to a Document parsed using the HTML parser or the XML parser described in this specification needs to ignore template contents.

The bitmaps of canvas elements, the bitmaps of ImageBitmap objects, as well as some of the bitmaps of rendering contexts, such as those described in the section on the CanvasRenderingContext2D object below, have an origin-clean#canvas-origin-cleanReferenced in:4.12.4. The canvas element (2) (3)4.12.4.4. Security with canvas elements (2) (3) (4) (5)7.7. Images (2) (3) (4) (5) (6) (7) (8) flag, which can be set to true or false. Initially, when the canvas element or ImageBitmap object is created, its bitmap’s origin-clean flag must be set to true.

A canvas bitmap can also have a hit region list, as described in the CanvasRenderingContext2D section below.

A canvas element can have a rendering context bound to it. Initially, it does not have a bound rendering context. To keep track of whether it has a rendering context or not, and what kind of rendering context it is, a canvas also has a canvas context mode#modedef-canvas-context-modeReferenced in:4.12.4. The canvas element (2) (3) (4) (5) (6) (7)4.12.4.1. Proxying canvases to workers (2), which is initially none#contextdef-canvas-noneReferenced in:4.12.4. The canvas element (2) (3)4.12.4.1. Proxying canvases to workers but can be changed to either direct-2d#contextdef-canvas-direct-2dReferenced in:4.12.4. The canvas element (2) (3), direct-webgl#contextdef-canvas-direct-webglReferenced in:4.12.4. The canvas element (2), indirect#contextdef-canvas-indirectReferenced in:4.12.4. The canvas element (2) (3), or proxied#contextdef-canvas-proxiedReferenced in:4.12.4. The canvas element4.12.4.1. Proxying canvases to workers by algorithms defined in this specification.

When its canvas context mode is none, a canvas element has no rendering context, and its bitmap must be fully transparent black with an intrinsic width equal to the numeric value of the element’s width attribute and an intrinsic height equal to the numeric value of the element’s height attribute, those values being interpreted in CSS pixels, and being updated as the attributes are set, changed, or removed.

When a canvas element represents embedded content, it provides a paint source whose width is the element’s intrinsic width, whose height is the element’s intrinsic height, and whose appearance is the element’s bitmap.

Whenever the width and height content attributes are set, removed, changed, or redundantly set to the value they already have, if the canvas context mode is direct-2d, the user agent must set bitmap dimensions to the numeric values of the width and height content attributes.

The width#dom-htmlcanvaselement-widthReferenced in:4.12.4. The canvas element and height#dom-htmlcanvaselement-heightReferenced in:4.12.4. The canvas element IDL attributes must reflect the respective content attributes of the same name, with the same defaults.

There are two ways for a canvas element to acquire a rendering context: the canvas element can provide one via the getContext() method, and one can be assigned to it via the setContext() method. In addition, the whole issue of a rendering context can be taken out of the canvas element’s hands and passed to a CanvasProxy object, which itself can then be assigned a rendering context using its setContext() method.

These three methods are mutually exclusive; calling any of the three makes the other two start throwing InvalidStateError exceptions when called.

Each rendering context has a context bitmap mode#canvas-context-bitmap-modeReferenced in:4.12.4. The canvas element (2) (3) (4) (5) (6)4.12.4.1. Proxying canvases to workers (2) (3) (4), which is one of fixed#contextdef-canvas-fixedReferenced in:4.12.4. The canvas element (2) (3)4.12.4.1. Proxying canvases to workers, unbound#contextdef-canvas-unboundReferenced in:4.12.4. The canvas element (2)4.12.4.1. Proxying canvases to workers, or bound#contextdef-canvas-boundReferenced in:4.12.4. The canvas element (2)4.12.4.1. Proxying canvases to workers (2). Initially, rendering contexts must be in the unbound mode.

The getContext(contextId, arguments...)#dom-htmlcanvaselement-getcontextReferenced in:4.12.4. The canvas element method of the canvas element, when invoked, must run the steps in the cell of the following table whose column header describes the canvas element’s canvas context mode and whose row header describes the method’s first argument.

* Vendors may define experimental contexts using the syntax vendorname-context, for example, moz-3d.

† For example, the "webgl" value in the case of a user agent having exhausted the graphics hardware’s abilities and having no software fallback implementation.

‡ The second (and subsequent) argument(s) to the method, if any, are ignored in all cases except this one. See the WebGL specification for details.

The probablySupportsContext(contextId, arguments...)#dom-htmlcanvaselement-probablysupportscontextReferenced in:4.12.4. The canvas element method of the canvas element, when invoked, must return false if calling getContext() on the same object and with the same arguments would definitely return null at this time, and true otherwise.

The setContext(context)#dom-htmlcanvaselement-setcontextReferenced in:4.12.4. The canvas element method of the canvas element, when invoked, must run the following steps:

1. If the canvas element’s canvas context mode is neither none nor indirect, throw an InvalidStateError exception and abort these steps.
2. If context’s context bitmap mode is fixed, then throw an InvalidStateError exception and abort these steps.
3. If context’s context bitmap mode is bound, then run context’s unbinding steps and set its context’s context bitmap mode to unbound.
4. Run context’s binding steps to bind it to this canvas element.
5. Set the canvas element’s context mode to indirect and the context’s context bitmap mode to bound.

The toDataURL() method must run the following steps:

1. If the canvas element’s bitmap’s origin-clean flag is set to false, throw a SecurityError exception and abort these steps.
2. If the canvas element’s bitmap has no pixels (i.e., either its horizontal dimension or its vertical dimension is zero) then return the string "data:," and abort these steps. (This is the shortest data: URL; it represents the empty string in a text/plain resource.)
3. Let file be a serialization of the canvas element’s bitmap as a file, using the method’s arguments (if any) as the arguments.
4. Return a data: URL representing file. [RFC2397]

The toBlob() method must run the following steps:

1. If the canvas element’s bitmap’s origin-clean flag is set to false, throw a SecurityError exception and abort these steps.
2. Let callback be the first argument.
3. Let arguments be the second and subsequent arguments to the method, if any.

4. If the canvas element’s bitmap has no pixels (i.e., either its horizontal dimension or its vertical dimension is zero) then let result be null.

   Otherwise, let result be a Blob object representing a serialization of the canvas element’s bitmap as a file, using arguments. [FILEAPI]

5. Return, but continue running these steps in parallel.
6. Queue a task to invoke the BlobCallback callback with result as its argument. The task source for this task is the canvas blob serialization task source.

4.12.4.2. Color spaces and color correction

The canvas APIs must perform color correction at only two points: when rendering images with their own gamma correction and color space information onto a bitmap, to convert the image to the color space used by the bitmaps (e.g., using the 2D Context’s drawImage() method with an HTMLImageElement object), and when rendering the actual canvas bitmap to the output device.

Thus, in the 2D context, colors used to draw shapes onto the canvas will exactly match colors obtained through the getImageData() method.

The toDataURL() method must not include color space information in the resources they return. Where the output format allows it, the color of pixels in resources created by toDataURL() must match those returned by the getImageData() method.

In user agents that support CSS, the color space used by a canvas element must match the color space used for processing any colors for that element in CSS.

The gamma correction and color space information of images must be handled in such a way that an image rendered directly using an img element would use the same colors as one painted on a canvas element that is then itself rendered. Furthermore, the rendering of images that have no color correction information (such as those returned by the toDataURL() method) must be rendered with no color correction.

Thus, in the 2D context, calling the drawImage() method to render the output of the toDataURL() method to the canvas, given the appropriate dimensions, has no visible effect.

4.12.4.3. Serializing bitmaps to a file

When a user agent is to create a serialization of the bitmap as a file#a-serialization-of-the-canvas-elements-bitmap-as-a-fileReferenced in:4.12.4. The canvas element (2), optionally with some given arguments, and optionally with a native flag set, it must create an image file in the format given by the first value of arguments, or, if there are no arguments, in the PNG format. [PNG]

If the native flag is set, or if the bitmap has one pixel per coordinate space unit, then the image file must have the same pixel data (before compression, if applicable) as the bitmap, and if the file format used supports encoding resolution metadata, the resolution of that bitmap (device pixels per coordinate space units being interpreted as image pixels per CSS pixel) must be given as well.

Otherwise, the image file’s pixel data must be the bitmap’s pixel data scaled to one image pixel per coordinate space unit, and if the file format used supports encoding resolution metadata, the resolution must be given as 96dpi (one image pixel per CSS pixel).

If arguments is not empty, the first value must be interpreted as a MIME type giving the format to use. If the type has any parameters, it must be treated as not supported.

For example, the value "image/png" would mean to generate a PNG image, the value "image/jpeg" would mean to generate a JPEG image, and the value "image/svg+xml" would mean to generate an SVG image (which would require that the user agent track how the bitmap was generated, an unlikely, though potentially awesome, feature).

User agents must support PNG ("image/png"). User agents may support other types. If the user agent does not support the requested type, it must create the file using the PNG format. [PNG]

User agents must convert the provided type to ASCII lowercase before establishing if they support that type.

For image types that do not support an alpha channel, the serialized image must be the bitmap image composited onto a solid black background using the source-over operator.

If the first argument in arguments gives a type corresponding to one of the types given in the first column of the following table, and the user agent supports that type, then the subsequent arguments, if any, must be treated as described in the second cell of that row.

For the purposes of these rules, an argument is considered to be a number if it is converted to an IDL double value by the rules for handling arguments of type any in the Web IDL specification. [WEBIDL]

Other arguments must be ignored and must not cause the user agent to throw an exception. A future version of this specification will probably define other parameters to be passed to these methods to allow authors to more carefully control compression settings, image metadata, etc.

4.12.4.4. Security with canvas elements

This section is non-normative.

Information leakage can occur if scripts from one origin can access information (e.g., read pixels) from images from another origin (one that isn’t the same).

To mitigate this, bitmaps used with canvas elements and ImageBitmap objects are defined to have a flag indicating whether they are origin-clean. All bitmaps start with their origin-clean set to true. The flag is set to false when cross-origin images or fonts are used.

The toDataURL(), toBlob(), and getImageData() methods check the flag and will throw a SecurityError exception rather than leak cross-origin data.

The value of the origin-clean flag is propagated from a source canvas element’s bitmap to a new ImageBitmap object by createImageBitmap(). Conversely, a destination canvas element’s bitmap will have its origin-clean flags set to false by drawImage if the source image is an ImageBitmap object whose bitmap has its origin-clean flag set to false.

The flag can be reset in certain situations; for example, when a CanvasRenderingContext2D is bound to a new canvas, the bitmap is cleared and its flag reset.