manakai DOM Extensions

manakai DOM Extensions

[7] This is a work-in-progress documentation for manakai's DOM extensions.

Conventions

[30]

Keywords MUST, MUST NOT, REQUIRED, SHOULD, SHOULD NOT, MAY, and OPTIONAL are interpreted as described in RFC 2119 [RFC 2119].

[32] An InterfaceName object refers to an object that implements InterfaceName interface. Note that the object might also implement other interfaces than InterfaceName. However, unless explicitly specified, the term Text object does not refer to a CDATASection object though the CDATASection interface extends the Text interface.

[33] When a CONSTANT_NAME ExceptionInterfaceName is said to be thrown, an implementation MUST throw an exception object that implements the ExceptionInterfaceName interface and whose code attribute is set to the value of CONSTANT_NAME.

[34] Algorithms shown in this document does not intend to constraint the way to implement that feature. Implementations are always free to implement that feature in any way as long as that has the same effect as the normative algorithm.

New interfaces

Extensions to existing interfaces

Backward compatibility

[64] It MUST implement the definitions in the DOM Standard but commented out with markers "AttrExodus" or "NodeExodus". DOM

[65] This is a willful violation to the DOM Standard that is intended to obsolete them. Since manakai is a Perl implementation of DOM, it has different compatibility requirements from those in Web browsers.

[68]

partial interface Node {
  attribute DOMString prefix;
};

[66] On setting, the prefix attribute of the Node interface MUST run these steps:

  1. Let prefix be the value being assigned.
  2. If the context object's namespace is null or the empty string, throw an "NamespaceError" exception and terminate these steps.
  3. If prefix is the empty string, let prefix be null.
  4. If prefix is not null, run these substeps:
    1. If prefix does not match the Name production in XML, throw an "InvalidCharacterError" exception and terminate these steps.
    2. If prefix does not match the NCName production in Namespaces in XML, throw a "NamespaceError" exception and terminate these steps.
  5. Let the prefix of the context object be prefix.

[67] This is the Chrome behavior.

[78] For the isEqualNode method of the Node interface, the following condition MUST be applied as well as the other conditions: If the nodes are Attr objects, their local name, namespace, and value are equal respectively.

[80] If the context object is an Attr, the textContent attribute of the Node interface MUST return the value of the attribute on getting, or assign new value to the value of the attribute on setting.

[81] In the "clone" steps, when node is an Attr node, or node is an Element node and its attribute list is copied, namespace prefix, namespace, local name, and value of attributes MUST be copied.

[82] Other values, including specified, are not copied.

[89] The isSupported method of the Node interface MUST return true.

[90] If a non-null value is set to the handler argument to the setUserData method of the Node interface, a "NotSupportedError" MAY be thrown.

[150] When the value attribute or the manakaiAppendText method of the Attr object set the value of the attribute, at the end of the steps, attribute is set and attribute is changed if there is non-null owner element for the context object.

[151] When the Attr node is adopted, if its owner element is not null, just after the node's owner element is set to null but before the node document is set to the new value, attribute is removed.

[152] When an element's id attribute is set to the empty string, unset the element's ID.

[153] When an element's class attribute is set to the empty string, set the element's classes to the empty list.

Extension to the Element interface

[54] Manakai's Element objects implement the innerHTML attribute of the HTMLElement interface.

Element type accessor

[83]

partial interface Element {
  readonly attribute DOMString manakaiTagName;
};

[84] The manakaiTagName attribute of the Element interface MUST return the same value as the tagName attribute, except that the return value are not converted to uppercase even when the context object is an HTML element.

[12] The manakaiElementTypeMatch method returns whether the Element belongs to the specified element type or not.

This method takes two parameters: namespaceURI and localName.

The namespaceURI parameter is a DOMString. It represents the namespace URI of the element type to test. Both null and an empty string represents the null namespace as in the namespaceURI parameters of other similar methods.

The localName parameter is a DOMString. It represents the local name of the element type to test.

This method returns a boolean value.

This method MUST return null if and only if:

Otherwise, the method MUST return false.

Metadata accessor

[18] The manakaiBaseURI attribute of the Element and ProcessingInstruction interfaces corresponding to the base URI property in the XML Information Set. It contains the base DOM URI of the Element or ProcessingInstruction object, if it is explicitly set to the object.

To obtain the computed base URI of the Element or ProcessingInstruction object, use the baseURI attribute of the Node interface instead.

The type of this attribute is DOMString. This attribute is read-write.

On getting, the base DOM URI MUST be returned if it is specified to the Element or ProcessingInstruction object. Otherwise, null MUST be returned.

On setting, if the Element or ProcessingInstruction object is read-only, then a NO_MODIFICATION_ALLOWED_ERR DOMException MUST be thrown. Otherwise, if the new value is null, then the explicit specification of the base URI of the Element or ProcessingInstruction object is unset. Otherwise, the new value is set to the Element or ProcessingInstruction object as the base URI. Note that no lexical checking is performed on the new value.

The manakaiBaseURI, which is analogue to the base URI property, is independent from the xml:base attribute. Setting the manakaiBaseURI does not affect to the xml:base or any other base URI sources and vice versa.

Identifiers

[104]

partial interface Element {
  readonly attribute DOMString[] manakaiIds;
};

[55] The manakaiIds attribute of an element element, on getting, MUST follow the steps below:

  1. Let list a new empty DOMStringList DOMString[] object.
  2. For each Attr attribute in the attributes list of the element:
    1. Skip the following substeps if the isId of the attribute is false.
    2. Let value the value of the attribute.
    3. Append value to list if there is no string that is equal to value in list yet.
  3. Return list.

The DOMStringList DOMString[] object returned by this attribute is not live.
Values contained in the DOMStringList DOMString[] object returned by this attribute might not be a valid ID; for example, it might be the empty string, or there are another element with same ID in the earlier part of the document in tree order.
The order in which strings are listed in the DOMStringList DOMString[] object depends on the order of the Attr nodes in the attributes attribute. In other word, the order is implementation dependent but is stable in a specific implementation.

The type of this attribute is DOMStringList. This attribute is read-only.

