0byt3m1n1

Path: /home/onesung/wl/cate/ [ Home ]
File: ozlib_euckr.js
/**
 * @fileoverview
 * ozlib는 XML개체를 쉽게 다루고 AJAX 요청을 쉽게 할 수 있도록
 * 도와주는 자바스크립트 라이브러리이다. ozlib.php와 그 사용 설명서, 
 * 테스트 프로그램의 저작권은 이혁에게 있으며 다음과 같은 조건하에서만 
 * 무료로 사용, 수정, 복사, 배포가 가능하다.<br/><br/>
 * 1. ozlib를 수정, 개선한 라이브러리도 동일한 조건으로 
 *		무료로 사용, 수정, 복사, 배포할 수 있도록 공개되어야 한다.<br/>
 * 2.	이 파일에서 ozlib에 대한 소개와 저작권 안내를 담고 있는 
 *		부분(줄1에서 줄 27까지)를 삭제하거나 수정할 수 없다.
 *		ozlib의 일부를 사용하더라도 ozlib에 대한 소개와 저작권
 *		안내를 꼭 포함해야 한다.<br/>
 * 3.	ozlib를 출판물이나 GPL로 공개되지 않는 제품(솔루션)에는 
 *		사용할 수 없다.<br/>
 * 4.	1항, 2항, 3항을 어긴 경우, 그 즉시 사용 허가가 
 *    취소된다. 사용 허가가 취소된 후에 1항과 2항을 다시
 *		지켜도 해당 사용자, 회사, 웹사이트는 모두 ozlib를
 *		사용할 수 없다. 예를 들어, ozlib의 저작권 안내 부분을
 *	  제외하고 웹사이트를 구축한 경우 발견 즉시 사용허가가 취소되며,
 *		저작권 안내 부분을 복원해도 무료로 사용할 수 없다.<br/>
 * 5. ozlib의 버그, 에러 등으로 인한 손해 발생시 책임은 모두
 *    ozlib 사용자에게 있으며 제작자는 손해에 대한 법적, 경제적
 *		책임을 지지 않는다.<br><br/>
 * ozlib 활용에 대한 의문점이 있으면 이혁(turnleft21@gmail.com)에게
 * 문의해 주시기 바랍니다.<br/><br/>
 * &copy; copyright by 이혁. 일부 권리는 보호됨.
 **/
/** 
 * 타이머나 이벤트 핸들러가 메쏘드를 실행하도록 지정할 때 사용한다. 
 * @priviate
 */
Function.prototype.bind = function(obj) {
	var __method = this;
	return function() {
		__method.apply(obj, arguments);
	}
}
/** 
 * 메쏘드의 인자를 그대로 다른 메쏘드에 넘겨서 실행할 때 사용한다. 
 * @priviate
 */
Function.prototype.apply = function(obj, parameters) {
	if (parameters == null) var parameters = new Array();
	if (obj == null)	var obj = window;
	var parameterStrings = new Array();
	for (var i = 0; i < parameters.length; i++) {
		parameterStrings[i] = 'parameters[' + i + ']';
	}	 
	obj.__apply__ = this;
	var result = eval('obj.__apply__(' + parameterStrings.join(', ') + ')');
	delete(obj.__apply__);
	return result;
}
/** 문자열의 앞부의 공백들을 삭제하여 돌려준다.
 * @type Function
 * @return String
 */
String.prototype.trim = function() {
	if(arguments.length == 0) {
		return this.replace(/^\s*/,"").replace(/\s*$/,"");	
	}
	else if(arguments.length == 1) {
		self.eval("var _temp1 = /^(" + arguments[0] + ")*/");
		self.eval("var _temp2 = /(" + arguments[0] + ")*$/");
		return this.replace(_temp1,"").replace(_temp2,"");	
	}
}
/**  문자열에서 HTML 요소와 속성을 삭제하여 돌려준다. 
 * @return String
 */
