diff --git a/src/js/redirect-engine.js b/src/js/redirect-engine.js
index cc9e475c8..14a47bc9c 100644
--- a/src/js/redirect-engine.js
+++ b/src/js/redirect-engine.js
@@ -307,7 +307,7 @@ RedirectEngine.prototype.compileRuleFromStaticFilter = function(line) {
     var µburi = µBlock.URI,
         des = matches[1] || '',
         pattern = (des + matches[2]).replace(/[.+?{}()|[\]\/\\]/g, '\\$&')
-                                    .replace(/\^/g, '[^\\w\\d%-]')
+                                    .replace(/\^/g, '[^\\w.%-]')
                                     .replace(/\*/g, '.*?'),
         type,
         redirect = '',
diff --git a/src/js/static-net-filtering.js b/src/js/static-net-filtering.js
index 789c13450..76bc35f8b 100644
--- a/src/js/static-net-filtering.js
+++ b/src/js/static-net-filtering.js
@@ -2134,9 +2134,10 @@ FilterContainer.prototype.compile = function(raw, writer) {
     if (
         parsed.hostnamePure &&
         parsed.domainOpt === '' &&
-        parsed.dataType === undefined &&
-        this.compileHostnameOnlyFilter(parsed, writer)
+        parsed.dataType === undefined
     ) {
+        parsed.tokenHash = this.dotTokenHash;
+        this.compileToAtomicFilter(parsed, parsed.f, writer);
         return true;
     }
 
@@ -2194,52 +2195,32 @@ FilterContainer.prototype.compile = function(raw, writer) {
         fdata.push(fwrapped);
     }
 
-    this.compileToAtomicFilter(fdata, parsed, writer);
+    this.compileToAtomicFilter(parsed, fdata, writer);
 
     return true;
 };
 
 /******************************************************************************/
 
-// Using fast/compact dictionary when filter is a pure hostname.
+FilterContainer.prototype.compileToAtomicFilter = function(
+    parsed,
+    fdata,
+    writer
+) {
+    let descBits = parsed.action |
+                   parsed.important |
+                   parsed.party |
+                   parsed.badFilter;
+    let type = parsed.types;
 
-FilterContainer.prototype.compileHostnameOnlyFilter = function(parsed, writer) {
-    // Can't fit the filter in a pure hostname dictionary.
-    // https://github.com/gorhill/uBlock/issues/1757
-    // This should no longer happen with fix to above issue.
-    //if ( parsed.domainOpt.length !== 0 ) {
-    //    return;
-    //}
-
-    var descBits = parsed.action | parsed.important | parsed.party | parsed.badFilter;
-
-    var type = parsed.types;
-    if ( type === 0 ) {
-        writer.push([ descBits, this.dotTokenHash, parsed.f ]);
-        return true;
-    }
-
-    var bitOffset = 1;
-    do {
-        if ( type & 1 ) {
-            writer.push([ descBits | (bitOffset << 4), this.dotTokenHash, parsed.f ]);
-        }
-        bitOffset += 1;
-        type >>>= 1;
-    } while ( type !== 0 );
-    return true;
-};
-
-/******************************************************************************/
-
-FilterContainer.prototype.compileToAtomicFilter = function(fdata, parsed, writer) {
-    var descBits = parsed.action | parsed.important | parsed.party | parsed.badFilter,
-        type = parsed.types;
+    // Typeless
     if ( type === 0 ) {
         writer.push([ descBits, parsed.tokenHash, fdata ]);
         return;
     }
-    var bitOffset = 1;
+
+    // Specific type(s)
+    let bitOffset = 1;
     do {
         if ( type & 1 ) {
             writer.push([ descBits | (bitOffset << 4), parsed.tokenHash, fdata ]);
@@ -2250,22 +2231,13 @@ FilterContainer.prototype.compileToAtomicFilter = function(fdata, parsed, writer
 
     // Only static filter with an explicit type can be redirected. If we reach
     // this point, it's because there is one or more explicit type.
-    if ( !parsed.redirect ) {
-        return;
-    }
-
-    if ( parsed.badFilter ) {
-        return;
-    }
-
-    var redirects = µb.redirectEngine.compileRuleFromStaticFilter(parsed.raw);
-    if ( Array.isArray(redirects) === false ) {
-        return;
-    }
-    descBits = typeNameToTypeValue.redirect;
-    var i = redirects.length;
-    while ( i-- ) {
-        writer.push([ descBits, redirects[i] ]);
+    if ( parsed.badFilter === 0 && parsed.redirect ) {
+        let redirects = µb.redirectEngine.compileRuleFromStaticFilter(parsed.raw);
+        if ( Array.isArray(redirects) ) {
+            for ( let redirect of redirects ) {
+                writer.push([ typeNameToTypeValue.redirect, redirect ]);
+            }
+        }
     }
 };