Microdata

[179]

partial interface HTMLElement {
  HTMLPropertiesCollection manakaiGetProperties();
};

[180] The manakaiGetProperties method MUST return a static HTMLPropertiesCollection that contains the nodes that would be contained in the properties HTMLPropertiesCollection of the context object. The PropertyNodeList objects returned by the HTMLPropertiesCollection MUST also be static.

[181] See also manakai's DOM Perl binding, which defines how HTMLPropertiesCollection is implemented in Perl.

Extension to the NodeList and the NamedNodeMap interfaces

This attribute is obsolete.

[8] The manakaiReadOnly attribute contains whether the NodeList or NamedNodeMap is read-only or not.

The type of this attribute is boolean. This attribute is read-only.

ISSUE: Is setter necessary?
  1. If the NodeList or NamedNodeMap is the read-only attribute value of a Node, then the getter MUST return the manakaiReadOnly attribute value of the Node.
  2. Otherwise, if the NodeList is the childNodes attribute value of a Node whose nodeType does never have any child by definition, then the getter MUST return true.
  3. Otherwise, the getter MUST return true unless otherwise specified.
For example, the manakaiReadOnly attribute of the childNodes NodeList of an Element has same value as the manakaiReadOnly of the Element, while the manakaiReadOnly attribute of a NodeList obtained by the getElementsByTagNameNS method of that Element or the manakaiReadOnly attribute of a NodeList of a ProcessingInstruction always exhibit true.

Extension to the Attr interface

[85]

partial interface Attr {
  readonly attribute DOMString manakaiName;
};

[86] The manakaiName attribute of the Attr interface MUST return the name of the context object.

[87] Use of this attribute is discouraged in favor of the name attribute.

Setter extension

[19] The specified attribute is now read-write.

partial interface Attr {
  attribute boolean specified;
}

On setting, if the Attr is read-only, then an NO_MODIFICATION_ALLOWED_ERR exception MUST be thrown. Otherwise, the new value MUST set as the specified flag of the Attr, except when the ownerElement of the Attr is null, in which case the specified flag MUST be set to true (if not yet) nevertheless the new value.

[77] On setting, the specified attribute of the Attr interface MUST set the specified flag of the context object to the newly-specified value.

[76] Note that setting specified flag to false might make the serialized representation of the Document inconsistent with the Document itself.

[102] The specified attribute MUST return true.

[20] The isId attribute is now read-write.

On setting, if the Attr is read-only, then an NO_MODIFICATION_ALLOWED_ERR exception MUST be thrown. Otherwise, the flag that represents whether the Attr is a user-determined ID attribute or not MUST be set to the new value.

Setting false to this attribute does not make the Attr non-ID if the Attr is marked as an ID by other mean than the user-determined ID flag, e.g. by DTD attribute definition.

[103] The isId attribute MUST return true if the namespace of the context object is null and the local name of the context object is id, or false otherwise.

Attribute type accessor

[21] The manakaiAttributeType attribute contains the declared type of the Attr.

The type of this attribute is unsigned short. This attribute is read-write.

This attribute corresponding to the attribute type property of an attribute information item in the XML Information Set.

The getter MUST return the declared type of the Attr. It is expected that a constant in the DeclaredValueType constant group is returned. If no declared type is explicitly set, then NO_TYPE_ATTR MUST be returned.

On setting, if the Attr is read-only, then an NO_MODIFICATION_ALLOWED_ERR exception MUST be thrown. Otherwise, the new value MUST be set as the attribute value. It is expected that a constant in the DeclaredValueType constant group is set to the attribute, though it is not checked by the attribute.

Extensions to the DocumentType interface

Children

[48] DocumentType nodes MAY contain zero or more ProcessingInstruction nodes in its child node list.

If a DocumentType node is created from the document type declaration information item in an XML information set, the children list MUST be reflected to the childNodes list of the DocumentType node; the list MUST contain zero or more ProcessingInstruction nodes created from the processing instruction information items in the children list in the same order.

If a DocumentType node is mapped to a document type declaration information item, the children list MUST reflect the childNodes list of the DocumentType node; the list MUST contain zero or more processing instruction information items mapped from the ProcessingInstruction nodes in the childNodes list in the same order.

If a parser create a DocumentType node and mark it as read-only, then all child nodes MUST also be marked as read-only.

[141]

partial interface DocumentType {
  [TreatNullAs=EmptyString] attribute DOMString publicId;
  [TreatNullAs=EmptyString] attribute DOMString systemId;
};
partial interface Entity {
  [TreatNullAs=EmptyString] attribute DOMString publicId;
  [TreatNullAs=EmptyString] attribute DOMString systemId;
};
partial interface Notation {
  [TreatNullAs=EmptyString] attribute DOMString publicId;
  [TreatNullAs=EmptyString] attribute DOMString systemId;
};

[37] The publicId attribute and the systemId attribute of DocumentType, Entity, and Notation objects are now read-write.

The setter MUST throw a NO_MODIFICATION_ALLOWED_ERR DOMException if the Node object is read-only. Otherwise, it MUST set the specified value to the attribute. No normalization, lexical validation, or relative reference resolving is performed. null, which represents no public or system identifier is provided, might be specified.

Setting public or system identifier does never result in any lexical or logical structure of the document being changed. In particular, no external entity referenced by new identifier will be loaded.

Setting an invalid or non-normalized identifier might make the object non-serializable. Setting a non-null public identifier to a DocumentType or Entity object that does not have non-null system identifier or setting null as the system identifier of a DocumentType or Entity object that does have non-null public identifier will make that object non-serializable.
ISSUE: In HTML5, Firefox 1.5, and Opera 9, not specifying public or system identifier results in empty strings.

[41] The declarationBaseURI attribute and the manakaiDeclarationBaseURI attribute of a DocumentType object represent the base DOM URI of the DocumentType object.

Use of declarationBaseURI attribute is deprecated.

It is the base URI of the document type declaration if the DocumentType object comes from an XML document entity and can be used to resolve relative DOM URI specified to the systemId attribute of the DocumentType object.

