WD-DOM/level-one-core-971009

Document Object Model (Core)
Level 1

W3C Working Draft 9-October-1997

This version:

http://www.w3.org/WD-DOM/level-one-core-971009

Latest version:

http://www.w3.org/WD-DOM/level-one-core

WG Chair:

Lauren Wood, SoftQuad, Inc.

Editor:

Steve Byrne, JavaSoft (Sun Microsystems, Inc.)

Principal contributors:

Vidur Apparao, Netscape; Steve Byrne, JavaSoft (Sun Microsystems, Inc.); Mike Champion, ArborText, Inc.; Scott Isaacs, MicroSoft; Arnaud Le Hors, W3C; Gavin Nicol, INSO; Peter Sharpe, SoftQuad, Inc.; Jared Sorensen, Novell; Bob Sutor, IBM

Status of this document

This document is part of the Document Object Model Specification

Introduction

Intended Audience

Design goals for the DOM Level One specification

The DOM objects and interfaces are designed to be:
• sufficient for representing the content of parsed HTML and XML documents without loss of [significant] information. The supported HTML version is 4.0; the supported XML version is 1.0.
• sufficient to construct an entirely new document instance programmatically that is identical to the parsed form of a given HTML or XML document. This means that it has sufficient constructive power to build any useful document object hierarchy, and that an implementation could be written such that the external document parser merely calls the methods specified in the level one specification to build the object hierarchy.
• the foundation for the rest of the document object model levels, which means it must be simple, flexible, and extensible.
• thread-safe: The operations supported by the DOM will not corrupt the document object or return corrupted state (as far as this API is concerned). Higher level consistency support mechanisms such as explicit locks or transactions are outside of the scope of the level one specification. For level one of the DOM, the assumption is that only one thread operates on the document at a time.

Overall type hierarchy

Primary object model types

Node
  |
  +--Document
  |
  +--Element
  |
  +--Attribute
  |
  +--Text
  |
  +--Comment 
  |
  +--PI 
  |
  +--Reference
  |    |
  |    +--NamedCharacterReference
  |
  +--NumericCharacterReference

Auxiliary types

NodeList

Represents a (possibly) lazily evaluated set of nodes.

NamedNodeList

Similar to a NodeList, but members are indexed by name.

NodeEnumerator

Used for iterating over (enumerating) a set of nodes.

DocumentContext

A repository for meta-data about a document, such as source, creation date, and other creation context information. This object will be fully specified in the level two DOM specification.

Selection

[Coming in a later draft of level one] Selections represent a range of document content, including markup, which may span partial subtrees of the document content.

IDL Issues

• In the DOM's IDL definition, within each interface there are primarily two kinds of things:
  1. Attribute definitions
  2. Method (IDL calls them "operation") definitions
• Attribute definitions are a shorthand notation for a pair of "get/set" accessors, and should not be thought of, nor mapped in a particular language binding to, data members directly.
• The "constructor" methods for the various IDL objects are not specified explicitly. Specific programming language implementations of the DOM will provide suitable object creation methods; typically these will be simple, no argument constructors, although this is not a requirement.
• IDL's long datatype represents 32 signed bit integers. In other language bindings, i.e. Java, this would be mapped to the Java int datatype.

For more information on OMG's IDL, please visit the OMG home page, or download the CORBA 2.0 (minor version number is expected to change in the near future) specification (it's rather large) which contains the IDL language definition in chapter 3.

Note: The Object Management Group Interface Definition Language (OMG IDL) was chosen as it was designed for specifying language and implementation-neutral interfaces. Various other IDLs could be used; the use of OMG IDL does not imply a requirement to use a specific object binding runtime.

Primary API Types

Node

Element

Document

Typical operation

Once the application has access to the root of the document object hierarchy, it can use the methods defined herein for accessing individual nodes, selection of specific node types such as all images, and so on.

Document Object Model APIs

• A brief overview of the semantics of the object and how it relates to other objects in the DOM.
• A sequence of pairs for each method that is defined for the object.

Node documentType

For XML, this provides access to the Document Type Definition (see DocumentType) associated with this XML document. For HTML documents and XML documents without a document type definition this returns the value null.

Element documentElement

The element that's the root element for the given document. For HTML, this will be an Element instance whose tagName is "HTML"; for XML this is the outermost element, i.e. the element non-terminal in production [23] in Section 2.9 of the XML-lang specification.

