Window)[48] Statements about conformance in this specification
are only applied to implementations that support related
feature. For example, MUST-level requirements
for treatement of the EventHandler objects
do not apply to implementations that do not support
DOM Events module.
[3]
A DOM object, i.e. an object implementing one
or more DOM interfaces, MUST be represented
by a Perl object, i.e. a thingly referenced
by some Perl references and blessed in
a Perl class, unless otherwise specified.
The Perl class MUST implement
the DOM interfaces implemented by the DOM object.
[114] The class implementing a DOM interface MAY inherit non-DOM classes.
[115] For example, the class implementing the DOMException interface
might inherit a class that defines the exception mechanism the implementation is build on top of it.
Another example is that any class implementing DOM interfaces might inherit from the "object"
base class provided by the object-orient programming framework used by the implementation.
[117] The implementation MAY provide ways to determine whether an object implements a specific DOM interface or not. However, this is not required.
[66] Specifications often requires that two objects be same. They don't have to be same object in Perl sense, but they have to exhibit following characteristics:
eq operation if and only if
they are same. Operations ne and cmp MUST be
consistent with the eq operation.[5] A DOM method MUST be implemented as a Perl method.
[6] A read-only DOM attribute MUST be implemented as a Perl method that returns the value contained in the DOM attribute. The Perl method MAY throw an implementation dependent exception if any argument is specified for the Perl method.
[7] A read-write DOM attribute MUST be implemented as a Perl method. The Perl method MUST return the value contained in the DOM attribute if no argument is specified for the Perl method (i.e. the only argument to the subroutine implementing the Perl method is the object itself). Otherwise, the Perl method MUST try to set the first argument specified for the method (i.e. the second argument to the subroutine implementing the Perl method) to the DOM attribute.
undef
as the argument to the Perl method, which
set the null value
to the DOM attribute, is different from
specifying no argument, which returns the DOM
attribute value.[8]
A DOM parameter to a method is optional if
either null or boolean
false value is allowed to be specified
to that parameter and any following DOM parameter
is optional.
The Perl method MUST act as if an undef
or a Perl false value, depending on the data type of the parameter,
is specified to each optional parameter if no argument
corresponding to that parameter is specified.
[98] If the return value of the operator is defined as void, the method implementing the operation MUST return an empty list.
[123] Since Perl objects can be overloaded such that stringification and similar operations can be defined by the application, it is important to ensure the conversion from the Perl value to the WebIDL value is performed in the right way.
[124] Following pairs of code fragments can make different side effects:
## Evaluation order is significant. $v1 = ''.$_[1]; $v2 = ''.$_[2]; $v2 = ''.$_[2]; $v1 = ''.$_[1]; ## Three serializations can be different. $v1 = ''.$_[1]; $v1 = 0+$_[1]; $v1 = !!$_[1]; ## Whether the overloaded operation has been invoked or not is observable. $v1 = ''.$_[1]; $v2 = ''.$_[2]; return; $v1 = ''.$_[1]; return if $v1; # or throw an exception $v2 = ''.$_[2]; return; ## How many times overloaded operation has been invoked is observable. $v1 = ''.$_[1]; $v1 = ''.$_[1]; $v1 = ''.$_[1];
[62] When a constant is defined by some interface, any platform object implementing the interface MUST have a method whose name is equal to the constant name. The method MUST return the constant value.
[65] Any class implementing the interface SHOULD have a method whose name is equal to the constant name. If there is such a method, it MUST return the constant value.
[63] If there is a module corresponding to the interface, it MAY have a constant subroutine whose name is equal to the constant name. If there is such a constant subroutine, it MUST return the constant value. It MAY be exported from the module.
ELEMENT_NODE
constant of the Node interface can be used like this:# >>62 is $node->ELEMENT_NODE, 1; # >>65 is +MyDOM::Node->ELEMENT_NODE, 1; # >>63 use MyDOM::Node; is ELEMENT_NODE, 1;Since module or class name appears in invocations of >>65 and >>63, they are not portable among implementations by definition, which is why they are not a MUST-level requirement. Note that when a constant is exported as mentioned in >>63, whether it is exported by default or not is implementation dependent. Moreover, it can be exported as part of some tag (e.g.
:node_type) if desired.[40] The legacycaller keyword MUST have no effect.
[54] The following IDL fragment MUST be implemented when
simple exception classes and/or SyntaxError is implemented:
[Constructor(optional DOMString message = "")]
interface Error {
readonly attribute DOMString name;
readonly attribute DOMString message;
readonly attribute DOMString fileName;
readonly attribute long lineNumber;
stringifier;
};
[Constructor(optional DOMString message = "")]
interface EvalError : Error {};
[Constructor(optional DOMString message = "")]
interface RangeError : Error {};
[Constructor(optional DOMString message = "")]
interface ReferenceError : Error {};
[Constructor(optional DOMString message = "")]
interface SyntaxError : Error {};
[Constructor(optional DOMString message = "")]
interface TypeError : Error {};
[Constructor(optional DOMString message = "")]
interface URIError : Error {};[183] The constructors of these interfaces MUST return a new object implementing the respective interface. The object's name MUST be set to the name of the interface. The object's message MUST be set to the message argument.
[182] An object which is a simple exception or DOMException
MUST be an object implementing the Perl Error Object Interface Level 1
<https://github.com/manakai/perl-web-dom/blob/master/lib/Web/DOM/Error.pod#error-object-api>.
Semantics of attributes name, message, fileName, and
lineNumber and the stringifier are defined by that specification.
The constructor is expected to set the fileName and lineNumber
of the created object.
[9] To throw an exception exception, die MUST
be invoked with exception.
[57] The fileName attribute MUST return the string identifying
the file where the method or attribute that throws the exception is invoked.
The lineNumber attribute MUST
return the line number in the file, where the method or attribute that throws the exception is invoked.
How to determine the these values are implementation dependent.
[58] The stringifier WebIDL method MUST return the message WebIDL
followed by string at followed by the fileName followed by string
line followed by stringified XXXref representation of lineNumber followed
by . followed by the value equal to Perl expression "\n".
[116] The DOMError object's "" operation MUST
return the implementation-specific value that describes the error.
[15] The name of the method corresponding to an IDL attribute or method MUST be the value
returned by the following steps:CSSStyleDeclaration interface:- character in prop by the _ character.method_name_map JSON object in <https://github.com/manakai/data-web-defs/blob/master/data/dom-perl.json>
contains a name name, return the corresponding value and abort these steps.If there is a row in the table >>14 whose first column is equal to n, return the value of the second column of the row and abort these steps.LOW LINE character,
the lowercase variant of the sequence except the last letter,
a LOW LINE character,
and the lowercase variant of the last letter of the sequence.LOW LINE character
followed by the lowercase variant of the letter.
[139] For example, localName
is mapped to local_name,
setAttributeNS to
set_attribute_ns,
createLSInput to
create_ls_input, and
MozBoxSizing to
_moz_box_sizing.
[140] If a random interface defines the itemId attribute, its Perl name is
item_id. However, since the itemId attribute of the
HTMLElement interface reflects the itemid
content attribute, its Perl name is itemid.
[14] Exceptions.
[10] In this section, number types includes:
long, unsigned long,
unsigned long long,
short,
and unsigned short.
[11]
If the return value of the DOM method or the DOM attribute
is of number type and a Perl method return a value
in that type, jt MUST return a value
that can be evaluated as a number (by, e.g., 0+
operation).
[12]
If a DOM method parameter or the DOM attribute is
of number type and it is necessary for a Perl method to
get the specified value, it MAY evaluate
the specified value as a value (by, e.g., 0+
operation).
is expected to be evaluated in the Boolean context.
IDL type <TYPE^^DISCore|QName::idl|any> is corresponding to any scalar valu\
e
in Perl. IDL type <TYPE^^DISCore|QName::idl|Object> is bound to object.[84] When an algorithm for JavaScript is executed for a Perl value, the word "ECMAScript value" in the algorithm is read as "Perl value" instead.
[85] Whenever the JavaScript ToNumber() operation
is applied to $n, the following steps MUST be run instead:0 + $x in
scalar context.
boolean[120] If a WebIDL boolean value true or false is converted into a Perl value,
it MUST be converted to a Perl true or false value, respectively.
If the value is returned in context where both boolean and null can be returned,
the false value MUST be represented as non-undef value in Perl.
unsigned long[83] A Perl value is converted to an IDL unsigned long value by running the
algorithm for JavaScript <http://dev.w3.org/2006/webapi/WebIDL/#es-unsigned-long>.
unsigned short[118] A Perl value is converted to an IDL unsigned short value by running the
algorithm for JavaScript <http://dev.w3.org/2006/webapi/WebIDL/#es-unsigned-short>.
null[23]
The null value in DOM is bound to
undef in Perl.
[24]
If something is defined to return or set null,
it MUST return or set undef
unless otherwise specified.
[25]
Where null is allowed to
be specified, an implementation MUST behave as if a
null is specified when
a undef is specified.
[26]
Where null is not allowed to
be specified, how an implementation behaves when
a undef depends on the
expected data type. An implementation MAY
cause zero or more uninitialized
warnings
reported by Perl or MAY report its own
uninitialized
warnings, when warnings
are enabled by e.g. use warnings
pragma.
DOMString and USVString[181] For the purpose of DOM Perl Binding, USVString
MUST be treated as a synonym for DOMString.
[96] Since some methods are defined in terms of UTF-16 code units, if the index used by the method
identifies a location between surrogate code points, a character is broken into two surrogate code points.
If the string "a\x{10003}b" is split into two substrings with index two (2),
the first substring is "a\x{D800}" and the second substring is "\x{DC03}b".
[71] When a string in WebIDL context is exposed to Perl, it MUST be represented as the value that can be interpreted as a sequence of characters. If no character in the sequence is greater than U+00FF, it MAY be represented as the value that can be interpreted as a sequence of bytes encoded in Latin-1.
iso-8859-1
encoding, which is equivalent to the windows-1252 encoding Encoding. [73] When a value in Perl in interpreted in WebIDL context, it MUST be first stringified by concatenated with the empty string and then interpreted as the sequence of characters. If the result of the stringification is the sequence of the bytes, then it is interpreted as encoded in the Latin-1 encoding.
[74] A Perl string can contain non-Unicode characters (i.e. code points greater than U+10FFFF). Unless otherwise specified, such a character MUST be treated as if that were an unassigned Unicode character.
U+10FFFF
is one (1).[92] A Perl string can contain both surrogate code points and code points greater than U+FFFF.
Since a Perl string is not encoded in UTF-16, combination of surrogate code points does not represent
a character, but are barely interpreted as sequence of those code points as is.
[93] For example, a string "\x{10003}" is different from "\x{D800}\x{DC03}".
[94] When a string ending with a high surrogate code point is concatenated with a string starting by a low surrogate code point by a DOM operation, these two code points MUST be replaced by corresponding code point.
[95] For example, if "a\x{D800}" is followed by "\x{DC03}b", then
the result is string "a\x{10003}b".
[97] Even when strings beginning with or ending by surrogate pair code points are concatenated, they are not automatically converted into a Unicode character. Therefore, even if same sequence of operations are performed, semantics of result strings could be different in the DOM Perl Binding and in the JavaScript-based Web browser environment. However, this does not mean requirements in Web platform specifications apply differently among these environments.
[121] The number of Unicode code points in the string "a\x{D800}\x{DC03}b" is three
in both environments.
[33]
Some methods are defined to accept a scalar reference
specified as a value of a parameter. Such a method,
when a scalar reference is specified as a parameter value,
MUST dereference the parameter value as a
scalar reference (i.e. by operator ${})
before it is in use, if the ref of the parameter
value is SCALAR.
[89] If the [TreatNullAs=EmptyString] extended attribute is specified,
when the value is undef it MUST be converted to the empty string before it is processed.
[155] Whether a string $P is an array index property name
MUST be determined by the following steps:
StringExtended[99] The operations of the StringExtended interface DOM3CORE
MUST be implemented as functions, where the zeroth argument to the function
is treated as the context object (i.e. the string) and the first argument to the function
is treated as the argument to the operation. The int data type MUST be
handled as WebIDL unsigned long data type. The StringIndexOutOfBoundsException
exception MUST be treated as the "IndexSizeError" exception.
[135] Enumeration types are represented as character strings in Perl.
[136] If an invalid value is specified to the method argument where the enumeration type is expected,
a TypeError MUST be thrown.
DOMTimeStamp[4] DOMTimeStamp for a Calendar Date-Time
A DOMTimeStamp value that is
an absolute date-time MUST be represented
by a scalar value of the number of the seconds
from 1970-01-01T00:00:00Z.
The scalar value MAY contain fraction part,
which represents a fraction of a second.
1970-01-01T00:00:00Z
is mapped to a numeric value of 0.1970-01-01T00:00:00Z[80] If WebIDL definition for the method parameter is typed with an interface but the
value that is not an instance of the interface is specified as the argument, then
a TypeError MUST be thrown and the processing of the method
MUST be aborted. This type checking MUST be performed in the
order of parameters.
[81] Likewise, if WebIDL definition for the attribute is typed with an interface but the
value that is not an instance of the interface is specified as the new value of the attribute,
then a TypeError MUST be thrown and the processing of the method
MUST be aborted.
[82] An implementation MAY treat an object from another DOM implementation as implementing no DOM interface at all.
DOMUserData[100] The DOMUserData data type DOM3CORE
corresponding to any scalar value in Perl.
DOMImplementationRegistry[16]
The variable
$Message::DOM::DOMImplementationRegistry
MUST contain a value via which methods
provided by DOMImplementationRegistry
object can be invoked.
$Message::DOM::DOMImplementationRegistry->get_dom_implementation
returns a DOM implementation.
DOMImplementationRegistry
object don't have to be an object in the Perl
context; it might be a string representing
the package name of the class implementing
the DOMImplementationRegistry
interface.[127] The implementation MUST NOT overload the following operators (using the overload
pragma) in a way that contradicts with this specification and any applicable specifications:"", 0+, bool,
@{}, %{}, &{},
cmp, eq, ne,
lt, le, gt, and ge.
[18] Unless otherwise specified, an object implementing some DOM interface SHOULD NOT overload these operators. If these operators are overloaded in implementation-specific ways, it MUST behave as if it were not overloaded to the extent applications don't have to distinguish whether it is overloaded or not.
[128] For example, an implementation can choose to let the "" operator of the
Element object to return the internal address of the object followed by the class name
of the implementation. An application can use this string to distinguish element objects each other,
or element objects and non-DOM objects, as it does for non-DOM objects. However, the implementation
cannot choose to let the operator to return the XML representation of the element.
[28] In any way, when an operator is overloaded, it MUST be consistent with other operators.
eq
operator is overloaded,my $eq = $a eq $b; my $ne = $a ne $b; die unless ($eq and not $ne) or (not $eq and $ne);
... must not die.
[86] If an interface supports indexed properties <http://dev.w3.org/2006/webapi/WebIDL/#dfn-support-indexed-properties>,
the object implementing the interface MUST behave as if that were a blessed array reference,
at least to the extent allowed by defining the Perl overload pragma's @{} operator.
[87] If only the indexed property getter is defined for the interface, the object MUST behave as if that were a read-only array reference.
[88] Following code fragment illustrates how the NodeList object behave:
my $node_list = $node->child_nodes; warn scalar @$node_list; # Number of child nodes warn $node_list->[1]; # Child node with index 1 (= second node in the children list) warn $node_list->[-1]; # Last child node $node_list->[2] = $new_node; # Error because setter is not defined for NodeList
Please note that index -1 is converted by Perl to the index of the last element in the
array before WebIDL processing (i.e. unsigned long conversion), it would return
different item in the list from the corresponding normal method;
warn $node_list->[-1]; # last item in the list warn $node_list->item (-1); # (-1 % 2^32 == 4294967295)th item (undef in most cases)
[17] For following interfaces, dereferencing an object as array acts as if it is an array:
That is,
$obj->[$n]
MUST return the same value as
$obj->item ($n)
if $obj is an object implementing
any of interfaces listed above and $n
is a non-negative integer less than
$obj->length.
[50] The to_a method and the as_list of an
array-like object MUST return a reference to a new array that contains
the items in the array-like object, in order.
as_list method is provided for compatibility with
Template::Iterator module. It should not be used for other purposes.[52] The to_list method of an array-like object MUST
return a Perl list that contains the items in the array-like object, in order.
CSSStyleDeclaration interface does not have these methods.[113] If an interface supports named properties, they MUST be accessible by
dereferencing the object by the %{} operator.
[133] keys and each do not have to preserve the order
of items in the hash-like object. However, the order has to be stable such that each
can be used for iteration.
[29]
If an array-like or hash-like object is read-only,
STORE, STORESIZE,
DELETE, and any other operations
that implies these operations MUST
throw an NO_MODIFICATION_ALLOWED_ERR
DOMException.
[112] When an array or hash is read-only, any attempt to modify it or its values MAY throw an exception. Whether an exception is thrown or not, any attempt to modify them MUST be ignored.
DOMConfiguration interface[105] The Perl parameter name of a parameter is the value returned by the following steps:
[106] The supported property names of a DOMConfiguration object is the
values returned by the following steps:parameterNames attribute of the object.
[107] To determine the value of a named property of a DOMConfiguration object,
the following steps MUST be run:getParameter method is invoked with
the parameter name whose Perl parameter name is name.undef.
[108] To set the value of an existing named property or set the value of a new named property
of a DOMConfiguration object, the following steps MUST be run:setParameter method is invoked with
the parameter name whose Perl parameter name is name and the assigned value.
For the purpose of this invocation only, the setParameter method MUST NOT
treat the undef value as WebIDL null.
[110] The following code set "false" to the parameter:
$config = $document->dom_config;
$config->{manakai_strict_document_children} = undef;
ok not $config->{manakai_strict_document_children};However, the following code unset the parameter:
$config->set_parameter ('manakai-strict-document-children', undef);
ok $config->{manakai_strict_document_children};Since the default value of the parameter is "true", unsetting the parameter results in the "true" value set to the parameter.
[109] To delete an existing named property of a DOMConfiguration object,
the following steps MUST be run:setParameter method is invoked with
the parameter name whose Perl parameter name is name and null.
[111] The IDL data type of the second argument to the setParameter method
is DOMUserData, which can be any Perl scalar value, while parameters have
their expected value type defined. Therefore "casting" of the value is performed within the
setParameter method. It MUST be performed by applying the steps
to convert the Perl value into WebIDL value of appropriate data type. If this fails,
as defined in the DOM3 Core specification, a "TypeMismatchError" exception
is thrown.
[21] Method names stringify, as_string,
and to_string are reserved.
[60] If the WebIDL interface has the stringifier WebIDL defined, the ""
operator of the class MUST be overloaded such that stringifying the object
invoke the stringifier.
[61] Unless otherwise defined, the bool operator of the class MUST
return a true value, whatever value is returned by the stringifier.
[22]
Several interfaces are defined as function-like.
Only Perl native CODE references, i.e.
values whose ref is CODE,
and objects for which the &{} operation is defined
MUST be treated as if they implement the
function-like interfaces and are referred to as objects
implementing the function-like interfaces. Each function-like interface
has a method, typically named as handleEvent.
Invoking that method on the object implementing a function-like
interface from another language binding invokes the
object itself, by &{} operation. In the Perl binding itself,
however, the method of the interface is not directly accessible on
the object implementing the interface.
handle_event method (and no
&{} operation defined) does not
implement the function-like interfaces.[43] Function-like interfaces are:
[44]
When the method would be invoked, the &{}
operation MUST be performed over the object with appropriate
arguments. The return value of the &{}
operation MUST be treated as if the return value
of the method. If the &{} operation
results in an exception is raised, it MUST
be treated as if it is an exception raised by the method.
$node->add_event_listener ('click', sub {
my $ev = shift;
print $ev->details, "\n";
return 0;
});would make the subroutine invoked when the node is clicked.
The subroutine, implementing the EventHandler
interface and treated as if it is the handleEvent
method, would prints the
number of clicks and then cancel the default action
for the event.
[45] Though in some of function-like interfaces constants are defined,
they are not accessible via the object implemeting that interface
in the Perl binding. Other interface might provide
such constants alternatively. For example,
objects implementing the Node
interface provides contants in UserDataHandler
interface (see >>42).
[144] If an interface defines the legacy caller, the &{} operation of the corresponding class
MUST invoke the legacy caller and return its result.
[153] dictionary is represented by a hash reference.
Node interface[27]
Multiple calles of the getter of
attributes or
childNodes on a Node
MUST return the same object respectively in terms
of Perl eq operator.
my $c1 = $node->child_nodes; my $c2 = $node->child_nodes; die unless $c1 eq $c2;
... must not die.
[34] The manakaiAppendText
method of the Node interface
accepts a scalar reference (>>33) as the first parameter.
[42]
A package that implements the Node
interface MUST implement the OperationType
constant group of the UserDataHandler
interface.
Document interface[119] Methods createElementNS, createAttributeNS,
setAttributeNS, createDocument:
qualifiedName,
is an array reference, i.e. the ref
operator with that parameter returns a string
of ARRAY, then the parameter
MUST be interpreted as following:undef, then there is
no namespace prefix (i.e. the qualified name has no
COLON character).undef; if it is, then
it MUST be treated as if an empty string
is specified.[122] In addition to qualified name's syntax tests performed by these methods, following steps
MUST be run:NamespaceError"
exception.NamespaceError" exception.
strictErrorChecking attribute also affects these checks.qualifiedName
parameter of the createDocumentType
method of the DOMImplementation
interface has no special interpretation for
an array reference, since the method does not
parse the parameter as a pair of
namespace prefix and local name.createDocumentType method[125] If the second or third argument to the createDocumentType method of the
DOMImplementation interface is undef, it MUST
be converted to the empty string.
createTextNode, createComment, createCDATASection[32] Methods createTextNode,
createComment, and
createCDATASection of the
Document interface
accept a scalar reference (>>33) as the first parameter.
DOMStringList interfacearg?DOMStirngMap interface[147] For the purpose of DOM Perl Binding, following definitions MUST be applied:
LOW LINE character (_), add a name-value pair to list whose name is the attribute's name with the first five characters removed and whose value is the attribute's value.LOW LINE character (_) by a U+002D HYPHEN-MINUS character (-).HYPHEN-MINUS character (-), throw a SyntaxError exception and abort these steps.LOW LINE character (_) in name by a U+002D HYPHEN-MINUS character (-).data- at the front of name.setAttribute() would have thrown an exception when setting an attribute with the name name, then this must throw the same exception.LOW LINE character (_) in name by a U+002D HYPHEN-MINUS character (-).data- at the front of name.data-* attributes accessible via the DOMStringMap
object of the DOM Perl Binding is different from those in JavaScript binding or the set of valid
data-* attribute names.[152] The CLEAR operation of the hash reference returned by the %{} operation
on the DOMStringMap object MUST remove all attributes in the null namespace whose name
begins with data-.
NodeList interface[30]
For any NodeList object,
the == operator MUST
be so overloaded that it returns whether
two arguments are equal in the equality defined
for the isEqualNode method
of the Node interface.
However, if the other operand is not a
NodeList object, then
it MUST return a false value.
NamedNodeMap interface[31]
For any NamedNodeMap object,
the == operator MUST
be so overloaded that it returns whether
two arguments are equal in the equality defined
for the isEqualNode method
of the Node interface.
[130] The NamedNodeMap object MUST be treated as a read-only hash-like object,
where keys are those accessible via the getNamedItem method.
NamedNodeMap,
the getNamedItem method returns the first one.XPathNSResolver InterfaceXPathNSResolver interface is part of DOM XPath. The
NSResolver interface is a variant of the XPathNSResolver
interface defined in the earlier versions of Selectors API.[46] The XPathNSResolver interface is unusual in that it can be existed both
as a platform object and as a user object.
[47] The createNSResolver method MUST return a platform object
implementing the XPathNSResolver interface.
[163] For the purpose of the XPathNSResolver interface used as a user object,
its IDL definition MUST be interpreted as if it were a callback interface.
XPathNSResolver object.[165] For example, the return value of the createNSResolver method
can be specified as an argument to the evaluate method:
$resolver = $document->create_ns_resolver ($node); $result = $document->evaluate ($expr, $ctx, $resolver);
[166] A code reference returning the namespace URL can also be used as an argument:
$result = $document->evaluate ($expr, $ctx, sub {
my ($self, $prefix) = @_;
return $PrefixToURL->{$prefix};
});document.all[141] The item method and the &{} operation
of the document.all object MUST run these steps:DOMString value and let index be the result.item(unsigned long index) of the HTMLCollection interface with index, return its result, and abort these steps.item(DOMString name) of the HTMLAllCollection
interface with index and return its result.
[143] The HTMLAllCollection's bool operation MUST
return the false value.
[145] The namedItem method MUST always return the same object
if the same argument is specified.
[146] The tags method MUST always return the same object
if the same argument (after converted to ASCII lowercase if it is an HTML document) is specified.
DOMImplementation interface[37] If the class for the DOMImplementation interface has the
constructor method, i.e. the new method, it MUST
follow these steps:Document constructor DOM.DOMImplementation object that is associated with
document.
HTMLPropertiesCollection interface and the PropertyNodeList interface[167] An HTMLPropertiesCollection object MUST be represented as a read-only hash
reference in Perl.
[168] The keys of the hash MUST be the values that would be returned by the names attribute
of the HTMLPropertiesCollection.
[171] The values of the hash MUST be the PropertyNodeList objects corresponding
to the keys, respectively.
[172] A PropertyNodeList object MUST be represented as a read-only array
reference in Perl.
[173] The items of the array MUST be the nodes in the PropertyNodeList, in same order.
AbortSignal interface[55] The following IDL fragment MUST be implemented:
partial interface AbortSignal { attribute ManakaiAbortCallback manakaiOnabort; attribute DOMException manakaiError; }; callback ManakaiAbortCallback = void ();
[56] An AbortSignal object has an associated abort callback
and error object,
which are initially null. When an AbortSignal object is created,
the following steps MUST be run:
DOMException object
whose name is AbortError.null:null.[184] On getting, the manakaiOnabort attribute of
the AbortSignal interface MUST run these steps:
[186] On setting, the attribute MUST run these steps:
[193] On getting, the manakaiError
attribute MUST run these steps:
[195] On setting, the attribute MUST run these steps:
[156] In general, when a feature is not supported at all, it SHOULD NOT be exposed to the application.
[157] If an implementation does not support the adoptNode method of the
Document interface, the Document object ought not have
the adopt_node method.
[158] When a feature might or might not be supported depending on the configuration of the implementation, the feature MAY be exposed even when it is not enabled.
[159] If a CSS implementation does support the 'float' property but the associated
renderer does not support floating of the box, the cssFloat attribute of the
CSSStyleDeclaration interface might be exposed as the css_float
method. As the method is defined in terms of the getPropertyValue and
setProperty methods, these methods' behavior on unsupported CSS properties apples.
(That is, the method return the empty on getting, or do nothing on setting.)
[160] An event handler IDL attribute might be exposed even when the implementation is currently not connected to the device that would fire the event in question.
[161] There might be the geolocation attribute of the Navigator object
even when no positioning device is known to available.
[101] Since Perl's garbage collection is reference count, simply implementing various DOM attributes as references could cause objects that could not be freed at all. To work around this situation, implementations can adopt different strategies, including:
For the purpose of DOM conformance, limitations caused by those strategies are considered "platform-specific limitations" <http://dom.spec.whatwg.org/#conformance>.
[191] The terms interface, attribute, and IDL fragment is defined by the Web IDL specification.
[192] The term
AbortSignal
is defined by the DOM Standard.
[189] The term report an exception is defined by the HTML Standard.
In binding languages that support setting to a readonly attribute setting media to a string must set the value of mediaText on the MediaList object.
[CSSOM]
@different_parents = grep { not $found{$node->parent_node}++ } @node;