This attribute is read-write. The type of this attribute is DOMString.

The getter MUST return the value of the baseURI attribute of the ownerDocument of the DocumentType object if the ownerDocument attribute is not null. If it is null, the getter MUST return null.

The setter MUST do nothing, including when the DocumentType object is read-only.

Implementation Information

This attribute is obsolete.

[49] The implementation attribute represents the DOM implementation which the DocumentType node belongs to.

This attribute is read-only. The type of this attribute is DOMImplementation.

The getter of this attribute MUST return the DOMImplementation object which the DocumentType node belongs to.

Extensions to the Entity interface

Entity Identifiers

[117]

partial interface Entity {
  attribute DOMString publicId;
  attribute DOMString systemId;
  attribute DOMString? declarationBaseURI;
  attribute DOMString? manakaiDeclarationBaseURI;
  attribute DOMString? manakaiEntityBaseURI;
  attribute DOMString? manakaiEntityURI;
};

partial interface Notation {
  attribute DOMString? manakaiDeclarationBaseURI;
};

[38] The publicId attribute and the systemId attribute of the Entity interface is so extended that they are read-write. See >>37 for the complete definition.

[40] The manakaiDeclarationBaseURI attribute of an Entity or Notation object and the declarationBaseURI attribute of the Entity object represents the base DOM URI of the entity or notation declaration by which the entity or notation represented by the Node object is declared.

The getter MUST return the declaration base DOM URI. If there is no explicit declaration base URI information attached to the Node object, then the base URI of the Node object, i.e. the baseURI attribute value of the Node object, MUST be returned.

Note that if there is no explicit base URI information attached to the Node object and the baseURI attribute of that object is null, then the value of this attribute is also null.

The setter MUST throw a NO_MODIFICATION_ALLOWED_ERR DOMException if the Node object is read-only. Otherwise, it MUST set the specified value as the declaration base DOM URI of the Node object. The specified value must be an absolute DOM URI. However, no lexical validation or relative reference resolution is performed on setting. In addition, it does not affect on the value of systemId attribute, the replacement subtree of the Entity object, nor any of entity reference or notation attribute in the document.

If null is specified, the declaration base DOM URI of the Node is unset. It does not affect to the baseURI attribute.

If an Entity or Notation object is created from an XML Information Set information item, the declaration base URI property value, if specified, or null otherwise, MUST be set to this attribute.

If an Entity or Notation object is mapped to an unexpanded entity information item or a notation information item, the manakaiDeclarationBaseURI attribute value, if it is non-null, or no value otherwise, MUST be set to the declaration base URI property of the information item.

[44] The manakaiEntityBaseURI attribute of an Entity object represents the base DOM URI of the entity represented by the Entity object.

This attribute is read-write. The type of this attribute is DOMString.

The getter MUST return the base DOM URI of the entity by the following algorithm:

  1. If the base DOM URI of the referenced entity is explicitly specified to the object, then return it.
  2. Otherwise, if the manakaiEntityURI attribute of the object has non-null value, then return it.
  3. Otherwise, return the baseURI attribute value of the EntityReference object.

Therefore, the entity base URI for internal general entities are same as the base URI for document unless explicitly overridden by the application.
Note that the algorithm might return null.

The setter MUST throw a NO_MODIFICATION_ALLOWED_ERR DOMException if the object is read-only. Otherwise, if the specified value is null, it MUST unset the explicit entity base URI specification for the object. Otherwise, it MUST set the specified value as the entity base URI of the object.

The specified value must be an absolute DOM URI. However, no lexical validation or relative reference resolution is performed on the setting. Likewise, setting the value does not affect on the entity base URI of any EntityReference object whose nodeName, publicId, or systemId is same as the Entity object's. The exception is the nodes in the subtree rooted by the Entity object, where the new base URI might affect the base URIs of those objects.

[45] The manakaiEntityURI attribute of an Entity object represents the DOM URI of the entity represented by the object.

It might or might not be equal to the DOM URI contained in the systemId attribute of the object or the absolute URI obtained by resolving systemId attribute against manakaiDeclarationBaseURI attribute of the object. In particular, in case a catalog mechanism is used or a redirection is encountered during the entity resolution phase of the parsing, the entity URI is typically different from the one specified as the system identifier.
ISSUE: Security concern - in scripted implementation, it might be inappropriate to leak a URI of catalog-resolved entity.

The getter MUST return the DOM URI of the entity obtained by the following algorithm:

  1. If the DOM URI of the entity represented by the object is explicitly set by application or during the tree construction, then return it.
  2. Otherwise, if the systemId attribute of the object contains a non-null value, then return the value, resolved against the manakaiDeclarationBaseURI attribute value if the value is not an absolute DOM URI and that attribute value is not null.
  3. Return null.

The setter MUST throw a NO_MODIFICATION_ALLOWED_ERR DOMException if the object is read-only. Otherwise, if the specified value is null, it MUST unset the explicit entity URI specification for the object. Otherwise, it MUST set the specified value as the entity URI of the object.

The specified value must be an absolute DOM URI. However, no lexical validation or relative reference resolution is performed on the setting. Likewise, setting the value does not affect on the entity base URI of any EntityReference object whose nodeName, publicId, or systemId is same as the Entity object's. The exception is the nodes in the subtree rooted by the Entity object, where the new base URI might affect the base URIs of those objects.

TODO: We need to define the exact way to get absolute DOM URI from a relative DOM URI. (And "http://www.example.com/a/../b/" is normalized or not.)
ISSUE: Should we provide an attribute that contains the absolute URI representation of the system id?

Character Encoding

[52] The inputEncoding attribute of the Entity interface is now read-write. See >>17 for the definition.

Entity Content

[118]

partial interface Entity {
  attribute boolean hasReplacementTree;
  attribute boolean isExternallyDeclared;
  attribute DOMString? notationName;
  attribute DOMString? xmlEncoding;
  attribute DOMString? xmlVersion;
};

[27] The hasReplacementTree attribute of an Entity object contains whether the structure of the replacement text is available via the child list of the Entity or not.

The getter MUST return the value of the flag associated to this attribute.

