Open Pdf In Iframe Passing Byte Data Not Found

Profound UI Version History 5.12.0 (Current Release) Release date: • Visual Designer and UI Framework • Fix autocomplete fields that failed to get values that were pasted via mouse. • Unobfuscate grid.dataArray property • 'error messages' property dialog displays long field names. • Added ability to include images in Excel XLSX export. • Improved Excel XLSX export: grid 'row height' and column widths determine the spreadsheet row height and column widths. • Genie (5250 Screen Refacing) • Your system may require PTFs for Genie to function properly. For more information.

• Fix intermittent 5250 print screen when reading input from Rich Display File applications. • Fix autocomplete fields that failed to get values that were pasted via mouse.

Mvc code that returns a byte array of pdf doc and store the bytes array in local machine as pdf.The pdf gets generated at desire location but when i open it, it shows file not supported error.So can anyone tell me how to resolve the issue.I also need API code that returns a pdf based on filename passed to it.

• New 'special key pattern2' to allow detecting special keys that span multiple fields • New 'special key map' to allow special key detections in languages other than English • Correct problem where function keys that match both 'function key pattern' and 'function key pattern2' could not be converted into buttons • Ignore non-display fields when building subfile options drop-down menu in 5250 mode. • Increased limit on size of screen data for Rich Display File applications. • Correct error when using copy/paste or duplicate in Genie Designer • Fixed issue with TELNET command. • Fixed copy/paste error when trying to duplicate widgets • JumpStart Application Generator • Added support for HTML displays with Node.js and added Standard HTML Node template. • Added template variables #fieldLC and #dbfieldLC.

• Modified 'Webservice to do Autocomplete.rpgle' template. All lines are now less than 80 characters. 5.11.0 Release date: • Profound UI Product Suite • Fixed PUISNDMSG USERID(*ACTIVE) problem: messages were not being sent to Genie users.

• Visual Designer and UI Framework • Corrected behavior of numbers with commas as decimal points on iOS • Add update message capability to the Visual Designer • Ability to Undo & Redo removing elements, adding elements, and changing screen level properties • Ability to Cut, Copy, Paste, and Duplicate Grids • New oninput event property • Added drag-drop ability to Elements list to help moving items between certain layouts. • Fixed grids not responding to PageUp/PageDown keys when inputs are hidden or disabled on some rows.

• Allow drag and drop on these elements: 'ajax container', 'button', 'graphic button', 'styled button', 'css button' • Corrected behavior of setDataValue API to not mark a row 'changed' if you only change an output field. • Prevent applyProperty() from duplicating labels on radio buttons and check boxes • Correct drag/drop position of an element in a layout when use proxy is not enabled • Fix PUIWRKSPLF 'view' option failure when using Kerberos authentication and user's password is expired. • Added config option, pui['read db driven data as ebcdic'], for backward compatibility of some DB-driven widgets to a change made in 5.8.0. • Fixed issue in DDS conversion caused by improper reporting of DBCS constant lengths.

HTML 5.2 W3C Recommendation, 14 December 2017 ← — — → Table of Contents • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • 2. Common infrastructure 2.1. Terminology This specification refers to both HTML and XML attributes and IDL attributes, often in the same context. When it is not clear which is being referred to, they are referred to as for HTML and XML attributes, and IDL attributes for those defined on IDL interfaces.

Similarly, the term 'properties' is used for both JavaScript object properties and CSS properties. When these are ambiguous they are qualified as object properties and CSS properties respectively. Generally, when the specification states that a feature applies to or, it also includes the other. When a feature specifically only applies to one of the two languages, it is called out by explicitly stating that it does not apply to the other format, as in 'for HTML.

(this does not apply to XHTML)'. This specification uses the term document to refer to any use of HTML, ranging from short static documents to long essays or reports with rich multimedia, as well as to fully-fledged interactive applications.

The term is used to refer both to objects and their descendant DOM trees, and to serialized byte streams using the or, depending on context. In the context of the DOM structures, the terms HTML document and are used as defined in the DOM specification, and refer specifically to two different modes that objects can find themselves in. (Such uses are always hyperlinked to their definition.) In the context of byte streams, the term refers to resources labeled as, and the term XML document refers to resources labeled with an. The term XHTML document is used to refer to both in the mode that contains element nodes in the, and byte streams labeled with an that contain elements from the, depending on context. For simplicity, terms such as shown, displayed, and visible might sometimes be used when referring to the way a document is rendered to the user. These terms are not meant to imply a visual medium; they must be considered to apply to other media in equivalent ways. When an algorithm B says to return to another algorithm A, it implies that A called B.

Upon returning to A, the implementation must continue from where it left off in calling B. Some algorithms run in parallel; this means that the algorithm’s subsequent steps are to be run, one after another, at the same time as other logic in the specification (e.g., at the same time as the ). This specification does not define the precise mechanism by which this is achieved, be it time-sharing cooperative multitasking, fibers, threads, processes, using different hyperthreads, cores, CPUs, machines, etc. By contrast, an operation that is to run immediately must interrupt the currently running task, run itself, and then resume the previously running task. The term 'transparent black' refers to the color with red, green, blue, and alpha channels all set to zero. Resources The specification uses the term supported when referring to whether a user agent has an implementation capable of decoding the semantics of an external resource. A format or type is said to be supported if the implementation can process an external resource of that format or type without critical aspects of the resource being ignored.

Whether a specific resource is supported can depend on what features of the resource’s format are in use. For example, a PNG image would be considered to be in a supported format if its pixel data could be decoded and rendered, even if, unbeknownst to the implementation, the image also contained animation data. An MPEG-4 video file would not be considered to be in a supported format if the compression format used was not supported, even if the implementation could determine the dimensions of the movie from the file’s metadata. What some specifications, in particular the HTTP specification, refer to as a representation is referred to in this specification as a resource. The term MIME type is used to refer to what is sometimes called an Internet media type in protocol literature.

The term media type in this specification is used to refer to the type of media intended for presentation, as used by the CSS specifications. A string is a valid MIME type if it matches the rule. In particular, a may include MIME type parameters. A string is a if it matches the rule, but does not contain any U+003B SEMICOLON characters (;). In other words, if it consists only of a type and subtype, with no MIME Type parameters. The term HTML MIME type is used to refer to the. A resource’s critical subresources are those that the resource needs to have available to be correctly processed.