For documents which were not retrieved via HTTP, or for those which were created directly in memory, there may be no DocumentContext.

NOTE: The DocumentContext interface described here is expected to be significantly expanded in the level two specification of the Document Object Model.

Document document

This is the root node of a Document Object Model. Any iteration, enumeration or other traversal of the entire document's content should begin with this node.

NodeType getNodeType()

Returns an indication of the underlying Node object's type. The actual type of the returned data is language binding dependent; the IDL specification uses an enum, and it is expected that most language bindings will represent this runtime-queryable Ndoe type using an integral data type. The names of the node type enumeration literals are straightforwardly derived from the names of the actual Node subtypes, and are fully specified in the IDL definition of Node in the IDL definition in Appendix A.

Node getParentNode()

Returns the parent of the given Node instance. If this node is the root of the document object tree, null is returned. [Note: because in ECMAScript get/set method pairs are surfaced as properties, Parent would conflict with the pre-defined Parent property, so we disambiguate this with "ParentNode" even though it is inconsistent with the naming convention of the other methods that do not include "Node"].

Node getFirstChild()

Returns the first child of a node. If there is no such node, null is returned.

NodeList getChildren()

Returns a NodeList object containing the children of this node. If there are no children, null is returned. The content of the returned NodeList is "live" in the sense that changes to the children of the Node object that it was created from will be immediately reflected in the set of Nodes the NodeList contains; it is not a static snapshot of the content of the Node. Similarly, changes made to the NodeList will be immediately reflected in the set of children of the Node that the NodeList was created from.

boolean hasChildren()

Returns true if the node has any children, false if the node has no children at all. This method exists both for convenience as well as to allow implementations to be able to bypass object allocation, which may be required for implementing getChildren().

Node getPreviousSibling()

Returns the node immediately preceding the current node in a breadth-first traversal of the tree. If there is no such node, null is returned.

Node getNextSibling()

Returns the node immediately following the current node in a breadth-first traversal of the tree. If there is no such node, null is returned.

Node insertChild(in unsigned long index, in Node newChild)

Inserts a child node into the list of children before zero-based location index. Nodes from index to the end of list are moved up by one. If index is 0, the node is added as the first child; if index is greater than or equal to the number of children, the node is added as the last child.

Node replaceChild(in unsigned long index, in Node newChild)

Replaces the child node at location index and returns the old Node that occupied that position. If the index is provided is larger than the number of nodes in the list, a NoSuchNodeException is thrown.

Node removeChild(in unsigned long index)

Removes the child node at location index and returns the old Node that occupied that position. If the index is provided is larger than the number of nodes in the list, a NoSuchNodeException is thrown.

NodeEnumerator getElementsByTagName(wstring name)

Produces an enumerator which iterates over all of the Element nodes that are descendants of the current node whose tagName matches the given name. The iteration order is a depth first enumeration of the elements as they occurred in the original document.

Note: a later level of the DOM will provide a more generalized querying mechanism for Nodes. One such query involves obtaining all the Elements in a subtree with a given tagName. A convenience method for this query has been included in the core document. This method might be removed at a later date in favor of a more comprehensive querying mechanism.

The items in the NodeList are accessible via an integral index, starting from 0. A NodeEnumerator object may be created to allow simple sequential traversal over the members of the list.

NodeEnumerator getEnumerator()

Creates and returns an object which allows traversal of the nodes in the list in an iterative fashion. Note this method may be very efficient in some implementations; that is, they can return the enumerator instance even before the first node in the set has been located.

Node item(in unsigned long index) raises(NoSuchNodeException)

Returns the indexth item in the collection. If index is greater than or equal to the number of nodes in the list, a NoSuchNodeException is thrown.

Node replace(in unsigned long index, in Node replacedNode) raises (NoSuchNodeException)

Replace the indexth item the list with replacedNode, and return the old node object at that index (null is returned if the index is equal to the previous number of nodes in the list). If index is greater than the number of nodes in the list, a NoSuchNodeException is thrown.

void append(in Node newNode)

A convenience function to add a new item at the end of the NodeList instance. Equivalent to insert(self.getLength(), newNode).

void prepend(in Node newNode)

A convenience function to add a new item at the beginning of the NodeList instance. Equivalent to insertChild(0, newNode).

void insert(in unsigned long index, in Node newNode) raises (NoSuchNodeException)