The setter MUST throw a NO_MODIFICATION_ALLOWED_ERR DOMException if the Entity object is read-only. Otherwise, it MUST set the specified value to the flag associated to this attribute.

If a parser create a Entity object that represents a general entity, it set the value of this attribute. If it set this attribute as false, then it MUST make the child list of the Entity object empty.

An application might set this attribute as false even if the Entity object has child nodes. If the value of this attribute is false, any child of the Entity object should be ignored for the purpose of e.g. serialization.

When an EntityReference object is created and then the subtree of the Entity object is cloned to that object, any child node MUST be ignored if the attribute is set to false.

Newly created Entity object by createGeneralEntity has hasReplacementTree attribute set to false.

[46] The notationName attribute is now read-write.

The setter MUST throw a NO_MODIFICATION_ALLOWED_ERR DOMException if the object is read-only. Otherwise, it MUST set the specified value as the notation name of the object. Note that the new value might be null.

The setter perform no lexical validation of the new value. The new notation name might not be an XML Name and therefore the object might become non-serializable. In a well-formed XML document, unparsed entities have notation names and parsed entities do not. However, setting new value to the attribute might break this rule and the result document might be inconsistent.

[47] The xmlEncoding attribute and the xmlVersion attribute of the Entity interface is now read-write. See >>26 for the definition.

[119] The isExternallyDeclared attribute of the Entity object, on getting, MUST return whether the externally declared flag of the context object is set or not. On setting, it MUST set the externally declared flag of the object if the new value is true, or unset the flag otherwise.

[120] When an Entity object is created in the process of parsing the XML document, if the entity is externally declared XML, the externally declared flag of the object MUST set. Otherwise the flag MUST be unset initially.

Parent

[50] The ownerDocumentTypeDefinition attribute of an Entity, Notation, or ElementTypeDefinition node is read-only and its type is DocumentTypeDefinition. Its value is the DocumentTypeDefinition node to which the Node is attached.

The attribute MUST return the DocumentTypeDefinition node in whose generalEntities, notations, or elementTypes list the Node is contained. There should be at most one such DocumentTypeDefinition node. If there is no such node, then the attribute MUST return null.

Extensions to the EntityReference interface

[36] The manakaiExpanded attribute of an EntityReference object represents whether the entity reference is expanded so that its children list represents a part of the document.

This attribute is read-write. The type of the this attribute is boolean.

The getter MUST return the value of the flag associated to this attribute.

The setter MUST throw a NO_MODIFICATION_ALLOWED_ERR DOMException if the Entity object is read-only. Otherwise, it MUST set the specified value to the flag associated to this attribute.

If a parser create a EntityReference object that represents a general entity reference, it set the value of this attribute. If it set this attribute as false, then it MUST make the child list of the EntityReference object empty.

An application might set this attribute as false even if the EntityReference object has child nodes. If the value of this attribute is false, any child of the EntityReference object should be ignored for the purpose of e.g. serialization.

When an EntityReference object is created and then the subtree of the Entity object is cloned to that object, the manakaiExpanded MUST be set to the same value as hasReplacementTree attribute of that object.

Newly created EntityReference object by createEntityReference has manakaiExpanded attribute set to false unless the replacement tree is cloned to the EntityReference object.

[42] The manakaiEntityBaseURI attribute of an EntityReference object represents the base DOM URI of the entity referenced by the EntityReference object.

This attribute is read-write. The type of this attribute is DOMString.

The getter MUST return the base DOM URI of the entity by the following algorithm:

  1. If the base DOM URI of the referenced entity is explicitly specified to the EntityReference object, then return it.
  2. Otherwise, return the baseURI attribute value of the EntityReference object.

Therefore, the entity base URI for internal general entities are same as the base URI for the external or document entity in which the entity is referenced, unless explicitly overridden later by application.
Note that the algorithm might return null.

The setter MUST throw a NO_MODIFICATION_ALLOWED_ERR DOMException if the EntityReference object is read-only. Otherwise, if the specified value is null, it MUST unset the explicit entity base URI specification for the EntityReference object. Otherwise, it MUST set the specified value as the entity base URI of the EntityReference object.

The specified value must be an absolute DOM URI. However, no lexical validation or relative reference resolution is performed on the setting. Likewise, setting the value does not affect on the entity base URI of any Entity object and any other EntityReference object whose nodeName, publicId, or systemId is same as EntityReference object's.

Setting null to this attribute removes the explicit entity base URI information attached to the EntityReference object entirely and never restores the original entity base URI set during the tree construction, if any. To synchronize entity base URI with that of the Entity objecet with same name attribute, use normalizeDocument method on the Document.

[43] The manakaiExternal attribute of an EntityReference object represents whether the entity referenced by the object is an external entity or not.

This attribute is read-write. The type of this attribute is boolean.

The getter MUST return the value of the flag associated to this attribute.

The setter MUST throw a NO_MODIFICATION_ALLOWED_ERR DOMException if the object is read-only. Otherwise, it MUST set the specified value to the flag associated to this attribute.

Setting this attribute might make an object inconsistent with the Entity object referenced by it, Such inconsistence might be fixed by the method normalizeDocument on the Document object.
TODO: DOM accessor to system identifier, public identifier, and declaration base URI of an unexpanded entity reference information item.

Extensions to the Notation Interface

Notation Identifiers

[39] The publicId attribute and the systemId attribute of the Notation interface is so extended that they are read-write. See >>37 for the complete definition.

Parent

[51] The ownerDocumentTypeDefinition attribute of the Notation interface is defined at >>50.

Extension to the ProcessingInstruction Interface

Base URI

[28] The manakaiBaseURI attribute is added to the ProcessingInstruction interface as well as the Element interface. See >>18 for details.

The DOMConfiguration interface

[92]

partial interface DOMConfiguration {
  readonly attribute DOMString[] parameterNames;
};

[93] The parameterNames attribute MUST return the read only array of the parameter names (DOMString[], not DOMStringList as specified in DOM3 Core), associated with the document. The attribute MUST returns the same object every time it is invoked with same context object. The items MUST be sorted by code point order.