Which resources are considered critical or not is defined by the specification that defines the resource’s format. XML compatibility To ease migration from HTML to XHTML, user agents conforming to this specification will place elements in HTML in the namespace, at least for the purposes of the DOM and CSS. The term ' HTML elements', when used in this specification, refers to any element in that namespace, and thus refers to both HTML and XHTML elements. Except where otherwise stated, all elements defined or mentioned in this specification are in the (' and all attributes defined or mentioned in this specification have no namespace. The term element type is used to refer to the set of elements that have a given local name and namespace.

For example, elements are elements with the element type, meaning they have the local name ' ' and (implicitly as defined above) the. Attribute names are said to be XML-compatible if they match the production defined in XML and they contain no U+003A COLON characters (:). The term XML MIME type is used to refer to the text/xml, application/xml, and any whose subtype ends with the four characters ' +xml'. DOM trees When it is stated that some element or attribute is ignored, or treated as some other value, or handled as if it was something else, this refers only to the processing of the node after it is in the DOM.

A user agent must not mutate the DOM in such situations. A content attribute is said to change value only if its new value is different than its previous value; setting an attribute to a value it already has does not change it. The term empty, when used for an attribute value, node, or string means that the length of the text is zero (i.e., not even containing spaces or ).

An element’s child text content is the concatenation of the of all the nodes that are children of the element (ignoring any other nodes such as comments or elements), in. A into a node B when the are invoked with A as the argument and A’s new parent is B. Similarly, a node A is removed from a node B when the are invoked with A as the removedNode argument and B as the oldParent argument. A node is inserted into a document when the are invoked with it as the argument and it is now. Analogously, a node is removed from a document when the are invoked with it as the argument and it is now no longer in a. Scripting The construction 'a Foo object', where Foo is actually an interface, is sometimes used instead of the more accurate 'an object implementing the interface Foo'. An IDL attribute is said to be getting when its value is being retrieved (e.g., by author script), and is said to be setting when a new value is assigned to it.

If a DOM object is said to be live, then the attributes and methods on that object must operate on the actual underlying data, not a snapshot of the data. In the contexts of events, the terms fire and dispatch are used as defined in the DOM specification: firing an event means to create and it, and dispatching an event means to follow the steps that propagate the event through the tree. The term trusted event is used to refer to events whose attribute is initialized to true. Plugins The term plugin refers to a user-agent defined set of content handlers that can be used by the user agent. The content handlers can take part in the user agent’s rendering of a object, but that neither act as of the nor introduce any objects to the 's DOM. Typically such content handlers are provided by third parties, though a user agent can also designate built-in content handlers as. A user agent must not consider the types text/plain and application/octet-stream as having a registered.

One example of a plugin would be a PDF viewer that is instantiated in a when the user navigates to a PDF file. This would count as a plugin regardless of whether the party that implemented the PDF viewer component was the same as that which implemented the user agent itself. However, a PDF viewer application that launches separate from the user agent (as opposed to using the same interface) is not a plugin by this definition. This specification does not define a mechanism for interacting with, as it is expected to be user-agent- and platform-specific.

Some user agents might opt to support a plugin mechanism such as the Netscape Plugin API; others might use remote content converters or have built-in support for certain types. Indeed, this specification doesn’t require user agents to support at all. A plugin can be secured if it honors the semantics of the attribute. For example, a secured plugin would prevent its contents from creating pop-up windows when the plugin is instantiated inside a sandboxed. Browsers should take extreme care when interacting with external content intended for. When third-party software is run with the same privileges as the user agent itself, vulnerabilities in the third-party software become as dangerous as if they were vulnerabilities of the user agent itself.

Since different users having different sets of provides a fingerprinting vector that increases the chances of users being uniquely identified, user agents are encouraged to support the exact same set of for each user. Character encodings A character encoding, or just encoding where that is not ambiguous, is a defined way to convert between byte streams and Unicode strings, as defined in the Encoding specification. An has an encoding name and one or more encoding labels, referred to as the encoding’s name and labels in the Encoding specification. A UTF-16 encoding is. An ASCII-compatible encoding is any that is not a. Since support for encodings that are not defined in the Encoding specification is prohibited, are the only encodings that this specification needs to treat as not being. The term code unit is used as defined in the Web IDL specification: a 16 bit unsigned integer, the smallest atomic component of a DOMString.

(This is a narrower definition than the one used in Unicode, and is not the same as a code point.) The term Unicode code point means a Unicode scalar value where possible, and an isolated surrogate code point when not. When a conformance requirement is defined in terms of characters or Unicode code points, a pair of consisting of a high surrogate followed by a low surrogate must be treated as the single code point represented by the surrogate pair, but isolated surrogates must each be treated as the single code point with the value of the surrogate. In this specification, the term character, when not qualified as Unicode character, is synonymous with the term. The term Unicode character is used to mean a Unicode scalar value (i.e.

Any Unicode code point that is not a surrogate code point). The code-unit length of a string is the number of in that string.

This complexity results from the historical decision to define the DOM API in terms of 16 bit (UTF-16), rather than in terms of. Conformance requirements All diagrams, examples, and notes in this specification are non-normative, as are all sections explicitly marked non-normative.

Everything else in this specification is normative. The key words 'MUST', 'MUST NOT', 'REQUIRED', 'SHALL', 'SHALL NOT', 'SHOULD', 'SHOULD NOT', 'RECOMMENDED', 'NOT RECOMMENDED', 'MAY', and 'OPTIONAL' in the normative parts of this document are to be interpreted as described in RFC2119. The key word 'OPTIONALLY' in the normative parts of this document is to be interpreted with the same normative meaning as 'MAY' and 'OPTIONAL'. For readability, these words do not appear in all uppercase letters in this specification. Requirements phrased in the imperative as part of algorithms (such as 'strip any leading space characters' or 'return false and abort these steps') are to be interpreted with the meaning of the key word ('must', 'should', 'may', etc) used in introducing the algorithm. For example, were the spec to say: To eat an orange, the user must: 1.

Peel the orange. Separate each slice of the orange. Eat the orange slices.it would be equivalent to the following: To eat an orange: 1. The user must peel the orange. The user must separate each slice of the orange. The user must eat the orange slices. Here the key word is 'must'.

The former (imperative) style is generally preferred in this specification for stylistic reasons. Conformance requirements phrased as algorithms or specific steps may be implemented in any manner, so long as the end result is equivalent. (In particular, the algorithms defined in this specification are intended to be easy to follow, and not intended to be performant.) 2.2.1. Conformance classes This specification describes the conformance criteria for user agents (relevant to implementors) and documents (relevant to authors and authoring tool implementors). Conforming documents are those that comply with all the conformance criteria for documents. For readability, some of these conformance requirements are phrased as conformance requirements on authors; such requirements are implicitly requirements on documents: by definition, all documents are assumed to have had an author. (In some cases, that author may itself be a user agent — such user agents are subject to additional rules, as explained below.) For example, if a requirement states that 'authors must not use the foobar element', it would imply that documents are not allowed to contain elements named foobar.

There is no implied relationship between document conformance requirements and implementation conformance requirements. User agents are not free to handle non-conformant documents as they please; the processing model described in this specification applies to implementations regardless of the conformity of the input documents. User agents fall into several (overlapping) categories with different conformance requirements. Web browsers and other interactive user agents Web browsers that support must process elements and attributes from the found in XML documents as described in this specification, so that users can interact with them, unless the semantics of those elements have been overridden by other specifications.

A conforming XHTML processor would, upon finding an XHTML element in an XML document, execute the script contained in that element. However, if the element is found within a transformation expressed in XSLT (assuming the user agent also supports XSLT), then the processor would instead treat the element as an opaque element that forms part of the transform. Web browsers that support must process documents labeled with an as described in this specification, so that users can interact with them. User agents that support scripting must also be conforming implementations of the IDL fragments in this specification, as described in the Web IDL specification.

The God Who Is There Schaeffer Ebook Torrents. Unless explicitly stated, specifications that override the semantics of HTML elements do not override the requirements on DOM objects representing those elements. For example, the element in the example above would still implement the interface. Non-interactive presentation user agents User agents that process HTML and XHTML documents purely to render non-interactive versions of them must comply to the same conformance criteria as Web browsers, except that they are exempt from requirements regarding user interaction. Typical examples of non-interactive presentation user agents are printers (static user agents) and overhead displays (dynamic user agents). It is expected that most static non-interactive presentation user agents will also opt to. A non-interactive but dynamic presentation user agent would still execute scripts, allowing forms to be dynamically submitted, and so forth.

However, since the concept of 'focus' is irrelevant when the user cannot interact with the document, the user agent would not need to support any of the focus-related DOM APIs. Visual user agents that support the suggested default rendering User agents, whether interactive or not, may be designated (possibly as a user option) as defined by this specification. This is not required. In particular, even user agents that do implement the suggested default rendering are encouraged to offer settings that override this default to improve the experience for the user, e.g., changing the color contrast, using different focus styles, or otherwise making the experience more accessible and usable to the user. User agents that are designated as must, while so designated, implement the rules in.

That section defines the behavior that user agents are expected to implement. User agents with no scripting support Implementations that do not support scripting (or which have their scripting features disabled entirely) are exempt from supporting the events and DOM interfaces mentioned in this specification.

For the parts of this specification that are defined in terms of an events model or in terms of the DOM, such user agents must still act as if events and the DOM were supported. Scripting can form an integral part of an application. Web browsers that do not support scripting, or that have scripting disabled, might be unable to fully convey the author’s intent.

Conformance checkers Conformance checkers must verify that a document conforms to the applicable conformance criteria described in this specification. Automated conformance checkers are exempt from detecting errors that require interpretation of the author’s intent (for example, while a document is non-conforming if the content of a element is not a quote, conformance checkers running without the input of human judgement do not have to check that elements only contain quoted material). Conformance checkers must check that the input document conforms when parsed without a (meaning that no scripts are run, and that the parser’s is disabled), and should also check that the input document conforms when parsed with a in which scripts execute, and that the scripts never cause non-conforming states to occur other than transiently during script execution itself. (This is only a 'SHOULD' and not a 'MUST' requirement because it has been proven to be impossible. ) The term 'HTML validator' can be used to refer to a conformance checker that itself conforms to the applicable requirements of this specification.

XML DTDs cannot express all the conformance requirements of this specification. Therefore, a validating XML processor and a DTD cannot constitute a conformance checker. Also, since neither of the two authoring formats defined in this specification are applications of SGML, a validating SGML system cannot constitute a conformance checker either. To put it another way, there are three types of conformance criteria: • Criteria that can be expressed in a DTD. • Criteria that cannot be expressed by a DTD, but can still be checked by a machine.

• Criteria that can only be checked by a human. A conformance checker must check for the first two. A simple DTD-based validator only checks for the first class of errors and is therefore not a conforming conformance checker according to this specification. Data mining tools Applications and tools that process HTML and XHTML documents for reasons other than to either render the documents or check them for conformance should act in accordance with the semantics of the documents that they process. A tool that generates but increases the nesting level for each paragraph and does not increase the nesting level for each section would not be conforming. Authoring tools and markup generators Authoring tools and markup generators must generate. Conformance criteria that apply to authors also apply to authoring tools, where appropriate.

Authoring tools are exempt from the strict requirements of using elements only for their specified purpose, but only to the extent that authoring tools are not yet able to determine author intent. However, authoring tools must not automatically misuse elements or encourage their users to do so. For example, it is not conforming to use an element for arbitrary contact information; that element can only be used for marking up contact information for the author of the document or section. However, since an authoring tool is likely unable to determine the difference, an authoring tool is exempt from that requirement. This does not mean, though, that authoring tools can use elements for any block of italics text (for instance); it just means that the authoring tool doesn’t have to verify, if a user inserts contact information for a section or something else.

In terms of conformance checking, an editor has to output documents that conform to the same extent that a conformance checker will verify. When an authoring tool is used to edit a non-conforming document, it may preserve the conformance errors in sections of the document that were not edited during the editing session (i.e., an editing tool is allowed to round-trip erroneous content). However, an authoring tool must not claim that the output is conformant if errors have been so preserved. Authoring tools are expected to come in two broad varieties: tools that work from structure or semantic data, and tools that work on a What-You-See-Is-What-You-Get media-specific editing basis (WYSIWYG). The former is the preferred mechanism for tools that author HTML, since the structure in the source information can be used to make informed choices regarding which HTML elements and attributes are most appropriate.

However, WYSIWYG tools are legitimate. WYSIWYG tools should use elements they know are appropriate, and should not use elements that they do not know to be appropriate. This might in certain extreme cases mean limiting the use of flow elements to just a few elements, like,,, and and making liberal use of the attribute. All authoring tools, whether WYSIWYG or not, should make a best effort attempt at enabling users to create well-structured, semantically rich, media-independent content.

User agents may impose implementation-specific limits on otherwise unconstrained inputs, e.g., to prevent denial of service attacks, to guard against running out of memory, or to work around platform-specific limitations. For compatibility with existing content and prior specifications, this specification describes two authoring formats: one based on XML (referred to as ), and one using a inspired by SGML (referred to as ). Implementations must support at least one of these two formats, although supporting both is encouraged. Some conformance requirements are phrased as requirements on elements, attributes, methods or objects. Such requirements fall into two categories: those describing content model restrictions, and those describing implementation behavior.

Those in the former category are requirements on documents and authoring tools. Those in the second category are requirements on user agents. Similarly, some conformance requirements are phrased as requirements on authors; such requirements are to be interpreted as conformance requirements on the documents that authors produce. (In other words, this specification does not distinguish between conformance criteria on authors and conformance criteria on documents.) 2.2.2. Dependencies This specification relies on several other underlying specifications. Unicode and Encoding The Unicode character set is used to represent textual data, and the Encoding specification defines requirements around.

This specification based on the terms defined in those specifications, as described earlier. For instance, a browser named 'FerretBrowser' could use 'ferret' as a vendor prefix, while a browser named 'Mellblom Browser' could use 'mb'. If both of these browsers invented extensions that turned elements into scratch-and-sniff areas, an author experimenting with these features could write: This smells of lemons!

Attribute names beginning with the two characters ' x-' are reserved for user agent use and are guaranteed to never be formally added to the HTML language. For flexibility, attributes names containing underscores (the U+005F LOW LINE character) are also reserved for experimental purposes and are guaranteed to never be formally added to the HTML language. Pages that use such attributes are by definition non-conforming. For DOM extensions, e.g., new methods and IDL attributes, the new members should be prefixed by vendor-specific strings to prevent clashes with future versions of this specification. For events, experimental event types should be prefixed with vendor-specific strings.

For example, while strongly discouraged from doing so, an implementation 'Foo Browser' could add a new IDL attribute ' fooTypeTime' to a control’s DOM interface that returned the time it took the user to select the current value of a control (say). On the other hand, defining a new control that appears in a form’s elements array would be in violation of the above requirement, as it would violate the definition of elements given in this specification. When adding new IDL attributes corresponding to content attributes of the form ' x- vendor- feature', the IDL attribute should be named ' vendor Feature' (i.e., the ' x' is dropped from the IDL attribute’s name). When vendor-neutral extensions to this specification are needed, either this specification can be updated accordingly, or an extension specification can be written that overrides the requirements in this specification. When someone applying this specification to their activities decides that they will recognize the requirements of such an extension specification, it becomes an for the purposes of conformance requirements in this specification. Someone could write a specification that defines any arbitrary byte stream as conforming, and then claim that their random junk is conforming. However, that does not mean that their random junk actually is conforming for everyone’s purposes: if someone else decides that the specification does not apply to their work, then they can quite legitimately say that the aforementioned random junk is just that, junk, and not conforming at all.

As far as conformance goes, what matters in a particular community is what that community agrees is applicable. Applicable specification. The conformance terminology for documents depends on the nature of the changes introduced by such applicable specifications, and on the content and intended interpretation of the document. Applicable specifications MAY define new document content (e.g., a foobar element), MAY prohibit certain otherwise conforming content (e.g., prohibit use of s), or MAY change the semantics, DOM mappings, or other processing rules for content defined in this specification. Whether a document is or is not a does not depend on the use of applicable specifications: if the syntax and semantics of a given is unchanged by the use of applicable specification(s), then that document remains a. If the semantics or processing of a given (otherwise conforming) document is changed by use of applicable specification(s), then it is not a. For such cases, the applicable specifications SHOULD define conformance terminology.

As a suggested but not required convention, such specifications might define conformance terminology such as: 'Conforming HTML+XXX document', where XXX is a short name for the applicable specification. (Example: 'Conforming HTML+AutomotiveExtensions document'). A consequence of the rule given above is that certain syntactically correct HTML documents may not be in the presence of applicable specifications. (Example: the applicable specification defines to be a piece of furniture — a document written to that specification and containing a element is NOT a, even if the element happens to be syntactically correct HTML.) User agents must treat elements and attributes that they do not understand as semantically neutral; leaving them in the DOM (for DOM processors), and styling them according to CSS (for CSS processors), but not inferring any meaning from them. When support for a feature is disabled (e.g., as an emergency measure to mitigate a security problem, or to aid in development, or for performance reasons), user agents must act as if they had no support for the feature whatsoever, and as if the feature was not mentioned in this specification. For example, if a particular feature is accessed via an attribute in a Web IDL interface, the attribute itself would be omitted from the objects that implement that interface — leaving the attribute on the object but making it return null or throw an exception is insufficient. Interactions with XPath and XSLT Implementations of XPath 1.0 that operate on parsed or created in the manners described in this specification (e.g., as part of the document.evaluate() API) must act as if the following edit was applied to the XPath 1.0 specification.

First, remove this paragraph: A in the node test is expanded into an using the namespace declarations from the expression context. This is the same way expansion is done for element type names in start and end-tags except that the default namespace declared with is not used: if the does not have a prefix, then the namespace URI is null (this is the same way attribute names are expanded). It is an error if the has a prefix for which there is no namespace declaration in the expression context. Then, insert in its place the following: A QName in the node test is expanded into an expanded-name using the namespace declarations from the expression context.

If the QName has a prefix, then there must be a namespace declaration for this prefix in the expression context, and the corresponding namespace URI is the one that is associated with this prefix. It is an error if the QName has a prefix for which there is no namespace declaration in the expression context. If the QName has no prefix and the principal node type of the axis is element, then the default element namespace is used. Otherwise if the QName has no prefix, the namespace URI is null. The default element namespace is a member of the context for the XPath expression. The value of the default element namespace when executing an XPath expression through the DOM3 XPath API is determined in the following way: • If the context node is from an HTML DOM, the default element namespace is '• Otherwise, the default element namespace URI is null.

This is equivalent to adding the default element namespace feature of XPath 2.0 to XPath 1.0, and using the HTML namespace as the default element namespace for HTML documents. It is motivated by the desire to have implementations be compatible with legacy HTML content while still supporting the changes that this specification introduces to HTML regarding the namespace used for HTML elements, and by the desire to use XPath 1.0 rather than XPath 2.0. This change is a of the XPath 1.0 specification, motivated by desire to have implementations be compatible with legacy content while still supporting the changes that this specification introduces to HTML regarding which namespace is used for HTML elements. XSLT 1.0 processors outputting to a DOM when the output method is 'html' (either explicitly or via the defaulting rule in XSLT 1.0) are affected as follows: If the transformation program outputs an element in no namespace, the processor must, prior to constructing the corresponding DOM element node, change the namespace of the element to the, the element’s local name, and the names of any non-namespaced attributes on the element. This requirement is a of the XSLT 1.0 specification, required because this specification changes the namespaces and case-sensitivity rules of HTML in a manner that would otherwise be incompatible with DOM-based XSLT transformations. (Processors that serialize the output are unaffected.) This specification does not specify precisely how XSLT processing interacts with the infrastructure (for example, whether an XSLT processor acts as if it puts any elements into a ). However, XSLT processors must if they successfully complete, and must set the first to ' interactive' and then to ' complete' if they are aborted.

This specification does not specify how XSLT interacts with the algorithm, how it fits in with the, nor how error pages are to be handled (e.g., whether XSLT errors are to replace an incremental XSLT output, or are rendered inline, etc). There are also additional non-normative comments regarding the interaction of XSLT and HTML, and of XSLT, XPath, and HTML. Case-sensitivity and string comparison Comparing two strings in a case-sensitive manner means comparing them exactly, code point for code point. Comparing two strings in an ASCII case-insensitive manner means comparing them exactly, code point for code point, except that the characters in the range U+0041 to U+005A (i.e., LATIN CAPITAL LETTER A to LATIN CAPITAL LETTER Z) and the corresponding characters in the range U+0061 to U+007A (i.e., LATIN SMALL LETTER A to LATIN SMALL LETTER Z) are considered to also match. Comparing two strings in a compatibility caseless manner means using the Unicode compatibility caseless match operation to compare the two strings, with no language-specific tailorings.

Except where otherwise stated, string comparisons must be performed in a manner. Converting a string to ASCII uppercase means replacing all characters in the range U+0061 to U+007A (i.e., LATIN SMALL LETTER A to LATIN SMALL LETTER Z) with the corresponding characters in the range U+0041 to U+005A (i.e., LATIN CAPITAL LETTER A to LATIN CAPITAL LETTER Z). Converting a string to ASCII lowercase means replacing all characters in the range U+0041 to U+005A (i.e., LATIN CAPITAL LETTER A to LATIN CAPITAL LETTER Z) with the corresponding characters in the range U+0061 to U+007A (i.e., LATIN SMALL LETTER A to LATIN SMALL LETTER Z). A string pattern is a prefix match for a string s when pattern is not longer than s and truncating s to pattern’s length leaves the two strings as matches of each other. Common microsyntaxes There are various places in HTML that accept particular data types, such as dates or numbers. This section describes what the conformance criteria for content in those formats is, and how to parse them. Implementors are strongly urged to carefully examine any third-party libraries they might consider using to implement the parsing of syntaxes described below.

For example, date libraries are likely to implement error handling behavior that differs from what is required in this specification, since error-handling behavior is often not defined in specifications that describe date syntaxes similar to those used in this specification, and thus implementations tend to vary greatly in how they handle errors. Common parser idioms The space characters, for the purposes of this specification, are U+0020 SPACE, U+0009 CHARACTER TABULATION (tab), U+000A LINE FEED (LF), U+000C FORM FEED (FF), and U+000D CARRIAGE RETURN (CR). The White_Space characters are those that have the Unicode property 'White_Space' in the Unicode PropList.txt data file.

This should not be confused with the 'White_Space' value (abbreviated 'WS') of the 'Bidi_Class' property in the Unicode.txt data file. The control characters are those whose Unicode 'General_Category' property has the value 'Cc' in the Unicode UnicodeData.txt data file. The uppercase ASCII letters are the characters in the range U+0041 LATIN CAPITAL LETTER A to U+005A LATIN CAPITAL LETTER Z. The lowercase ASCII letters are the characters in the range U+0061 LATIN SMALL LETTER A to U+007A LATIN SMALL LETTER Z. The ASCII letters are the characters that are either. The ASCII digits are the characters in the range U+0030 DIGIT ZERO (0) to U+0039 DIGIT NINE (9).

The alphanumeric ASCII characters are those that are either,,. The ASCII hex digits are the characters in the ranges U+0030 DIGIT ZERO (0) to U+0039 DIGIT NINE (9), U+0041 LATIN CAPITAL LETTER A to U+0046 LATIN CAPITAL LETTER F, and U+0061 LATIN SMALL LETTER A to U+0066 LATIN SMALL LETTER F. The uppercase ASCII hex digits are the characters in the ranges U+0030 DIGIT ZERO (0) to U+0039 DIGIT NINE (9) and U+0041 LATIN CAPITAL LETTER A to U+0046 LATIN CAPITAL LETTER F only. The lowercase ASCII hex digits are the characters in the ranges U+0030 DIGIT ZERO (0) to U+0039 DIGIT NINE (9) and U+0061 LATIN SMALL LETTER A to U+0066 LATIN SMALL LETTER F only. Some of the micro-parsers described below follow the pattern of having an input variable that holds the string being parsed, and having a position variable pointing at the next character to parse in input. For parsers based on this pattern, a step that requires the user agent to collect a sequence of characters means that the following algorithm must be run, with characters being the set of characters that can be collected: • Let input and position be the same variables as those of the same name in the algorithm that invoked these steps. • Let result be the empty string.

• While position doesn’t point past the end of input and the character at position is one of the characters, append that character to the end of result and advance position to the next character in input. • Return result. The step skip white space means that the user agent must that are. The collected characters are not used. When a user agent is to strip line breaks from a string, the user agent must remove any U+000A LINE FEED (LF) and U+000D CARRIAGE RETURN (CR) characters from that string. When a user agent is to strip leading and trailing white space from a string, the user agent must remove all that are at the start or end of the string. When a user agent is to strip and collapse white space in a string, it must replace any sequence of one or more consecutive in that string with a single U+0020 SPACE character, and then from that string.

When a user agent has to strictly split a string on a particular delimiter character delimiter, it must use the following algorithm: • Let input be the string being parsed. • Let position be a pointer into input, initially pointing at the start of the string. • Let tokens be an ordered list of tokens, initially empty. • While position is not past the end of input: • that are not the delimiter character. • Append the string collected in the previous step to tokens.

• Advance position to the next character in input. • Return tokens. For the special cases of splitting a string and, this algorithm does not apply (those algorithms also perform ). Boolean attributes A number of attributes are boolean attributes. The presence of a boolean attribute on an element represents the true value, and the absence of the attribute represents the false value.

If the attribute is present, its value must either be the empty string or a value that is an match for the attribute’s canonical name, with no leading or trailing white space. A boolean attribute without a value assigned to it (e.g. Checked) is implicitly equivalent to one that has the empty string assigned to it (i.e.

As a consequence, it represents the true value. The values 'true' and 'false' are not allowed on. To represent a false value, the attribute has to be omitted altogether.

Here is an example of a checkbox that is checked and disabled. The checked and disabled attributes are the. Cheese This could be equivalently written as this: Cheese You can also mix styles; the following is still equivalent: Cheese 2.4.3. Keywords and enumerated attributes Some attributes are defined as taking one of a finite set of keywords. Such attributes are called enumerated attributes.

The keywords are each defined to map to a particular state (several keywords might map to the same state, in which case some of the keywords are synonyms of each other; additionally, some of the keywords can be said to be non-conforming, and are only in the specification for historical reasons). In addition, two default states can be given.

The first is the invalid value default, the second is the missing value default. If an enumerated attribute is specified, the attribute’s value must be an match for one of the given keywords that are not said to be non-conforming, with no leading or trailing white space.

When the attribute is specified, if its value is an match for one of the given keywords then that keyword’s state is the state that the attribute represents. If the attribute value matches none of the given keywords, but the attribute has an invalid value default, then the attribute represents that state. Otherwise, if the attribute value matches none of the keywords but there is a missing value default state defined, then that is the state represented by the attribute. Otherwise, there is no default, and invalid values mean that there is no state represented. When the attribute is not specified, if there is a missing value default state defined, then that is the state represented by the (missing) attribute. Otherwise, the absence of the attribute means that there is no state represented. The empty string can be a valid keyword.

Numbers 2.4.4.1. Signed integers A string is a valid integer if it consists of one or more, optionally prefixed with a U+002D HYPHEN-MINUS character (-). A without a U+002D HYPHEN-MINUS (-) prefix represents the number that is represented in base ten by that string of digits.

A with a U+002D HYPHEN-MINUS (-) prefix represents the number represented in base ten by the string of digits that follows the U+002D HYPHEN-MINUS, subtracted from zero. The rules for parsing integers are as given in the following algorithm. When invoked, the steps must be followed in the order given, aborting at the first step that returns a value.

This algorithm will return either an integer or an error. • Let input be the string being parsed. • Let position be a pointer into input, initially pointing at the start of the string. • Let sign have the value 'positive'. • If position is past the end of input, return an error. • If the character indicated by position (the first character) is a U+002D HYPHEN-MINUS character (-): • Let sign be 'negative'.

• Advance position to the next character. • If position is past the end of input, return an error. Otherwise, if the character indicated by position (the first character) is a U+002B PLUS SIGN character (+): • Advance position to the next character. (The ' +' is ignored, but it is not conforming.) • If position is past the end of input, return an error.

• If the character indicated by position is not an, then return an error. • that are, and interpret the resulting sequence as a base-ten integer. Let value be that integer. • If sign is 'positive', return value, otherwise return the result of subtracting value from zero.

Non-negative integers A string is a valid non-negative integer if it consists of one or more. A represents the number that is represented in base ten by that string of digits.

The rules for parsing non-negative integers are as given in the following algorithm. When invoked, the steps must be followed in the order given, aborting at the first step that returns a value. This algorithm will return either zero, a positive integer, or an error. • Let input be the string being parsed. • Let value be the result of parsing input using the.

• If value is an error, return an error. • If value is less than zero, return an error. • Return value. Floating-point numbers A string is a valid floating-point number if it consists of: • Optionally, a U+002D HYPHEN-MINUS character (-). • One or both of the following, in the given order: • A series of one or more. • Both of the following, in the given order: • A single U+002E FULL STOP character (.).

• A series of one or more. • Optionally: • Either a U+0065 LATIN SMALL LETTER E character (e) or a U+0045 LATIN CAPITAL LETTER E character (E). Arcgis License Manager Pre-release Version. • Optionally, a U+002D HYPHEN-MINUS character (-) or U+002B PLUS SIGN character (+). • A series of one or more.

This specification encodes dates and times according to a common subset of the standard for dates. This means that encoded dates will look like 1582-03-01, 0033-03-27, or 2016-03-01, and date-times will look like 1929-11-13T19:00Z, 0325-06-03T00:21+10:30. The format is approximately YYYY-MM-DDTHH:MM:SS.DD±HH:MM, although some parts are optional, for example to express a month and day as in a birthday, a time without time-zone information, and the like. Times are expressed using the 24-hour clock, and it is an error to express leap seconds. Dates are expressed in the between the proleptic year 0000, and the year 9999.

Other years cannot be encoded. The is the calendar most common globally since around 1950, and is likely to be understood by almost everyone for dates between the years 1950 and 9999, and for many people for dates in the last few decades or centuries. The Gregorian calendar was adopted officially in different countries at different times, between the years 1582 when it was proposed by Pope Gregory XIII as a replacement for the Julian calendar, and 1949 when it was adopted by the People’s republic of China. For most practical purposes, dealing with the present, recent past, or the next few thousand years, this will work without problems. For dates before the adoption of the Gregorian Calendar - for example prior to 1917 in Russia or Turkey, prior to 1752 in Britain or the then British colonies of America, or prior to 1582 in Spain, the Spanish colonies in America, and the rest of the world, dates will not match those written at the time. The use of the Gregorian calendar as an underlying encoding is a somewhat arbitrary choice.

Many other calendars were or are in use, and the interested reader should look for information on the Web. See also the discussion of in forms (for authors),, and the element. In the algorithms below, the number of days in month month of year year is: 31 if month is 1, 3, 5, 7, 8, 10, or 12; 30 if month is 4, 6, 9, or 11; 29 if month is 2 and year is a number divisible by 400, or if year is a number divisible by 4 but not by 100; and 28 otherwise. This takes into account leap years in the Gregorian calendar. When are used in the date and time syntaxes defined in this section, they express numbers in base ten. While the formats described here are intended to be subsets of the corresponding ISO8601 formats, this specification defines parsing rules in much more detail than ISO8601. Implementors are therefore encouraged to carefully examine any date parsing libraries before using them to implement the parsing rules described below; ISO8601 libraries might not parse dates and times in exactly the same manner.

Where this specification refers to the proleptic Gregorian calendar, it means the modern Gregorian calendar, extrapolated backwards to year 1. A date in the, sometimes explicitly referred to as a proleptic-Gregorian date, is one that is described using that calendar even if that calendar was not in use at the time (or place) in question. Months A month consists of a specific with no time-zone information and no date information beyond a year and a month. A string is a valid month string representing a year year and month month if it consists of the following components in the given order: • Four or more, representing year, where year >0 • A U+002D HYPHEN-MINUS character (-) • Two, representing the month month, in the range 1 ≤ month ≤ 12 For example, February 2005 is encoded 2005-02, and March of the year 33AD (as a proleptic gregorian date) is encoded 0033-03. The expression 325-03 does not mean March in the year 325, it is an error, because it does not have 4 digits for the year.

The rules to parse a month string are as follows. This will return either a year and month, or nothing. If at any point the algorithm says that it 'fails', this means that it is aborted at that point and returns nothing. • Let input be the string being parsed. • Let position be a pointer into input, initially pointing at the start of the string. • to obtain year and month.

If this returns nothing, then fail. • If position is not beyond the end of input, then fail. • Return year and month.

The rules to parse a month component, given an input string and a position, are as follows. This will return either a year and a month, or nothing.

If at any point the algorithm says that it 'fails', this means that it is aborted at that point and returns nothing. If the collected sequence is not at least four characters long, then fail. Otherwise, interpret the resulting sequence as a base-ten integer. Let that number be the year. • If year is not a number greater than zero, then fail. • If position is beyond the end of input or if the character at position is not a U+002D HYPHEN-MINUS character, then fail. Otherwise, move position forwards one character.

If the collected sequence is not exactly two characters long, then fail. Otherwise, interpret the resulting sequence as a base-ten integer. Let that number be the month. • If month is not a number in the range 1 ≤ month ≤ 12, then fail. • Return year and month.

Dates A date consists of a specific with no time-zone information, consisting of a year, a month, and a day. A string is a valid date string representing a year year, month month, and day day if it consists of the following components in the given order: • A, representing year and month • A U+002D HYPHEN-MINUS character (-) • Two, representing day, in the range 1 ≤ day ≤ maxday where maxday is the For example, 29 February 2016 is encoded 2016-02-29, and 3 March of the year 33AD (as a proleptic gregorian date) is encoded 0033-03-03. The expression 325-03-03 does not mean 3 March in the year 325, it is an error, because it does not have 4 digits for the year.

The rules to parse a date string are as follows. This will return either a date, or nothing. If at any point the algorithm says that it 'fails', this means that it is aborted at that point and returns nothing. • Let input be the string being parsed.

• Let position be a pointer into input, initially pointing at the start of the string. • to obtain year, month, and day. If this returns nothing, then fail. • If position is not beyond the end of input, then fail. • Let date be the date with year year, month month, and day day. • Return date. The rules to parse a date component, given an input string and a position, are as follows.

This will return either a year, a month, and a day, or nothing. If at any point the algorithm says that it 'fails', this means that it is aborted at that point and returns nothing. • to obtain year and month. If this returns nothing, then fail. • Let maxday be the. • If position is beyond the end of input or if the character at position is not a U+002D HYPHEN-MINUS character, then fail. Otherwise, move position forwards one character.

If the collected sequence is not exactly two characters long, then fail. Otherwise, interpret the resulting sequence as a base-ten integer. Let that number be the day.

• If day is not a number in the range 1 ≤ day ≤ maxday, then fail. • Return year, month, and day. Yearless dates A yearless date consists of a Gregorian month and a day within that month, but with no associated year. A string is a valid yearless date string representing a month month and a day day if it consists of the following components in the given order: • Optionally, two U+002D HYPHEN-MINUS characters (-) • Two, representing the month month, in the range 1 ≤ month ≤ 12 • A U+002D HYPHEN-MINUS character (-) • Two, representing day, in the range 1 ≤ day ≤ maxday where maxday is the in the month month and any arbitrary leap year (e.g., 4 or 2000) In other words, if the month is ' 02', meaning February, then the day can be 29, as if the year was a leap year.

For example, 29 February is encoded 02-29, and 3 March is encoded 03-03. The rules to parse a yearless date string are as follows. This will return either a month and a day, or nothing.

If at any point the algorithm says that it 'fails', this means that it is aborted at that point and returns nothing. • Let input be the string being parsed. • Let position be a pointer into input, initially pointing at the start of the string. • to obtain month and day. If this returns nothing, then fail. • If position is not beyond the end of input, then fail.

• Return month and day. The rules to parse a yearless date component, given an input string and a position, are as follows. This will return either a month and a day, or nothing. If at any point the algorithm says that it 'fails', this means that it is aborted at that point and returns nothing. • that are U+002D HYPHEN-MINUS characters (-). If the collected sequence is not exactly zero or two characters long, then fail. If the collected sequence is not exactly two characters long, then fail.

Otherwise, interpret the resulting sequence as a base-ten integer. Let that number be the month. • If month is not a number in the range 1 ≤ month ≤ 12, then fail.

• Let maxday be the in month month of any arbitrary leap year (e.g., 4 or 2000). • If position is beyond the end of input or if the character at position is not a U+002D HYPHEN-MINUS character, then fail. Otherwise, move position forwards one character.

If the collected sequence is not exactly two characters long, then fail. Otherwise, interpret the resulting sequence as a base-ten integer. Let that number be the day. • If day is not a number in the range 1 ≤ day ≤ maxday, then fail.

• Return month and day. Times A time consists of a specific time with no time-zone information, consisting of an hour, a minute, a second, and a fraction of a second. The following are some examples of dates written as. ' 0037-12-13 00:00Z' Midnight 'London time' (UTC) on the birthday of the Roman Emperor Nero. See below for further discussion on which date this actually corresponds to. ' 1979-10-14T12:00:00.001-04:00' One millisecond after noon on October 14th 1979, in the time zone in use on the east coast of the USA during daylight saving time.

' 8592-01-01T02:09+02:09' Midnight UTC on the 1st of January, 8592. The time zone associated with that time is two hours and nine minutes ahead of UTC, which is not currently a real time zone, but is nonetheless allowed. Several things are notable about these dates: • Years with fewer than four digits have to be zero-padded. The date '37-12-13' is not a valid date.

• If the ' T' is replaced by a space, it must be a single space character. The string ' 2001-12-21 12:00Z' (with two spaces between the components) would not be parsed successfully. • To unambiguously identify a date it has to be first converted to the Gregorian calendar (e.g., from the Hijri, Jewish, Julian or other calendar). For example, the Roman Emperor Nero was born on the 15th of December 37 in the Julian Calendar, which is the 13th of December 37 in the. • The time and time-zone offset components are not optional. • Dates before the year one or after the year 9999 in teh Gregorian calendar cannot be represented as a datetime in this version of HTML.

• Time-zone offsets for a place may vary, for example due to daylight savings time. The zone offset is not a complete time zone specification. When working with real date and time values, consider using a separate field for time zone, perhaps using IANA time zone IDs. If a user connects to a server with a self-signed certificate, the user agent could allow the connection but just act as if there had been no encryption.

If the user agent instead allowed the user to override the problem and then displayed the page as if it was fully and safely encrypted, the user could be easily tricked into accepting man-in-the-middle connections. If a user connects to a server with full encryption, but the page then refers to an external resource that has an expired certificate, then the user agent will act as if the resource was unavailable, possibly also reporting the problem to the user. If the user agent instead allowed the resource to be used, then an attacker could just look for 'secure' sites that used resources from a different host and only apply man-in-the-middle attacks to that host, for example taking over scripts in the page. If a user bookmarks a site that uses a CA-signed certificate, and then later revisits that site directly but the site has started using a self-signed certificate, the user agent could warn the user that a man-in-the-middle attack is likely underway, instead of simply acting as if the page was not encrypted.

Determining the type of a resource The Content-Type metadata of a resource must be obtained and interpreted in a manner consistent with the requirements of the MIME Sniffing specification. The computed type of a resource must be found in a manner consistent with the requirements given in the MIME Sniffing specification for finding the computed media type of the relevant sequence of octets. The rules for sniffing images specifically and the rules for distinguishing if a resource is text or binary are also defined in the MIME Sniffing specification. Both sets of rules return a as their result. It is imperative that the rules in the MIME Sniffing specification be followed exactly.

When a user agent uses different heuristics for content type detection than the server expects, security problems can occur. For more details, see the MIME Sniffing specification. Extracting character encodings from elements The algorithm for extracting a character encoding from a element, given a string s, is as follows.

It either returns a character encoding or nothing. • Let position be a pointer into s, initially pointing at the start of the string. • Loop: Find the first seven characters in s after position that are an match for the word ' charset'. If no such match is found, return nothing and abort these steps. • Skip any that immediately follow the word ' charset' (there might not be any).

• If the next character is not a U+003D EQUALS SIGN (=), then move position to point just before that next character, and jump back to the step labeled loop. • Skip any that immediately follow the equals sign (there might not be any). • Process the next character as follows: If it is a U+0022 QUOTATION MARK character (') and there is a later U+0022 QUOTATION MARK character (') in s If it is a U+0027 APOSTROPHE character (') and there is a later U+0027 APOSTROPHE character (') in s Return the result of from the substring that is between this character and the next earliest occurrence of this character. If it is an unmatched U+0022 QUOTATION MARK character (') If it is an unmatched U+0027 APOSTROPHE character (') If there is no next character Return nothing. Otherwise Return the result of from the substring that consists of this character up to but not including the first or U+003B SEMICOLON character (;), or the end of s, whichever comes first. This algorithm is distinct from those in the HTTP specification (for example, HTTP doesn’t allow the use of single quotes and requires supporting a backslash-escape mechanism that is not supported by this algorithm). While the algorithm is used in contexts that, historically, were related to HTTP, the syntax as supported by implementations diverged some time ago.

CORS settings attributes A CORS settings attribute is an. The following table lists the keywords and states for the attribute — the keywords in the left column map to the states in the cell in the second column on the same row as the keyword. Keyword State Brief description anonymous Anonymous for the element will have their set to ' cors' and their set to ' same-origin'. Use-credentials Use Credentials for the element will have their set to ' cors' and their set to ' include'. The empty string is also a valid keyword, and maps to the state.

The attribute’s invalid value default is the state. For the purposes of, the canonical case for the state is the keyword. The missing value default, used when the attribute is omitted, is the No CORS state. Referrer policy attributes A referrer policy attribute is an.

Each, including the empty string, is a keyword for this attribute, mapping to a state of the same name. The attribute’s and are both the empty string state. The impact of these states on the processing model of various is defined in more detail throughout this specification, in the WHATWG Fetch standard, and in Referrer Policy. For example, the attribute on the object means that there is a strong reference from a object to its object. Similarly, there is always a strong reference from a to any descendant nodes, and from any node to its owner. Namespaces The HTML namespace is: The MathML namespace is: The SVG namespace is: The XLink namespace is: The XML namespace is: The XMLNS namespace is: Data mining tools and other user agents that perform operations on content without running scripts, evaluating CSS or XPath expressions, or otherwise exposing the resulting DOM to arbitrary content, may 'support namespaces' by just asserting that their DOM node analogs are in certain namespaces, without actually exposing the above strings.

In, namespace prefixes and namespace declarations do not have the same effect as in XML. For instance, the colon has no special meaning in HTML element names. Safe passing of structured data This section uses the terminology and typographic conventions from the JavaScript specification. Serializable objects support being serialized, and later deserialized, in a way that is independent of any given. This allows them to be stored on disk and later restored, or cloned across and boundaries (including across documents of different or in different ).

Not all objects are, and not all aspects of objects that are are necessarily preserved when they are serialized. Can be if they implement only interfaces decorated with the [Serializable] IDL. Such interfaces must also define the following algorithms: serialization steps, taking a value, a serialized, and a boolean forStorage A set of steps that serializes the data in value into fields of serialized. The resulting data serialized into serialized must be independent of any. These steps may throw an exception if serialization is not possible. These steps may perform a to serialize nested data structures.

They should not call directly, as doing so will omit the important memory argument. The introduction of these steps should omit mention of the forStorage argument if it is not relevant to the algorithm. Deserialization steps, taking a serialized and a value A set of steps that deserializes the data in serialized, using it to set up value as appropriate. Value will be a newly-created instance of the type in question, with none of its internal data set up; setting that up is the job of these steps. These steps may throw an exception if deserialization is not possible. These steps may perform a to deserialize nested data structures. They should not call directly, as doing so will omit the important targetRealm and memory arguments.

It is up to the definition of individual platform objects to determine what data is serialized and deserialized by these steps. Typically the steps are very symmetric. The [Serializable] extended attribute must take no arguments, and must not appear on anything other than an interface. It must appear only once on an interface. It must not be used on a callback interface. If it appears on a partial interface or an interface that is really a mixin, then it must also appear on the original or mixed-in-to interface, and any supplied and for the partial interface or mixin should be understood as being appended to those of the original or mixed-in-to interface.