| OLD | NEW | 
|---|
|  | (Empty) | 
| 1 /* |  | 
| 2  * This file is part of Adblock Plus <https://adblockplus.org/>, |  | 
| 3  * Copyright (C) 2006-2016 Eyeo GmbH |  | 
| 4  * |  | 
| 5  * Adblock Plus is free software: you can redistribute it and/or modify |  | 
| 6  * it under the terms of the GNU General Public License version 3 as |  | 
| 7  * published by the Free Software Foundation. |  | 
| 8  * |  | 
| 9  * Adblock Plus is distributed in the hope that it will be useful, |  | 
| 10  * but WITHOUT ANY WARRANTY; without even the implied warranty of |  | 
| 11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the |  | 
| 12  * GNU General Public License for more details. |  | 
| 13  * |  | 
| 14  * You should have received a copy of the GNU General Public License |  | 
| 15  * along with Adblock Plus.  If not, see <http://www.gnu.org/licenses/>. |  | 
| 16  */ |  | 
| 17 |  | 
| 18 // |  | 
| 19 // This file has been generated automatically, relevant repositories: |  | 
| 20 // * https://hg.adblockplus.org/adblockplus/ |  | 
| 21 // * https://hg.adblockplus.org/jshydra/ |  | 
| 22 // |  | 
| 23 |  | 
| 24 function Filter(text) |  | 
| 25 { |  | 
| 26   this.text = text; |  | 
| 27   this.subscriptions = []; |  | 
| 28 } |  | 
| 29 exports.Filter = Filter; |  | 
| 30 Filter.prototype = { |  | 
| 31   text: null, |  | 
| 32   subscriptions: null, |  | 
| 33   get type() |  | 
| 34   { |  | 
| 35     throw new Error("Please define filter type in the subclass"); |  | 
| 36   }, |  | 
| 37   serialize: function(buffer) |  | 
| 38   { |  | 
| 39     buffer.push("[Filter]"); |  | 
| 40     buffer.push("text=" + this.text); |  | 
| 41   }, |  | 
| 42   toString: function() |  | 
| 43   { |  | 
| 44     return this.text; |  | 
| 45   } |  | 
| 46 }; |  | 
| 47 Filter.knownFilters = Object.create(null); |  | 
| 48 Filter.elemhideRegExp = /^([^\/\*\|\@"!]*?)#(\@)?(?:([\w\-]+|\*)((?:\([\w\-]+(?:
     [$^*]?=[^\(\)"]*)?\))*)|#([^{}]+))$/; |  | 
| 49 Filter.regexpRegExp = /^(@@)?\/.*\/(?:\$~?[\w\-]+(?:=[^,\s]+)?(?:,~?[\w\-]+(?:=[
     ^,\s]+)?)*)?$/; |  | 
| 50 Filter.optionsRegExp = /\$(~?[\w\-]+(?:=[^,\s]+)?(?:,~?[\w\-]+(?:=[^,\s]+)?)*)$/
     ; |  | 
| 51 Filter.csspropertyRegExp = /\[\-abp\-properties=(["'])([^"']+)\1\]/; |  | 
| 52 Filter.fromText = function(text) |  | 
| 53 { |  | 
| 54   if (text in Filter.knownFilters) |  | 
| 55   { |  | 
| 56     return Filter.knownFilters[text]; |  | 
| 57   } |  | 
| 58   var ret; |  | 
| 59   var match = text.indexOf("#") >= 0 ? Filter.elemhideRegExp.exec(text) : null; |  | 
| 60   if (match) |  | 
| 61   { |  | 
| 62     ret = ElemHideBase.fromText(text, match[1], !!match[2], match[3], match[4], 
     match[5]); |  | 
| 63   } |  | 
| 64   else if (text[0] == "!") |  | 
| 65   { |  | 
| 66     ret = new CommentFilter(text); |  | 
| 67   } |  | 
| 68   else |  | 
| 69   { |  | 
| 70     ret = RegExpFilter.fromText(text); |  | 
| 71   } |  | 
| 72   Filter.knownFilters[ret.text] = ret; |  | 
| 73   return ret; |  | 
| 74 }; |  | 
| 75 Filter.fromObject = function(obj) |  | 
| 76 { |  | 
| 77   var ret = Filter.fromText(obj.text); |  | 
| 78   if (ret instanceof ActiveFilter) |  | 
| 79   { |  | 
| 80     if ("disabled" in obj) |  | 
| 81     { |  | 
| 82       ret._disabled = obj.disabled == "true"; |  | 
| 83     } |  | 
| 84     if ("hitCount" in obj) |  | 
| 85     { |  | 
| 86       ret._hitCount = parseInt(obj.hitCount) || 0; |  | 
| 87     } |  | 
| 88     if ("lastHit" in obj) |  | 
| 89     { |  | 
| 90       ret._lastHit = parseInt(obj.lastHit) || 0; |  | 
| 91     } |  | 
| 92   } |  | 
| 93   return ret; |  | 
| 94 }; |  | 
| 95 Filter.normalize = function(text) |  | 
| 96 { |  | 
| 97   if (!text) |  | 
| 98   { |  | 
| 99     return text; |  | 
| 100   } |  | 
| 101   text = text.replace(/[^\S ]/g, ""); |  | 
| 102   if (/^\s*!/.test(text)) |  | 
| 103   { |  | 
| 104     return text.trim(); |  | 
| 105   } |  | 
| 106   else if (Filter.elemhideRegExp.test(text)) |  | 
| 107   { |  | 
| 108     var _tempVar0 = /^(.*?)(#\@?#?)(.*)$/.exec(text); |  | 
| 109     var domain = _tempVar0[1]; |  | 
| 110     var separator = _tempVar0[2]; |  | 
| 111     var selector = _tempVar0[3]; |  | 
| 112     return domain.replace(/\s/g, "") + separator + selector.trim(); |  | 
| 113   } |  | 
| 114   else |  | 
| 115   { |  | 
| 116     return text.replace(/\s/g, ""); |  | 
| 117   } |  | 
| 118 }; |  | 
| 119 Filter.toRegExp = function(text) |  | 
| 120 { |  | 
| 121   return text.replace(/\*+/g, "*").replace(/\^\|$/, "^").replace(/\W/g, "\\$&").
     replace(/\\\*/g, ".*").replace(/\\\^/g, "(?:[\\x00-\\x24\\x26-\\x2C\\x2F\\x3A-\\
     x40\\x5B-\\x5E\\x60\\x7B-\\x7F]|$)").replace(/^\\\|\\\|/, "^[\\w\\-]+:\\/+(?!\\/
     )(?:[^\\/]+\\.)?").replace(/^\\\|/, "^").replace(/\\\|$/, "$").replace(/^(\.\*)/
     , "").replace(/(\.\*)$/, ""); |  | 
| 122 }; |  | 
| 123 |  | 
| 124 function InvalidFilter(text, reason) |  | 
| 125 { |  | 
| 126   Filter.call(this, text); |  | 
| 127   this.reason = reason; |  | 
| 128 } |  | 
| 129 exports.InvalidFilter = InvalidFilter; |  | 
| 130 InvalidFilter.prototype = { |  | 
| 131   __proto__: Filter.prototype, |  | 
| 132   type: "invalid", |  | 
| 133   reason: null, |  | 
| 134   serialize: function(buffer) |  | 
| 135   {} |  | 
| 136 }; |  | 
| 137 |  | 
| 138 function CommentFilter(text) |  | 
| 139 { |  | 
| 140   Filter.call(this, text); |  | 
| 141 } |  | 
| 142 exports.CommentFilter = CommentFilter; |  | 
| 143 CommentFilter.prototype = { |  | 
| 144   __proto__: Filter.prototype, |  | 
| 145   type: "comment", |  | 
| 146   serialize: function(buffer) |  | 
| 147   {} |  | 
| 148 }; |  | 
| 149 |  | 
| 150 function ActiveFilter(text, domains) |  | 
| 151 { |  | 
| 152   Filter.call(this, text); |  | 
| 153   this.domainSource = domains; |  | 
| 154 } |  | 
| 155 exports.ActiveFilter = ActiveFilter; |  | 
| 156 ActiveFilter.prototype = { |  | 
| 157   __proto__: Filter.prototype, |  | 
| 158   _disabled: false, |  | 
| 159   _hitCount: 0, |  | 
| 160   _lastHit: 0, |  | 
| 161   get disabled() |  | 
| 162   { |  | 
| 163     return this._disabled; |  | 
| 164   }, |  | 
| 165   set disabled(value) |  | 
| 166   { |  | 
| 167     if (value != this._disabled) |  | 
| 168     { |  | 
| 169       var oldValue = this._disabled; |  | 
| 170       this._disabled = value; |  | 
| 171     } |  | 
| 172     return this._disabled; |  | 
| 173   }, |  | 
| 174   get hitCount() |  | 
| 175   { |  | 
| 176     return this._hitCount; |  | 
| 177   }, |  | 
| 178   set hitCount(value) |  | 
| 179   { |  | 
| 180     if (value != this._hitCount) |  | 
| 181     { |  | 
| 182       var oldValue = this._hitCount; |  | 
| 183       this._hitCount = value; |  | 
| 184     } |  | 
| 185     return this._hitCount; |  | 
| 186   }, |  | 
| 187   get lastHit() |  | 
| 188   { |  | 
| 189     return this._lastHit; |  | 
| 190   }, |  | 
| 191   set lastHit(value) |  | 
| 192   { |  | 
| 193     if (value != this._lastHit) |  | 
| 194     { |  | 
| 195       var oldValue = this._lastHit; |  | 
| 196       this._lastHit = value; |  | 
| 197     } |  | 
| 198     return this._lastHit; |  | 
| 199   }, |  | 
| 200   domainSource: null, |  | 
| 201   domainSeparator: null, |  | 
| 202   ignoreTrailingDot: true, |  | 
| 203   domainSourceIsUpperCase: false, |  | 
| 204   get domains() |  | 
| 205   { |  | 
| 206     var prop = Object.getOwnPropertyDescriptor(this, "domains"); |  | 
| 207     if (prop) |  | 
| 208     { |  | 
| 209       return prop.value; |  | 
| 210     } |  | 
| 211     var domains = null; |  | 
| 212     if (this.domainSource) |  | 
| 213     { |  | 
| 214       var source = this.domainSource; |  | 
| 215       if (!this.domainSourceIsUpperCase) |  | 
| 216       { |  | 
| 217         source = source.toUpperCase(); |  | 
| 218       } |  | 
| 219       var list = source.split(this.domainSeparator); |  | 
| 220       if (list.length == 1 && list[0][0] != "~") |  | 
| 221       { |  | 
| 222         domains = { |  | 
| 223           __proto__: null, |  | 
| 224           "": false |  | 
| 225         }; |  | 
| 226         if (this.ignoreTrailingDot) |  | 
| 227         { |  | 
| 228           list[0] = list[0].replace(/\.+$/, ""); |  | 
| 229         } |  | 
| 230         domains[list[0]] = true; |  | 
| 231       } |  | 
| 232       else |  | 
| 233       { |  | 
| 234         var hasIncludes = false; |  | 
| 235         for (var i = 0; i < list.length; i++) |  | 
| 236         { |  | 
| 237           var domain = list[i]; |  | 
| 238           if (this.ignoreTrailingDot) |  | 
| 239           { |  | 
| 240             domain = domain.replace(/\.+$/, ""); |  | 
| 241           } |  | 
| 242           if (domain == "") |  | 
| 243           { |  | 
| 244             continue; |  | 
| 245           } |  | 
| 246           var include; |  | 
| 247           if (domain[0] == "~") |  | 
| 248           { |  | 
| 249             include = false; |  | 
| 250             domain = domain.substr(1); |  | 
| 251           } |  | 
| 252           else |  | 
| 253           { |  | 
| 254             include = true; |  | 
| 255             hasIncludes = true; |  | 
| 256           } |  | 
| 257           if (!domains) |  | 
| 258           { |  | 
| 259             domains = Object.create(null); |  | 
| 260           } |  | 
| 261           domains[domain] = include; |  | 
| 262         } |  | 
| 263         domains[""] = !hasIncludes; |  | 
| 264       } |  | 
| 265       this.domainSource = null; |  | 
| 266     } |  | 
| 267     Object.defineProperty(this, "domains", |  | 
| 268     { |  | 
| 269       value: domains, |  | 
| 270       enumerable: true |  | 
| 271     }); |  | 
| 272     return this.domains; |  | 
| 273   }, |  | 
| 274   sitekeys: null, |  | 
| 275   isActiveOnDomain: function(docDomain, sitekey) |  | 
| 276   { |  | 
| 277     if (this.sitekeys && (!sitekey || this.sitekeys.indexOf(sitekey.toUpperCase(
     )) < 0)) |  | 
| 278     { |  | 
| 279       return false; |  | 
| 280     } |  | 
| 281     if (!this.domains) |  | 
| 282     { |  | 
| 283       return true; |  | 
| 284     } |  | 
| 285     if (!docDomain) |  | 
| 286     { |  | 
| 287       return this.domains[""]; |  | 
| 288     } |  | 
| 289     if (this.ignoreTrailingDot) |  | 
| 290     { |  | 
| 291       docDomain = docDomain.replace(/\.+$/, ""); |  | 
| 292     } |  | 
| 293     docDomain = docDomain.toUpperCase(); |  | 
| 294     while (true) |  | 
| 295     { |  | 
| 296       if (docDomain in this.domains) |  | 
| 297       { |  | 
| 298         return this.domains[docDomain]; |  | 
| 299       } |  | 
| 300       var nextDot = docDomain.indexOf("."); |  | 
| 301       if (nextDot < 0) |  | 
| 302       { |  | 
| 303         break; |  | 
| 304       } |  | 
| 305       docDomain = docDomain.substr(nextDot + 1); |  | 
| 306     } |  | 
| 307     return this.domains[""]; |  | 
| 308   }, |  | 
| 309   isActiveOnlyOnDomain: function(docDomain) |  | 
| 310   { |  | 
| 311     if (!docDomain || !this.domains || this.domains[""]) |  | 
| 312     { |  | 
| 313       return false; |  | 
| 314     } |  | 
| 315     if (this.ignoreTrailingDot) |  | 
| 316     { |  | 
| 317       docDomain = docDomain.replace(/\.+$/, ""); |  | 
| 318     } |  | 
| 319     docDomain = docDomain.toUpperCase(); |  | 
| 320     for (var domain in this.domains) |  | 
| 321     { |  | 
| 322       if (this.domains[domain] && domain != docDomain && (domain.length <= docDo
     main.length || domain.indexOf("." + docDomain) != domain.length - docDomain.leng
     th - 1)) |  | 
| 323       { |  | 
| 324         return false; |  | 
| 325       } |  | 
| 326     } |  | 
| 327     return true; |  | 
| 328   }, |  | 
| 329   isGeneric: function() |  | 
| 330   { |  | 
| 331     return !(this.sitekeys && this.sitekeys.length) && (!this.domains || this.do
     mains[""]); |  | 
| 332   }, |  | 
| 333   serialize: function(buffer) |  | 
| 334   { |  | 
| 335     if (this._disabled || this._hitCount || this._lastHit) |  | 
| 336     { |  | 
| 337       Filter.prototype.serialize.call(this, buffer); |  | 
| 338       if (this._disabled) |  | 
| 339       { |  | 
| 340         buffer.push("disabled=true"); |  | 
| 341       } |  | 
| 342       if (this._hitCount) |  | 
| 343       { |  | 
| 344         buffer.push("hitCount=" + this._hitCount); |  | 
| 345       } |  | 
| 346       if (this._lastHit) |  | 
| 347       { |  | 
| 348         buffer.push("lastHit=" + this._lastHit); |  | 
| 349       } |  | 
| 350     } |  | 
| 351   } |  | 
| 352 }; |  | 
| 353 |  | 
| 354 function RegExpFilter(text, regexpSource, contentType, matchCase, domains, third
     Party, sitekeys) |  | 
| 355 { |  | 
| 356   ActiveFilter.call(this, text, domains, sitekeys); |  | 
| 357   if (contentType != null) |  | 
| 358   { |  | 
| 359     this.contentType = contentType; |  | 
| 360   } |  | 
| 361   if (matchCase) |  | 
| 362   { |  | 
| 363     this.matchCase = matchCase; |  | 
| 364   } |  | 
| 365   if (thirdParty != null) |  | 
| 366   { |  | 
| 367     this.thirdParty = thirdParty; |  | 
| 368   } |  | 
| 369   if (sitekeys != null) |  | 
| 370   { |  | 
| 371     this.sitekeySource = sitekeys; |  | 
| 372   } |  | 
| 373   if (regexpSource.length >= 2 && regexpSource[0] == "/" && regexpSource[regexpS
     ource.length - 1] == "/") |  | 
| 374   { |  | 
| 375     var regexp = new RegExp(regexpSource.substr(1, regexpSource.length - 2), thi
     s.matchCase ? "" : "i"); |  | 
| 376     Object.defineProperty(this, "regexp", |  | 
| 377     { |  | 
| 378       value: regexp |  | 
| 379     }); |  | 
| 380   } |  | 
| 381   else |  | 
| 382   { |  | 
| 383     this.regexpSource = regexpSource; |  | 
| 384   } |  | 
| 385 } |  | 
| 386 exports.RegExpFilter = RegExpFilter; |  | 
| 387 RegExpFilter.prototype = { |  | 
| 388   __proto__: ActiveFilter.prototype, |  | 
| 389   domainSourceIsUpperCase: true, |  | 
| 390   length: 1, |  | 
| 391   domainSeparator: "|", |  | 
| 392   regexpSource: null, |  | 
| 393   get regexp() |  | 
| 394   { |  | 
| 395     var prop = Object.getOwnPropertyDescriptor(this, "regexp"); |  | 
| 396     if (prop) |  | 
| 397     { |  | 
| 398       return prop.value; |  | 
| 399     } |  | 
| 400     var source = Filter.toRegExp(this.regexpSource); |  | 
| 401     var regexp = new RegExp(source, this.matchCase ? "" : "i"); |  | 
| 402     Object.defineProperty(this, "regexp", |  | 
| 403     { |  | 
| 404       value: regexp |  | 
| 405     }); |  | 
| 406     return regexp; |  | 
| 407   }, |  | 
| 408   contentType: 2147483647, |  | 
| 409   matchCase: false, |  | 
| 410   thirdParty: null, |  | 
| 411   sitekeySource: null, |  | 
| 412   get sitekeys() |  | 
| 413   { |  | 
| 414     var prop = Object.getOwnPropertyDescriptor(this, "sitekeys"); |  | 
| 415     if (prop) |  | 
| 416     { |  | 
| 417       return prop.value; |  | 
| 418     } |  | 
| 419     var sitekeys = null; |  | 
| 420     if (this.sitekeySource) |  | 
| 421     { |  | 
| 422       sitekeys = this.sitekeySource.split("|"); |  | 
| 423       this.sitekeySource = null; |  | 
| 424     } |  | 
| 425     Object.defineProperty(this, "sitekeys", |  | 
| 426     { |  | 
| 427       value: sitekeys, |  | 
| 428       enumerable: true |  | 
| 429     }); |  | 
| 430     return this.sitekeys; |  | 
| 431   }, |  | 
| 432   matches: function(location, typeMask, docDomain, thirdParty, sitekey) |  | 
| 433   { |  | 
| 434     if (this.contentType & typeMask && (this.thirdParty == null || this.thirdPar
     ty == thirdParty) && this.isActiveOnDomain(docDomain, sitekey) && this.regexp.te
     st(location)) |  | 
| 435     { |  | 
| 436       return true; |  | 
| 437     } |  | 
| 438     return false; |  | 
| 439   } |  | 
| 440 }; |  | 
| 441 Object.defineProperty(RegExpFilter.prototype, "0", |  | 
| 442 { |  | 
| 443   get: function() |  | 
| 444   { |  | 
| 445     return this; |  | 
| 446   } |  | 
| 447 }); |  | 
| 448 RegExpFilter.fromText = function(text) |  | 
| 449 { |  | 
| 450   var blocking = true; |  | 
| 451   var origText = text; |  | 
| 452   if (text.indexOf("@@") == 0) |  | 
| 453   { |  | 
| 454     blocking = false; |  | 
| 455     text = text.substr(2); |  | 
| 456   } |  | 
| 457   var contentType = null; |  | 
| 458   var matchCase = null; |  | 
| 459   var domains = null; |  | 
| 460   var sitekeys = null; |  | 
| 461   var thirdParty = null; |  | 
| 462   var collapse = null; |  | 
| 463   var options; |  | 
| 464   var match = text.indexOf("$") >= 0 ? Filter.optionsRegExp.exec(text) : null; |  | 
| 465   if (match) |  | 
| 466   { |  | 
| 467     options = match[1].toUpperCase().split(","); |  | 
| 468     text = match.input.substr(0, match.index); |  | 
| 469     for (var _loopIndex1 = 0; _loopIndex1 < options.length; ++_loopIndex1) |  | 
| 470     { |  | 
| 471       var option = options[_loopIndex1]; |  | 
| 472       var value = null; |  | 
| 473       var separatorIndex = option.indexOf("="); |  | 
| 474       if (separatorIndex >= 0) |  | 
| 475       { |  | 
| 476         value = option.substr(separatorIndex + 1); |  | 
| 477         option = option.substr(0, separatorIndex); |  | 
| 478       } |  | 
| 479       option = option.replace(/-/, "_"); |  | 
| 480       if (option in RegExpFilter.typeMap) |  | 
| 481       { |  | 
| 482         if (contentType == null) |  | 
| 483         { |  | 
| 484           contentType = 0; |  | 
| 485         } |  | 
| 486         contentType |= RegExpFilter.typeMap[option]; |  | 
| 487       } |  | 
| 488       else if (option[0] == "~" && option.substr(1) in RegExpFilter.typeMap) |  | 
| 489       { |  | 
| 490         if (contentType == null) |  | 
| 491         { |  | 
| 492           contentType = RegExpFilter.prototype.contentType; |  | 
| 493         } |  | 
| 494         contentType &= ~RegExpFilter.typeMap[option.substr(1)]; |  | 
| 495       } |  | 
| 496       else if (option == "MATCH_CASE") |  | 
| 497       { |  | 
| 498         matchCase = true; |  | 
| 499       } |  | 
| 500       else if (option == "~MATCH_CASE") |  | 
| 501       { |  | 
| 502         matchCase = false; |  | 
| 503       } |  | 
| 504       else if (option == "DOMAIN" && typeof value != "undefined") |  | 
| 505       { |  | 
| 506         domains = value; |  | 
| 507       } |  | 
| 508       else if (option == "THIRD_PARTY") |  | 
| 509       { |  | 
| 510         thirdParty = true; |  | 
| 511       } |  | 
| 512       else if (option == "~THIRD_PARTY") |  | 
| 513       { |  | 
| 514         thirdParty = false; |  | 
| 515       } |  | 
| 516       else if (option == "COLLAPSE") |  | 
| 517       { |  | 
| 518         collapse = true; |  | 
| 519       } |  | 
| 520       else if (option == "~COLLAPSE") |  | 
| 521       { |  | 
| 522         collapse = false; |  | 
| 523       } |  | 
| 524       else if (option == "SITEKEY" && typeof value != "undefined") |  | 
| 525       { |  | 
| 526         sitekeys = value; |  | 
| 527       } |  | 
| 528       else |  | 
| 529       { |  | 
| 530         return new InvalidFilter(origText, "Unknown option " + option.toLowerCas
     e()); |  | 
| 531       } |  | 
| 532     } |  | 
| 533   } |  | 
| 534   try |  | 
| 535   { |  | 
| 536     if (blocking) |  | 
| 537     { |  | 
| 538       return new BlockingFilter(origText, text, contentType, matchCase, domains,
      thirdParty, sitekeys, collapse); |  | 
| 539     } |  | 
| 540     else |  | 
| 541     { |  | 
| 542       return new WhitelistFilter(origText, text, contentType, matchCase, domains
     , thirdParty, sitekeys); |  | 
| 543     } |  | 
| 544   } |  | 
| 545   catch (e) |  | 
| 546   { |  | 
| 547     return new InvalidFilter(origText, e); |  | 
| 548   } |  | 
| 549 }; |  | 
| 550 RegExpFilter.typeMap = { |  | 
| 551   OTHER: 1, |  | 
| 552   SCRIPT: 2, |  | 
| 553   IMAGE: 4, |  | 
| 554   STYLESHEET: 8, |  | 
| 555   OBJECT: 16, |  | 
| 556   SUBDOCUMENT: 32, |  | 
| 557   DOCUMENT: 64, |  | 
| 558   XBL: 1, |  | 
| 559   PING: 1024, |  | 
| 560   XMLHTTPREQUEST: 2048, |  | 
| 561   OBJECT_SUBREQUEST: 4096, |  | 
| 562   DTD: 1, |  | 
| 563   MEDIA: 16384, |  | 
| 564   FONT: 32768, |  | 
| 565   BACKGROUND: 4, |  | 
| 566   POPUP: 268435456, |  | 
| 567   GENERICBLOCK: 536870912, |  | 
| 568   ELEMHIDE: 1073741824, |  | 
| 569   GENERICHIDE: 2147483648 |  | 
| 570 }; |  | 
| 571 RegExpFilter.prototype.contentType &= ~ (RegExpFilter.typeMap.DOCUMENT | RegExpF
     ilter.typeMap.ELEMHIDE | RegExpFilter.typeMap.POPUP | RegExpFilter.typeMap.GENER
     ICHIDE | RegExpFilter.typeMap.GENERICBLOCK); |  | 
| 572 |  | 
| 573 function BlockingFilter(text, regexpSource, contentType, matchCase, domains, thi
     rdParty, sitekeys, collapse) |  | 
| 574 { |  | 
| 575   RegExpFilter.call(this, text, regexpSource, contentType, matchCase, domains, t
     hirdParty, sitekeys); |  | 
| 576   this.collapse = collapse; |  | 
| 577 } |  | 
| 578 exports.BlockingFilter = BlockingFilter; |  | 
| 579 BlockingFilter.prototype = { |  | 
| 580   __proto__: RegExpFilter.prototype, |  | 
| 581   type: "blocking", |  | 
| 582   collapse: null |  | 
| 583 }; |  | 
| 584 |  | 
| 585 function WhitelistFilter(text, regexpSource, contentType, matchCase, domains, th
     irdParty, sitekeys) |  | 
| 586 { |  | 
| 587   RegExpFilter.call(this, text, regexpSource, contentType, matchCase, domains, t
     hirdParty, sitekeys); |  | 
| 588 } |  | 
| 589 exports.WhitelistFilter = WhitelistFilter; |  | 
| 590 WhitelistFilter.prototype = { |  | 
| 591   __proto__: RegExpFilter.prototype, |  | 
| 592   type: "whitelist" |  | 
| 593 }; |  | 
| 594 |  | 
| 595 function ElemHideBase(text, domains, selector) |  | 
| 596 { |  | 
| 597   ActiveFilter.call(this, text, domains || null); |  | 
| 598   if (domains) |  | 
| 599   { |  | 
| 600     this.selectorDomain = domains.replace(/,~[^,]+/g, "").replace(/^~[^,]+,?/, "
     ").toLowerCase(); |  | 
| 601   } |  | 
| 602   this.selector = selector; |  | 
| 603 } |  | 
| 604 exports.ElemHideBase = ElemHideBase; |  | 
| 605 ElemHideBase.prototype = { |  | 
| 606   __proto__: ActiveFilter.prototype, |  | 
| 607   domainSeparator: ",", |  | 
| 608   ignoreTrailingDot: false, |  | 
| 609   selectorDomain: null, |  | 
| 610   selector: null |  | 
| 611 }; |  | 
| 612 ElemHideBase.fromText = function(text, domain, isException, tagName, attrRules, 
     selector) |  | 
| 613 { |  | 
| 614   if (!selector) |  | 
| 615   { |  | 
| 616     if (tagName == "*") |  | 
| 617     { |  | 
| 618       tagName = ""; |  | 
| 619     } |  | 
| 620     var id = null; |  | 
| 621     var additional = ""; |  | 
| 622     if (attrRules) |  | 
| 623     { |  | 
| 624       attrRules = attrRules.match(/\([\w\-]+(?:[$^*]?=[^\(\)"]*)?\)/g); |  | 
| 625       for (var _loopIndex2 = 0; _loopIndex2 < attrRules.length; ++_loopIndex2) |  | 
| 626       { |  | 
| 627         var rule = attrRules[_loopIndex2]; |  | 
| 628         rule = rule.substr(1, rule.length - 2); |  | 
| 629         var separatorPos = rule.indexOf("="); |  | 
| 630         if (separatorPos > 0) |  | 
| 631         { |  | 
| 632           rule = rule.replace(/=/, "=\"") + "\""; |  | 
| 633           additional += "[" + rule + "]"; |  | 
| 634         } |  | 
| 635         else |  | 
| 636         { |  | 
| 637           if (id) |  | 
| 638           { |  | 
| 639             return new InvalidFilter(text); |  | 
| 640           } |  | 
| 641           id = rule; |  | 
| 642         } |  | 
| 643       } |  | 
| 644     } |  | 
| 645     if (id) |  | 
| 646     { |  | 
| 647       selector = tagName + "." + id + additional + "," + tagName + "#" + id + ad
     ditional; |  | 
| 648     } |  | 
| 649     else if (tagName || additional) |  | 
| 650     { |  | 
| 651       selector = tagName + additional; |  | 
| 652     } |  | 
| 653     else |  | 
| 654     { |  | 
| 655       return new InvalidFilter(text); |  | 
| 656     } |  | 
| 657   } |  | 
| 658   if (isException) |  | 
| 659   { |  | 
| 660     return new ElemHideException(text, domain, selector); |  | 
| 661   } |  | 
| 662   var match = Filter.csspropertyRegExp.exec(selector); |  | 
| 663   if (match) |  | 
| 664   { |  | 
| 665     if (!/,[^~][^,.]*\.[^,]/.test("," + domain)) |  | 
| 666     { |  | 
| 667       return new InvalidFilter(text); |  | 
| 668     } |  | 
| 669     return new CSSPropertyFilter(text, domain, selector, match[2], selector.subs
     tr(0, match.index), selector.substr(match.index + match[0].length)); |  | 
| 670   } |  | 
| 671   return new ElemHideFilter(text, domain, selector); |  | 
| 672 }; |  | 
| 673 |  | 
| 674 function ElemHideFilter(text, domains, selector) |  | 
| 675 { |  | 
| 676   ElemHideBase.call(this, text, domains, selector); |  | 
| 677 } |  | 
| 678 exports.ElemHideFilter = ElemHideFilter; |  | 
| 679 ElemHideFilter.prototype = { |  | 
| 680   __proto__: ElemHideBase.prototype, |  | 
| 681   type: "elemhide" |  | 
| 682 }; |  | 
| 683 |  | 
| 684 function ElemHideException(text, domains, selector) |  | 
| 685 { |  | 
| 686   ElemHideBase.call(this, text, domains, selector); |  | 
| 687 } |  | 
| 688 exports.ElemHideException = ElemHideException; |  | 
| 689 ElemHideException.prototype = { |  | 
| 690   __proto__: ElemHideBase.prototype, |  | 
| 691   type: "elemhideexception" |  | 
| 692 }; |  | 
| 693 |  | 
| 694 function CSSPropertyFilter(text, domains, selector, regexpSource, selectorPrefix
     , selectorSuffix) |  | 
| 695 { |  | 
| 696   ElemHideBase.call(this, text, domains, selector); |  | 
| 697   this.regexpSource = regexpSource; |  | 
| 698   this.selectorPrefix = selectorPrefix; |  | 
| 699   this.selectorSuffix = selectorSuffix; |  | 
| 700 } |  | 
| 701 exports.CSSPropertyFilter = CSSPropertyFilter; |  | 
| 702 CSSPropertyFilter.prototype = { |  | 
| 703   __proto__: ElemHideBase.prototype, |  | 
| 704   type: "cssproperty", |  | 
| 705   regexpSource: null, |  | 
| 706   selectorPrefix: null, |  | 
| 707   selectorSuffix: null, |  | 
| 708   get regexpString() |  | 
| 709   { |  | 
| 710     var prop = Object.getOwnPropertyDescriptor(this, "regexpString"); |  | 
| 711     if (prop) |  | 
| 712     { |  | 
| 713       return prop.value; |  | 
| 714     } |  | 
| 715     var regexp = Filter.toRegExp(this.regexpSource); |  | 
| 716     Object.defineProperty(this, "regexpString", |  | 
| 717     { |  | 
| 718       value: regexp |  | 
| 719     }); |  | 
| 720     return regexp; |  | 
| 721   } |  | 
| 722 }; |  | 
| OLD | NEW | 
|---|