[94] The domConfig attribute of the Document interface MUST return the same object every time it is invoked with same context object.

[101] If a parameter is an alias of another parameter, methods getParameter, setParameter, and canSetParameter MUST treat those names as equivalent.

[97] The parameter manakai-create-child-element specifies whether several Atom DOM attributes should create a child element if it is not exists. The expected value type of the parameter is boolean. The default value is false. The parameter http://suika.fam.cx/www/2006/dom-config/create-child-element is an alias of the parameter manakai-create-child-element.

[99] The parameter manakai-strict-document-children specifies whether the constraints on Document node's child nodes should not be relaxed or not. The expected value type of the parameter is boolean. The default value is true. The parameter http://suika.fam.cx/www/2006/dom-config/strict-document-children is an alias of the paramter manakai-strict-document-children.

[132] The parameter manakai-allow-doctype-children specifies whether the DocumentType node can contain ProcessingInstruction nodes as children or not. The expected value type of the parameter is boolean. The default value is false.

[174] For the purpose of conformance checkers, child nodes of Document and DocumentType MUST conform to the constraints for node trees <http://dom.spec.whatwg.org/#node-tree>, whatever values configuration parameters are set to.

[95] The parameter http://suika.fam.cx/www/2006/dom-config/clone-entity-reference-subtree specifies whether the entity reference subtree should be cloned from corresponding entity node upon creation of the node. The expected value type of the parameter is boolean. If it is the DOM3 implementation, the default value is true. Otherwise, the default value is false.

[96] The parameter http://suika.fam.cx/www/2006/dom-config/dtd-attribute-type specifies whether the DTD attribute type should be set to the schemaTypeInfo attribute of the newly created attribute node or not. The expected value type of the parameter is boolean. If it is the DOM3 implementation, the default value is true. Otherwise, the default value is false.

[98] The parameter http://suika.fam.cx/www/2006/dom-config/dtd-default-attribute specifies whether the DTD default attributes should be automatically set to elements or not. The expected value type of the parameter is boolean. If it is the DOM3 implementation, the default value is true. Otherwise, the default value is false.

[100] The parameter http://suika.fam.cx/www/2006/dom-config/xml-id specifies whether the processing of the xml:id attribute should be enabled or not. The expected value type of the parameter is boolean. If it is the DOM3 implementation, the default value is true. Otherwise, the default value is false.

[133] If the manakai-strict-document-children configuration parameter is set to true, the pre-insert operation and the replace operation on the document MUST NOT throw a "HierarchyRequestError" exception for node tree's constraints on node types in following cases:

[134] If the manakai-allow-doctype-children configuration parameter of the node document is set to true, the pre-insert operation and the replace operation on the DocumentType node MUST NOT throw a "HierarchyRequestError" exception for node tree's constraints on node types in following cases:

[135] If the manakai-strict-document-children configuration parameter is set to true, the textContent attribute of the Document object MUST act as if the context object were a DocumentFragment node.

Extension to the DOMLocator interface

[22] The utf32Offset attribute represents the UTF-32 offset into the input source the DOMLocator is pointing to.

The type of this attribute is long. This attribute is read-only.

The getter MUST return the UTF-32 offset specified when the DOMLocator object is created. If no such information is provided, then -1 MUST be returned.

Extensions to the TextTrack interface

[59]

partial interface TextTrack {
  readonly attribute boolean manakaiIsInvalid;
  readonly attribute TextTrackCueList manakaiAllCues;
  TextTrack manakaiCloneTrack();
};

[60] The manakaiIsInvalid attribute of the TextTrack object, on getting, MUST return true if the track has been created by a WebVTT parser and the WebVTT parser has reported that the WebVTT file from which the track object was created cannot be successfully processed as WebVTT. Otherwise, it MUST return false.

For the purpose of this method, a WebVTT file is invalid if it does not contain the WebVTT signature such that the WebVTT parser does not continue to parse the file. Any other conformance error does not cause the attribute return true.

[61] The manakaiAllCues attribute of the TextTrack object, on getting, MUST return the live list that contains the cues found in the track, whether active or not, or effective or not.

[62] The manakaiCloneTrack method of the TextTrack object MUST return a new TextTrack object. The new object MUST have the same values as the original object for the attributes: kind, label, language, mode, and manakaiIsInvalid. The manakaiAllCues attribute of the new object MUST have a new TextTrackCueList object, containing the clones of the cues in the manakaiAllCues list of the original object, in order. The clones MUST be the object that would be created by the manakaiCloneCue method of the cues, with their track attributes set to the new TextTrack object.

Extensions to the TextTrackCue interface

[56]

partial interface TextTrackCue {
  readonly attribute long manakaiLine;
  readonly attribute long manakaiColumn;
  TextTrackCue manakaiCloneCue();
};

[57] The manakaiLine attribute of the TextTrackCue object, on getting, MUST return the line number in the original resource at which the cue is declared, if available, or the value -1, otherwise.

[58] The manakaiColumn attribute of the TextTrackCue object, on getting, MUST return the column number in the original resource at which the cue is declared, if available, or the value -1, otherwise.

[63] The manakaiCloneCue method of the TextTrackCue object MUST return a new TextTrackCue object. The new object MUST have the same values as the original object for the attributes: id, startTime, endTime, pauseOnExit, vertical, snapToLines, line, position, size, align, and text.

The URIReference interface

[105]

partial interface DOMImplementation {
  URIReference createURIReference((DOMString or URIReference) url);
};

