Index: lib/filterClasses.js
===================================================================
--- a/lib/filterClasses.js
+++ b/lib/filterClasses.js
@@ -35,31 +35,31 @@
  * Abstract base class for filters
  *
  * @param {string} text   string representation of the filter
  * @constructor
  */
 function Filter(text)
 {
   this.text = text;
-  this.subscriptions = [];
+  this.subscriptions = new Set();
 }
 exports.Filter = Filter;
 
 Filter.prototype =
 {
   /**
    * String representation of the filter
    * @type {string}
    */
   text: null,
 
   /**
    * Filter subscriptions the filter belongs to
-   * @type {Subscription[]}
+   * @type {Set.<Subscription>}
    */
   subscriptions: null,
 
   /**
    * Filter type as a string, e.g. "blocking".
    * @type {string}
    */
   get type()
Index: lib/filterListener.js
===================================================================
--- a/lib/filterListener.js
+++ b/lib/filterListener.js
@@ -137,20 +137,18 @@
  */
 function addFilter(filter)
 {
   if (!(filter instanceof ActiveFilter) || filter.disabled)
     return;
 
   let hasEnabled = false;
   let allowSnippets = false;
-  for (let i = 0; i < filter.subscriptions.length; i++)
+  for (let subscription of filter.subscriptions)
   {
-    let subscription = filter.subscriptions[i];
-
     if (!subscription.disabled)
     {
       hasEnabled = true;
 
       // Allow snippets to be executed only by the circumvention lists or the
       // user's own filters.
       if (subscription.type == "circumvention" ||
           subscription instanceof SpecialSubscription)
@@ -184,19 +182,19 @@
 function removeFilter(filter)
 {
   if (!(filter instanceof ActiveFilter))
     return;
 
   if (!filter.disabled)
   {
     let hasEnabled = false;
-    for (let i = 0; i < filter.subscriptions.length; i++)
+    for (let subscription of filter.subscriptions)
     {
-      if (!filter.subscriptions[i].disabled)
+      if (!subscription.disabled)
       {
         hasEnabled = true;
         break;
       }
     }
     if (hasEnabled)
       return;
   }
Index: lib/filterStorage.js
===================================================================
--- a/lib/filterStorage.js
+++ b/lib/filterStorage.js
@@ -205,36 +205,38 @@
    *   particular group that the filter should be added to
    * @param {number} [position]
    *   position within the subscription at which the filter should be added
    */
   addFilter(filter, subscription, position)
   {
     if (!subscription)
     {
-      if (filter.subscriptions.some(s => s instanceof SpecialSubscription &&
-                                         !s.disabled))
+      for (let currentSubscription of filter.subscriptions)
       {
-        return;   // No need to add
+        if (currentSubscription instanceof SpecialSubscription &&
+            !currentSubscription.disabled)
+        {
+          return;   // No need to add
+        }
       }
       subscription = FilterStorage.getGroupForFilter(filter);
     }
     if (!subscription)
     {
       // No group for this filter exists, create one
       subscription = SpecialSubscription.createForFilter(filter);
       this.addSubscription(subscription);
       return;
     }
 
     if (typeof position == "undefined")
       position = subscription.filters.length;
 
-    if (filter.subscriptions.indexOf(subscription) < 0)
-      filter.subscriptions.push(subscription);
+    filter.subscriptions.add(subscription);
     subscription.filters.splice(position, 0, filter);
     FilterNotifier.triggerListeners("filter.added", filter, subscription,
                                     position);
   },
 
   /**
    * Removes a user-defined filter from the list
    * @param {Filter} filter
@@ -242,21 +244,20 @@
    *      the filter should be removed from (if ommited will be removed from all
    *      subscriptions)
    * @param {number} [position]  position inside the filter group at which the
    *      filter should be removed (if ommited all instances will be removed)
    */
   removeFilter(filter, subscription, position)
   {
     let subscriptions = (
-      subscription ? [subscription] : filter.subscriptions.slice()
+      subscription ? [subscription] : filter.subscriptions
     );
-    for (let i = 0; i < subscriptions.length; i++)
+    for (let currentSubscription of subscriptions)
     {
-      let currentSubscription = subscriptions[i];
       if (currentSubscription instanceof SpecialSubscription)
       {
         let positions = [];
         if (typeof position == "undefined")
         {
           let index = -1;
           do
           {
@@ -270,21 +271,17 @@
 
         for (let j = positions.length - 1; j >= 0; j--)
         {
           let currentPosition = positions[j];
           if (currentSubscription.filters[currentPosition] == filter)
           {
             currentSubscription.filters.splice(currentPosition, 1);
             if (currentSubscription.filters.indexOf(filter) < 0)
-            {
-              let index = filter.subscriptions.indexOf(currentSubscription);
-              if (index >= 0)
-                filter.subscriptions.splice(index, 1);
-            }
+              filter.subscriptions.delete(currentSubscription);
             FilterNotifier.triggerListeners(
               "filter.removed", filter, currentSubscription, currentPosition
             );
           }
         }
       }
     }
   },
@@ -657,35 +654,31 @@
  *   filter subscription that should be connected to its filters
  */
 function addSubscriptionFilters(subscription)
 {
   if (!FilterStorage.knownSubscriptions.has(subscription.url))
     return;
 
   for (let filter of subscription.filters)
-    filter.subscriptions.push(subscription);
+    filter.subscriptions.add(subscription);
 }
 
 /**
  * Removes subscription's filters from the subscription without any
  * notifications.
  * @param {Subscription} subscription filter subscription to be removed
  */
 function removeSubscriptionFilters(subscription)
 {
   if (!FilterStorage.knownSubscriptions.has(subscription.url))
     return;
 
   for (let filter of subscription.filters)
-  {
-    let i = filter.subscriptions.indexOf(subscription);
-    if (i >= 0)
-      filter.subscriptions.splice(i, 1);
-  }
+    filter.subscriptions.delete(subscription);
 }
 
 /**
  * Listener returned by FilterStorage.importData(), parses filter data.
  * @constructor
  */
 function INIParser()
 {
@@ -738,17 +731,17 @@
               {
                 let subscription = this.subscriptions[
                   this.subscriptions.length - 1
                 ];
                 for (let text of this.curObj)
                 {
                   let filter = Filter.fromText(text);
                   subscription.filters.push(filter);
-                  filter.subscriptions.push(subscription);
+                  filter.subscriptions.add(subscription);
                 }
               }
               break;
           }
         }
 
         if (val === null)
           return;
Index: test/filterListener.js
===================================================================
--- a/test/filterListener.js
+++ b/test/filterListener.js
@@ -292,28 +292,28 @@
   checkKnownFilters(test, "enable blocking filters", {blacklist: [filter1.text]});
 
   let subscription3 = Subscription.fromURL("~wl~");
   subscription3.disabled = true;
   checkKnownFilters(test, "disable exception rules", {blacklist: [filter1.text]});
 
   FilterStorage.addFilter(filter2);
   checkKnownFilters(test, "add @@filter2", {blacklist: [filter1.text], whitelist: [filter2.text]});
-  test.equal(filter2.subscriptions.length, 1, "@@filter2.subscription.length");
-  test.ok(filter2.subscriptions[0] instanceof SpecialSubscription, "@@filter2 added to a new filter group");
-  test.ok(filter2.subscriptions[0] != subscription3, "@@filter2 filter group is not the disabled exceptions group");
+  test.equal(filter2.subscriptions.size, 1, "@@filter2.subscription.length");
+  test.ok([...filter2.subscriptions][0] instanceof SpecialSubscription, "@@filter2 added to a new filter group");
+  test.ok([...filter2.subscriptions][0] != subscription3, "@@filter2 filter group is not the disabled exceptions group");
 
   subscription3.disabled = false;
   checkKnownFilters(test, "enable exception rules", {blacklist: [filter1.text], whitelist: [filter2.text]});
 
   FilterStorage.removeFilter(filter2);
   FilterStorage.addFilter(filter2);
   checkKnownFilters(test, "re-add @@filter2", {blacklist: [filter1.text], whitelist: [filter2.text]});
-  test.equal(filter2.subscriptions.length, 1, "@@filter2.subscription.length");
-  test.ok(filter2.subscriptions[0] == subscription3, "@@filter2 added to the default exceptions group");
+  test.equal(filter2.subscriptions.size, 1, "@@filter2.subscription.length");
+  test.ok([...filter2.subscriptions][0] == subscription3, "@@filter2 added to the default exceptions group");
 
   let subscription4 = Subscription.fromURL("http://test/");
   FilterStorage.updateSubscriptionFilters(subscription4, [filter3, filter4, filter5]);
   checkKnownFilters(test, "update subscription not in the list yet", {blacklist: [filter1.text], whitelist: [filter2.text]});
 
   FilterStorage.addSubscription(subscription4);
   checkKnownFilters(test, "add subscription to the list", {blacklist: [filter1.text, filter3.text], whitelist: [filter2.text, filter4.text]});
 
Index: test/filterStorage.js
===================================================================
--- a/test/filterStorage.js
+++ b/test/filterStorage.js
@@ -51,17 +51,17 @@
   let result = FilterStorage.subscriptions.map(
     subscription => subscription.filters.map(
       filter => filter.text));
   test.deepEqual(result, list, testMessage);
 }
 
 function compareFilterSubscriptions(test, testMessage, filter, list)
 {
-  let result = filter.subscriptions.map(subscription => subscription.url);
+  let result = [...filter.subscriptions].map(subscription => subscription.url);
   let expected = list.map(subscription => subscription.url);
   test.deepEqual(result, expected, testMessage);
 }
 
 exports.testAddingSubscriptions = function(test)
 {
   let subscription1 = Subscription.fromURL("http://test1/");
   let subscription2 = Subscription.fromURL("http://test2/");