Inserts a child node into the list BEFORE zero-based location index. Nodes from index to the end of list are moved up by one. If index is 0, the node is added at the beginning of the list; if index is self.getLength(), the node is added at the end of the list.

Node remove(in unsigned long index) raises (NoSuchNodeException)

Removes the node at index from the list and returns it. The indices of the members of the list which followed this node are decremented by one following the removal. If the index is provided is larger than the number of nodes in the list, the NoSuchNodeException is thrown.

unsigned long getLength()

Returns the number of nodes in the NodeList instance. The range of valid child node indices is 0 to getLength()-1 inclusive.

Typical usage (in some C++ like language) might look like:

    NodeEnumerator nodeEnum = document.getChildren().getEnumerator();

    for (Node node = nodeEnum.first(); node != null; node = nodeEnum.next()) {

	// ... do some computation on that node
    }

Node getFirst()

Returns the first node that the enumeration refers to, and resets the enumerator to reference the first node. If there are no nodes in the enumeration, null is returned.

NOTE: in some implementations this may or may not be a fast operation; it may be the case that the enumeration finds the requested node on demand, and for very large document object, this may take some time.

Node getNext()

Return the next node in the enumeration, and advances the enumeration. Returns null after the last node in the list has been passed, and leaves the current pointer at the last node.

Node getPrevious()

Return the previous node in the enumeration, and regresses the enumeration. Returns null after the first node in the enumeration has been returned, and leaves the current pointer at the first node.

Node getLast()

Retuns the last node in the enumeration, and sets the enumerator to reference the last node in the enumeration. If the enumeration is empty, this method will return null. Doing a getNext() immediately after this operation will return null.

Node getCurrent()

This returns the node that the enumeration is currently referring to, without affecting the state of the enumeration object in any way. When invoked before any of the enumeration positioning methods above, the node returned will be the first node in the enumeration, or null if the enumeration is empty.

boolean atStart()

Returns true if the enumeration's "pointer" is positioned at the start of the set of nodes, i.e. if getCurrent() will return the same node as getFirst() would return. For empty enumerations, true is always returned. Does not affect the state of the enumeration in any way.

boolean atEnd()

Returns true if the enumeration's "pointer" is positioned at the end of the set of nodes, i.e. if getCurrent() will return the same node as getLast() would return. For empty enumerations, true is always returned. Does not affect the state of the enumeration in any way.

Node getNode(in wstring name)

Retrieve a node by its name.

Node setNode(in wstring name, in Node node)

Add a new node to the end of the collection and associate it with the given name. If the name already exists, the previous contents are replaced, and returned. If no object of the same name exists, null is returned, and the named node is added to the end of the NamedNodeList object; that is, it is accessible via the item method using the index one less than the value returned by getLength().

Node remove(in wstring name) raises (NoSuchNodeException)

Removes the named name from the list and returns it. If the name provided does not exist, the NoSuchNodeException is thrown.

Node item(in unsigned long index) raises(NoSuchNodeException)

Returns the indexth item in the collection. If index is greater than or equal to the number of nodes in the list, a NoSuchNodeException is thrown.

unsigned long getLength()

Returns the number of nodes in the NamedNodeList instance.

NodeEnumerator getEnumerator()

Creates and returns an object which allows traversal of the nodes in the list in an iterative fashion. Note this method may be very efficient in some implementations; that is, they can return the enumerator instance even before the first node in the set has been located.

For example (in XML):

<elementExample id="demo">
    <subelement1/>
    <subelement2>
	<subsubelement/>
    </subelement2>
</elementExample>

wstring tagName

This is the string that is the element's name. For example, in:

<elementExample id="demo">
    ...
</elementExample>

This would have the value "elementExample". Note that this is case-preserving, as are all of the operations of the DOM. See Name case in the DOM for a description of why the DOM preserves case.

Note:This attribute's name may change in the near future to "elementType", which is a more technically correct term.

NamedNodeList attributes

The attributes for this element. In the elementExample example above, the attributes list would consist of the id attribute, as well as any attributes which were defined by the document type definition for this element which have default values.

void setAttribute(in Attribute newAttr)

Adds a new attribute/value pair to an Element node object. If an attribute by that name is already present in the element, it's value is changed to be that of the Attribute instance.

wstring name

The name of this attribute. Note that this name is case-sensitive, and is not changed or canonicalized by the DOM. See ^casing for further details.