[NoInterfaceObject]
interface URIReference {
  attribute DOMString uriReference;
  attribute DOMString uriScheme;
  attribute DOMString uriAuthority;
  attribute DOMString uriUserinfo;
  attribute DOMString uriHost;
  attribute DOMString uriPort;
  attribute DOMString uriPath;
  attribute DOMString uriQuery;
  attribute DOMString uriFragment;
  DOMString[] getURIPathSegment(unsigned long index);
  void setURIPathSegment(unsigned long index, DOMString newValue);
  boolean isURI();
  boolean isURI3986();
  boolean isIRI();
  boolean isIRI3987();
  boolean isRelativeReference();
  boolean isRelativeReference3986();
  boolean isRelativeIRIReference();
  boolean isRelativeIRIReference3987();
  boolean isURIReference();
  boolean isURIReference3986();
  boolean isIRIReference();
  boolean isIRIReference3987();
  boolean isAbsoluteURI();
  boolean isAbsoluteURI3986();
  boolean isAbsoluteIRI();
  boolean isAbsoluteIRI3987();
  boolean isEmptyReference();
  URIReference getURIReference();
  URIReference getURIReference3986();
  URIReference getIRIReference();
  URIReference getIRIReference3987();
  URIReference getAbsoluteReference((DOMString or URIReference) base, any opt...);
  URIReference getAbsoluteReference3986((DOMString or URIReference) base, any opt...);
  URIReference getAbsoluteReference3987((DOMString or URIReference) base, any opt...);
  boolean isSameDocumentReference((DOMString or URIReference) base);
  boolean isSameDocumentReference3986((DOMString or URIReference) base);
  boolean getRelativeReference((DOMString or URIReference) base);
  URIReference cloneURIReference();
};

[106] The createURIReference method MUST run the following steps:

  1. If url is a URIReference object, let url be the url of url.
  2. Create a new URIReference object whose url is url and return the object.

[107] In DOM Perl Binding, url MAY be a reference to the string. It MUST be dereferenced before the aforementioned steps are invoked.

[110] The URIReference object represents a URL. It has the associated url.

[108] The uriReference attribute of the URIReference object, on getting, MUST return the url of the context object. On setting, the attribute MUST set the url of the context object to the new value.

[109] In DOM Perl binding, the stringify method of the URIReference object MUST return the url of the context object.

[111] Attributes uriScheme, uriAuthority, uriUserinfo, uriHost, uriPort, uriPath, uriQuery, and uriFragment corresponding to scheme, authority, userinfo, hostname, port, path, query, and fragment components respectively. On getting, these attributes MUST return the corresponding component of the url of the context object, not including delimiters before or after the component, if any, or null otherwise. On setting, these attributes MUST replace the corresponding component by the new value, if the new value is syntactically sound value as that component, or do nothing, otherwise.

Need more precious definition.

[112] The getURIPathSegment method of the URIReference object MUST return the path segment of the url of the context object with the index specified as the argument. The path segments of the URL is the components of the path separated by a / character. If the path segment with the specified index is not found, null MUST be returned instead.

[113] The setURIPathSegment method of the URIReference object MUST set the path segment of the url of the context object with the index specified by the first argument MUST be replaced or added by the value specified as the second argument. If the index is greater than the number of path segments, the path segments with indexes greater than or equal to the number of the path segments and less than the specified index MUST be set to the empty string.

[114] Define methods; In DOM Perl Binding, string arguments can be scalar references.

[115] In DOM Perl Binding, the clone method MUST act as if the cloneURIReference method has been invoked.

[116] In DOM Perl Binding, the eq operator on the URIReference object MUST compare the url of the context object with the other value.

The InternetMediaType interface

[121]

partial interface DOMImplementation {
  InternetMediaType createInternetMediaType(DOMString type, DOMString subtype);
};

[NoInterfaceObject]
interface InternetMediaType {
  stringifier readonly attribute DOMString imtText;
  readonly attribute DOMString type;
  attribute DOMString topLevelType;
  attribute DOMString subtype;
  readonly attribute unsigned long parameterLength;
  DOMString? getAttribute(unsigned long index);
  void setAttribute(unsigned long index, DOMString attr);
  DOMString? getValue(unsigned long index);
  void setValue(unsigned long index, DOMString value);
  DOMString? getParameter(DOMString attr);
  void setParameter(DOMString attr, DOMString value);
  void addParameter(DOMString attr, DOMString value);
  void removeParameter(DOMString attr);
};

[122] The InternetMediaType object represents a MIME type. It has associated type, subtype, and ordered list of parameter name/value pairs. The type, subtype, and parameter names MUST be converted to ASCII lowercase when it is set.

[123] The createInternetMediaType method MUST return a new InternetMediaType object whose type is set to the first argument, whose subtype is set to the second argument, and the parameters is set to empty.

[124] For the DOM Perl Binding, the cmp operation MUST compare the stringifier's return value with the other value.

[125] The imtText attribute MUST return the serialized representation of the MIME type.

Need to define serialization.

[126] The type attribute MUST return the serialized representation of the MIME type without parameters.

Need to define serialization.

[127] The topLevelType attribute, on getting, MUST return the type of the context object. On setting, it MUST set the type of the context object.

[128] The subtype attribute, on getting, MUST return the subtype of the context object. On setting, it MUST set the subtype of the context object.

Methods...

New configuration parameters

Loose document children

[14] The configuration parameter http://suika.fam.cx/www/2006/dom-config/strict-document-children can be used to force the implementation to obey DOM Level 3 Core rule for children of Document nodes.

Note that this configuration parameter does affect operations only after it is set. Changing the configuration parameter value itself does not mutate the underlying document tree even if the tree violate the rule applied under the new value.
The definition is incomplete.

[24] If the parameter is set to false, the getter of the textContent attribute of a Document object MUST behave as if it were a DocumentFragment object, except that the concatenation process MUST ignore any DocumentType object.

If the parameter is set to false, the setter of the textContent attribute of a Document object MUST behave as if it were a DocumentFragment object.

The ParentNode interface

[177] Following members are moved to the ParentNode interface.

[175]

partial interface ParentNode {
  attribute DOMString innerHTML;
  HTMLCollection getElementsByTagName(DOMString localName);
  HTMLCollection getElementsByTagNameNS(DOMString? namespace, DOMString localName);
  HTMLCollection getElementsByClassName(DOMString classNames);
  NodeList getItems(optional DOMString typeNames = "");
};

[143] The innerHTML attribute of the DocumentFragment object MUST act as if that were the body element in the HTML namespace.

[146] The body element is used here such that this definition is consistent with the outerHTML attribute.

