0.6.x/js/05_util/04_XXML.js

   1 /*\r
   2  * XMLWrapper_find 周りの オリジナルコードに関する情報\r
   3  *  Original code by pettanR team\r
   4  *  - http://sourceforge.jp/projects/pettanr/scm/git/clientJs/blobs/master/0.6.x/js/01_dom/18_XDomQuery.js\r
   5  *  and\r
   6  *  Original code by ofk ( kQuery, ksk )\r
   7  *  - http://d.hatena.ne.jp/ofk/comment/20090106/1231258010\r
   8  *  - http://d.hatena.ne.jp/ofk/20090111/1231668170\r
   9  */\r
  10 \r
  11 X[ 'XML' ] = XMLWrapper;\r
  12 \r
  13 function XMLWrapper( xml ){\r
  14         this._rawXML = xml;\r
  15 };\r
  16 \r
  17 XMLWrapper.prototype.length    = 1;\r
  18 XMLWrapper.prototype[ 'has' ]  = XMLWrapper_has;\r
  19 XMLWrapper.prototype[ 'get' ]  = XMLWrapper_get;\r
  20 XMLWrapper.prototype[ 'val' ]  = XMLWrapper_val;\r
  21 XMLWrapper.prototype[ 'find' ] = XMLWrapper_find;\r
  22 \r
  23 function XMLWrapper_has( queryString ){\r
  24         return !!this.find( queryString ).length;\r
  25 };\r
  26 \r
  27 function XMLWrapper_get( index ){\r
  28         if( this.length === 1 ) return this;\r
  29         if( this.length === 0 ) return null;\r
  30         // 一度発行した XMLWrapper は控えて置いて再発行する。\r
  31         if( this._wraps && this._wraps[ index ] ) return this._wraps[ index ];\r
  32         if( !this._wraps ) this._wraps = [];\r
  33         return this[ index ] ?\r
  34                 ( this._wraps[ index ] = new XMLWrapper( this[ index ] ) ) :\r
  35                 null;\r
  36 };\r
  37 \r
  38 function XMLWrapper_val( queryString, type ){\r
  39         var attr_textContent = X.UA.IE < 9 || X.UA.Opera ? 'innerText' : X.UA.IE9 ? 'text' : 'textContent',\r
  40                 wrapper, xml, v;\r
  41         \r
  42         switch( queryString ){\r
  43                 case 'number' :\r
  44                 case 'int' :\r
  45                 case 'boolean' :\r
  46                 case 'string' :\r
  47                 case undefined :\r
  48                         type = queryString;\r
  49                         queryString = undefined;\r
  50         };\r
  51                 \r
  52         wrapper = queryString ? this.find( queryString ) : this;\r
  53         xml     = wrapper.length === 1 ? wrapper._rawXML : wrapper[ 0 ];\r
  54 \r
  55         if( !xml ){\r
  56                 switch( type ){\r
  57                         case 'number' :\r
  58                         case 'int' :\r
  59                                 return NaN;\r
  60                         case 'boolean' :\r
  61                                 return false;\r
  62                         case 'string' :\r
  63                                 return '';\r
  64                         default :\r
  65                                 return null;\r
  66                 };\r
  67         };\r
  68         \r
  69         v = xml.nodeType === 1 ? xml.innerText || xml.text || xml.textContent : xml.nodeValue;\r
  70         //xml.toStrign()\r
  71         switch( type ){\r
  72                 case 'number' :\r
  73                         return parseFloat( v );\r
  74                 case 'int' :\r
  75                         return parseInt( v );\r
  76                 case 'boolean' :\r
  77                         return v && v !== '0' && v !== 'false' && v !== 'null' && v !== 'undefined' && v !== 'NaN';\r
  78                 //case 'string' :\r
  79                 //default :     \r
  80         };\r
  81         return v || '';\r
  82 };\r
  83 \r
  84         function XMLWrapper_find( queryString ){\r
  85 \r
  86                 var scope     = this.constructor === XMLListWrapper ? this : [ this._rawXML ],\r
  87                         parents   = scope, // 探索元の親要素 xmlList の場合あり\r
  88                         ARY_PUSH  = Array.prototype.push,\r
  89                         ret       = [], // 結果要素\r
  90                         isXML     = true,\r
  91                         isMulti   = 1 < scope.length,// 要素をマージする必要がある\r
  92                         isStart   = true,\r
  93                         _         = ' ',\r
  94                         isAll, isNot, hasRoot,\r
  95                         l, i, n, parsed,\r
  96                         xmlList, // 一時保存用\r
  97                         merge, // 要素がコメントノードで汚染されている場合使う\r
  98                         combinator, selector, name, tagName,\r
  99                         uid, tmp, xml, filter, key, op, val, toLower, useName,\r
 100             links, className, attr, flag;\r
 101 \r
 102                 // 文字列以外は空で返す\r
 103                 if( !X_Type_isString( queryString ) ) return XMLListWrapper_0;\r
 104                 \r
 105                 xmlList = [];\r
 106                 \r
 107                 // 以下、パースと探索\r
 108                 for( ; queryString.length; ){\r
 109                         //console.log( 'queryString[' + queryString + ']' );\r
 110                         \r
 111                         // 初期化処理\r
 112                         if( !parsed ){\r
 113                                 parsed = X_Node_Selector__parse( queryString );\r
 114                                 \r
 115                                 if( X_Type_isNumber( parsed ) ){\r
 116                                         // error\r
 117                                         return XMLListWrapper_0;\r
 118                                 };\r
 119                                 \r
 120                                 queryString = queryString.substr( parsed[ 0 ] );\r
 121                                 parsed      = parsed[ 1 ];\r
 122                                 \r
 123                                 if( parsed === 5 ){\r
 124                                         isMulti = true;\r
 125                                         parents = scope;\r
 126                                         xmlList && xmlList.length && ARY_PUSH.apply( ret, xmlList );\r
 127                                         parsed  = null;\r
 128                                         xmlList = [];\r
 129                                         isStart = true;\r
 130                                         continue;\r
 131                                 };\r
 132                         };\r
 133                         \r
 134                         combinator  = parsed[ 0 ];\r
 135                         selector    = parsed[ 1 ];\r
 136                         name        = parsed[ 2 ];\r
 137                         tagName     = selector === 1 ? name : '*';\r
 138                         isAll       = tagName === '*';\r
 139         \r
 140                         if( !isStart ){\r
 141                                 if( !xmlList.length ){\r
 142                                         parsed = null;\r
 143                                         continue;                                       \r
 144                                 } else\r
 145                                 if( combinator !== 0 ){\r
 146                                         parents = xmlList;\r
 147                                         xmlList = [];\r
 148                                         //console.log( 'cobinator !== 0 ' + parents.length + ' : ' + xmlList.length );\r
 149                                 };\r
 150                         };\r
 151                         \r
 152                         i = 0;\r
 153                         l = parents.length;\r
 154                         n = -1; \r
 155                         isMulti = isMulti || 1 < l;\r
 156                         \r
 157                         console.log( 'combinator ' + combinator );\r
 158         \r
 159                         switch( combinator ){\r
 160                                 // > TagName|*\r
 161                                 case 2 :\r
 162                                         for( ; i < l; ++i ){\r
 163                                                 for( xml = parents[ i ].firstChild; xml; xml = xml.nextSibling ){\r
 164                                                         if( xml.nodeType === 1 && ( isAll || tagName === xml.tagName ) ) xmlList[ ++n ] = xml;\r
 165                                                 };                              \r
 166                                         };\r
 167                                         break;\r
 168                                 // + TagName|*\r
 169                                 case 3 :\r
 170                                         for( ; i < l; ++i ){\r
 171                                                 for( xml = parents[ i ].nextSibling; xml; xml = xml.nextSibling ){\r
 172                                                         if( xml.nodeType === 1 ){\r
 173                                                                 if( isAll || tagName === xml.tagName ) xmlList[ ++n ] = xml;\r
 174                                                                 break;                                                          \r
 175                                                         };\r
 176                                                 };                                                              \r
 177                                         };\r
 178                                         break;\r
 179                                 // ~ TagName|*\r
 180                                 case 4 :\r
 181                                         merge = [];\r
 182                                         for( ; i < l; ++i ){\r
 183                                                 for( xml = parents[ i ].nextSibling; xml; xml = xml.nextSibling ){\r
 184                                                         if( xml.nodeType === 1 && ( isAll || tagName === xml.tagName ) ){\r
 185                                                                 if( merge.indexOf( xml ) !== -1 ){\r
 186                                                                         break;\r
 187                                                                 } else {\r
 188                                                                         merge[ merge.length ] = xml;\r
 189                                                                         xmlList[ ++n ] = xml;\r
 190                                                                 };\r
 191                                                         };                                                                      \r
 192                                                 };                                                              \r
 193                                         };\r
 194                                         break;\r
 195 \r
 196                                 // @ 属性ノード\r
 197                                 case 6 :\r
 198                                         selector = 0;\r
 199                                         tagName  = '*';\r
 200                                         for( ; i < l; ++i ){\r
 201                                                 if( xml = parents[ i ].getAttributeNode( name ) ){\r
 202                                                         xmlList[ ++n ] = xml;\r
 203                                                 };\r
 204                                         };\r
 205                                         break;\r
 206                                 default :\r
 207                                         if( combinator === 1 || ( isStart && selector < 7 ) ){\r
 208                                                 console.log( l + ' > ' + xmlList.length + ' tag:' + tagName );\r
 209                                                 for( ; i < l; ++i ){\r
 210                                                         xml = parents[ i ];\r
 211                                                         xml.childNodes && xml.childNodes.length && XMLWrapper_fetchElements( xmlList, xml, isAll ? null : tagName );\r
 212                                                 };\r
 213                                                 console.log( l + ' >> ' + xmlList.length + ' tag:' + tagName );\r
 214                                         };\r
 215                         };\r
 216                         \r
 217                         isStart = false;\r
 218                         \r
 219                         //alert( 'pre-selector:' + ( xmlList && xmlList.length ) )\r
 220                         \r
 221                         switch( selector ){\r
 222                                 // #, ID\r
 223                                 case 2 :\r
 224                                         filter = [ 'id', 1, name ]; break;\r
 225                                 // ., class\r
 226                                 case 3 :\r
 227                                         filter = [ 'class', 3 /*'~='*/, name ]; break;\r
 228                                 // :, 擬似クラス\r
 229                                 case 4 :\r
 230                                         if( !( filter = XMLWrapper_filter[ name ] ) ){\r
 231                                                 return XMLListWrapper_0;;\r
 232                                         };\r
 233                                         break;\r
 234                                 // [] 属性\r
 235                                 case 5 :\r
 236                                         filter = [ name, parsed[ 3 ], parsed[ 4 ] ]; break;\r
 237                                 // :not\r
 238                                 case 6 :\r
 239                                         isNot  = true;\r
 240                                         parsed = parsed[ 2 ];\r
 241                                         name   = parsed[ 2 ];\r
 242                                         switch( parsed[ 1 ] ) {\r
 243                                                 case 1 :\r
 244                                                         filter = [ 'tag', 1, name ]; break;\r
 245                                                 // #, ID\r
 246                                                 case 2 :\r
 247                                                         filter = [ 'id', 1, name ]; break;\r
 248                                                 // ., class\r
 249                                                 case 3 :\r
 250                                                         filter = [ 'class', 3, name ]; break;\r
 251                                                 // :, 擬似クラス\r
 252                                                 case 4 :\r
 253                                                         if( !( filter = X_Node_Selector__filter[ name ] ) ){\r
 254                                                                 return [];\r
 255                                                         };\r
 256                                                         break;\r
 257                                                 // [] 属性\r
 258                                                 case 5 :\r
 259                                                         filter = [ name, parsed[ 3 ], parsed[ 4 ] ]; break;\r
 260                                         };\r
 261                                         break;\r
 262                                 // scope\r
 263                                 case 7 :\r
 264                                         xmlList = scope; break;\r
 265                                 /* root\r
 266                                 case 8 :\r
 267                                         hasRoot = true;\r
 268                                         xmlList = [ HTML ]; break;\r
 269                                 // link\r
 270                                 case 9 :\r
 271                                         if( links = document.links ){\r
 272                                                 for( xmlList = [], i = links.length; i; ){\r
 273                                                         xmlList[ --i ] = new Node( links[ i ] );\r
 274                                                 };\r
 275                                         } else {\r
 276                                                 // area[href],a[href]\r
 277                                         }; */\r
 278                         };\r
 279                         \r
 280                         if( filter && xmlList.length ){\r
 281                                 // filter.mが関数の場合\r
 282                                 if( filter.m ){\r
 283                                         xmlList = filter.m(\r
 284                                                 {\r
 285                                                         not : isNot,\r
 286                                                         xml : isXML\r
 287                                                 },\r
 288                                                 xmlList,\r
 289                                                 parsed[ 3 ], parsed[ 4 ]\r
 290                                         );\r
 291                                 } else\r
 292                                 // filterが関数の場合\r
 293                                 if( X_Type_isFunction( filter ) ){\r
 294                                         tmp = [];\r
 295                                         for( i = 0, n = -1; xml = xmlList[ i ]; ++i ){\r
 296                                                 if( ( !!filter( xml ) ) ^ isNot ) tmp[ ++n ] = xml;     \r
 297                                         };\r
 298                                         xmlList = tmp;\r
 299                                 } else {\r
 300                                 // 属性セレクター                        \r
 301                                         tmp = [];\r
 302                                         key = filter[ 0 ];\r
 303                                         op  = filter[ 1 ];\r
 304                                         val = filter[ 2 ];\r
 305 \r
 306                                         // 通常\r
 307                                                 if( op === 3 ) val = _ + val + _;\r
 308 \r
 309                                                 for( i = 0, n = -1, l = xmlList.length; i < l; ++i ){\r
 310                                                         xml  = xmlList[ i ];\r
 311                                                         attr = elem.getAttribute( key, 2 );\r
 312                                                         flag = attr != null;// && ( !useName || attr !== '' );\r
 313                                                         if( flag && op ){\r
 314                                                                 //if( toLower ) attr = attr.toLowerCase();\r
 315                                                                 \r
 316                                                                 switch( op ){\r
 317                                                                         case 1: // =\r
 318                                                                                 flag = attr === val;\r
 319                                                                                 break;\r
 320                                                                         case 2: // !=\r
 321                                                                                 flag = attr !== val;\r
 322                                                                                 break;\r
 323                                                                         case 3: // ~=\r
 324                                                                                 flag = ( _ + attr + _ ).indexOf( val ) !== -1;\r
 325                                                                                 break;\r
 326                                                                         case 4: // ^=\r
 327                                                                                 flag = attr.indexOf( val ) === 0;\r
 328                                                                                 break;\r
 329                                                                         case 5: // $=\r
 330                                                                                 flag = attr.lastIndexOf( val ) + val.length === attr.length;\r
 331                                                                                 break;\r
 332                                                                         case 6: // *=\r
 333                                                                                 flag = attr.indexOf( val ) !== -1;\r
 334                                                                                 break;\r
 335                                                                         case 7: // |=\r
 336                                                                                 flag = attr === val || attr.substring( 0, val.length + 1 ) === val + '-';\r
 337                                                                                 break;\r
 338                                                                 };\r
 339                                                         };\r
 340                                                         if( !!flag ^ isNot ) tmp[ ++n ] = xml;\r
 341                                                 //};\r
 342                                         };\r
 343                                         xmlList = tmp;\r
 344                                 };\r
 345                         };\r
 346                         filter  = null;\r
 347                         isNot   = false;\r
 348                         parsed  = null;\r
 349                         \r
 350                         //console.log( '//end :' + ( xmlList && xmlList.length ) );\r
 351                 };\r
 352                 //console.log( 'multi:' + ( xmlList && xmlList.length ) );\r
 353                 \r
 354                 // tree 順に並び替え、同一要素の排除\r
 355                 if( isMulti ){\r
 356                         xmlList && xmlList.length && ARY_PUSH.apply( ret, xmlList );\r
 357                         l = ret.length;\r
 358                         if( l === 0 ) return XMLListWrapper_0;\r
 359                         if( l === 1 ) return new XMLWrapper( ret[ 0 ] );\r
 360                         \r
 361                         xmlList = [];\r
 362                         //merge   = [];\r
 363                         for( i = 0, n = -1; i < l; ++i ){\r
 364                                 //alert( 'multi:' + i )\r
 365                                 xml = ret[ i ];\r
 366                                 if( xmlList.indexOf( xml ) === -1 ){\r
 367                                         //merge[ merge.length ] = xml;\r
 368                                         xmlList[ ++n ] = xml;\r
 369                                 };\r
 370                         };\r
 371                         XMLWrapper_sortElementOrder( ret = [], xmlList, this._rawXML.childNodes );\r
 372                         \r
 373                         // @\r
 374                         for( i = 0, l = xmlList.length; i < l; ++i ){\r
 375                                 if( ret.indexOf( xml = xmlList[ i ] ) === -1 ){\r
 376                                         ret[ ret.length ] = xml;\r
 377                                 };\r
 378                         };\r
 379                         \r
 380                         xmlList = ret;\r
 381                 };\r
 382 \r
 383                 return xmlList.length === 1 ? new XMLWrapper( xmlList[ 0 ] ) : new XMLListWrapper( xmlList );\r
 384         };\r
 385 \r
 386         function XMLWrapper_sortElementOrder( newList, list, xmlList ){\r
 387                 var l = xmlList.length,\r
 388                         i = 0,\r
 389                         j, child, _xmlList;\r
 390                 for( ; i < l; ++i ){\r
 391                         child = xmlList[ i ];\r
 392                         //if( child.nodeType !== 1 ) continue;\r
 393                         //console.log( child.tagName );\r
 394                         if( ( j = list.indexOf( child ) ) !== -1 ){\r
 395                                 newList[ newList.length ] = child;\r
 396                                 list.splice( j, 1 );\r
 397                                 if( list.length === 1 ){\r
 398                                         newList[ newList.length ] = list[ 0 ];\r
 399                                         list.length = 0;\r
 400                                         return true;\r
 401                                 };\r
 402                                 if( list.length === 0 ) return true;\r
 403                         };\r
 404                         if( ( _xmlList = child.childNodes ) && XMLWrapper_sortElementOrder( newList, list, _xmlList ) ){\r
 405                                 return true;\r
 406                         };\r
 407                 };\r
 408         };\r
 409         \r
 410         function XMLWrapper_fetchElements( list, parent, tag ){\r
 411                 var xmlList = parent.childNodes,\r
 412                         l      = xmlList.length,\r
 413                         i      = 0,\r
 414                         child;\r
 415                 for( ; i < l; ++i ){\r
 416                         child = xmlList[ i ];\r
 417                         if( child.nodeType === 1 ){\r
 418                                 ( !tag || child.tagName === tag ) && ( list[ list.length ] = child );\r
 419                                 //console.log( parent.tagName + ' > ' + child.tagName + ' == ' + tag+ ' l:' + list.length );\r
 420                                 child.childNodes && child.childNodes.length && XMLWrapper_fetchElements( list, child, tag );\r
 421                         };\r
 422                 };\r
 423         };\r
 424 \r
 425         function XMLWrapper_funcSelectorChild( type, flag_all, flags, xmlList ){\r
 426                 var res      = [],\r
 427                         flag_not = flags.not,\r
 428                         i = 0, n = -1, xnode, node,\r
 429                         tagName, tmp;\r
 430                 for( ; xnode = xmlList[ i ]; ++i ){\r
 431                         tagName = flag_all || xnode.tagName;\r
 432                         tmp     = null;\r
 433                         if( /* tmp === null && */ type <= 0 ){\r
 434                                 for( node = xnode.previousSibling; node; node = node.previousSibling ){\r
 435                                         if( node.nodeType === 1 && ( flag_all || tagName === node.tagName ) ){\r
 436                                                 tmp = false;\r
 437                                                 break;\r
 438                                         };\r
 439                                 };\r
 440                         };\r
 441                         if( tmp === null && 0 <= type ){\r
 442                                 for( node = xnode.nextSibling; node; node = node.nextSibling ){\r
 443                                         if( node.nodeType === 1 && ( flag_all || tagName === node.tagName ) ){\r
 444                                                 tmp = false;\r
 445                                                 break;\r
 446                                         };              \r
 447                                 };                                              \r
 448                         };\r
 449                         if( tmp === null ) tmp = true;\r
 450                         if( tmp ^ flag_not ) res[ ++n ] = xnode;\r
 451                 };\r
 452                 return res;\r
 453         };\r
 454         function XMLWrapper_funcSelectorNth( pointer, sibling, flag_all, flags, xmlList, a, b ){\r
 455                 var res      = [],\r
 456                         checked  = {},\r
 457                         flag_not = flags.not,\r
 458                         i = 0, n = -1, uid,\r
 459                         c, xnode, tmp, node, tagName;\r
 460                 for( ; xnode = xmlList[ i ]; ++i ){\r
 461                         uid = xnode._uid;\r
 462                         tmp = checked[ uid ];\r
 463                         if( tmp === void 0 ){\r
 464                                 for( c = 0, node = xnode.parentNode[ pointer ], tagName = flag_all || xnode.tagName; node; node = node[ sibling ] ){\r
 465                                         if( node.nodeType === 1 && ( flag_all || tagName === node.tagName ) ){\r
 466                                                 ++c;\r
 467                                                 checked[ node._uid ] = a === 0 ? c === b : (c - b) % a === 0 && (c - b) / a >= 0;\r
 468                                         };                                                      \r
 469                                 };\r
 470                                 tmp = checked[ uid ];\r
 471                         };\r
 472                         if( tmp ^ flag_not ) res[ ++n ] = xnode;\r
 473                 };\r
 474                 return res;\r
 475         };\r
 476         function XMLWrapper_funcSelectorProp( prop, flag, flags, xmlList ){\r
 477                 var res = [],\r
 478                         flag_not = flag ? flags.not : !flags.not,\r
 479                         i = 0, n = -1, xnode;\r
 480                 for( ; xnode = xmlList[ i ]; ++i ){\r
 481                         if( xnode.getAttributeNode( prop ) ^ flag_not ) res[ ++n ] = xnode;\r
 482                 };\r
 483                 return res;\r
 484         };\r
 485 \r
 486 var XMLWrapper_filter = {\r
 487         'first-child' : {\r
 488                 m : function( flags, xmlList ){ return XMLWrapper_funcSelectorChild( -1, true, flags, xmlList ); }\r
 489         },\r
 490         'last-child' : {\r
 491                 m : function( flags, xmlList ){ return XMLWrapper_funcSelectorChild( 1, true, flags, xmlList ); }\r
 492         },\r
 493         'only-child' : {\r
 494                 m : function( flags, xmlList ){ return XMLWrapper_funcSelectorChild( 0, true, flags, xmlList ); }\r
 495         },\r
 496         'first-of-type' : {\r
 497                 m : function( flags, xmlList ){ return XMLWrapper_funcSelectorChild( -1, false, flags, xmlList ); }\r
 498         },\r
 499         'last-of-type' : {\r
 500                 m : function( flags, xmlList ){ return XMLWrapper_funcSelectorChild( 1, false, flags, xmlList ); }\r
 501         },\r
 502         'only-of-type' : {\r
 503                 m : function( flags, xmlList ){ return XMLWrapper_funcSelectorChild( 0, false, flags, xmlList ); }\r
 504         },\r
 505         'nth-child' : {\r
 506                 m : function( flags, xmlList, a, b ){ return XMLWrapper_funcSelectorNth( 'firstChild', 'nextSibling', true, flags, xmlList, a, b ); }\r
 507         },\r
 508         'nth-last-child' : {\r
 509                 m : function( flags, xmlList, a, b ){ return XMLWrapper_funcSelectorNth( 'lastChild', 'previousSibling', true, flags, xmlList, a, b ); }\r
 510         },\r
 511         'nth-of-type' : {\r
 512                 m : function( flags, xmlList, a, b ){ return XMLWrapper_funcSelectorNth( 'firstChild', 'nextSibling', false, flags, xmlList, a, b ); }\r
 513         },\r
 514         'nth-last-of-type' : {\r
 515                 m : function( flags, xmlList, a, b ){ return XMLWrapper_funcSelectorNth( 'lastChild', 'previousSibling', false, flags, xmlList, a, b ); }\r
 516         },\r
 517         empty : {\r
 518                 m : function( flags, xmlList ){\r
 519                         var res = [],\r
 520                                 flag_not = flags.not,\r
 521                                 i = 0, n = -1, xnode, tmp, node;\r
 522                         for( ; xnode = xmlList[i]; ++i ){\r
 523                                 tmp = true;\r
 524                                 for( node = xnode.firstChild; node; node = node.nextSibling ){\r
 525                                         if( node.nodeType === 1 || ( node.nodeType === 3 && node._text ) ){\r
 526                                                 tmp = false;\r
 527                                                 break;\r
 528                                         };                              \r
 529                                 };\r
 530                                 if( tmp ^ flag_not ) res[ ++n ] = xnode;\r
 531                         };\r
 532                         return res;\r
 533                 }\r
 534         },\r
 535         contains : {\r
 536                 m : function( flags, xmlList, arg ){\r
 537                         var res = [],\r
 538                                 flag_not = flags.not,\r
 539                                 i = 0, n = -1, xnode, text = '',\r
 540                                 // kquery\r
 541                                 attr_textContent = X_UA[ 'IE' ] < 9 || X_UA[ 'Opera' ] ? 'innerText' : X_UA[ 'IE9' ] ? 'text' : 'textContent';\r
 542                         for( ; xnode = xmlList[ i ]; ++i ){\r
 543                                 switch( xnode.nodeType ){\r
 544                                         case 1 :\r
 545                                                 text = xml.nodeType === 1 ? xml.innerText || xml.text || xml.textContent : xml.nodeValue;// xnode[ attr_textContent ];\r
 546                                                 break;\r
 547                                         case 2 :\r
 548                                         case 3 :\r
 549                                                 text = xnode.nodeValue;\r
 550                                                 break;\r
 551                                 };\r
 552                                 console.log( text + ' ' + arg );\r
 553                                 if ( ( -1 < text.indexOf( arg ) ) ^ flag_not ) res[ ++n ] = xnode;                                              \r
 554                         };\r
 555                         return res;\r
 556                 }\r
 557         }\r
 558 };\r
 559 \r
 560 function XMLListWrapper( xmlList ){\r
 561         var i = 0, l = xmlList ? xmlList.length : 0;\r
 562         for( ; i < l; ++i ){\r
 563                 this[ i ] = xmlList[ i ];\r
 564         };\r
 565         this.length = l;\r
 566 };\r
 567 \r
 568 var XMLListWrapper_0 = new XMLListWrapper();\r
 569 \r
 570 XMLListWrapper.prototype.length    = 0;\r
 571 XMLListWrapper.prototype._wraps    = null;\r
 572 XMLListWrapper.prototype[ 'has' ]  = XMLWrapper_has;\r
 573 XMLListWrapper.prototype[ 'get' ]  = XMLWrapper_get;\r
 574 XMLListWrapper.prototype[ 'val' ]  = XMLWrapper_val;\r
 575 XMLListWrapper.prototype[ 'find' ] = XMLWrapper_find;\r