String.prototype.stripTags = function() {
	return this.replace(/\<(\/)?([_a-zA-Z][_a-zA-Z0-9]*)((\s*[_a-zA-Z][_a-zA-Z0-9]*((\s*\=\s*[\'\"][^\'\"]*[\'\"])|(\s*\=\s*[^\s\/\>]+))?)*)\s*(\/)?\>/gi,"");
}
/**  문자열에서 요소와 속성의 이름은 소문자로 변환하며, 속성의 값은 따옴표로 감싸고, 
 * 닫는 택을  사용하지 않은 요소는 닫는 택을 추가해서 돌려준다.
 * @return String
 */
String.prototype.wellFormed = function() {
	var todo = this;
	var myRe = /\<(\/)?([_a-zA-Z][_a-zA-Z0-9]*)((\s*[_a-zA-Z][_a-zA-Z0-9]*((\s*\=\s*[\'\"][^\'\"]*[\'\"])|(\s*\=\s*[^\s\/\>]+))?)*)\s*(\/)?\>/gi;
	var pos = 0;
	var result = "";
	var work = myRe.exec(todo);
	while(work != null) {
		result += todo.substring(pos,work.index);
		if(typeof(work[1]) == "undefined" || work[1] == "") {
			result += "<" + work[2].toLowerCase();
			var myRe2= /\s*([_a-zA-Z][_a-zA-Z0-9]*)((\s*\=\s*[\'\"]([^\'\"]*)[\'\"])|(\s*\=\s*([^\/\s\>]+)))?/gi;
			var work2 = myRe2.exec(work[3]);
			while(work2 != null) {
				if(ozNavigator.isMO1) {
					if(typeof(work2[4]) != "undefined") result += " " + work2[1] + "=\"" + work2[4] + "\""; 
					else if(typeof(work2[6]) != "undefined") result += " " + work2[1] + "=\"" + work2[6] + "\""; 
					else result += " " + work2[1] + "=\"" + work2[1] + "\""; 
				}
				else if(ozNavigator.isIE4) {
					if(work2[4] != "") result += " " + work2[1] + "=\"" + work2[4] + "\""; 
					else if(work2[6] != "") result += " " + work2[1] + "=\"" + work2[6] + "\""; 
					else result += " " + work2[1] + "=\"" + work2[1] + "\""; 
				}
				work2 = myRe2.exec(work[3]);
			}
			if(typeof(work[8]) != "undefined" && work[8] == "/") {
				result += "/";	
			}  
			result += ">";
		}
		else {
			result += "</" + work[2].toLowerCase();
			result += ">";
		}
		pos = (work.index + work[0].length);
		work = myRe.exec(todo);
	}
	if(work == null) {
		if(pos < todo.length) {
			result += todo.substring(pos,todo.length);
		}
	}
	return result;
}
ozNavigator = {};
ozNavigator._init = function() {
	ozNavigator.name = null;
	ozNavigator.version = null;
	ozNavigator.isIE4 = false;
	ozNavigator.isMO1 = false;
	var userAgent = self.navigator.userAgent.split(";");
	var re = /MSIE\s([\d\.]+)/gi;
	var result = re.exec(userAgent[1]);
	if((result != null)&&(result.length==2)) {
		ozNavigator.name = "MSIE";
		ozNavigator.version = parseFloat(result[1]);	
		if(ozNavigator.version >= 4) {
			ozNavigator.isIE4 = true;		
		}
	}
	else {
		re = /rv\:([\d\.\w]+)\)\sGecko/gi;
		result = re.exec(userAgent[4]);
		if((result != null)&&(result.length==2)) {
			ozNavigator.name = "Mozilla";
			ozNavigator.version = parseFloat(result[1]);	
			if(ozNavigator.version >= 1) {
				ozNavigator.isMO1 = true;		
			}
		}	
	} 
}
ozNavigator._init();
delete(ozNavigator._init);
/** Map 클래스. (key, value) 형태로 된 여러 개의 데이터를 key의 중복없이 
 * 저장하는 Map 개체이다. @constructor 
 **/
ozMap = function() {
	/** 저장된 (key,value) 쌍의 개수. @type Number 
	**/
	this.length = 0;	
	/** 데이터를 key로 접근할 때 사용함 _data[key]가 _list 배열의 
	* 항목인 {key:key, value:value}인 개체를 나타냄. 
	* @type Object 
	* @private
	**/
	this._data = new Object();
	/** 각각의 데이터가 저장되는 배열. 각 항목은 key, value를 
	* 속성으로 가진 개체임. @type Array 
	* @private
	**/
	this._list = new Array();
	/** next 메쏘드에서 사용. Iterator의 현재 위치를 나타냄. @type Number 
	* @private
	**/
	this._cursor = null;
	/** key를 인자로 지정하면 해당하는 value를 돌려준다. key에 해당하는 
	 * 값이 없으면 아무런 값을 돌려주지 않는다. @type Function 
	 * @param 얻고자하는 데이터의 key.
	 * @return Object 
	 **/
	this.get = function(key) {
		if(typeof(this._data[key]) != "undefined") {
			return this._data[key].value;
		}
	}
	/** 인자로 지정한 (key, value)를 추가한다. 동일한 key 값을 가진 
	 * 데이터가 있는 경우에는 value를 수정한다. 새로 추가된 경우는 length가 
	 * 1 커진다. 성공하면 true를 돌려준다. 실패하면 false를 돌려준다.
	 * @type Function  
	 * @param key 지정하려는 key
	 * @param name 지정하려는 value
	 * @return Boolean 
	 **/
	this.set = function(key, value) {
		if(typeof(this._data[key])=="undefined") {
			var temp = new Object();
			temp.key = key;
			temp.value = value;
			temp._index = this._list.length;
			this._list.push(temp);
			this._data[key] = temp;
			this.length = this._list.length;
			return true;
		}
		else {
			this._data[key].value = value;			
			return true;
		}
	}
	/** 인자로 지정한 key에 해당하는 데이터를 삭제한다.
	 * 삭제에 성공하면 length가 1감소하고 true를 돌려준다.
	 * @type Function  
	 * @param key 삭제하려는 데이터의 키.
	 * @return Object 
	 **/
	this.del = function(key) {
		if(typeof(this._data[key]) != "undefined") {
			this._list.splice(this._data[key]._index, 1);
			this.length = this._list.length;
			delete(this._data[key]);	
			return true;
		}
		else {
			return false;			
		}
	}
	/** (key, value) 데이터 전체를 
	 * 'key1=value1&…&keyN=valueN' 형태의 문자열로
	 * 돌려준다. 이 때 value 값은 encodeURIComponent로
	 * 인코딩한다.
	 * @type Function  
	 * @return String 
	 **/
	this.getString = function() {
		var result = "";
		var temp = this.next();
		while(temp) {
			result += temp.key + "=" + encodeURIComponent(temp.value);
			if(temp._index != (this._list.length-1)) result += "&";
			temp = this.next();
		}
		return result;
	}
	/** next 메쏘드로 Iterator 형태로 데이터를 접근하는 것을
	 * 초기화함. 이 메쏘드를 실행하고 next 메쏘드를 실행하면
	 * 첫 데이터부터 돌려줌.
	 * @type Function  
	 * @return Boolean 
	 **/
	this.reset = function() {
		this._cursor = null;		
	}
	/** 데이터를 하나씩 돌려줌. 실행할 때 마다 다음 데이터를 돌려줌.
	 * 맨 끝이면 null을 돌려줌.
	 * @type Function  
	 * @return Object 
	 **/
	this.next = function() {
		if(this._cursor == null) {
			if(this._list.length == 0) return null;
			else {
				this._cursor = 0;
				return this._list[0];
			}			
		}
		else if(this._cursor == (this.length-1)) {
			this._cursor = null;
			return null;			
		}
		else {
			this._cursor++;
			return this._list[this._cursor];
		}
	}
	/** i번째 추가한 데이터를 돌려준다.
	 * @type Function  
	 * @return Object 
	 **/
	this.item = function(idx) {
		if(idx >= 0 && idx < this._list.length) {
			return this._list[idx];	
		}
		else return null;
	}
}
/** XML 개체 클래스. 원본 XML 개체를 감싸는 자바스크립트 개체를 생성하여 
 * 돌려준다. @constructor 
 * @param param	param 인자의 속성에 따라서 XML 개체가 생성된다.
 * rootName, root, documentURI, xmlContent 속성 중에 하나만 사용할 수 있다.
 * 하나도 사용하지 않으면 빈 XML 문서로 생성된다.
 * async 속성을 지정하면 비동기 통신 여부를 지정할 수 있다.
 * <br/>- rootName : 최상위 노드의 이름, 
 * - root : 최상위 노드,
 * - documentURI : XML 문서의 URL,
 * - xmlContent : XML 문서의 내용<br/>
 * - async : 비동기 통신 여부. documentURI로 URL을 로딩하는 경우에
 * 사용된다.
 **/
ozXML = function(param) {
	/** 원본 XML 개체가 저장됨. @private@type Object  **/
	this._source = null;
	/** @type Function @private **/
	this._onload = null;
	/** load 메쏘드로 로딩한 XML 문서의 URL. 인터넷 익스플로러는 XML 문서 
	* 개체의 url 속성에 URL이 저장되어있고 모질라 웹브라우저 documentURI 속성에
	* URL이 저장되어있다.
	* @type String @private
	**/
	this._documentURI = null;
	/** XML 문서의 문서타입정의를 문자열로 돌려준다. @type Function 
	* @return String 문서타입정의를 나타내는 !DOCTYPE 선언을 문자열로
	* 돌려준다. 문서타입정의가 없으면 null을 돌려준다. 
	**/
	this.doctype = function() {
		if(this._source == null || this._source.doctype == null) return null;	
		else return this.xmlContent(this._source.doctype);			
	}
	/** load 메소드로 XML 문서를 로딩할 때 비동기 통신 방식 여부를
	* 지정하거나 지정된 값을 읽어올 때 사용한다.
	* @param async 비동기 통신은 true, 동기통신은 false 
	* @type Function
	* @return Boolean 인자를 지정하지 않으면 동기통신 방식 여부를 
	* 돌려준다. 인자를 사용하거나 에러인 경우에는 리턴값이 없다.
	**/
	this.async = function(async) {
		if(arguments.length == 0) {
			if(this._source != null) return this._source.async;
		}
		else this._source.async = async;	
	}
	/** XML 개체를 사용할 수 있는 상태이면 true를, 아니면 false를 돌려준다.
	* @type Function @return Boolean XML 개체를 사용할 수 있으면 true를 돌려준다.
	**/
	this.ready = function() {
		if(this._source != null && this._source.documentElement!= null) return true;
		else return false;		
	}
	/** XML 문서를 로딩하고 파싱하던 중에 발생한 에러 메시지를 돌려준다. 
	* 에러가 없으면 null을 돌려준다. @type Function
	* @param xml XML 개체. 없으면 현재 xml 개체를 사용한다.
	* @return String 에러 메시지.
	**/	
	this.error = function(xml) {
		if(xml == null) { 
			if(this._source == null ) {
				return "(reason : XML 개체가 없습니다.)";
			}
			else if(typeof(this._source.documentElement) == "undefined") {
				return "(reason : XML 개체에 최상위 노드를 나타내는 속성이 없습니다.)";	
			}
			else if(this._source.documentElement == null) {
				return "(reason : XML 개체에 최상위 노드가 없습니다.)";	
			}
			else {
				var todo = this._source;
			}	
		}	
		else if(typeof(xml.nodeType) != "undefined" && xml.nodeType == 9) var todo = xml;	
		else return null;
		if(ozNavigator.isIE4) {
			if(todo != null && todo.parseError != null && todo.parseError.errorCode != 0) {
	 			var message = "(errorCode : " + todo.parseError.errorCode + ", reason : " + todo.parseError.reason + ")";
	 			return message;
		 	}
		 	else return null;
		}
		else if(ozNavigator.isMO1) {
	 		if(todo != null && todo.documentElement != null && todo.documentElement.nodeName == "parsererror") {
	 			var message = "(" + todo.documentElement.childNodes[0].nodeValue + ")";
	 			return message;
	 		}
	 		else return null;
		}
		else return ("(지원하지 않는 브라우저입니다.)");
	}
	/** 인자를 사용하지 않으면 XML 개체의 최상위 노드를 돌려주고,
	* 인자를 사용하고 그 인자가 노드 개체이면 그 노드의 최상위 노드를 돌려준다.
	* @type Function @param node 노드 
	* @return Object 인자를 사용하지 않은 경우 XML 문서의 최상위 노드를 돌려준다. 
	* 최상위 노드가 없는 경우 null을 돌려준다. 인자를 사용한 경우는 그 노드의
	* 최상위 노드를 돌려준다.
	**/
	this.documentElement = function(node) {
		if(arguments.length == 0) {
			if(this._source != null && this._source.documentElement != null) return this._source.documentElement;	
			else return null;
		}
		else {
			if(typeof(node.nodeType) != "undefined" && node.nodeType == 1) {
				if(this.ownerDocument(node) != null) return this.ownerDocument(node).documentElement;
				else return null;
			}
			else return null;
		}
	}
	/** load 메쏘드로 로딩한 XML 문서의 주소를 돌려준다. @type Function
	* @return String 로딩한 XML 문서의 주소
	**/	
	this.documentURI = function() { return this._documentURI; }
	/** 인자가 없으면 XML 문서 개체의 노드 이름을 돌려준다. 노드를 인자로 지정하면 
	* 그 노드의 nodeName 속성을 돌려준다. @type Function
	* @return String XML 문서 개체나 인자의 nodeName 속성
	**/	
	this.nodeName = function() {
		if(arguments.length == 0) {
			if(this._source != null && typeof(this._source.nodeName) != "undefined") return this._source.nodeName;
			else return null;
		}
		else {
			if(typeof(arguments[0].nodeName) != "undefined") return arguments[0].nodeName;	
			else return null;
		}
	}
	/** 인자가 없으면 XML 문서 개체의 노드 타입을 돌려준다. 노드를 인자로 지정하면 
	* 그 노드의 nodeType 속성을 돌려준다. @type Function
	* @return String XML 문서 개체나 인자의 nodeType 속성
	**/	
	this.nodeType = function() {
		if(arguments.length == 0) {
			if(this._source != null && typeof(this._source.nodeType) != "undefined") return this._source.nodeType;
			else return null;
		}
		else {
			if(typeof(arguments[0].nodeType) != "undefined") return arguments[0].nodeType;	
			else return null;
		}
	}
	/** 인자가 없으면 XML 문서 개체의 노드 값을 돌려준다. 노드를 인자로 지정하면 
	* 그 노드의 nodeValue 속성을 돌려준다. @type Function
	* @return String XML 문서 개체나 인자의 nodeValue 속성
	**/	
	this.nodeValue = function() {
		if(arguments.length == 0) {
			if(this._source != null && typeof(this._source.nodeValue) != "undefined") return this._source.nodeValue;
			else return null;
		}
		else {
			if(typeof(arguments[0].nodeValue) != "undefined") return arguments[0].nodeValue;	
			else return null;
		}
	}
	/** [IE 전용] XML 문서를 로딩하면서 유효성 검사를 할지 여부를 지정한다. 인자가 없으면 
	* 현재 설정된 유효성 검사 여부를 돌려준다. @type Function
	* @return Boolean 인자를 지정하지 않으면 유효성 검사 여부를 
	* 돌려준다. 인자를 사용하거나 에러인 경우에는 리턴값이 없다.
	**/	
	this.strictErrorChecking = function() {
		if(arguments.length == 0) {
			if(this._source != null && ozNavigator.isIE4) return this._source.validateOnParse;
		}
		else {
			if(this._source != null && ozNavigator.isIE4) this._source.validateOnParse = new Boolean(arguments[0]);
		}	
	}
	/** 인자로 지정한 요소 노드의 노드 이름을 돌려준다. 그 외에는 null을 돌려준다.
	* @type Function @param node 요소 노드
	* @return String 요소 노드의 노드 이름. 요소 노드가 아니면 null.
	**/	
	this.tagName = function(node) {
		if(node == null) return null;
		if(typeof(node.nodeType) != "undefined" && node.nodeType == 1) return node.tagName;	
		else return null;
	}
	/** 인자로 지정한 노드의 내용을 문자열로 돌려준다.
	* 인자를 지정하지 않으면 전체 XML 문서의 내용을 문자열로 돌려준다.
	* @type Function @param node 요소 노드
	* @return String 노드의 내용을 문자열로 돌려준다.
	**/	
	this.textContent = function(node) {
		if(arguments.length == 0) {
			if(this._source != null && this._source.documentElement != null) {
				if(ozNavigator.isIE4) return this._source.documentElement.text;	
				else if(ozNavigator.isMO1) return this._source.documentElement.textContent;	
			}	
			return null;
		}
		else {
			if(typeof(node.nodeType) != "undefined") {
				if(node.nodeType == 9) {
					if(ozNavigator.isIE4) return this._source.documentElement.text;	
					else if(ozNavigator.isMO1) return this._source.documentElement.textContent;	
				}
				else {
					if(ozNavigator.isIE4) return node.text;	
					else if(ozNavigator.isMO1) return node.textContent;	
				}	
			}
			return null;			
		}
	}	
	/** 인자로 지정한 노드의 XML 코드로 돌려준다. 인자를 지정하지 않으면 
	* 전체 XML 문서의 XML 코드를 돌려준다. @type Function
	* @param node 요소 노드
	* @return String 노드의 내용을 문자열로 돌려준다.
	**/	
	this.xmlContent = function(node) {
		if(arguments.length ==0) {
			if(this._source != null) {	
				if(ozNavigator.isIE4) return this._source.xml;
				else if(ozNavigator.isMO1) {
			 var serializer = new XMLSerializer();
					return serializer.serializeToString(this._source);
				}
			}	
		}
		else {
			if(this._source != null) {	
				if(ozNavigator.isIE4) return node.xml;
				else if(ozNavigator.isMO1) {
			 var serializer = new XMLSerializer();
					return serializer.serializeToString(node);
				}
			}	
		}
		return null;
	}
	/** XML 문서의 인코딩 방식을 돌려준다. 실제 인코딩 방식이 아니라 xml 문서에 
	* 지정된 인코딩 방식을 돌려준다. @type Function
	* @return String XML 문서의 인코딩 방식. 
	**/	
	this.xmlEncoding = function() {
		if(this.error() == null) {
			if(ozNavigator.isIE4) {
				for(var i=0;i<this._source.childNodes[0].attributes.length;i++) {
					if(this._source.childNodes[0].attributes[i].name == "encoding") {
						return this._source.childNodes[0].attributes[i].value.toUpperCase(); 	
					}	
				}
			}
			else if(ozNavigator.isMO1) {
				if(this._source.xmlEncoding != null) return this._source.xmlEncoding.toUpperCase();
				else if(this._source.inputEncondig != null) return this._source.inputEncoding.toUpperCase();	
			}
			return "UTF-8";
		}		
		else return null;
	}			
	/** XML 문서의 버전을 돌려준다. XML 문서에 버전에 없는 경우에 1을 돌려준다.
	* @type Function @return Number XML 문서의 버전.
	**/	
	this.xmlVersion = function() {
		if(this.error() == null) {
			if(ozNavigator.isIE4) {
				for(var i=0;i<this._source.childNodes[0].attributes.length;i++) {
					if(this._source.childNodes[0].attributes[i].name == "version") {
						return this._source.childNodes[0].attributes[i].value; 	
					}	
				}
				return 1;
			}	
			else if(ozNavigator.isMO1) {
				if(typeof(this._source.xmlVersion) != "undefined") return this._source.xmlVersion;	
				else return 1;
			}	
		}
		else return null;	
	}
	/** 노드의 자식 노드를 돌려준다. 인자를 지정하지 않으면, 최상위 노드의 자식 노드를 
	* 돌려준다(조심!!!). @type Function @param node 요소 노드
	* @return Array 자식 노드를 항목으로 하는 배열
	**/	
	this.childNodes = function(node) {
		if(arguments.length == 0) {
			if(this.error() == null && this._source.documentElement != null) {
				var node = this._source.documentElement;
			}
			else return null;
		}	
		if(node.hasChildNodes()) {
			var result = new Array();
			var myRe = /^[\s](1,)$/gi;
			for(var i=0;i<node.childNodes.length;i++) {
				if(node.childNodes[i].nodeType == 3) {
					if(node.childNodes[i].nodeValue.replace(/\s/gi,"") != "") {
						result.push(node.childNodes[i]);
					}	
				}
				else {
					result.push(node.childNodes[i]);
				}
			}	
			return result;
		}
		else return null;			
	}
	/** 노드의 첫번째 자식을 돌려준다. 인자를 지정하지 않으면 최상위 노드의 첫번째 자식 노드를
	* 돌려준다(조심!!!). @type Function @param node 노드 @return Object 노드
	**/	
	this.firstChild = function(node) {
		if(arguments.length == 0) {
			if(this.error() == null && this._source.documentElement != null) {
				var node = this._source.documentElement;
			}
			else return null;
		}	
		var found = node.firstChild;
		if(found == null) return null;
		else {
			if(found.nodeType == 3) {
				if(found.nodeValue.replace(/\s/gi,"") == "") {
					return this.nextSibling(found);	
				}	
			}	
			return found;
		}
	}
	/** 노드의 마지막 자식을 돌려준다. 인자를 지정하지 않으면 최상위 노드의 마지막 자식 노드를 
	* 돌려준다(조심!!!). @type Function @param node 노드
	* @return Object 노드
	**/	
	this.lastChild = function() {
		if(arguments.length == 0) {
			if(this.error() == null && this._source.documentElement != null) {
				var node = this._source.documentElement;
			}
			else return null;
		}	
		var found = node.lastChild;
		if(found == null) return null;
		else {
			if(found.nodeType == 3) {
				if(found.nodeValue.replace(/\s/gi,"") == "") return this.previsousSibling(found);	
			}	
			return found;
		}
	}
	/** 노드의 다음 노드를 돌려준다. @type Function @param node 노드 @return Object 노드
	**/	
	this.nextSibling = function(node) {
		if(node == null) return null;
		var found = node.nextSibling;
		if(found == null) return null;
		if(found.nodeType == 3 && found.nodeValue.replace(/\s/gi,"") == "") {
			return this.nextSibling(found);
		}	
		return found;		
	}
	/** 노드의 이전 노드를 돌려준다. @type Function @param node 노드 @return Object 노드
	**/	
	this.previousSibling = function(node) {
		if(node == null) return null;
		var found = node.previousSibling;
		if(found == null) return null;
		if(found.nodeType == 3 && found.nodeValue.replace(/\s/gi,"") == "") {
			return this.previousSibling(found);
		}	
		return found;		
	}
	/** 노드가 자식 노드를 가지고 있으면 true를, 아니면 false를 돌려준다. 인자를 
	* 지정하지 않으면 XML 문서 개체의 최상위 노드가 자식 노드를 가지고 있는 지를 
	* 테스트한다. @type Function @param node 노드
	* @return Boolean 자식 노드를 가지고 있으면 true, 없으면 false
	**/	
	this.hasChildNodes = function(node) {
		if(arguments.length == 0) {
			if(this.error() == null && this._source.documentElement != null) {
				var node = this._source.documentElement;
			}
			else return null;
		}
		if(node.hasChildNodes()) return true;
		else return false;
	}
	/** 노드의 XML 문서 개체를 돌려준다. 인자를 지정하지 않으면 ozXML 
	* 개체의 원본 XML 문서 개체를 돌려준다. @type Function
	* @param node 노드 @return Object XML 문서 개체
	**/	
	this.ownerDocument = function(node) {
		if(arguments.length == 0) {
			if(this.error() == null) return this._source;
			else return null;
		}		
		else return node.ownerDocument;	
	}
	/** 노드의 부모 노드를 돌려준다. 최상위 노드인 경우 XML 문서 개체를 돌려준다.
	* XML 문서 개체의 경우 null을 돌려준다. @type Function
	* @param node 노드 @return Object 노드
	**/	
	this.parentNode = function(node) {
		if(arguments.length == 0) return null;
		return node.parentNode;
	}
	/** parentNode의 맨 마지막 자식노드로 newNode를 추가한다. @type Function
	* @param newNode 추가하려는 노드 @param parentNode newNode를 추가하는 부모 노드
	* @return Object 추가한 노드를 돌려준다.
	**/	
	this.appendChild = function(newNode, parentNode) {
		if(newNode == null || parentNode == null) return null;
		return parentNode.appendChild(newNode);
	}
	/** parentNode 아래의 removeNode를 삭제한다. @type Function
	* @param removeNode 삭제하려는 노드 @param parentNode removeNode의 부모 노드
	* @return Object 삭제한 노드를 돌려준다.
	**/	
	this.removeChild = function(removeNode, parentNode) {
		if(removeNode == null || parentNode == null) return null;
		return parentNode.removeChild(removeNode);
	}
	/** removeNode를 트리에서 삭제한다. 부모 노드가 없는 경우에 삭제되지 않고 null을 돌려준다. 
	* @type Function @param removeNode 삭제하려는 노드 @return Object 삭제한 노드를 돌려준다.
	**/	
	this.remove = function(removeNode) {
		if(removeNode == null || this.parentNode(removeNode) == null) return null;
		return removeNode.parentNode(removeNode);
	}
	/** newNode를 posNode 전에 추가한다. posNode의 부모 노드가
	* 없는 경우에는 추가에 실패하고 null을 돌려준다. 
	* @type Function @param newNode 추가하려는 노드
	* @param posNode 추가하는 위치의 노드. 이 노드 전에 추가한다.
	* @return Object 추가한 노드를 돌려준다.
	**/	
	this.insertBefore = function(newNode, posNode) {
		if(newNode == null || posNode == null || this.parentNode(posNode) == null) return null;
		return this.parentNode(posNode).insertBefore(newNode, posNode);
	}
	/** newNode를 posNode 다음에 추가한다. posNode의 부모 노드가 없는 경우에는 추가에 실패하고 
	* null을 돌려준다. 
	* @type Function @param newNode 추가하려는 노드 
	* @param posNode 추가하는 위치의 노드. 이 노드 다음에 추가한다.
	* @return Object 추가한 노드를 돌려준다.
	**/	
	this.insertAfter = function(newNode, posNode) {
		if(newNode == null || posNode == null || this.parentNode(posNode) == null) return null;
		if(this.nextSibling(posNode) == null) return this.appendChild(newNode, this.parentNode(posNode));
		else return this.parentNode(this.nextSibling(posNode)).insertBefore(newNode, this.nextSibling(posNode));
	}
	/** oldNode 노드를 newNode로 바꾼다. oldNode의 부모 노드가 없으면 바꾸지 못하고 null을 돌려준다.
	* @type Function
	* @param newNode 새 노드 @param oldNode 이전 노드 @return Object oldNode
	**/	
	this.replaceChild = function(newNode, oldNode) {
		if(this.newNode == null || this.oldNode == null || this.parentNode(oldNode) == null) return null;
		return this.parentNode(oldNode).replaceChild(newNode, oldNode);
	}
	/** 인자로 지정한 노드를 복사해서 돌려준다. option 인자가 true면 자식 노드도 복사하고, 
	* false면 자식 노드는 복사하지 않는다. 기본값은 true이다. @type Function
	* @param node 복사하려는 node @param option 자식 노드 복사 여부. 기본값은 true이다.
	* @return Object 복사된 노드
	**/	
	this.cloneNode = function(node, option) {
		if(node == null) return null;
		if(option == null) var option = true;
		else option = new Boolean(Option);
		return node.cloneNode(Option);	 
	}
	/** CDATASection 개체를 생성하여 돌려준다. @type Function
	* @param str CDATASection의 내용 @return Object 생성된 CDATASection 개체
	**/	
	this.createCDATASection = function(str) {
		if(this._source == null) return (this.createXMLDocument()).createCDATASection(str);
		else return this._source.createCDATASection(str);
	}
	/** DocumentFragment 개체를 생성하여 돌려준다. 노드를 항목으로 하는 배열을 지정하면 
	* 각각의 노드를 복사하여 자식 노드로 추가한 후에 DocumentFragment 개체를 돌려준다.
	* @type Function
	* @param nodes	DocumentFragment 개체에 추가하려는 노드를 항목으로 Array. 
	* @return Object 생성된 DocumentFragment 개체
	**/	
	this.createDocumentFragment = function(nodes) {
		if(this._source == null) var result = (this.createXMLDocument()).createDocumentFragment();
		else var result = this._source.createDocumentFragment();
		if(nodes != null && typeof(nodes.length) != null) {
			for(var i=0;i<nodes.length;i++) {
				this.appendChild(this.cloneNode(nodes[i],true),result);
			}	
		}
		return result;
	}
	/** XML 문서 개체를 생성하여 돌려준다.
	* 인자를 사용하면 인자에 따라서 XML 문서 개체를 생성한다.<br/>
	* - xmlContent : XML 코드로 XML 문서를 생성<br/>
	* - documentURI : url의 XML 문서를 로딩함. 동기 통신<br/>
	* - rootName : 최상위 노드의 이름<br/>
	* - root : 최상위 노드. appendChild 메쏘드로 원래 위치에서 삭제된다는 
	* 것을 조심. 삭제를 방지하려면 cloneNode(true)로 복사해서 생성해야함.<br/>
	* - type : xsl로 지정하면 인터넷 익스플로러에서 MSXML2.FreeThreadedDOMDocument.5.0
	* 형태로 생성한다.
	* @type Function @param param 개체. 
	* @return Object 생성된 XML 문서 개체
	**/	
	this.createXMLDocument = function(param) {
		if(ozNavigator.isIE4){
			if(param != null && typeof(param.type) != "undefined" && param.type == "xsl") {
				var newDoc = new ActiveXObject('MSXML2.FreeThreadedDOMDocument.5.0');
			}
			else if(param != null && typeof(param.documentURI) != "undefined" && (/\.xsl$/i).test(param.documentURI)) {
				var newDoc = new ActiveXObject('MSXML2.FreeThreadedDOMDocument.5.0');
			}
			else var newDoc = new ActiveXObject("Msxml2.DOMDocument.5.0");
		 if(param != null) {
			 if(typeof(param.xmlContent) != "undefined") newDoc.loadXML(param.xmlContent);
			 else if(typeof(param.documentURI) != "undefined") {
			 	newDoc.async = false;
			 	newDoc.load(param.documentURI);
			 }
			 else if(typeof(param.rootName) != "undefined") {
					var root = newDoc.createElement(param.rootName);
					newDoc.appendChild(root);
			 }
			 else if(typeof(param.root) != "undefined") newDoc.appendChild(param.root);			 	
			} 
	 	if(this.error(newDoc) != null) {
	 		alert("로딩 중 에러가 발생했습니다. " + this.error(newDoc));
	 		return null;
	 	}
		 return newDoc;
		} 
		else if(ozNavigator.isMO1) {
			var newDoc = self.document.implementation.createDocument("","",null);
		 if(param != null) {
			 if(typeof(param.xmlContent) != "undefined") {
			 	var parser = new DOMParser();
					newDoc = parser.parseFromString(param.xmlContent,"text/xml");
			 }
			 else if(typeof(param.documentURI) != "undefined") {
			 	newDoc.async = false;
			 	newDoc.load(param.documentURI);
			 }
			 else if(typeof(param.rootName) != "undefined") {
					var root = newDoc.createElement(param.rootName);
					newDoc.appendChild(root);					
			 }
			 else if(typeof(param.root) != "undefined") newDoc.appendChild(param.root);
			}
	 	if(this.error(newDoc) != null) {
	 		alert("로딩 중 에러가 발생했습니다. " + this.error(newDoc));
	 		return null;
	 	}
		 return newDoc;
		}
		else return null; 
	}
	/** XML 노드 개체를 생성하여 돌려줌. 네임스페이스prefix:요소local 이름과 같은 
	* 형식으로 지정해도 된다.
	* @param nodeName 노드의 이름 @type Function 
	* @return Object 생성된 XML 노드를 돌려준다. 
	**/
	this.createElementFromString = function(xmlContent) {
		if(xmlContent == null) return null;
		var temp = this.createXMLDocument({xmlContent : xmlContent});
		if(this.error(temp) == null) return temp.documentElement.cloneNode(true);
		else return null;
	}
	/** XML 노드 개체를 생성하여 돌려줌. 
	* @param nodeName 노드의 이름. 네임 스페이스를 사용하는 경우, 노드 locaName이 
	* 아니라 네임스페이스 prefix까지 포함하는 전체 이름을 지정해야 한다. 
	* @param nsMap 네임스페이스 prefix와 네임스페이스 url이 저장된 Map 개체.
	* @type Function @return Object 생성된 XML 노드를 돌려준다. 
	**/
	this.createElement = function(nodeName, nsMap) {
		if(this._source != null) var source = this._source;
		else var source = this.createXMLDocument();
		if(nodeName.indexOf(":") == -1) return source.createElement(nodeName);	
		else {
			if(nsMap == null && this._source != null) var nsMap = this.createNSMap();
			if(nsMap == null) return null;
			var temp = nodeName.split(":");
			if(temp == null || temp.length != 2) return null;
			if(ozNavigator.isIE4) return source.createElement(nodeName);	
			else if(ozNavigator.isMO1) {
				var nsUrl = this.lookupNamespaceURI(temp[0],nsMap);
				if(nsUrl == null) return null;
				return this.createElementNS(nsUrl, nodeName);
			}	
		}
	}
	/** XML 노드 개체를 생성하여 돌려줌. 두번째 인자로 지정하는 노드 이름은
	* 네임 스페이스 prefix까지 포함하는 전체 노드 이름이라는 것을 조심하자!
	* @param nsUrl 노드의 네임 스페이스 URL.
	* @param nodeName 노드의 이름. 네임 스페이스를 사용하는 경우, 노드 locaName이 
	* 아니라 네임스페이스 prefix까지 포함하는 전체 이름을 지정해야 한다. 
	* @type Function @return Object 생성된 XML 노드를 돌려준다. 
	**/
	this.createElementNS = function(nsUrl, nodeName) {
		if(nsUrl == null) return null;
		if(nodeName == null) return null;
		if(this._source != null) var source = this._source;
		else var source = this.createXMLDocument();
		if(ozNavigator.isIE4) return source.createElement(nodeName);
		else if(ozNavigator.isMO1) return source.createElementNS(nsUrl, nodeName);
		else return null;
	}
	/** 텍스트 노드를 생성하여 돌려준다.
	* @param str 텍스트 노드의 내용이 될 문자열. @type Function 
	* @return Object 생성된 XML 텍스트 노드를 돌려준다. 
	**/
	this.createTextNode = function(str) {
		if(this._source != null) return this._source.createTextNode(str);
			return (this.createXMLDocument()).createTextNode(str);
	}
	/** 속성 개체를 생성하여 돌려준다.
	* @param attrName 속성의 이름. 네임 스페이스를 사용하는 경우,
	* 네임스페이스 prefix:localName과 같은 형식을 사용해도 된다.
	* @param attrValue 속성의 값. 
	* @param nsMap 네임 스페이스 맵. 
	* 네임스페이스를 사용하는 경우, XML 문서 개체에 최상위
	* 노드에 네임 스페이스 지정이 없는 경우에는 nsMap으로
	* 네임스페이스 맵을 지정해야 한다.
	* @type Function @return Object 생성된 XML 속성 노드를 돌려준다. 
	**/
	this.createAttribute = function(attrName, attrValue, nsMap) {
		if(attrName == null) return null;
		if(this._source != null) var source = this._source;
		else var source = this.createXMLDocument();
		if(attrName.indexOf(":") == -1) {
			var attr = source.createAttribute(attrName);	
			if(attrValue != null) attr.value = attrValue;
			return attr;
		}	
		else {
			if(nsMap == null && this._source != null) var nsMap = this.createNSMap();
			if(nsMap == null) return null;
			var temp = attrName.split(":");
			if(temp == null || temp.length != 2) return null;
			if(ozNavigator.isIE4) {
				var attr = source.createAttribute(attrName);	
				if(attrValue != null) attr.value = attrValue;
				return attr;
			}
			else if(ozNavigator.isMO1) {
				var nsUrl = this.lookupNamespaceURI(temp[0],nsMap);
				if(nsUrl == null) return null;
				return this.createAttributeNS(nsUrl, attrName, attrValue);
			}	
		}
	}
	/** 속성 개체를 생성하여 돌려준다.
	* @param nsUrl 네임 스페이스 url. @param attrName 속성의 이름. 
	* 네임스페이스 prefix:localName과 같은 형식으로 지정해야 한다.
	* @param attrValue 속성의 값. 
	* @type Function @return Object 생성된 XML 속성 노드를 돌려준다. 
	**/
	this.createAttributeNS = function(nsUrl, attrName, attrValue) {
		if(nsUrl == null) return null;
		if(attrName == null) return null;
		if(this._source != null) var source = this._source;
		else var source = this.createXMLDocument();
		if(ozNavigator.isIE4) {
			var attr = source.createAttribute(attrName);
			if(attrValue != null) attr.value = attrValue;
			return attr;
		}
		else if(ozNavigator.isMO1) {
			var attr = source.createAttributeNS(nsUrl, attrName);
			if(attrValue != null) attr.value = attrValue;
			return attr;
		}
		else return null;
	}
	/** 노드의 속성들을 Map 개체로 돌려준다. @param node XML 요소 노드. @type Function 
	* @return Object MAP 개체. 
	**/
	this.attributes = function(node) {
		if(node == null || typeof(node.nodeType) == "undefined" || node.nodeType != 1) return null;
		var attrMap = new ozMap();
		for(var i=0;i<node.attributes.length;i++) {
			attrMap.set(node.attributes[i].name,node.attributes[i].value); 	
		}
		return attrMap;
	}
	/** node 노드가 attrName 속성을 가진 경우에 true를 아니면 false를 돌려준다.
	* @param node XML 요소 노드. @param attrName 노드의 이름.
	* @type Function @return Boolean 속성을 갖고 있는 경우에 true, 아니면 false를 돌려준다. 
	**/
	this.hasAttribute = function(node, attrName) {
		if(node == null || attrName == null || typeof(node.nodeType) == "undefined" || node.nodeType != 1) return null;
		if(ozNavigator.isIE4) {
			if(node.getAttribute(attrName) != null) return true;
			else return false;
		}	
		else if(ozNavigator.isMO1) return node.hasAttribute(attrName);
		else return null;
	}
	/** node 노드가 네임스페이스 URL이 nsUrl이고 localName이 localName인 속성을
	* 가지고 있으면 true를 아니면 false를 돌려준다.
	* 네임스페이스를 사용하지 않은 속성의 경우 false를 돌려준다.
	* @param node XML 요소 노드. @param nsUrl 속성의 네임스페이스 url
	* @param localName 속성의 이름에서 네임스페이스 prefix 부분을 제외한 이름
	* @type Function 
	* @return Boolean 속성을 갖고 있는 경우에 true, 아니면 false를 돌려준다. 
	**/
	this.hasAttributeNS = function(node, nsUrl, localName) {
		if(node == null || typeof(node.nodeType) == "undefined" || node.nodeType != 1 || nsUrl == null || localName == null) return null;
		if(ozNavigator.isMO1) return node.hasAttributeNS(nsUrl, localName);
		else if(ozNavigator.isIE4) {
			var prefix = 	this.lookupPrefix(nsUrl, node);
			if(prefix == null || prefix == "default") return false;
			else {
				return this.hasAttribute(node, prefix + ":" + localName);
			}	
		}
	}
	/** node 노드가 속성을 가지고 있으면 true를 아니면 false를 돌려준다.
	* @param node XML 요소 노드. @type Function 
	* @return Boolean 속성을 갖고 있는 경우에 true, 아니면 false를 돌려준다. 
	**/
	this.hasAttributes = function(node) {
		if(node == null || typeof(node.nodeType) == "undefined" || node.nodeType != 1) return null;
		if(ozNavigator.isIE4) {
			if(node.attributes.length > 0) return true;
			else return false;
		}	
		else if(ozNavigator.isMO1) return node.hasAttributes();
		else return null;
	}
	/** node 노드에서 attrName 속성의 값을 돌려준다. @param node XML 요소 노드.
	* @param attrName 속성의 이름. @type Function 
	* @return String 속성의 값을 문자열로 돌려준다.
	**/
	this.getAttribute = function(node, attrName) {
		if(node == null || typeof(node.nodeType) == "undefined" || node.nodeType != 1 || attrName == null) return null;
		return node.getAttribute(attrName);
	}
	/** node 노드에서 네임스페이스 url이 nsUrl인 localName 속성의 값을 돌려준다.
	* @param node XML 요소 노드. @param nsUrl 네임스페이스 URL.
	* @param localName 속성의 이름에 네임스페이스 prefix를 제외한 부분.
	* @type Function @return String 속성의 값을 문자열로 돌려준다.
	**/
	this.getAttributeNS = function(node, nsUrl, localName) {
		if(node == null || typeof(node.nodeType) == "undefined" || node.nodeType != 1 || localName == null) return null;
		if(ozNavigator.isMO1) {
			var result = this.getAttributeNodeNS(node, nsUrl, localName);
			if(result == null) return null;
			else return result.value;
		}
		else if(ozNavigator.isIE4) {
			var prefix = this.lookupPrefix(nsUrl, node);
			if(prefix == null || prefix == "default") return null;
			else return this.getAttribute(node, prefix + ":" + localName);
		}
	}
	/** node 노드에서 attrName 속성 개체를 돌려준다.
	* @param node XML 요소 노드. @param attrName 속성의 이름.
	* @type Function @return Object 속성 개체.
	**/
	this.getAttributeNode = function(node, attrName) {
		if(node == null || typeof(node.nodeType) == "undefined" || node.nodeType != 1 || attrName == null) return null;
		return node.getAttributeNode(attrName);
	}
	/** node 노드에서 네임스페이스 url이 nsUrl인 localName 속성 개체를 돌려준다.
	* @param node XML 요소 노드. @param nsUrl 네임스페이스 URL.
	* @param localName 속성의 이름에 네임스페이스 prefix를 제외한 부분.
	* @type Function @return Object 속성 개체.
	**/
	this.getAttributeNodeNS = function(node, nsUrl, localName) {
		if(node == null || typeof(node.nodeType) == "undefined" || node.nodeType != 1 || localName == null) return null;
		if(ozNavigator.isMO1) {
			return node.getAttributeNodeNS(nsUrl, localName);
		}
		else if(ozNavigator.isIE4) {
			var prefix = this.lookupPrefix(nsUrl, node);
			if(prefix == null || prefix == "default") return null;
			else return this.getAttributeNode(node, prefix + ":" + localName);
		}
	}
	/** node 노드에서 attrName 속성의 값을 attrValue로 지정한다.
	* @param node XML 요소 노드. @param attrName 네임스페이스 URL.
	* @param attrValue 속성의 이름에 네임스페이스 prefix를 제외한 부분.
	* @return Boolean 성공하면 true를 실패하면 false를 돌려준다. 
	* @type Function
	**/
	this.setAttribute = function(node, attrName, attrValue) {
		if(node == null || typeof(node.nodeType) == "undefined" || node.nodeType != 1 || attrName == null || attrValue == null) return false;
		var todo = this.getAttributeNode(node, attrName);
		if(todo == null) return false;
		else {
			todo.value = attrValue;
			return true;
		}	
	}
	/** node 노드에서 네임스페이스 url이 nsURL이고, localName이 localName인 속성의 
	* 값을 attrValue로 지정한다. @param node XML 요소 노드. @param attrName 네임스페이스 URL.
	* @param attrValue 속성의 이름에 네임스페이스 prefix를 제외한 부분.
	* @return Boolean 성공하면 true를 실패하면 false를 돌려준다. 
	* @type Function
	**/
	this.setAttributeNS = function(node, nsUrl, localName, attrValue) {
		if(node == null || typeof(node.nodeType) == "undefined" || node.nodeType != 1 || localName == null || nsUrl == null || attrValue == null) return false;
		var todo = this.getAttributeNodeNS(node, nsUrl, localName);
		if(todo == null) return false;
		else {
			todo.value = attrValue;
			return true;
		}	
	}
	/** node 노드에 attrNode 속성 개체를 지정한다.
	* 기존 속성이 있으면 속성의 값이 변경되어 없으면 추가된다. 
	* @param node XML 요소 노드.
	* @param attrNode 속성 개체
	* @return Boolean 성공하면 true를 실패하면 false를 돌려준다. 
	* @type Function
	**/
	this.setAttributeNode = function(node, attrNode) {
		if(node == null || typeof(node.nodeType) == "undefined" || node.nodeType != 1 || attrNode == null || typeof(attrNode.nodeType) == "undefined" || attrNode.nodeType != 2) return false;
		try { node.setAttributeNode(attrNode); }
		catch(error) { return false; }	
		return true;
	}
	/** node 노드에 attrNoame 속성 개체를 삭제한다. 성공하면 true를 실패하면 false를 돌려준다.
	* @param node XML 요소 노드. @param attrName 삭제하려는 속성 개체의 이름
	* @return Boolean 성공하면 true를 실패하면 false를 돌려준다. @type Function
	**/
	this.removeAttribute = function(node, attrName) {
		if(node == null || typeof(node.nodeType) == "undefined" || node.nodeType != 1 || attrName == null) return false;
		var todo = this.getAttributeNode(node, attrName);
		if(todo == null) return false;
		else return this.removeAttributeNode(node,todo);	
	}
	/** node 노드에 attrNode 속성 개체를 삭제한다. 성공하면 true를 실패하면 false를 돌려준다.
	* @param node XML 요소 노드. @param attrNode 삭제하려는 속성 개체
	* @return Boolean 성공하면 true를 실패하면 false를 돌려준다. @type Function
	**/
	this.removeAttributeNode = function(node, attrNode) {
		if(node == null || typeof(node.nodeType) == "undefined" || node.nodeType != 1 || attrNode == null || typeof(attrNode.nodeType) == "undefined" || attrNode.nodeType !=2 ) return false;
		if(this.hasAttribute(node, attrNode.name) == false) return false;
		else {
			try { node.removeAttributeNode(attrNode); }
			catch(error) { return false; }	
			return true;
		}
	}
	/** node 노드에서 네임스페이스 url이 nsUrl이고 localName이 localName인 속성을 삭제한다.
	* @param node XML 요소 노드. @param nsUrl 네임스페이스 url
	* @param localName 속성의 이름에서 네임스페이스 prefix 부분을 삭제한 것.
	* @return Boolean 성공하면 true를 실패하면 false를 돌려준다. @type Function
	**/
	this.removeAttributeNS = function(node, nsUrl, localName) {
		if(node == null || typeof(node.nodeType) == "undefined" || node.nodeType != 1 || nsUrl == null || localName == null) return false;
		var todo = this.getAttributeNodeNS(node, nsUrl, localName);
		if(todo == null) return false;
		else return this.removeAttributeNode(node,todo);	
	}
	/** XML 문서 개체나 인자로 지정한 node에서 특정한 이름을
	* 갖는 요소 노드를 모두 찾아서 돌려준다.
	* @param tagName 노드의 이름. prefix:localName 형태로 사용할 수 있다.
	* @param node 검색하고자 하는 node. 
	* @param nsMap 네임스페이스 Map 개체. 지정하지 않으면 node나 전체 XML 
	* 문서 개체로 네임스페이스 맵을 만든다. 노드의 중간에 네임스페이스를 지정한
	* 경우 따로 지정해야한다. 네임스페이스가 없으면 null을 돌려준다.
	* @type Function @return Array 찾은 요소 노드를 항목으로 하는 배열. 
	**/
	this.getElementsByTagName = function(tagName, node, nsMap) {
		if(arguments.length == 0) return null;
		else if(arguments.length == 1) {
			if(this._source == null || this._source.documentElement == null) return null;
			var node = this._source.documentElement;
			var nsMap = this.createNSMap(node);	
		}
		else if(arguments.length == 2) {
			if(typeof(arguments[1].nodeType) != "undefined") {
				if(node.nodeType == 9) var node = node.documentElement;
				if(node == null) return null;
				var nsMap = this.createNSMap(node);
			}
			else {
				var nsMap = arguments[1];
				if(this._source == null || this._source.documentElement == null) return null;
				var node = this._source.documentElement;
			} 	
		}
		if(ozNavigator.isIE4) {
			if(tagName.indexOf(":") == -1) {
				if(typeof(nsMap.get("default")) == "undefined" || (nsMap.length == 0) || (nsMap.length == 1 && typeof(nsMap.get("default")) != "undefined")) {
					return node.getElementsByTagName(tagName);	
				}
				else return this.getElementsByTagNameNS(nsMap.get("default"), tagName, node);
			}
			else {
				var splited = tagName.split(":");
				if(splited.length == 2) {
					return this.getElementsByTagNameNS(nsMap.get(splited[0]), splited[1], node, nsMap);
				}
				else return null;	
			}			
		}
		else if(ozNavigator.isMO1) {
			if(tagName.indexOf(":") == -1) {
				if(nsMap.length == 0) return node.getElementsByTagName(tagName);
				else {
					var temp = node.getElementsByTagName(tagName);
					var result = new Array();
					for(var i=0;i<temp.length;i++) {
						if(this.prefix(temp[i]) == null) result.push(temp[i]);	
					}
					return result;
				}
			}
			else {
				var splited = tagName.split(":");
				if(splited.length == 2) return this.getElementsByTagNameNS(nsMap.get(splited[0]), splited[1], node, nsMap);
				else return null;	
			}			
		}
	}
	/** XML 문서 개체나 인자로 지정한 node에서 인자로 지정한
	* namespaceURI와 localName을 가지는 요소 노드를 모두 찾아서 돌려준다.
	* @param uri 찾고자 하는 노드의 namespaceURI
	* @param node 검색하고자 하는 node. 
	* @param nsMap 네임스페이스 Map 개체. 지정하지 않으면 node나 전체 XML 
	* 문서 개체로 네임스페이스 맵을 만든다. 노드의 중간에 네임스페이스를 지정한
	* 경우 따로 지정해야한다. 네임스페이스가 없으면 null을 돌려준다.
	* @type Function @return Array 찾은 요소 노드를 항목으로 하는 배열. 
	**/
	this.getElementsByTagNameNS = function(uri,localName, node, nsMap) {
		if(uri == null) return null;
		else if(localName == null) return null;
		else if(node == null) {
			if(this._source == null || this._source.documentElement == null) return null;
			var node = this._source.documentElement;
			var nsMap = this.createNSMap(node);
		}
		else if(nsMap == null) {
			if(typeof(node.nodeType) != "undefined") var nsMap = this.createNSMap(node); 
			else if(typeof(node.length) != "undefined") {
				if(this._source == null || this._source.documentElement == null) return null;
				var nsMap = node;
				var node = this._source.documentElement;
			}
		}
		if(nsMap == null) return null;
		if(ozNavigator.isIE4) {
			if(node.ownerDocument == null) return null;
			var prefix = this.lookupPrefix(uri, nsMap);
			if(prefix == null) return null;
			node.ownerDocument.setProperty("SelectionNamespaces","xmlns:" + prefix + "=\"" + uri + "\"");
			return node.selectNodes("descendant::" + prefix + ":" + localName);
		}
		else if(ozNavigator.isMO1) {
			var prefix = this.lookupPrefix(uri, nsMap);
			if(prefix == null) return null;
			return node.getElementsByTagNameNS(uri, localName);	
		}
		else return null;
	}
	/** 노드 이름에서 네임 스페이스를 제외한 부분을 돌려준다.
	* @param node XML 요소 노드 혹은 속성 노드
	* @type Function @return String 네임 스페이스를 제외한 노드 이름.
	**/
	this.localName = function(node) {
		if(node == null) return null;
		if(node.nodeType == 1 || node.nodeType == 2) {		
			if(ozNavigator.isIE4) {
				if(node.nodeName.indexOf(":") != -1) {
					var temp = node.nodeName.split(":");
					if(temp.length == 2) return temp[1];	
				}
				else return node.nodeName;	
			}
			else if(ozNavigator.isMO1) return node.localName;				
		}	
		return null;
	}
	/** 노드 이름에서 네임 스페이스 prefix 부분을 돌려준다. 
	* 네임 스페이스 prefix가 없는 노드 이름의 경우 null을 돌려준다.
	* @param node XML 요소 노드 혹은 속성 노드 @type Function 
	* @return String 네임 스페이스 prefix 부분. 
	**/
	this.prefix = function(node) {
		if(node == null) return null;
		if(node.nodeType == 1 || node.nodeType == 2) {		
			if(ozNavigator.isIE4) {
				if(node.prefix != null && node.prefix != "") return node.prefix;
				else return null;
			}
			else if(ozNavigator.isMO1) return node.prefix;
		}	
		return null;
	}
	/** XPath 검색에 사용하는 NSResolver 함수를 돌려준다. 인자가 없는 경우에는 최상위 노드를,
	* 노드를 지정한 경우에는 최상위 노드까지 거꾸로 올라가면서 네임스페이스를 찾는다.
	* @param node XML 노드 또는 NSMap @type Function 
	* @return Function NSResolver 함수를 돌려준다. 
	**/
	this.createNSResolver = function(node) {
		if(node == null) {
			if(this._source != null && this._source.documentElement != null) {
				var NSMap = this.createNSMap(this._source.documentElement);	
			}
			else return null;	
		}
		else {
			if(typeof(node.nodeType) != "undefined") var NSMap = this.createNSMap(node);
			else if(typeof(node.length) != "undefined" && typeof(node.item) != "undefined") {
				var NSMap = node;
			}
			else return null;
		}		
		if(NSMap.length == 0) return null;
		var funcBody = "var ns = { ";
			for(var i=0;i<NSMap.length;i++) {
				funcBody += "\"" + NSMap.item(i).key + "\" : \"" + NSMap.item(i).value + "\"";
				if( i != (NSMap.length-1)) funcBody += ", ";	
			}
			funcBody += "};\n";
			funcBody += "return ns[prefix] || null;";
			return new Function("prefix",funcBody);
	}
	/** 네임스페이스 prefix, 네임스페이스 URI로 Map 개체를 만들어서 돌려준다.
	* 인자가 없는 경우에는 최상위 노드를, 노드를 지정한 경우에는 최상위 노드까지 
	* 거꾸로 올라가면서 네임스페이스 Map 개체를 만든다.
	* @param node XML 노드 @type Function 
	* @return Object ozMap 인스턴스 
	**/
	this.createNSMap = function(node) {
		var result = new ozMap();
		if(node == null) {
			if(this._source != null && this._source.documentElement != null) {
				var node = this._source.documentElement;	
			}	
			else return result;
		}			
		if (node.nodeType == 9) result = this._createNSMapSub(node.documentElement, result);
		else if(node.nodeType == 1) result = this._createNSMapSub(node, result);			
		return result;
	}
	/** @private **/
	this._createNSMapSub = function(node, result) {
		for(var i=0;i<node.attributes.length;i++) {
			if(this.prefix(node.attributes[i]) == "xmlns") {
					result.set(this.localName(node.attributes[i]), node.attributes[i].value);
			}
			else if(this.localName(node.attributes[i]) == "xmlns") {
					result.set("default", node.attributes[i].value);
			}
		}
		if(node.parentNode != null && node.parentNode.nodeType != 9) {
			result = this._createNSMapSub(node.parentNode, result);										
		}	
		return result;
	}
	/** node 노드 아래를 xpath로 검색하여 그 결과로 Array를 돌려준다.
	* node 인자를 사용하지 않으면 최상위 노드를 사용한다.
	* 기본 네임스페이스를 지정한 경우에 XPath는 aa 노드를 찾는 경우에 
	* //default:aa라고 해야한다. node 검색을 하는 경우, 네임스페이스를 사용하는
	* 노드를 검색하는 경우 네임 스페이스 설정이 그 노드 아래에 있는 경우에는
	* 에러가 발생할 수 있으므로 네임스페이스 맵을 인자로 넘기는 것이 좋다. 
	* @param xpath XPath 
	* @param node XML 노드. 생략 가능하다.
	* @param nsMap XPath 검색에 사용할 네임스페이스 맵. 생략 가능하다.
	* @type Function @return Array 찾은 노드를 배열로 돌려준다. 
	**/
	this.search = function(xpath, node, nsMap) {
		if(nsMap == null) { // 인자가 1개 또는 2개
			if(node == null) { // 인자가 1개
				if(this._source == null || this._source.documentElement == null) return null;	
				else var xmlDoc = this._source;
				var nsMap = this.createNSMap(xmlDoc);
			}	
			else { // 인자가 2개
				if(typeof(node.nodeType) != "undefined") { // 2번째 인자가 노드인 경우
					var nsMap = this.createNSMap(node);
					if(node.nodeType == 9) var xmlDoc = node;
					else if(node.nodeType == 1) {
						if(node.nodeName.indexOf("xsl:") != -1) var xmlDoc = this.createXMLDocument({type : "xsl"});
						else var xmlDoc = this.createXMLDocument();
						xmlDoc.appendChild(node.cloneNode(true));	
					}
				}	
				else { // 2번째 인자가 nsMap인 경우
					if(this._source == null || this._source.documentElement == null) return null;	
					else var xmlDoc = this._source;
					var nsMap = node;
				}
			}
		}
		else { // 인자가 3개
			if(node.nodeType == 9) var xmlDoc = node;
			else if(node.nodeType == 1) {
				if(node.nodeName.indexOf("xsl:") != -1) var xmlDoc = this.createXMLDocument({type : "xsl"});
				else var xmlDoc = this.createXMLDocument();
				xmlDoc.appendChild(node.cloneNode(true));	
			}
		}
		if(ozNavigator.isMO1) {
			var nsResolver = this.createNSResolver(nsMap);
			try {
				var temp = window.document.evaluate(xpath, xmlDoc.documentElement, nsResolver, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE ,null);
			}
			catch(error) {
				var message = "Xpath 검색 중에 에러가 발생했습니다. [message : " + error.message + "]";
				alert(message);
				return null;
			}
			var result = new Array();
			for(var i=0;i<temp.snapshotLength;i++) {
				result.push(temp.snapshotItem(i));
			}
			return result;
		}
		else if(ozNavigator.isIE4) {
			var nsvalue = "";
			for(var i=0;i<nsMap.length;i++) {
				nsvalue += "xmlns:" + nsMap.item(i).key + "='" + nsMap.item(i).value + "' ";
			}
			if(nsvalue != "") xmlDoc.setProperty("SelectionNamespaces", nsvalue);
		 	xmlDoc.setProperty("SelectionLanguage", "XPath");
		 	try { 
		 		var result = xmlDoc.selectNodes(xpath); 			
			}
			catch(error) {
				var message = "Xpath 검색 중에 에러가 발생했습니다. [message : " + error.message + "]";
				alert(message);
				return null;
			}
			return result;
		}
		return null;
	}
	/** 네임 스페이스 prefix 지정하면 네임 스페이스 url을 돌려줌. @param prefix 네임 스페이스 prefix
	* @param node 네임 스페이스 참조를 위한 노드 혹은 노드 맵. 생략 가능.
	* @type Function @return String 찾은 url을 돌려준다. 없으면 null을 돌려준다.
	**/
	this.lookupNamespaceURI = function(prefix, node) {
		if(prefix == null) return null;
		if(node == null) {
			if(this._source == null) return null;
			if(this._source.documentElement == null) return null;
			var nsMap = this.createNSMap(this._source.documentElement);
		}
		else {
			if(typeof(node.nodeType) != "undefined") var nsMap = this.createNSMap(node);
			else {
				if(typeof(node.length) == "undefined" || typeof(node.get) == "undefined") return null;					
				else var nsMap = node;	
			}
		}
		if(nsMap == null) return null;
		return nsMap.get(prefix);
	}
	/** 네임 스페이스 url 지정하면 네임 스페이스 prefix을 돌려줌. @param uri 네임 스페이스 URL
	* @param node 네임 스페이스 참조를 위한 노드 혹은 노드 맵. 생략 가능.
	* @type Function @return String 찾은 prefix을 돌려준다. 없으면 null을 돌려준다.
	**/
	this.lookupPrefix = function(uri, node) {
		if(uri == null) return null;
		if(node == null) {
			if(this._source == null) return null;
			if(this._source.documentElement == null) return null;
			var nsMap = this.createNSMap(this._source.documentElement);
		}
		else {
			if(typeof(node.nodeType) != "undefined") var nsMap = this.createNSMap(node);
			else {
				if(typeof(node.length) == "undefined" || typeof(node.get) == "undefined") return null;					
				else var nsMap = node;	
			}
		}
		if(nsMap == null) return null;
		for(var i=0;i<nsMap.length;i++) {
			if(nsMap.item(i).value == uri) return nsMap.item(i).key;				
		}
		return null;
	}
	/** 네임 스페이스 url이 기본 네임스페이스이며 true를 아니면 false를 돌려준다. 
	* node 인자로는 네임스페이스를 살펴볼 노드를 지정한다.
	* @param uri 네임 스페이스 URL @type Function 
	* @return Boolean 기본 네임 스페이스면 true, 아니면 false를 돌려준다.
	**/
	this.isDefaultNamespace = function(uri, node) {
		var result = this.lookupPrefix(uri, node);
		if(result == null) return null;
		if(result == "default") return true;
		else return false;
	}
	/** xsl:template 노드로 XSL 문서 개체를 만들어서 돌려준다.
	* xsl:template 노드가 xsl 문서 개체에 attach된 상태가 아니면
	* null을 돌려준다는 것을 조심하자. @param template XSL 문서 개체로 만들 xsl:template 노드
	* @param output xsl:output 요소의 method 속성의 값을 지정한다. html|xml. 기본값은 xml.
	* @type Function @return Object XSL 문서 개체(XML 문서 개체)
	**/
	this.template2XSLDocument = function(template, output) {
		if(template == null) return null;
		if(template.ownerDocument == null) return null;
		if(output == null) var output = "xml";
		if(output == "xml") var newXSL = this.createXMLDocument({xmlContent:"<?xml version=\"1.0\"?><xsl:stylesheet version=\"1.0\" xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\"><xsl:output method=\"xml\"/></xsl:stylesheet>",type: "xsl"});
		else var newXSL = this.createXMLDocument({xmlContent:"<?xml version=\"1.0\"?><xsl:stylesheet version=\"1.0\" xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\"><xsl:output method=\"html\"/></xsl:stylesheet>",type: "xsl"});
		if(newXSL == null) return null;
		var params = this.getElementsByTagName("xsl:param", template.ownerDocument.documentElement);
		for(var i=0;i<params.length;i++) {
			newXSL.documentElement.appendChild(params[i].cloneNode(true));
		}	
		newXSL.documentElement.appendChild(template.cloneNode(true));
		var includedTemplates = this._searchIncludedTemplates(template);
		for(var i=0;i<includedTemplates.length;i++) {
			newXSL.documentElement.appendChild(includedTemplates.item(i).value.cloneNode(true));			
		}
		return newXSL;
	}
	/** @private **/
	this._searchIncludedTemplates =function(node, result, nsMap) {
		if(result == null) result = new ozMap();
		if(nsMap == null) {
			var nsMap = new ozMap();
			nsMap.set("xsl","http://www.w3.org/1999/XSL/Transform");
		}		
		var found = this.search("descendant::xsl:apply-templates",node, nsMap);
		if(found == null) return result;
		for(var i=0;i<found.length;i++) {
			if(result.get(found[i].getAttribute("select")) == null) {
				var found2 = this.search("//xsl:template[@match = '" + found[i].getAttribute("select") + "']", node.ownerDocument, nsMap);
				if(found2 != null && found2.length == 1) {
					result.set(found[i].getAttribute("select"),found2[0]);
					result = this._searchIncludedTemplates(found2[0], result, nsMap);	
				}
			}
		}						
		return result;
	}
	/** xsl 문서 개체, xsl 문서의 url, xsl:template 요소 노드로
	* XSLTProcessor 개체를 생성하여 돌려준다.
	* @param template XSL 문서 개체로 만들 xsl:template 노드
	* @type Function 
	* @return Object XSLTProcessor
	**/
	this.createXSLTProcessor = function(xsl) {
		if(xsl == null) return null;
		if(typeof(xsl.nodeType) != "undefined" && xsl.nodeType == 9) var xslDoc = xsl;			
		else if(typeof(xsl.nodeType) != "undefined" && xsl.nodeType == 1) var xslDoc = this.template2XSLDocument(xsl);
		else var xslDoc = this.createXMLDocument({documentURI:xsl, type:"xsl"});			
		if(xslDoc == null) return null;
		if(ozNavigator.isIE4) {
			var xslCache = new ActiveXObject("Msxml2.XSLTemplate.5.0");
			xslCache.stylesheet = xslDoc;
			var processor = xslCache.createProcessor();
			return processor;
		}
		else if(ozNavigator.isMO1) {
			processor = new XSLTProcessor();
			processor.importStylesheet(xslDoc);
			return processor;
		}
		else return null;
	}
	/** XML 문서에 포함된 XSL 문서의 URL을 돌려준다. 없는 경우에 null을 돌려준다.
	* @param node XML 문서 개체나 XML 노드 @type Function 
	* @return String 문자열을 돌려준다.
	**/
	this.lookupStylesheetURI = function(node) {
		if(node == null) {
			if(this._source != null && this._source.documentElement != null) {
				var node = this._source;
			}
			else return null;
		}
		else {
			if(typeof(node.nodeType) != "undefined") {
				if(node.nodeType == 1 && node.ownerDocument != null) {
					var node = node.ownerDocument;	
				}
			}
			else return null;
		}
		for(var i=0;i<node.childNodes.length;i++) {
			if(node.childNodes[i].nodeName == "xml-stylesheet") {
				var myRe = /href\s*\=\s*[\"\']([^\"\']+)[\"\']/;
				var result = myRe.exec(node.childNodes[i].nodeValue);
				if(result != null) return result[1];				
				else return null;
			}
		}	
		return null;
	}
	/** HTML 요소 개체를 xml 노드 개체로 변환한다. @param 변환할 HTML 요소 개체
	* @type Function @return Object XML 노드
	**/
	this.html2xml = function(node) {
		if(node == null) return null;
		if(node.nodeType == 1 && typeof(node.innerHTML) != "undefined") {
			if(typeof(node.outerHTML) != "undefined") var message = node.outerHTML;
			else var message = (new XMLSerializer()).serializeToString(node);
			var result = this.createXMLDocument({ xmlContent : "<?xml version='1.0'?>" + message.wellFormed() });
			return result.documentElement;
		}
		else return null;		
	}
	/** XML 노드 개체를 HTML 요소 개체로 변환한다. @param 변환할 XML 요소 노드 @type Function 
	* @return Object HTML 요소 개체
	**/
	this.xml2html = function(node) {
		if(node == null) return null;
		if(node.nodeType == 1 && typeof(node.innerHTML) == "undefined") {
			if(node.nodeName.indexOf(":") != -1) return null;
			var result = window.document.createElement(node.tagName);
			for(var i=0;i<node.attributes.length;i++) {
				result.setAttribute(node.attributes[i].name, node.attributes[i].value);	
			}
			var temp = "";
			for(var i=0;i<node.childNodes.length;i++) {
				if(node.childNodes[i].nodeType == 1) temp += this.xmlContent(node.childNodes[i]);
				else temp += node.childNodes[i].nodeValue;
			}
			result.innerHTML = temp;
			return result;
		}	
		else return null;	
	}
	/** 인자로 지정한 문자열을 XML 개체로 로딩한다. @param xmlContent
	* @type Function @return boolean XML 개체 생성에 성공하면 true를 실패하면 false를 돌려준다.
	**/
	this.loadXML = function(xmlContent) {
		if(this._source == null) this._source = this.createXMLDocument(); 
		if(ozNavigator.isMO1) {
			var parser = new DOMParser();
			this._source = parser.parseFromString(xmlContent,"text/xml");
			this._documentURI = null;
		  if(this._source.documentElement.nodeName == "parsererror") {
		 		var message = "(" + this._source.documentElement.childNodes[0].nodeValue + ")";
		 		alert("ozXML.loadXML : XML 문서 파싱중에러가 발생했습니다." + message);
				this._source = null;
				return false;
		 	}
		}
		else if(ozNavigator.isIE4) {
			this._documentURI = null;
			this._source.loadXML(xmlContent);
		 	if(this._source.parseError.errorCode == 0) return true;
		 	else {
	 			var message = "(errorCode : " + this._source.parseError.errorCode + ", reason : " + this._source.parseError.reason + ")";
	 			alert("ozXML.loadXML : XML 문서 파싱중에러가 발생했습니다." + message);
	 			this._source = null;
	 			return false;
	 		}
		}
		return true;
	}
	/** 인자로 load 메쏘드로 XML 문서를 로딩한 다음에 실행할 함수를 지정한다.
	* 인자가 없으면 load 메쏘드로 XML 문서를 로딩한 다음에 실행할 함수를 돌려준다.
	* 실행되는 함수에는 
	* xml 개체를 인자로 넘겨준다는 것을 조심하자. @type Function
	* @return Function load 메쏘드로 XML 문서를 로딩한 다음에 실행할 함수를 돌려준다.
	**/
	this.onload = function() {
		if(this._source != null) {
			if(arguments.length == 0) return this._onload;
			else {
				if(ozNavigator.isIE4) {
					this._onload = arguments[0];
					this._source.onreadystatechange = this._loadCheck;
					return this._onload;
				}
				else if(ozNavigator.isMO1) {
					this._onload = arguments[0];
					this._source.onload = this._loadCheck;
					return this._onload;
				}
				else {
					this._onload = null;
					return null;
				}
			} 
		}	
		else return null;
	}
	/** load 메쏘드로 URL을 로딩하는 경우에 XML 문서가 로딩되었는 지를 확인하는 함수이다. 
	* XML 문서가 로딩이 확인되면, onload 메쏘드로 지정한 함수를 실행한다. 이 때 그 함수의 인자로 
	* xml 개체를 넘겨준다.
	* @private @type Function
	* @return Boolean XML 문서가 로딩되어 onload 메쏘드로 지정한 함수가 실행되면 true를, 
	* 그렇지 않으면 false를 돌려준다.
	**/
	this._loadCheck = function() {
		if(this._source!= null && this.onload() != null) {
			if(ozNavigator.isIE4) {
				if(this._source.readyState == 4) {
					if(this.error() == null) {
						this._onload(this);						
						return true;
					}
				}			
			}
			else if(ozNavigator.isMO1) {
				if(this.error() == null) {
					this._onload(this);	
					return true;
				}
			}	
			return false;
		}		
	}
	/** 인자로 지정한 xml 문서를 xsl 문서를 사용하여 변환한다. output이 xml이면 xml 개체를, 
	* string이면 xml 코드를 문자열로 돌려준다. 인자의 속성의 사용법은 다음과 같다.<br/>
	* - xml : xml 문서 개체, xml 노드, xml url. 지정하지 않으면,
	* 현재 xml 개체를 사용한다.<br/>
	* - xsl : xsl 문서 개체, xsl template 노드, xsl url. 지정하지 않으면,
	* 현재 xml 개체나 인자로 지정한 xml 개체에 지정된 xsl 문서를
	* 읽어온다.<br/>
	* - ouput : xml이면 xml 개체를, text이면 xml 코드를 문자열로
	* 돌려준다.<br/>
	* - parameters : 변환시에 xsl 문서에 전달될 parameter의 이름과 값을
	* 나타내는 map 개체.
	* @param param 인자 개체 @type Function 
	* @return Object 변환된 XML 개체나 XML 코드
	**/
	this.transform = function(param) {
		if(param == null) {
			if(this._source != null && this.error() == null)  var xmlDoc = this._source;			
			else return null;
			if(this.lookupStylesheetURI(xmlDoc) == null) return null;
			var xslDoc = this.createXMLDocument({documentURI : this.lookupStylesheetURI(xmlDoc), type : "xsl"});
			if(this.error(xslDoc) != null) return null;
			var output = "xml";
		}
		else {
			if(typeof(param.xml) != "undefined") {
				if(typeof(param.xml.nodeType) != "undefined" && param.xml.nodeType == 9) var xmlDoc = param.xml;					
				else if(typeof(param.xml.nodeType) != "undefined" && param.xml.nodeType == 1) {
					var xmlDoc = this.createXMLDocument({root : param.xml.cloneNode(true) });
				}	
				else var xmlDoc = this.createXMLDocument({documentURI : param.xml });
				if(this.error(xmlDoc) != null) return null;
			}
			else {
				if(this._source != null && this.error() == null) var xmlDoc = this._source;			
				else return null;
			}
			if(typeof(param.output) != "undefined") {
				if(param.output == "text") var output = "text";
				else var output = "xml";
			}
			else var output = "xml";
			if(typeof(param.xsl) != "undefined") {
				if(typeof(param.xsl.nodeType) != "undefined" && param.xsl.nodeType == 9) var xslDoc = param.xsl;					
				else if(typeof(param.xsl.nodeType) != "undefined" && param.xsl.nodeType == 1 && param.xsl.nodeName == "xsl:template") {
					var xslDoc = this.template2XSLDocument(param.xsl);
				}	
				else if(typeof(param.xsl.nodeType) != "undefined" && param.xsl.nodeType == 1 && param.xsl.nodeName == "xsl:stylesheet") {
					var xslDoc = this.createXMLDocument({type : "xsl"});
					xslDoc.appendChild(param.xsl.cloneNode(true));
				}
				else var xslDoc = this.createXMLDocument({documentURI : param.xsl, type : "xsl"});
				if(xslDoc == null) return null;
				if(this.error(xslDoc) != null) return null;
			}
			else {
				if(this.lookupStylesheetURI(xmlDoc) == null) return null;
				var xslDoc = this.createXMLDocument({documentURI : this.lookupStylesheetURI(xmlDoc), type : "xsl"});
				if(this.error(xslDoc) != null) return null;
			}
		}
		if(ozNavigator.isIE4) {
			var processor = this.createXSLTProcessor(xslDoc);
			if(param != null && typeof(param.parameters) != "undefined" && typeof(param.parameters.length) != "undefined" && typeof(param.parameters.item) != "undefined") {
				for(var i=0;i<param.parameters.length;i++) {
					processor.addParameter(param.parameters.item(i).key, param.parameters.item(i).value, "");
				}
			}
			processor.input = xmlDoc;
			if(output == "xml") processor.output = this.createXMLDocument();
			processor.transform();
			return processor.output;
		}
		else if(ozNavigator.isMO1) {
			var processor = this.createXSLTProcessor(xslDoc);
			if(param != null && typeof(param.parameters) != "undefined" && typeof(param.parameters.length) != "undefined" && typeof(param.parameters.item) != "undefined") {
				for(var i=0;i<param.parameters.length;i++) {
					processor.setParameter("",param.parameters.item(i).key, param.parameters.item(i).value);
				}
			}
			var result = processor.transformToDocument(xmlDoc);
			if(this.error(result) == null) {
				if(output == "xml") return result;									
				else {
					var serializer = new XMLSerializer();
					return serializer.serializeToString(result);	
				}
			}
			else return null;
		}
		else return null;
	}
	/** XML 문서 개체의 유효성을 검증한다. 모질라 웹브라우저는 유효성 검증을 지원하지 
	* 않으므로 항상 null을 돌려준다.
	* @param xmlDoc XML 문서 개체. 없으면 현재 XML 문서 개체를 사용한다.
	* @type Function @return Boolean 유효하면 true, 유효하지 않으면 false를 돌려준다.
	**/
	this.validate = function(xmlDoc) {
		if(!ozNavigator.isIE4) return null;
		if(xmlDoc == null) {
			if(this._source != null) var xmlDoc = this._source;
			else return null;
			if(xmlDoc != null && typeof(xmlDoc.nodeType) != "undefined" && xmlDoc.nodeType == 9) {
				var result = xmlDoc.validate();
				if(result.errorCode == 0) return true;
				else return false;	
			}		
			else return null;
		}		
	}
	/** 인자로 지정한 URL의 XML 문서를 로딩한다.
	* @param documentURI @type Function
	* @return Boolean 성공하면 true를, 실패하면 false를 돌려준다.
	* 비동기 통신을 사용하여 성공과 실패여부를 알 수 없을 때는 true를 돌려준다.
	**/
	this.load = function(documentURI) {
		if(this._source != null) {
			this._documentURI = documentURI;
			this._source.load(documentURI);
			return true;
		}	
		else return false;
	}
	/** XML 개체를 생성하거나 초기화 할 때 사용한다. 
	* @param param param 인자의 속성에 따라서 XML 개체가 생성된다
	* @type Function
	**/
	this.init = function(param) {
		this._documentURI = null;
		this._onload = null;
		if( (param != null && typeof(param.type) != "undefined" && param.type == "xsl") || (param != null && typeof(param.rootName) != "undefined" && param.rootName == "xsl:stylesheet") || (param != null && typeof(param.root) != "undefined" && param.root.nodeName == "xsl:stylesheet") || (param != null && typeof(param.xmlObject) != "undefined" && param.xmlObject.documentElement != null && param.xmlObject.documentElement.nodeName == "xsl:stylesheet") || (param != null && typeof(param.documentURI) != "undefined" && /\.xsl$/.test(param.documentURI)) ) {
			this._source = this.createXMLDocument({type:"xsl"});
		}
		else this._source = this.createXMLDocument();
		if(this._source != null) {
			if(param != null) {
				if(typeof(param.async) != "undefined") this.async(param.async);
				else this.async(false);	
				if(typeof(param.onload) != "undefined") this.onload(param.onload);
				if(typeof(param.strictErrorChecking) != "undefined") this._source.validateOnParse = new Boolean(param.stricErrorChecking);
				else this._source.validateOnParse = false;
				if(typeof(param.rootName) != "undefined") {
					var temp = this.createElement(param.rootName);
					if(temp != null) return this._source.appendChild(temp);
					else {
						alert("ozXML.init : " + param.rootName + "으로된 최상위 노드를 생성하지 못했습니다.");
						return false;	
					}	
				}
				else if(typeof(param.root) != "undefined") {
					if(typeof(param.root.nodeType) != "undefined" && param.root.nodeType == 1) {
						return this._source.appendChild(param.root);
					}
					else alert("ozXML.init : 정상적인 노드가 아닙니다.");						
				}
				else if(typeof(param.documentURI) != "undefined") return this.load(param.documentURI);					
				else if(typeof(param.xmlContent) != "undefined") return this.loadXML(param.xmlContent);					
				else if(typeof(param.xmlObject) != "undefined") {
					if(typeof(param.xmlObject.nodeType) != "undefined" && param.xmlObject.nodeType == 9) {
						this._source = param.xmlObject; 	
						return true;
					}
					else return false;
				}
				else return true;
			}
			else return true;	
		}
		else return false;
	}
	var result = this.init(param);
	if(result == false) {
		alert("ozXML.init : XMLDocument 개체를 생성하지 못했습니다.");
	}		
}
/** AJAX 개체 클래스. 원본 AJAX 개체를 감싸는 자바스크립트 개체를 생성하여 
 * 돌려준다. param 인자 개체의 속성에 따라서 초기화된다.<br/>
 * - async : 동기화 통신 여부. 기본값은 true.<br/>
 * - documentURI : 요청할 페이지의 주소.<br/>
 * - method : http 통신 방식. get 또는 post<br/>
 * - requestHeader : 
 * - body : 서버로 보낼 내용. Map 개체<br/>
 * @constructor 
 * @param param	param 인자의 속성에 따라서 XML 개체가 생성된다.
 **/
ozAjax = function(param) {
	/**
	* 원본 AJAX 개체가 저장된다. @type Object
	* @private
	**/
	this._source = null;
	/**
	* 동기화 통신 여부를 나타낸다.
	* @type Boolean 
	**/
	this.async = true;
	/**
	* 요청한 문서의 URL
	* @type String 
	**/
	this.documentURI = null;
	/**
	* 요청 방식. get 또는 post
	* @type String 
	**/
	this.method = "get";
	/**
	* 요청시 보낼 헤더. Map 개체.
	* @type Object
	**/
	this.requestHeaders = new ozMap();
	/**
	* 요청시 보낼 내용. Map 개체.
	* @type Object
	**/
	this.body = new ozMap();
	/**
	* 응답 상태. 4이면 응답이 정상적으로 도착한 것이다.
	* @type Object
	**/
	this.readyState = 0;
	/**
	* 응당 상태 코드. 200번대가 정상적인 응답이다.
	* @type Number
	**/
	this.status = null;
	/**
	* 응답 상태 메시지.
	* @type String
	**/
	this.statusText = null;
	/**
	* 문자열을 요청한 경우에 응답 결과가 저장된 속성.
	* @type String
	**/
	this.responseText = null;
	/**
	* XML 개체를 요청한 경우에 XML 개체({@link ozXML}) 저장된 속성.
	* @type Object
	**/
	this.responseXML = null;
	/**
	* XML 개체를 응답으로 받은 경우 true가 됩니다.
	* @type Object
	**/
	this.hasResponseXML = false;
	/**
	* 응답 헤더가 저장된 Map 개체.
	* @type Object
	**/
	this.responseHeaders = new ozMap();
	/**
	* 주기적으로 AJAX 개체를 요청하는 경우에 그 간격이 1/1000초 단위로 저장된다.
	* 이 값이 null이면 응답을 받은 후에 다시 요청하지 않는다.
	* 자세한 내용은 setInterval, clearInterval 메쏘드를 참고하라.
	* @type Number
	**/
	this.interval = null;
	/**
	* 주기적으로 AJAX 개체를 요청하는 경우 그 타이머 개체를 
	* 저장하는 목적으로 내부적으로 사용한다.
	* @type Number
	* @private
	**/
	this._timer = null;
	/**
	* 요청하는 XML 문서의 MIME 타입.
	* 이 속성은 requestHeaders 맵에 저장된 값보다 우선한다.
	* @type String
	**/
	this.mimeType = null;
	/**
	* 요청 헤더의 문자 인코딩 방식.
	* 이 속성은 requestHeaders 맵에 저장된 값보다 우선한다.
	* @type String
	**/
	this.encoding = "UTF-8";
	/**
	* 응답이 정상적으로 도착한 경우에 실행될 함수 개체가 저장된다.
	* 응답으로 받은 문자열이나 XML 개체를 항상 인자로 사용한다.
	* @type Function
	**/
	this.onload = null;
	/**
	* 응답에 에러가 있는 경우에 에러 내용을 돌려준다.
	* 에러가 없는 경우에 null을 돌려준다.
	* @type Function
	**/
	this.error = function() {
		if(this._source == null) {
			return "(reason : ajax 개체가 없습니다.)";	
		}
		else if(this._source.readyState != 4) {
			return "(reason : 응답이 아직 완료되지 않았습니다. readyState : " + this._source.readyState + ")";	
		}
		else if(this._source.status != 200) {
			return "(reason : 응답에 에러가 있습니다. status : " + this._source.status + ", statusText : " + this._source.statusText +")";	
		}
		else {
			if(this._source.responseXML == null && this._source.responseHTML == null) {
				return "(reason : 응답으로 받은 내용이 없습니다.)";	
			}
			else if(this._source.responseText == null) {
				return "(reason : 응답으로 받은 문자열이 없습니다.)";
			}			
			else if(this.mimeType == "text/xml" || this.mimeType == "application/xml+rss") {
				return this.responseXML.error() ;
			}
			else return null;
		}
	}
	/**
	* 응답이 정상적으로 도착하면 응답 내용을 개체로 저장하고, onload 속성으로 지정한
	* 함수를 실행한다.
	* @type Function
	* @private
	**/
	this._onreadystatechange = function() {
		if(this._source != null) {
			this.readyState = this._source.readyState;
			if(this._source.readyState == 4) {
				this._afterSuccess();
			}
		}
	}
	/**
	* 응답이 정상적으로 도착하면 응답 내용을 개체로 저장하고, onload 속성으로 지정한
	* 함수를 실행한다.
	* @type Function
	* @private
	**/
	this._afterSuccess = function() {
		this.readyState = this._source.readyState;
		this.status = this._source.status;
		this.statusText = this._source.statusText;
		if(this._source != null) {
			this.responseHeaders = new ozMap();
			this.mimeType = null;
			this.hasResponseXML = false;
			this.encoding = "UTF-8";
			headers = this._source.getAllResponseHeaders();
			if(headers != null && headers != "") {
				// requestHeaders 맵에 헤더를 저장합니다.
				var myRe = /([^\:]+)\:\s([^\n]+)\n/gi;
				var exResult = myRe.exec(headers);
				while(exResult != null && exResult.length == 3) {
					this.responseHeaders.set(exResult[1], exResult[2]);
					exResult = myRe.exec(headers);							
				}
				// mimeType, encoding을 처리합니다.
				var contentType = this.responseHeaders.get("Content-Type");
				if(typeof(contentType) != "undefined") {
					var splited = contentType.split(";");
					if(splited != null) {
						if(splited.length >= 1) {
							this.mimeType = splited[0].trim();
						}	
						if(splited.length >= 2) {
							var temp = splited[1].split("=");
							if(temp != null && temp.length == 2) {
								if(temp[0].trim() == "charset") {
									this.encoding = temp[1].trim().toUpperCase();											
								}
							}	
						}
						// hasResponseXML 속성을 지정합니다.
						if(this.mimeType == "text/xml" || this.mimeType == "application/xml+rss") {
							this.hasResponseXML = true;	
						} 
					}
				}
			}
			// 응답 내용을 저장합니다.
			this.responseText = this._source.responseText;
			if(this.hasResponseXML) {
				this.responseXML = new ozXML({xmlObject: this._source.responseXML});	
			}
			else {
				this.mimeType = "text/plain";	
			}
			// onload가 있는 경우에 onload를 실행하고 종료합니다.
			if(this.onload != null) {
				if(this.hasResponseXML) this.onload(this);
				else this.onload(this);
				// 주기적으로 요청하도록 되어있는 경우 다음 실행을 예약한다.
				if(this._timer != null) {
					window.clearTimeout(this._timer);
					this._timer = null;
				}
				if(this.interval != null) {
					this._timer = window.setTimeout(this.send.bind(this),this.interval);
				}
			}
			return true;
		}
		else {
			alert("error");
			this.reset();
			return false;
		}	
	}
	/**
	* AJAX 개체의 속성을 초기화한다. 에러가 있는 경우에 주로 사용한다.
	* @type Function
	* @private
	**/
	this.reset = function() {
		this.responseHeaders = new ozMap();
		this.mimeType = null;
		this.responseXML = null;
		this.responseText = null;
		this.hasResponseXML = false;
		this.statusText = null;
		this.status = null; 
	}

	/**
	* AJAX 개체로 요청을 보낸다. body 맵의 값은 encodeURIComponent로 자동으로 
	* 인코딩된다는 것을 조심하자. 그리고, body 맵의 각 항목의 value 값은
	* 문자열로 되어있어야 한다. 
	* @type Function
	* @pram param 다음과 같은 속성을 가진 개체이. 각 속성의 값이 
	* AJAX 개체의 속성으로 저장된다는 것을 조심하라.<br/>
	* - asyn : 동기화 통신 여부.<br/>
	* - documentURI : AJAX로 요청하는 페이지 주소.<br/>
	* - method : 통신 방식.<br/>
	* - requestHeaders : 헤더 Map 개체.<br/>
	* - interval : 반복해서 요청하는 시간(miliseconds).<br/>
	* - onload : 정상적으로 응답을 받은 경우에 실행할 함수.<br/>
	* - body : 요청시 보낼 내용. Map 개체이거나 문자열<br/>
	**/
	this.send = function(param) {
		this.reset();
		// 인자를 설정합니다.
		if(param != null) {
			if(typeof(param.async) != "undefined") this.async = param.async;
			if(typeof(param.documentURI) != "undefined") this.documentURI = param.documentURI;
			if(typeof(param.method) != "undefined") this.method = param.method;
			if(typeof(param.requestHeaders) != "undefined") this.requestHeaders = param.requestHeaders;
			if(typeof(param.interval) != "undefined") this.interval = param.interval;
			if(typeof(param.onload) != "undefined") this.onload = param.onload;
			if((typeof(param.body) != "undefined")) this.body = param.body;
		}
		if(this._source != null && this.documentURI != null) {
			// open을 호출합니다.
			if(this.method=="get"&&this.body != null && typeof(this.body.length) != "undefined" && typeof(this.body.getString) != "undefined" && this.body.length != 0) {
				var temp = this.documentURI.split("?");
				if(temp != null && temp.length == 2) {
					this._source.open(this.method, temp[0] + "?" + temp[1] + "&" + this.body.getString(), this.async);
				}		
				else {
					this._source.open(this.method, this.documentURI + "?" + this.body.getString(), this.async);
				}
			}
			else {
				this._source.open(this.method, this.documentURI, this.async);
			}
			// 요청 헤더를 설정합니다.	
			if(this.requestHeaders != null && this.requestHeaders.length != 0) {
				for(var i=0;i<this.requestHeaders.length;i++) {
					var todo = this.requestHeaders.item(i);
					this._source.setRequestHeader(todo.key, todo.value);
				}
			}
			// 비동기 통신시에 처리할 함수를 지정합니다.
			if(this.onload != null && this.async == true) {
				if(ozNavigator.isMO1) {
					this._source.onload = this._onreadystatechange.bind(this);
				}
				else {
					this._source.onreadystatechange = this._onreadystatechange.bind(this);
				}
			}
			// 요청을 보냅니다.
			if(this.method == "get") {
				this._source.send("");
			}
			else if(this.method == "post") {
				if(this.body != null) {
					if(typeof(this.body.length) != "undefined" && typeof(this.body.getString) != "undefined" && this.body.length != 0) {
						this._source.setRequestHeader("Content-Type", "application/x-www-form-urlencoded"); 
						this._source.send(this.body.getString());
					}
					else {
						this._source.send(this.body);
					}
				}
				else {
					this._source.send("");
				}
			}
			else {
				alert("지원하지 않는 method 입니다.");
				return false;
			}
			// 동기 통신 시에 처리할 함수를 실행합니다. 
			if(this.async == false) {
				this._afterSuccess();			
			}
			return true;
		}
		else return false;
	}

	/**
	* 주기적으로 AJAX 요청을 보내도록 설정한다.
	* @type Function
	* @param ms 응답이 도착하고 다시 요청을 보낼 때 까지 시간.
	* @return Boolean 성공하면 true, 실패하면 false를 돌려준다.
	**/
	this.setInterval = function(ms) {
		if(ms != null && !isNaN(new Number(ms))) {
			this.interval = parseInt(new Number(ms));
			return true;
		}
		else return false;
	}
	/**
	* 주기적으로 AJAX 요청을 보내도록 한 것을 취소한다.
	* @type Function
	* @return Boolean 성공하면 true, 실패하면 false를 돌려준다.
	**/
	this.clearInterval = function() {
		if(this._timer != null) {
			window.clearTimeout(this._timer);
			this._timer = null;
		}
		this.interval = null;
		return true;
	}
	/**
	* 요청을 취소한다. 주기적으로 요청하도록 된 경우에는
	* 그 요청도 멈춘다.
	* @type Function
	* @return Boolean 성공하면 true, 실패하면 false를 돌려준다.
	**/
	this.abort = function() {
		if(this._timer != null) {
			window.clearTimeout(this._timer);
			this._timer = null;
		}
		if(this._source != null) {
			this._source.abort();
			this.reset();	
		}
	}
	/**
	* 모든 응답 헤더를 Map 개체로 돌려준다.
	* @type Function
	* @return Object Map 개체.
	**/
	this.getAllResponseHeaders = function() {
		return this.responseHeaders();
	}
	/**
	* 이름이 name인 응답 헤더의 값을 돌려준다.
	* @type Function
	* @return String 응답 헤더의 값.
	**/
	this.getResponseHeader = function(name) {
		if(typeof(this.responseHeaders.get(name)) == "undefined") {
			return null;
		}
		else {
			return this.responseHeaders.get(name);	
		}
	}
	/**
	* 요청 헤더를 설정한다.
	* @type Function
	* @return Boolean 성공하면 true, 실패하면 false를 돌려준다.
	**/
	this.setRequestHeader = function(name, value) {
		this.requestHeaders.set(name, value);
	}
	/**
	* AJAX 개체를 생성하여 돌려준다.
	* @type Function
	* @return Object 생성된 AJAX 개체.
	**/
	this.createAjax = function() {
		if(ozNavigator.isIE4) {
		  return new ActiveXObject("Microsoft.XMLHTTP");  
		}  
		else if(ozNavigator.isMO1){
		  return new XMLHttpRequest();
		}  
		else {
		  return null;
		}
	}
	/**
	* AJAX 개체를 초기화 한다.
	* @param param 다음과 같은 속성을 사용할 수 있다.<br/>
	* - async : 동기화 통신 여부. 기본값은 true.<br/>
	* - documentURI : 요청할 페이지의 주소.<br/>
	* - method : http 통신 방식. get 또는 post<br/>
	* - requestHeader : 서버로 보낼 헤더 Map<br/>
	* - body : 서버로 보낼 내용. Map 개체<br/>
	* @type Function
	**/
	this.init = function(param) {
		if(param != null) {
			if(typeof(param.async) != "undefined") this.async = param.async;
			if(typeof(param.documentURI) != "undefined") this.documentURI = param.documentURI;
			if(typeof(param.method) != "undefined") this.method = param.method;
			if(typeof(param.requestHeader) != "undefined") this.requestHeader = param.requestHeader;
			if(typeof(param.body) != "undefined") this.body = param.body;
			if(typeof(param.onload) != "undefined") this.onload = param.onload;
			if(typeof(param.interval) != "undefined") this.interval = param.interval;
			if(typeof(param.encoding) != "undefined") this.encoding = param.encoding;
		}
	}
	this._source = this.createAjax();
	if(param != null) {
		this.init(param);	
	}
}