[154] Methods getElementsByClassName, getElementsByTagName, and getElementsByTagNameNS of the DocumentFragment object MUST act as if those methods of the Element interface.

[176] The getItems method MUST return the node list containing elements that create top-level microdata items in the subtree rooted by the context object (inclusive). The method MUST return a static node list.

Parsing and Serialization

[145] Need to define XML parsing

[147] The steps to produce an HTML serialization or produce an XML serialization MUST be defined as following:

[148] If the serializeToString method is invoked with an Attr, ElementTypeDefinition, AttributeDefinition, Entity, or Notation node, then a "NotSupportedError" exception MUST be thrown.

Events

[158]

partial interface Event {
  readonly attribute boolean manakaiDispatched;
  readonly attribute boolean manakaiImmediatePropagationStopped;
  readonly attribute boolean manakaiPropagationStopped;
};

[159] The manakaiDispatched attribute of the Event interface MUST return the dispatch flag of the context object.

[160] The manakaiImmediatePropagationStopped attribute of the Event interface MUST return whether the stop immediate propagation flag of the context object is set or not.

[161] The manakaiPropagationStopped attribute of the Event interface MUST return whether the stop propagation flag of the context object is set or not.

[162]

partial interface MouseEvent {
  readonly attribute boolean altGraphKey;
};
partial interface KeyboardEvent {
  readonly attribute boolean altGraphKey;
};

[163] The altGraphKey attribute MUST return the return value of the getModifierState method on the context object with the argument AltGraph.

[164] Implemented by Chrome.

[165] The initKeyboardEvent] method of the KeyboardEvent interface MUST also recognize the key name AltGraph in its modifiersListArg argument.

CSSOM

[166]

partial interface StyleSheet {
  readonly attribute DOMString manakaiBaseURI;
  readonly attribute DOMString manakaiInputEncoding;
};

partial interface CSSStyleSheet {
  attribute DOMString cssText;
  DOMString? manakaiLookupNamespaceURI([TreatNullAs=EmptyString] DOMString prefix);
  DOMString? manakaiLookupNamespacePrefix([TreatNullAs=EmptyString] DOMString namespace);
  boolean manakaiIsDefaultNamespace([TreatNullAs=EmptyString] DOMString namespace);
};

[167] The manakaiBaseURI attribute of the StyleSheet interface MUST return the base URL associated with the style sheet when it is created.

[168] The manakaiInputEncoding attribute of the StyleSheet interface MUST return the encoding name Encoding Standard used to interpret the style sheet. If the style sheet is created from a character sequence (rather than byte sequence), it MUST return utf-8 instead.

[169] On getting, the cssText attribute MUST return the cssText attribute values of the rules contained in the cssRules of the CSSStyleSheet object, in same order, separated by a U+000A character.

Setter is not yet defined.

[170] The manakaiLookupNamespaceURI method of the CSSStyleSheet interface MUST return the namespace name of the namespace prefix specified by the argument, if any, or null otherwise. If there are multiple @namespace at-rules in the style sheet, only the last one takes effect by definition. If the argument is the empty string, namespace name of the default namespace, if any, is returned instead.

[171] The manakaiLookupNamespacePrefix method of the CSSStyleSheet interface MUST return the namespace prefix bound to the namespace which is equal to the argument, if any, or null otherwise. If there are more than one namespace prefixes bound to the namespace, the namespace prefix declared later in the list of rules in the style sheet MUST be returned. Note that any @namespace at-rules with no prefix is ignored for the purpose of this method.

[172] The manakaiIsDefaultNamespace method of the CSSStyleSheet interface MUST return true if the default namespace of the style sheet css-namespaces is equal to the argument, or false otherwise.

[173] A namespace name consist of the empty string represents the null namespace in CSS Namespaces css-namespaces.

Non-browser script support

[156] When the steps are invoked in the context where the "entry script" concept is not defined by any other specification (e.g. when a non-browser script invokes a DOM method), the base URL of the entry script MUST be about:blank unless otherwise specified by an applicable specification.

DOM3 bug fixes

[71] The createAttribute method of the Document interface MUST run the following steps:

  1. Let localName be the argument.
  2. If localName does not match the XML Name production, throw an "InvalidCharacterError" exception and terminate these steps.
  3. Return a new attribute with namespace set to null, local name set to localName, node document set to the context object, owner element set to null, and value set to the empty string.

[72] The createAttributeNS method of the Document interface MUST act as if the createElementNS method was invoked, except that a new attribute, instead of a new element, MUST be created. The value of the newly created attribute MUST be the empty string.

[73] Methods createEntityReference and createCDATASection of the Document interface MUST throw a "NotSupportedError" exception.

[74] If the getAttributeNode method of the Element interface founds multiple attributes, it MUST return the first attribute. If the document is an HTML document and the context object is in the HTML namespace, the argument to the method MUST be converted to ASCII lowercase first.

[75] The setAttributeNode method and the setAttributeNodeNS method of the Element interface MUST run these steps:

  1. Let newAttr be the argument.
  2. If the owner element of newAttr is not null and is different from the context object, throw an "InUseAttributeError" exception and abort these steps.
  3. Adopt newAttr.
  4. If the context object has the attribute whose namespace and local name are equal to those of newAttr, let oldAttr be the attribute and set the owner element of oldAttr to null. Otherwise, let oldAttr be null.
  5. If oldAttr is null, append newAttr to the attributes of the context object.
  6. Otherwise, if oldAttr is not null, replace oldAttr in the attributes of the context object by newAttr.
  7. Set the owner element of newAttr to the context object.
  8. If oldAttr is null, attribute is set and attribute is added.
  9. Otherwise, attribute is set and attribute is changed.
  10. Return oldAttr.
MutationEvent integration is necessary...

[149] If the removeAttributeNode method removes an attribute, then attribute is removed just before the method returns a node.

[88] The setNamedItem method and the setNamedItemNS method of the NamedNodeMap interface MUST act in the consistent way with these methods.

[79] The isSameNode method of the Node interface MUST return false if the argument is null.

partial interface Node {
  boolean isSameNode (Node? other);
};