NodeList value

The effective value of this attribute. (The attribute's effective value is determined as follows: if this attribute has been explicitly assigned any value, that value is the attribute's effective value; otherwise, if there is a declaration for this attribute, and that declaration includes a default value, then that default value is the attribute's effective value; otherwise, the attribute has no effective value.) Note, in particular, that an effective value of the null string would be returned as a Text node instance whose toString() method will return a zero length string (as will toString() invoked directly on this Attribute instance). If the attribute has no effective value, then this method will return null. Note the toString() method on the Attribute instance can also be used to retrieve the string version of the attribute's value(s).

Even seemingly simple string-valued attributes will be represented as a set of more than one Node if the value of the attribute includes things like entity references. For example:

    <p class="foo&amp;bar">

The nodes would be a Text containing "foo", then a NamedCharacterReference, and finally a Text instance containing "bar".

boolean specified

If this attribute was explicitly given a value in the original document, this will be true; otherwise, it will be false.

wstring toString()

Returns the value of the attribute as a string. Character and general entity references will have been replaced with their values in the returned string.

wstring data

The content of the comment, exclusive of the comment begin and end sequence.

wstring name

XML defines a name as the first token following the markup that begins the processing instruction, and this attribute returns that name. For HTML, the returned value is null.

wstring data

The content of the processing instruction, from the character immediately after the <? (after the name in XML) to the character immediately preceding the ?>.

wstring name

The name of the entity being referred to.

wstring getReplacementText()

Returns the string that consists of the actual character that the NamedCharacterReference refers to. For example, for <, the returned string would be "<".

wchar character

The Character instance that this character reference indicated.

wstring original

This is the original string representing the numeric character reference, without the introducing markup. For example, given < this attribute would be "60" (sans the '&#' and ';'), and for H, this attribute would have "x48" for its value.

wstring data

This holds the actual content of the text node. Text nodes contain just plain text, without markup and without entities, both of which are manifest as separate objects in the DOM.

boolean isIgnorableWhitespace

This is true if the Text node contains only whitespace, and if the whitespace is ignorable by the application. Only XML processors will make use of this, as HTML abides by SGML's rules for whitespace handling.

Footnotes

Application developers using the DOM for HTML would be wise to use case-insensitive comparisons when testing for equality.

Appendix A: IDL Interface definitions

// $Date: 1997/10/07 19:37:20 $
module DOM {

  // Basic grove object types
  interface Node;
  interface Document;

  // Objects related to the instance
  interface Element;

  typedef sequence StringList;


  exception NoSuchNodeException {};


  //////////////////////////////////////////////////////////////////////////
  //                                                                      //
  // OBJECTS USED TO DEFINE A GROVE                                       //
  //                                                                      //
  //////////////////////////////////////////////////////////////////////////

  // Enumerator class for a node list
  interface NodeEnumerator {
    Node getFirst();
    Node getNext();
    Node getPrevious();
    Node getLast();

    Node getCurrent();

    // not sure about these...
    // the rationale for their existence is that the enumerator may be used
    // internally to a method, which may return some interesting value, and
    // therefore cannot also indicate whether the start or end of enumeration
    // was reached.  Any of the traversal methods affects the state, and
    // so are not suitable for usage as predicates (unless possible state
    // manipulation is acceptable).
    boolean atStart();
    boolean atEnd();
  };

  // Define the type for a sequence of nodes
  interface NodeList {
    NodeEnumerator getEnumerator();

    Node item(in unsigned long index)
        raises(NoSuchNodeException);

    void replace(in unsigned long index, in Node replacedNode) 
	raises (NoSuchNodeException);

    void append(in Node newNode);

    void prepend(in Node newNode);

    void insert(in unsigned long index, in Node newNode) 
        raises (NoSuchNodeException);

    Node remove(in unsigned long index)
        raises (NoSuchNodeException);

    // This may be expensive to compute
    unsigned long     getLength();
  };

  // Interface to a node in a grove
  interface Node {
    
    enum NodeType {
         NODE,
 	 DOCUMENT,
         ELEMENT,
         ATTRIBUTE,
         PI,
         COMMENT,
         REFERENCE,
         NAMED_CHARACTER_REFERENCE,
         NUMERIC_CHARACTER_REFERENCE,
	 TEXT
    };
    
    NodeType getNodeType();

    // Simple traversal interface
    Node     getParentNode();
    NodeList getChildren();
    boolean  hasChildren();
    Node     getPreviousSibling();
    Node     getNextSibling();

    void insertChild(in unsigned long index, in Node newChild);

    Node replaceChild(in unsigned long index, in Node newChild)
        raises (NoSuchNodeException);

    Node removeChild(in unsigned long index)
        raises (NoSuchNodeException);

    NodeEnumerator getElementsByTagName(in wstring name);
  };

  // Named node list
  interface NamedNodeList {
    // Core get and set interface. Note that implementations may
    // build the list lazily
    Node getNode(in wstring name);
    Node setNode(in wstring name, in Node node);

    Node remove(in wstring name) raises (NoSuchNodeException);

    Node item(in unsigned long index)
        raises(NoSuchNodeException);

    unsigned long getLength();

    NodeEnumerator getEnumerator();
  };

  
  // Placeholders
  typedef wstring Date;
  typedef wstring Location;

  //////////////////////////////////////////////////////////////////////////
  //                                                                      //
  // OBJECTS RELATED TO THE INSTANCE                                      //
  //                                                                      //
  //////////////////////////////////////////////////////////////////////////

  interface DocumentContext {
    attribute Document	document;
  };

  interface Document : Node {
    attribute Node      documentType;

    attribute Element 	documentElement;
  };

  interface Attribute : Node {
    attribute wstring	name;

    attribute NodeList  value;

    attribute boolean	specified;

    // provides a connection to the DTD 
    // attribute Node  	definition;

    wstring toString();
  };

  interface PI : Node {
    attribute wstring 	name;
    attribute wstring 	data;
  };

  interface Element : Node {
    attribute wstring	tagName;

    attribute NamedNodeList  attributes;

    void setAttribute(in Attribute newAttr);
  };

  // Represents the content of 
  interface Comment : Node {
    attribute wstring	data;
  };

  // base type for named entities, including parameter entities, but not
  // numeric entites
  interface Reference : Node {
    attribute wstring	name;

    // Entity will be defined in a later draft of the level one specification
    //attribute Entity	definition;
  };

  interface NamedCharacterReference : Reference {
    wstring getReplacementText();
  };

  interface NumericCharacterReference : Node {
    attribute wchar character;

    // The "60" part of < or "x48" for H
    attribute wstring original;
  };


  interface Text : Node {
     attribute wstring    data;

     attribute boolean isIgnorableWhitespace;
  };

};

Appendix B: Java Core API definitions

Node.java

// $Id: Node.java,v 1.13 1997/10/07 19:37:55 sbb Exp $

package w3c.dom;

public interface Node {
    // Node type enumeration; these represent the set of
    //  values returned by the getNodeType() method.
    static final int NODE      = 1;
    static final int DOCUMENT  = 2;
    static final int ELEMENT   = 3;
    static final int ATTRIBUTE = 4;
    static final int PI        = 5;
    static final int COMMENT   = 6;
    static final int REFERENCE = 7;
    static final int NAMED_CHARACTER_REFERENCE = 8;
    static final int NUMERIC_CHARACTER_REFERENCE = 9;
    static final int TEXT      = 10;

    int getNodeType();

    // can return null
    Node getParentNode();

    NodeList getChildren();
    boolean  hasChildren();
    Node     getPreviousSibling();
    Node     getNextSibling();

    void insertChild(int index, Node newChild);


    Node replaceChild(int index, Node newChild)
	 	 throws NoSuchNodeException;

    Node removeChild(int index)
	 	 throws NoSuchNodeException;

    NodeEnumerator getElementsByTagName(String name);
}

NodeList.java

// $Id: NodeList.java,v 1.2 1997/10/07 19:37:56 sbb Exp $

package w3c.dom;

public interface NodeList {
    NodeEnumerator getEnumerator();

    Node item(int index)
	 throws NoSuchNodeException;

    void replace(int index, Node replacedNode) 
	 throws NoSuchNodeException;

    void append(Node newNode);

    void prepend(Node newNode);

    void insert(int index, Node newNode) 
	 throws NoSuchNodeException;

    Node remove(int index)
	 throws NoSuchNodeException;

    // This may be expensive to compute
    int getLength();
}

NamedNodeList.java

// $Id: NamedNodeList.java,v 1.5 1997/10/07 19:37:54 sbb Exp $

package w3c.dom;

public interface NamedNodeList {
    // Core get and set interface. Note that implementations may
    // build the list lazily
    Node getNode(String name);
    Node setNode(String name, Node node);

    Node remove(String name)
	 throws NoSuchNodeException;

    Node item(int index)
	 throws NoSuchNodeException;

    int getLength();

    NodeEnumerator getEnumerator();
}

NodeEnumerator.java

// $Id: NodeEnumerator.java,v 1.5 1997/10/07 19:37:55 sbb Exp $

package w3c.dom;

public interface NodeEnumerator {
    Node getFirst();
    Node getNext();
    Node getPrevious();
    Node getLast();

    Node getCurrent();

    // not sure about these...
    // the rationale for their existence is that the enumerator may be used
    // internally to a method, which may return some interesting value, and
    // therefore cannot also indicate whether the start or end of enumeration
    // was reached.  Any of the traversal methods affects the state, and
    // so are not suitable for usage as predicates (unless possible state
    // manipulation is acceptable).

    boolean atStart();
    boolean atEnd();
}

DocumentContext.java

// $Id: DocumentContext.java,v 1.3 1997/10/07 19:37:51 sbb Exp $

package w3c.dom;

public interface DocumentContext {
    Document getDocument();
    void setDocument(Document document);
}

Document.java

// $Id: Document.java,v 1.4 1997/10/07 19:37:51 sbb Exp $

package w3c.dom;

public interface Document extends Node {
    Node getDocumentType();
    void setDocumentType(Node documentType);

    Element getDocumentElement();
    void setDocumentElement(Element documentElement);
}

Attribute.java

// $Id: Attribute.java,v 1.4 1997/10/07 19:37:50 sbb Exp $

package w3c.dom;


public interface Attribute extends Node {
    String getName();
    void   setName(String name);

    NodeList getValue();
    void     setValue(NodeList value);

    boolean getSpecified();
    void    setSpecified(boolean specified);

    String toString();
}

PI.java

// $Id: PI.java,v 1.4 1997/10/07 19:37:57 sbb Exp $

package w3c.dom;

public interface PI extends Node {
    String getName();
    void   setName(String name);

    String getData();
    void   setData(String data);
}

Element.java

// $Id: Element.java,v 1.4 1997/10/07 19:37:52 sbb Exp $

package w3c.dom;

public interface Element extends Node {
    String getTagName();
    void setTagName(String tagName);

    NamedNodeList  getAttributes();
    void setAttributes(NamedNodeList attributes);

    void setAttribute(Attribute newAttr);
}

Comment.java

// $Id: Comment.java,v 1.3 1997/10/07 19:37:50 sbb Exp $

package w3c.dom;

// Represents the content of 

public interface Comment extends Node {
    String getData();
    void   setData(String data);
}

Reference.java

// $Id: Reference.java,v 1.3 1997/10/07 19:37:57 sbb Exp $

package w3c.dom;

// base type for named entities, including parameter entities, but not
// numeric entites

public interface Reference extends Node {
    String getName();
    void   setName(String name);

    // not until the DTD exists
    //attribute Entity	definition;
}

NamedCharacterReference.java

// $Id: NamedCharacterReference.java,v 1.1 1997/10/07 19:37:54 sbb Exp $

package w3c.dom;

// For Named character references

public interface NamedCharacterReference extends Reference {
    String getReplacementText();
}

NumericCharacterReference.java

// $Id: NumericCharacterReference.java,v 1.3 1997/10/07 19:37:56 sbb Exp $

package w3c.dom;

public interface NumericCharacterReference extends Node {
    char getCharacter();
    void setCharacter(char character);

    // The "60" part of < or "x48" for H
    String getOriginal();
    void   setOriginal(String original);
}

Text.java

// $Id: Text.java,v 1.3 1997/10/07 19:37:58 sbb Exp $

package w3c.dom;

public interface Text extends Node {
     String getData();
     void   setData(String data);

     boolean getIsIgnorableWhitespace();
     void    setIsIgnorableWhitespace(boolean isIgnorableWhitespace);
}

NoSuchNodeException.java

// $Id: NoSuchNodeException.java,v 1.3 1997/09/26 17:57:36 sbb Exp $

package w3c.dom;

public class NoSuchNodeException extends Exception {

    // Adds nothing over the base Exception class.

}

Appendix C: ECMAScript Core API definitions

Appendix D: Glossary