@awayfl/avm1
Version:
Virtual machine for executing AS1 and AS2 code
243 lines (242 loc) • 12 kB
JavaScript
/**
* The XMLNode class represents the legacy XML object
* that was present in ActionScript 2.0 and that was renamed in ActionScript 3.0.
* In ActionScript 3.0, consider using the new top-level <xref href="../../XML.html" class="- topic/xref ">XML</xref>
* class and related classes instead,
* which support E4X (ECMAScript for XML).
* The XMLNode class is present for backward compatibility.
*/
var XMLNode = /** @class */ (function () {
/**
* Creates a new XMLNode object. You must use the constructor to create an XMLNode object before you
* call any of the methods of the XMLNode class.
* Note: Use the createElement() and createTextNode()
* methods to add elements and text nodes to an XML document tree.
* @param type The node type: either 1 for an XML element or 3 for a text node.
* @param value The XML text parsed to create the new XMLNode object.
*/
function XMLNode(type, value) {
}
// for AVM1:
XMLNode.prototype.axCallPublicProperty = function (value1, value2) {
return null;
};
XMLNode.prototype.axGetPublicProperty = function (value) {
return null;
};
XMLNode.prototype.axSetPublicProperty = function (value, value2) {
return null;
};
XMLNode.prototype.removeChild = function (child) {
};
Object.defineProperty(XMLNode.prototype, "attributes", {
/**
* An object containing all of the attributes of the specified XMLNode instance. The
* XMLNode.attributes object contains one variable for each attribute of the XMLNode instance.
* Because these variables are defined as part of the object, they are generally referred to as
* properties of the object. The value of each attribute is stored in the corresponding property as a
* string. For example, if you have an attribute named color, you would retrieve
* that attribute's value
* by specifying color as the property name, as the following code shows:
*
* var myColor:String = doc.firstChild.attributes.color
*/
get: function () {
console.log('attributes not implemented yet in flash/XMLNode');
return null;
},
set: function (value) {
console.log('attributes not implemented yet in flash/XMLNode');
},
enumerable: false,
configurable: true
});
Object.defineProperty(XMLNode.prototype, "childNodes", {
/**
* An array of the specified XMLNode object's children. Each element in the array is a reference
* to an XMLNode object that represents a child node. This is a read-only property and cannot be
* used to manipulate child nodes. Use the appendChild(), insertBefore(),
* and removeNode() methods to manipulate child nodes.
*
* This property is undefined for text nodes (nodeType == 3).
*/
get: function () {
console.log('childNodes not implemented yet in flash/XMLNode');
return [];
},
enumerable: false,
configurable: true
});
Object.defineProperty(XMLNode.prototype, "localName", {
/**
* The local name portion of the XML node's name. This is the element name without
* the namespace prefix. For example, the node
* <contact:mailbox/>bob@example.com</contact:mailbox>
* has the local name "mailbox", and the prefix "contact", which comprise the full
* element name "contact.mailbox".
*
* You can access the namespace prefix through the prefix property of
* the XML node object. The nodeName property returns the full name
* (including the prefix and the local name).
*/
get: function () {
console.log('localName not implemented yet in flash/XMLNode');
return '';
},
enumerable: false,
configurable: true
});
Object.defineProperty(XMLNode.prototype, "namespaceURI", {
/**
* If the XML node has a prefix, namespaceURI is the value of the xmlns
* declaration for that prefix (the URI), which is typically called the namespace URI.
* The xmlns declaration is in the current node or in a node higher in the XML
* hierarchy.
*
* If the XML node does not have a prefix, the value of the namespaceURI property
* depends on whether there is a default namespace defined (as in
* xmlns="http://www.example.com/"). If there is a default namespace, the value of
* the namespaceURI property is the value of the default namespace.
* If there is no default namespace, the namespaceURI property for
* that node is an empty string ("").You can use the getNamespaceForPrefix()
* method to identify the namespace associated with a
* specific prefix. The namespaceURI property returns the prefix associated with the node name.
*/
get: function () {
console.log('namespaceURI not implemented yet in flash/XMLNode');
return '';
},
enumerable: false,
configurable: true
});
Object.defineProperty(XMLNode.prototype, "prefix", {
/**
* The prefix portion of the XML node name. For example, the node
* <contact:mailbox/>bob@example.com</contact:mailbox> prefix
* "contact" and the local name "mailbox", which comprise the full element name "contact.mailbox".
*
* The nodeName property of an XML node object returns the full name
* (including the prefix and the local name). You can access the local name portion of the
* element's name via the localName property.
*/
get: function () {
console.log('prefix not implemented yet in flash/XMLNode');
return '';
},
enumerable: false,
configurable: true
});
/**
* Appends the specified node to the XML object's child list. This method operates directly on the
* node referenced by the childNode parameter; it does not append a copy of the
* node. If the node to be appended already exists in another tree structure, appending the node to the
* new location will remove it from its current location. If the childNode
* parameter refers to a node that already exists in another XML tree structure, the appended child node
* is placed in the new tree structure after it is removed from its existing parent node.
* @param node An XMLNode that represents the node to be moved from its current location to the child
* list of the my_xml object.
*/
XMLNode.prototype.appendChild = function (node) {
console.log('appendChild not implemented yet in flash/XMLNode');
};
/**
* Constructs and returns a new XML node of the same type, name, value, and attributes as the
* specified XML object. If deep is set to true, all child nodes are
* recursively cloned, resulting in an exact copy of the original object's document tree.
* The clone of the node that is returned is no longer associated with the tree of the cloned item.
* Consequently, nextSibling, parentNode, and previousSibling
* all have a value of null. If the deep parameter is set to
* false, or the my_xml node has no child nodes,
* firstChild and lastChild are also null.
* @param deep A Boolean value; if set to true,
* the children of the specified XML object will be recursively cloned.
* @return An XMLNode Object.
*/
XMLNode.prototype.cloneNode = function (deep) {
console.log('cloneNode not implemented yet in flash/XMLNode');
return null;
};
/**
* Returns the namespace URI that is associated with the specified prefix for the node. To determine
* the URI, getPrefixForNamespace() searches up the XML hierarchy from the node, as
* necessary, and returns the namespace URI of the first xmlns declaration for the
* given prefix.
*
* If no namespace is defined for the specified prefix,
* the method returns null.If you specify an empty string ("") as the prefix and there is a
* default namespace defined for the node (as in xmlns="http://www.example.com/"),
* the method returns that default namespace URI.
* @param prefix The prefix for which the method returns the associated namespace.
* @return The namespace that is associated with the specified prefix.
* @refpath
*/
XMLNode.prototype.getNamespaceForPrefix = function (prefix) {
console.log('getNamespaceForPrefix not implemented yet in flash/XMLNode');
return '';
};
/**
* Returns the prefix that is associated with the specified namespace URI for the node. To determine
* the prefix, getPrefixForNamespace() searches up the XML hierarchy from the node, as
* necessary, and returns the prefix of the first xmlns declaration with a namespace URI
* that matches ns.
*
* If there is no xmlns
* assignment for the given URI, the method returns null. If there is an
* xmlns assignment for the given URI but no prefix is associated with the assignment,
* the method returns an empty string
* ("").
* @param ns The namespace URI for which the method returns the associated prefix.
* @return The prefix associated with the specified namespace.
*/
XMLNode.prototype.getPrefixForNamespace = function (ns) {
console.log('getPrefixForNamespace not implemented yet in flash/XMLNode');
return '';
};
/**
* Indicates whether the specified XMLNode object has child nodes. This property is true if the
* specified XMLNode object has child nodes; otherwise, it is false.
* @return Returns true if the
* specified XMLNode object has child nodes; otherwise, false.
*/
XMLNode.prototype.hasChildNodes = function () {
console.log('hasChildNodes not implemented yet in flash/XMLNode');
return false;
};
/**
* Inserts a new child node into the XML object's child list, before the
* beforeNode node. If the beforeNode parameter is undefined
* or null, the node is added using the appendChild() method. If beforeNode
* is not a child of my_xml, the insertion fails.
* @param node The XMLNode object to be inserted.
* @param before The XMLNode object before the insertion point for the childNode.
*/
XMLNode.prototype.insertBefore = function (node, before) {
console.log('insertBefore not implemented yet in flash/XMLNode');
};
/**
* Removes the specified XML object from its parent. Also deletes all descendants of the node.
*/
XMLNode.prototype.removeNode = function () {
console.log('removeNode not implemented yet in flash/XMLNode');
};
/**
* Evaluates the specified XMLNode object, constructs a textual representation of the XML structure,
* including the node, children, and attributes, and returns the result as a string.
*
* For top-level XMLDocument objects (those created with the constructor),
* the XMLDocument.toString() method outputs the document's XML declaration
* (stored in the XMLDocument.xmlDecl property), followed by the document's
* DOCTYPE declaration (stored in the XMLDocument.docTypeDecl property),
* followed by the text representation of all XML nodes in the object. The XML declaration is not
* output if the XMLDocument.xmlDecl property is null.
* The DOCTYPE declaration is not output if the
* XMLDocument.docTypeDecl property is null.
* @return The string representing the XMLNode object.
*/
XMLNode.prototype.toString = function () {
console.log('toString not implemented yet in flash/XMLNode');
return '';
};
return XMLNode;
}());
export { XMLNode };