[142] The node has a strong reference to each of user data and user data handler associated with the node using the setUserData method until they has been removed from the node by another invocation of the method with the same name argument.

[157] For the purpose of the media IDL attribute, the attribute has no default value.

Implementation-specific requirements

[155] When a method on an object may or may not return the same NodeList or HTMLCollection object as returned by the earlier calls, then the same object MUST be returned.

[69] Steps list of elements with local name localName, list of elements with namespace namespace and local name localName, and list of elements with class names classNames MUST always return the same HTMLCollection object as returned by the earlier calls with the same context object and argument.

[70] In DOM Standard this is optional.

[91] The document has the strict error checking flag. By default, the flag is set. The strictErrorChecking of the Document interface DOM3CORE, on getting, MUST return whether the strict error checking flag of the document is set or not. On setting, the attribute MUST set the flag if the true value is assigned, or unset otherwise.

[129] Non-DOM3 implementation MUST throw exceptions or report errors as specified by relevant specifications, unless an applicable specification explicitly specifies the applicability of the strict error checking flag.

[35] As specified in DOM Level 3 Core specification DOM3CORE, a DOM3 implementation may choose not to throw an exception when the strictErrorChecking attribute of the Document object is set to false.

[130] If the strict error checking flag of the node document is set, for the purpose of setting name, namespace, namespace prefix, target, and/or local name of a node or attribute only, the definitions of Name, NCName, and QName MUST be replaced by the following definition: "a string of one or more Unicode code points".

[140] If the strict error checking flag of the node document is set, for the purpose of setting the name of the DocumentType node only, the definition of Name and QName MUST be replaced by the following definition: "a string of zero or more Unicode code points".

[136] If the strict error checking flag of the node document is set, when a QName is split to obtain the optional namespace prefix and the local name,

[131] If the strict error checking flag of the node document is set, following tests, if any, MUST be skipped upon creation of elements and attributes, or setting of the namespace prefix and MUST NOT throw an exception for them:

[139] If the strict error checking flag of the node document is set, the createProcessingInstruction method MUST skip the test whether the data contains ?> or not and MUST NOT throw an exception for it.

[137] If the strict error checking flag of the node document is set, the xmlVersion attribute of the document, on setting, MUST NOT throw an exception because of the new value's invalidness and it [MUST]] set the new value as the XML version of the document.

[138] If an operation is defined in terms of the XML version of the document or the xmlVersion attribute value but its behavior on occurrence of unknown XML version is not defined, it MUST behave as if the XML version is 1.0.

New language binding (informative)

[29] manakai is a set of Perl modules and it defines its own binding of DOM. For more information, see DOM Perl Binding [MDPB].

References

Normative References

[DOM3Core]
Document Object Model (DOM) Level 3 Core Specification Version 1.0, W3C Recommendation, 7 April 2004, <http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407>. The latest version of DOM Level 3 Core is avalable at <http://www.w3.org/TR/DOM-Level-3-Core>. (This version of the specification is referenced.)
[HTML5]
HTML 5, WHATWG Working Draft, work in progress, <http://whatwg.org/html5>.
[RFC 2119]
Key words for use in RFCs to Indicate Requirement Levels, IETF, RFC 2119, BCP 14, March 2004, <urn:ietf:rfc:2119>. (This version of the specification is referenced.)
[Infoset]
XML Information Set (Second Edition), W3C Recommendation, 4 February 2004, <http://www.w3.org/TR/2004/REC-xml-infoset-20040204>. The latest version of XML Information Set is available at <http://www.w3.org/TR/xml-infoset>. (Latest version of the specifcation whose maturity level is higher than Candidate Recommendation is referenced.)
[SelectorsAPI]
Selectors API, W3C Editor's Draft, 29 August 2007, <http://dev.w3.org/cvsweb/~checkout~/2006/webapi/selectors-api/Overview.html?rev=1.28&content-type=text/html;%20charset=utf-8>. The latest published version of Selectors API is available at <http://www.w3.org/TR/selectors-api/>. (Latest version of the specifcation whose maturity level is higher than Candidate Recommendation, if any, or latest Editor's Draft is referenced.)

Informative References

[DOM2Traversal]
Document Object Model (DOM) Level 2 Traversal and Range Specification Version 1.0, W3C Recommendation, 13 November 2000, <http://www.w3.org/TR/2000/REC-DOM-Level-2-Traversal-Range-20001113>. The latest version of DOM Level 2 Traversal and Range is available at <http://www.w3.org/TR/DOM-Level-2-Traversal-Range>.
[EBFD]
ECMAScript binding for DOM, W3C Editor's Draft.
[MDPB]
manakai's DOM Perl binding, work in progress, DOM Perl Binding.

memo (informative)

[53]

       - If they are <IF::tx|DocumentType>s and at least one of them
          has the <Feature::fe|XDoctype> feature, their <A::DTDef.elementTypes>
          <IF::NamedNodeMap>s are equal, i.e. they both has the
          <Feature::fe|XDoctype> feature and their <A::DTDef.elementTypes>
          are equal (as defined for <A::Node.attributes> except
          that they cannot be <DOM::null>), or the <A::DTDef.elementTypes>
          of the node that has the <Feature::fe|XDoctype> feature
          is empty (i.e. its <A::NamedNodeMap.length> is zero).
          <SRC::manakai>
        - If they are <IF::ETDef>s, their <A::ETDef.attributeDefinitions>
          <IF::NamedNodeMap>s are equal (as defined for
          <A::Node.attributes> except that they cannot be <DOM::null>).
          <SRC::manakai>
        - If they are <IF::ATDef>s, the numeric attributes
          <A::ATDef.declaredType> and <A::ATDef.defaultType> are equal.
          <SRC::manakai>
        - If they are <IF::ATDef>s, the <A::ATDef.allowedToken>
          <IF::c|DOMStringList>s are equal, i.e. they have
          the same <A::c|DOMStringList.length> and for each string
          that exists in one list there is a string that
          exists in the other list and is equal, although
          not necessarily at the same index.  In addition,
          the number of the items that are equal to a string in one list
          is equal to the number of such items in the other list.