diff --git a/README.md b/README.md
index 4c11792..91c10af 100644
--- a/README.md
+++ b/README.md
@@ -1,2 +1,157 @@
-# userscript-proxy
-MITM userscript injector
+# Userscript Proxy
+
+Browser extensions on iOS, Android and pretty much any other web browsing device.
+No jailbreak/root required.
+
+Userscript Proxy is built around [mitmproxy](mitmproxy) and acts as a MITM, injecting matching userscripts into web pages as they flow through it.
+Both HTTP and HTTPS are supported.
+
+
+## Security
+
+**Userscript Proxy can (and must be able to) read and modify all HTTP(S) traffic** sent to and from the device in question, so the only reasonably secure way to use it is to run it on a server controlled by oneself.
+
+
+## Ignoring hosts
+
+Apps like App Store and Facebook Messenger refuse to connect through a MITM proxy, so their traffic must be ignored by mitmproxy.
+There are two approaches:
+
+  * Blacklisting hosts that cannot connect through the proxy.
+    Tedious, because you have to add exceptions for apps and such all the time.
+  * Whitelisting hosts where userscripts should be applied.
+    Works well in general, but does not allow universal userscripts that run on all sites, and the whitelist must be updated when a new userscript is added.
+
+Blacklisting or whitelisting is done by giving the `--ignore` or `--intercept` flag together with one or more files containing **ignore/intercept rules**.
+Examples:
+
+```bash
+# Take ignore rules from ignore.txt (included):
+python3.6 launcher.py --ignore "ignore.txt"
+
+# Take intercept rules from all .txt files whose names start with "foo":
+python3.6 launcher.py --intercept "foo*.txt"
+```
+
+Rules can be specified in two ways:
+
+### Basic pattern
+
+Based on the syntax used by userscript `@include` directives.
+Asterisk (`*`) means any string (including the empty string).
+`*.` is automatically prepended.
+`:*` is automatically appended unless the rule contains a colon (`:`).
+
+To match a domain without matching all of its subdomains, use a regex rule instead (see below).
+
+#### Examples
+
+| Rule           | Matches                                                         |
+|----------------|-----------------------------------------------------------------|
+| `site.com`     | `site.com` and `x.site.com`                                     |
+| `api.site.com` | `api.site.com` and `x.api.site.com`, but not `www.site.com`     |
+| `*cdn.net`     | `cdn.net`, `fbcdn.net` and `x.fbcdn.net`, but not `cdn.net.com` |
+| `site.com:80`  | `site.com:80` and `x.site.com:80`, but not `site.com:443`       |
+
+### Regular expression
+
+If a rule starts and ends with a slash (`/`), it is treated as a Python regex.
+
+Note that the string to match against contains both a host and a port, e.g. `example.com:443`, and that the regex is used verbatim (i.e. you have to explicitly provide `^` etc if desired).
+The only exception is that the case-insensitivity flag (`?i`) is automatically added.
+
+Also, be careful with `$`: A regex like `/site.com$/` will never match, because it will only be used to check strings like `site.com:80`.
+
+Anything from a `#` until the end of the line is treated as a comment.
+Leading and trailing whitespace have no effect.
+
+#### Examples
+
+| Rule            | Matches                                                           |
+|-----------------|-------------------------------------------------------------------|
+| `/cdn\./`       | `fbcdn.net`, `cdn.site.com`, `cdn.x.site.com`, but not `cdna.com` |
+| `/^site\.com:/` | `site.com`, but not `x.site.com`, `mysite.com` or `site.com.net`  |
+
+
+## Data usage
+
+Userscript Proxy has no data usage impact when no userscript is injected, i.e. for URLs without any matching userscript.
+When a script _is_ injected, **exactly one** of the following things happens:
+
+  * The entire userscript is injected as inline JavaScript (potentially dozens or even hundreds of kilobytes).
+  * A `<script>` tag referencing the userscript is injected (~100 bytes, depending on the length of the `@downloadURL`).
+
+A userscript is injected by reference if and only if it has a specified `@downloadURL` in its metadata.
+(This can be overridden using the `--inline` flag, in which case all userscripts are injected inline.)
+
+Userscripts are injected into _every_ response from a matching URL, and the size of a userscript can be anything from a few hundred bytes for the most basic ones to hundreds of kilobytes in extreme cases, so there are _massive_ data usage reductions to be gained from making the userscript accessible by URL and including a `@downloadURL`.
+If the `@downloadURL` approach is not possible, for one reason or the other, it is a good idea to be aware of this issue, and to take appropriate action such as [minifying](minification) userscripts and adding suitable ignore rules.
+
+
+## Userscript compatibility
+
+Userscript Proxy supports (a subset of) the [Greasemonkey metadata syntax](metadata).
+No adaptation of plain JavaScript userscripts should be required.
+These directives are supported:
+
+  * `@name`
+  * `@version`
+  * `@run-at document_(start|end|idle)`
+  * `@match`
+  * `@include` (basic pattern and regex)
+  * `@exclude`
+  * `@noframes`
+  * `@downloadURL`
+
+The [`GM` API](gm-api) and similar runtime facilities are not supported, because userscripts can only be injected as regular scripts.
+
+
+## Options
+
+### `--ignore FILE`/`--intercept FILE`
+
+Take ignore or intercept rules from `FILE`, which can be a glob pattern matching multiple files.
+`--ignore` and `--intercept` cannot be used together.
+See examples above.
+
+### `--inline`, `-i`
+
+Always inject scripts inline (`<script>...</script>`), never linked (`<script src="..."></script>`).
+Useful to test new userscript features without having to re-upload the userscript and clear browser cache.
+
+### `--list-injected`, `-l`
+
+Insert an HTML comment in each page specifying which userscripts (if any) were injected.
+
+### `--port PORT`, `-p PORT`
+
+Make mitmproxy listen to TCP port `PORT`.
+Defaults to `8080`.
+
+### `--query-param-to-disable PARAM`, `-q PARAM`
+
+Disable userscripts when the request URL contains `PARAM` as a query parameter.
+For example, use `-q foo` to disable userscripts for `http://example.com?foo`.
+Defaults to `nouserscripts`.
+
+### `--recursive`, `-r`
+
+Recurse into directories when looking for userscripts.
+
+### `--transparent`, `-t`
+
+Run mitmproxy in [transparent mode](transparent-mode).
+Useful if you cannot set a proxy in the client, e.g. when using OpenVPN Connect on Android to connect to a VPN server on the network where your proxy is running.
+In such cases, you have to route traffic from the client to the proxy at the network layer instead, making transparent mode necessary.
+
+### `--userscripts DIR`, `-u DIR`
+
+Load userscripts from directory `DIR`.
+Defaults to `userscripts`.
+
+
+[mitmproxy]: https://mitmproxy.org
+[minification]: https://en.wikipedia.org/wiki/Minification_(programming)
+[metadata]: https://wiki.greasespot.net/Metadata_Block
+[transparent-mode]: https://docs.mitmproxy.org/stable/concepts-modes/#transparent-proxy
+[gm-api]: https://wiki.greasespot.net/GM.getValue
diff --git a/ignore.txt b/ignore.txt
new file mode 100644
index 0000000..c556106
--- /dev/null
+++ b/ignore.txt
@@ -0,0 +1,39 @@
+# See README.md for information about the syntax used in this file.
+
+# Applications that cannot connect through mitmproxy:
+    itunes.apple.com           # App Store
+    xp.apple.com               # App Store
+    apps.apple.com             # App Store
+    mzstatic.com               # App Store
+    graph.facebook.com         # Messenger
+    api.facebook.com           # Messenger
+    edge-mqtt.facebook.com     # Messenger
+    edge-chat.facebook.com     # Messenger
+    slack.com                  # Slack
+    api*.dropbox.com           # Dropbox app
+    bolt.dropbox.com           # Dropbox app
+    ls.apple.com               # Apple services
+    icloud.com                 # Apple services
+    crashlytics.com            # Crashlytics error reporting
+    twimg.com                  # Twitter
+    ap.spotify.com             # Spotify app
+    wg.spotify.com             # Spotify app
+    api.branch.io              # Branch™ deep links
+    ggpht.com                  # Google/Android
+    www.google.com             # Google/Android
+    gvt1.com                   # Google/Android
+
+# Traffic irrelevant to Userscript Proxy:
+    /cdn\./
+    akamai*.net                # Akamai CDN
+    googleusercontent.com      # Google CDN
+    clients*.google.com        # Google Maps etc
+    googleapis.com             # Google APIs
+    i.ytimg.com                # YouTube thumbnails
+    googlevideo.com            # YouTube video content
+    s.youtube.com              # YouTube stats
+    api.twitch.tv              # Twitch app metadata
+    ttvnw.net                  # Twitch video content
+    /^149\.154\.16[4-7]\.\d+:/ # Telegram Messenger Network
+    audio-fa.spotify.com       # Spotify audio content
+    slack-msgs.com             # Slack app
diff --git a/injector.py b/injector.py
new file mode 100644
index 0000000..d88553f
--- /dev/null
+++ b/injector.py
@@ -0,0 +1,212 @@
+from typing import Optional, Iterable, List, Callable, Pattern, Match, Tuple
+import glob, os
+from bs4 import BeautifulSoup, Comment, Doctype
+from mitmproxy import ctx, http
+from functools import partial
+import shlex
+import warnings
+from modules.metadata import MetadataError, PREFIX_TAG
+import modules.userscript as userscript
+import modules.inline as inline
+import modules.text as T
+from modules.userscript import Userscript, UserscriptError, document_end, document_start, document_idle
+from modules.utilities import first, second, itemList, fromOptional, flag, idem
+from modules.constants import VERSION, VERSION_PREFIX, APP_NAME, DEFAULT_USERSCRIPTS_DIR, DEFAULT_QUERY_PARAM_TO_DISABLE
+from modules.inject import Options, inject
+from modules.misc import sanitize
+from modules.requests import CONTENT_TYPE, inferEncoding, requestContainsQueryParam
+
+PATTERN_USERSCRIPT: str = "*.user.js"
+RELEVANT_CONTENT_TYPES: List[str] = ["text/html", "application/xhtml+xml"]
+CHARSET_DEFAULT: str = "utf-8"
+TAB: str = "    "
+LIST_ITEM_PREFIX: str = TAB + "• "
+HTML_PARSER: str = "lxml"
+# lxml handles non-uppercase DOCTYPE correctly; html.parser does not: It emits
+# <!DOCTYPE doctype html> if the original source code contained <!doctype html>.
+HTML_INFO_COMMENT_PREFIX: str = f"""
+[{T.INFO_MESSAGE}]
+"""
+
+
+def logInfo(s: str) -> None:
+    try:
+        ctx.log.info(s)
+    except Exception:
+        print(s)
+
+def logWarning(s: str) -> None:
+    try:
+        ctx.log.warn(s)
+    except Exception:
+        print(s)
+
+def logError(s: str) -> None:
+    try:
+        ctx.log.error(s)
+    except Exception:
+        print(s)
+
+def indexOfDTD(soup: BeautifulSoup) -> Optional[int]:
+    index: int = 0
+    for item in soup.contents:
+        if isinstance(item, Doctype):
+            return index
+        index += 1
+    return None
+
+bulletList: Callable[[Iterable[str]], str] = partial(itemList, LIST_ITEM_PREFIX)
+
+def unsafeSequencesMessage(script: Userscript) -> str:
+    sequences = script.unsafeSequences
+    return f"""{script.name} cannot be injected because it contains {"these unsafe sequences" if len(sequences) > 1 else "this unsafe sequence"}:
+
+{itemList(TAB, sequences)}
+
+<script> tags cannot contain any of these sequences (case-insensitive):
+
+{itemList(TAB, inline.DANGEROUS_SEQUENCES)}
+
+Possible solutions:
+""" + bulletList([
+    f"Make sure the userscript does not contain any of the sequences listed above.",
+    f"Make the userscript available online and give it a {PREFIX_TAG}{userscript.directive_downloadURL}",
+    f"Remove the {flag(T.option_inline)} flag.",
+])
+
+
+# Because ctx.options is not subscriptable and we want to be able to use
+# expressions as keys:
+def option(key: str):
+    return ctx.options.__getattr__(sanitize(key))
+
+
+def loadUserscripts(directories: Iterable[str], recursive: bool) -> List[Userscript]:
+    logInfo("Loading userscripts ...")
+    loadedUserscripts: List[Tuple[Userscript, str]] = []
+    workingDirectory = os.getcwd()
+    for directory in directories:
+        logInfo(f"""Looking{" recursively" if recursive else ""} for userscripts ({PATTERN_USERSCRIPT}) in directory `{directory}` ...""")
+        if not recursive:
+            logInfo(f"{TAB}(use {flag(T.option_recursive)} to look recursively)")
+        try:
+            os.chdir(directory)
+        except FileNotFoundError:
+            logWarning("Directory `"+directory+"` does not exist.")
+            continue
+        except PermissionError:
+            logError("Permission was denied when trying to read directory `"+directory+"`.")
+            continue
+        pattern = ("**/" if recursive else "") + PATTERN_USERSCRIPT
+        # recursive=True only affects the meaning of "**".
+        # https://docs.python.org/3/library/glob.html#glob.glob
+        for unsafe_filename in glob.glob(pattern, recursive=True):
+            filename = shlex.quote(unsafe_filename)
+            logInfo("Loading " + filename + " ...")
+            try:
+                content = open(filename).read()
+            except PermissionError:
+                logError("Could not read file `"+filename+"`: Permission denied.")
+                continue
+            except Exception as e:
+                logError("Could not read file `"+filename+"`: " + str(e))
+                continue
+            try:
+                script = userscript.create(content)
+                loadedUserscripts.append((script, filename))
+                if script.downloadURL is None and len(script.unsafeSequences) > 0:
+                    logError(unsafeSequencesMessage(script))
+            except MetadataError as err:
+                logError("Metadata error:")
+                logError(str(err))
+                continue
+            except UserscriptError as err:
+                logError("Userscript error:")
+                logError(str(err))
+                continue
+        os.chdir(workingDirectory) # so mitmproxy does not unload the script
+    logInfo("")
+    logInfo(str(len(loadedUserscripts)) + " userscript(s) loaded:")
+    logInfo(bulletList(map(
+        lambda s: f"{first(s).name} ({second(s)})",
+        loadedUserscripts
+    )))
+    logInfo("")
+    return list(map(first, loadedUserscripts))
+
+
+class UserscriptInjector:
+    def __init__(self):
+        self.userscripts: List[Userscript] = []
+
+
+    def load(self, loader):
+        loader.add_option(sanitize(T.option_inline), bool, False, T.help_inline)
+        loader.add_option(sanitize(T.option_recursive), bool, False, T.help_recursive)
+        loader.add_option(sanitize(T.option_list_injected), bool, False, T.help_list_injected)
+        loader.add_option(sanitize(T.option_userscripts), str, DEFAULT_USERSCRIPTS_DIR, T.help_userscripts)
+        loader.add_option(sanitize(T.option_query_param_to_disable), str, DEFAULT_QUERY_PARAM_TO_DISABLE, T.help_query_param_to_disable)
+
+
+    def configure(self, updates):
+        if sanitize(T.option_inline) in updates and option(T.option_inline):
+            logWarning(f"""Only inline injection will be used due to {flag(T.option_inline)} flag.""")
+        if sanitize(T.option_query_param_to_disable) in updates:
+            logInfo(f"""Userscripts will not be injected when the request URL contains a `{option(T.option_query_param_to_disable)}` query parameter.""")
+        if sanitize(T.option_userscripts) in updates:
+            self.userscripts = loadUserscripts(
+                directories = [ option(T.option_userscripts) ],
+                recursive = option(T.option_recursive),
+            )
+
+
+    def response(self, flow: http.HTTPFlow):
+        response = flow.response
+        if CONTENT_TYPE in response.headers:
+            if any(map(lambda t: t in response.headers[CONTENT_TYPE], RELEVANT_CONTENT_TYPES)):
+                # Response is a web page; proceed.
+                insertedScripts: List[str] = []
+                soup = BeautifulSoup(
+                    response.content,
+                    HTML_PARSER,
+                    from_encoding=inferEncoding(response)
+                )
+                requestURL = flow.request.pretty_url # should work in transparent mode too, unless the Host header is spoofed
+                if requestContainsQueryParam(option(T.option_query_param_to_disable), flow.request):
+                    logInfo(f"""Not injecting any userscripts into {requestURL} because it contains a `{option(T.option_query_param_to_disable)}` query parameter.""")
+                    return
+                isApplicable: Callable[[Userscript], bool] = userscript.applicableChecker(requestURL)
+                for script in self.userscripts:
+                    if isApplicable(script):
+                        useInline = option(T.option_inline) or script.downloadURL is None
+                        if useInline and len(script.unsafeSequences) > 0:
+                            logError(unsafeSequencesMessage(script))
+                            continue
+                        logInfo(f"""Injecting {script.name}{"" if script.version is None else " " + VERSION_PREFIX + script.version} into {requestURL} ({"inline" if useInline else "linked"}) ...""")
+                        result = inject(script, soup, Options(
+                            inline = option(T.option_inline),
+                        ))
+                        if type(result) is BeautifulSoup:
+                            soup = result
+                            insertedScripts.append(script.name + ("" if script.version is None else " " + T.stringifyVersion(script.version)))
+                        else:
+                            logError("Injection failed due to the following error:")
+                            logError(str(result))
+
+                index_DTD: Optional[int] = indexOfDTD(soup)
+                # Insert information comment:
+                if option(T.option_list_injected):
+                    soup.insert(0 if index_DTD is None else 1+index_DTD, Comment(
+                        HTML_INFO_COMMENT_PREFIX + (
+                            "No matching userscripts for this URL." if insertedScripts == []
+                            else "These scripts were inserted:\n" + bulletList(insertedScripts)
+                        ) + "\n"
+                    ))
+                # Serialize and encode:
+                response.content = str(soup).encode(
+                    fromOptional(soup.original_encoding, CHARSET_DEFAULT),
+                    "replace"
+                )
+
+
+addons = [ UserscriptInjector() ]
diff --git a/intercept.txt b/intercept.txt
new file mode 100644
index 0000000..6c8d25c
--- /dev/null
+++ b/intercept.txt
@@ -0,0 +1,3 @@
+# See README.md for information about the syntax used in this file.
+
+example.com
diff --git a/launcher.py b/launcher.py
new file mode 100755
index 0000000..5344302
--- /dev/null
+++ b/launcher.py
@@ -0,0 +1,138 @@
+#!/usr/bin/env python3
+
+from typing import List
+import glob
+import subprocess
+from modules.utilities import itemList, flag, shortFlag, idem, isSomething
+from modules.constants import DEFAULT_PORT, DEFAULT_USERSCRIPTS_DIR, DEFAULT_QUERY_PARAM_TO_DISABLE
+from modules.misc import sanitize
+import modules.ignore as ignore
+import modules.text as T
+import shlex
+from argparse import ArgumentParser
+from functools import reduce
+
+FILENAME_INJECTOR: str = "injector.py"
+MATCH_NO_HOSTS = r"^$"
+
+argparser = ArgumentParser(description=T.description)
+group = argparser.add_mutually_exclusive_group()
+group.add_argument(
+    flag(T.option_ignore),
+    type=str,
+    metavar=T.metavar_file,
+    help=T.help_ignore,
+)
+group.add_argument(
+    flag(T.option_intercept),
+    type=str,
+    metavar=T.metavar_file,
+    help=T.help_intercept,
+)
+argparser.add_argument(
+    flag(T.option_inline), shortFlag(T.option_inline_short),
+    action="store_true",
+    help=T.help_inline,
+)
+argparser.add_argument(
+    flag(T.option_list_injected),
+    action="store_true",
+    help=T.help_list_injected,
+)
+argparser.add_argument(
+    flag(T.option_port), shortFlag(T.option_port_short),
+    type=int,
+    default=DEFAULT_PORT,
+    help=T.help_port,
+)
+argparser.add_argument(
+    flag(T.option_query_param_to_disable), shortFlag(T.option_query_param_to_disable_short),
+    type=str,
+    metavar=T.metavar_param,
+    default=DEFAULT_QUERY_PARAM_TO_DISABLE,
+    help=T.help_query_param_to_disable,
+)
+argparser.add_argument(
+    flag(T.option_recursive), shortFlag(T.option_recursive_short),
+    action="store_true",
+    help=T.help_recursive,
+)
+argparser.add_argument(
+    flag(T.option_transparent), shortFlag(T.option_transparent_short),
+    action="store_true",
+    help=T.help_transparent,
+)
+argparser.add_argument(
+    flag(T.option_userscripts), shortFlag(T.option_userscripts_short),
+    type=str,
+    metavar=T.metavar_dir,
+    default=DEFAULT_USERSCRIPTS_DIR,
+    help=T.help_userscripts,
+)
+
+def readRuleFile(accumulatedContent: str, filename: str) -> str:
+    print("Reading " + filename + " ...")
+    try:
+        fileContent: str = open(filename).read()
+        return accumulatedContent + fileContent
+    except Exception as e:
+        print("Could not read file `"+filename+"`: " + str(e))
+        return accumulatedContent
+
+
+def printWelcomeMessage():
+    print("")
+    print("╔═" + "═" * len(T.INFO_MESSAGE) + "═╗")
+    print("║ " +           T.INFO_MESSAGE  + " ║")
+    print("╚═" + "═" * len(T.INFO_MESSAGE) + "═╝")
+    print("")
+
+
+try:
+    args = argparser.parse_args()
+    printWelcomeMessage()
+    glob_ignore = args.ignore
+    glob_intercept = args.intercept
+    globPattern = (
+        glob_intercept if isSomething(glob_intercept)
+        else glob_ignore if isSomething(glob_ignore)
+        else None
+    )
+    useFiltering = globPattern is not None
+    regex: str = MATCH_NO_HOSTS
+    if useFiltering:
+        useIntercept = isSomething(glob_intercept)
+        print(f"Reading {'intercept' if useIntercept else 'ignore'} rules ...")
+        filenames: List[str] = [ shlex.quote(unsafeFilename) for unsafeFilename in glob.glob(globPattern) ]
+        ruleFilesContent: str = reduce(readRuleFile, filenames, "")
+        maybeNegate = ignore.negate if useIntercept else idem
+        regex = maybeNegate(ignore.entireIgnoreRegex(ruleFilesContent))
+        print(f"Traffic from hosts matching any of these rules will be {'INTERCEPTED' if useIntercept else 'IGNORED'} by mitmproxy:")
+        print()
+        print(itemList("    ", ignore.rulesIn(ruleFilesContent)))
+        print()
+    useTransparent = args.transparent
+    print("mitmproxy will be run in " + ("TRANSPARENT" if useTransparent else "REGULAR") + " mode.")
+    print()
+    if not useFiltering:
+        print(f"Since neither {flag(T.option_ignore)} nor {flag(T.option_intercept)} was given, ALL traffic will be intercepted.")
+    if useFiltering and useTransparent:
+        print(f"Please note that ignore/intercept rules based on hostnames may not work in transparent mode; it may be necessary to use IP addresses instead.")
+    print()
+    subprocess.run([
+        "mitmdump", "--ignore-hosts", regex,
+        "--listen-port", str(args.port),
+        "--mode", "transparent" if useTransparent else "regular",
+        "--showhost", # use Host header for URL display
+        "-s", FILENAME_INJECTOR,
+        "--set", f"""{sanitize(T.option_inline)}={str(args.inline).lower()}""",
+        "--set", f"""{sanitize(T.option_recursive)}={str(args.recursive).lower()}""",
+        "--set", f"""{sanitize(T.option_list_injected)}={str(args.list_injected).lower()}""",
+        "--set", f"""{sanitize(T.option_userscripts)}={args.userscripts}""",
+        "--set", f"""{sanitize(T.option_query_param_to_disable)}={args.query_param_to_disable}""",
+        # Empty string breaks the argument chain:
+        "--rawtcp" if useTransparent else "", # for apps like Facebook Messenger
+    ])
+except KeyboardInterrupt:
+    print("")
+    print("Interrupted by user.")
diff --git a/modules/constants.py b/modules/constants.py
new file mode 100644
index 0000000..7c27f11
--- /dev/null
+++ b/modules/constants.py
@@ -0,0 +1,7 @@
+VERSION_PREFIX: str = "v"
+APP_NAME: str = "Userscript Proxy"
+VERSION: str = "0.11.0"
+ATTRIBUTE_UP_VERSION: str = "data-userscript-proxy-version"
+DEFAULT_PORT: int = 8080
+DEFAULT_USERSCRIPTS_DIR: str = "userscripts"
+DEFAULT_QUERY_PARAM_TO_DISABLE: str = "nouserscripts"
diff --git a/modules/ignore.py b/modules/ignore.py
new file mode 100644
index 0000000..a39cfec
--- /dev/null
+++ b/modules/ignore.py
@@ -0,0 +1,42 @@
+from typing import List, Pattern
+import re
+from modules.patterns import isIncludePattern_regex, regexify, withoutSurroundingSlashes
+
+COMMENT_PREFIX: str = "#"
+PORT_PREFIX: str = ":"
+PIPE: str = "|"
+REGEX_COMMENT: Pattern = re.compile(r"\#.*$")
+
+def rulesIn(text: str) -> List[str]:
+    return list(filter(
+        lambda s: s != "",
+        map(withoutCommentAndTrimmed, text.splitlines())
+    ))
+
+
+def withoutCommentAndTrimmed(line: str) -> str:
+    return re.sub(REGEX_COMMENT, "", line).strip()
+
+
+def withPortSuffix(regex: str) -> str:
+    return regex if PORT_PREFIX in regex else regex + r"\:\d+"
+
+
+def ignoreRegex(ignoreRule: str) -> str:
+    return (
+        withoutSurroundingSlashes(ignoreRule)
+        if isIncludePattern_regex(ignoreRule)
+        else r"^(?:.+\.)?" + withPortSuffix(regexify(ignoreRule)) + r"$"
+    )
+
+
+def entireIgnoreRegex(ignoreFileContent: str) -> str:
+    return PIPE.join(map(
+        ignoreRegex,
+        rulesIn(ignoreFileContent)
+    ))
+
+
+# https://stackoverflow.com/a/2637899
+def negate(regex: str) -> str:
+    return "^(?!(?:" + regex + ")$).*$"
diff --git a/modules/inject.py b/modules/inject.py
new file mode 100644
index 0000000..69afa4f
--- /dev/null
+++ b/modules/inject.py
@@ -0,0 +1,62 @@
+from typing import Union, NamedTuple
+import modules.userscript as userscript
+from bs4 import BeautifulSoup, Tag
+from modules.userscript import Userscript, document_end, document_start, document_idle
+from modules.constants import VERSION, ATTRIBUTE_UP_VERSION
+from modules.utilities import idem, fromOptional, stripIndentation
+
+class Options(NamedTuple):
+    inline: bool
+
+
+def inject(script: Userscript, soup: BeautifulSoup, options: Options) -> Union[BeautifulSoup, Exception]:
+    useInline = options.inline or script.downloadURL is None
+    tag = soup.new_tag("script")
+    tag[ATTRIBUTE_UP_VERSION] = VERSION
+    withLoadListenerIfRunAtIdle = userscript.withEventListener("load") if script.runAt == document_idle else idem
+    withNoframesIfNoframes = userscript.withNoframes if script.noframes else idem
+    try:
+        if useInline:
+            tag.string = withNoframesIfNoframes(withLoadListenerIfRunAtIdle(script.content))
+            if script.runAt == document_end:
+                insertLateIn(soup, tag)
+            else:
+                insertEarlyIn(soup, tag)
+        else:
+            s = "s" # JS variable name
+            src = userscript.withVersionSuffix(script.downloadURL, script.version)
+            JS_insertScriptTag = f"""document.head.appendChild({s});"""
+            JS_insertionCode = (stripIndentation(f"""
+                const {s} = document.createElement("script");
+                {s}.setAttribute("{ATTRIBUTE_UP_VERSION}", "{VERSION}");
+                {s}.src = "{src}";
+                {withLoadListenerIfRunAtIdle(JS_insertScriptTag)}
+            """))
+            if script.runAt == document_idle or script.noframes:
+                tag.string = withNoframesIfNoframes(JS_insertionCode)
+            else:
+                tag["src"] = src
+            # Tag prepared. Insert it:
+            if script.runAt == document_end:
+                insertLateIn(soup, tag)
+            else:
+                insertEarlyIn(soup, tag)
+        return soup
+    except Exception as e:
+        return e
+
+
+
+def insertEarlyIn(soup: BeautifulSoup, tag: Tag):
+    if soup.body is not None and soup.body.find() is not None:
+        soup.body.find().insert_before(tag)
+    elif soup.title is not None:
+        soup.title.insert_after(tag)
+    elif soup.find() is not None:
+        soup.find().insert_after(tag) # after first element
+    else:
+        soup.append(tag)
+
+
+def insertLateIn(soup: BeautifulSoup, tag: Tag):
+    fromOptional(soup.body, soup).append(tag)
diff --git a/modules/inline.py b/modules/inline.py
new file mode 100644
index 0000000..4183369
--- /dev/null
+++ b/modules/inline.py
@@ -0,0 +1,18 @@
+from typing import List, Pattern
+import re
+
+# https://www.w3.org/TR/html/semantics-scripting.html#script-content-restrictions
+
+DANGEROUS_SEQUENCES: List[str] = [
+    r"<!--",
+    r"<script",
+    r"</script",
+]
+
+REGEX: Pattern = re.compile(
+    "|".join(DANGEROUS_SEQUENCES),
+    re.IGNORECASE, # to match e.g. <SCRIPT as well
+)
+
+def unsafeSequencesIn(source: str) -> List[str]:
+    return re.findall(REGEX, source)
diff --git a/metadata.py b/modules/metadata.py
similarity index 68%
rename from metadata.py
rename to modules/metadata.py
index b3e415a..773188e 100644
--- a/metadata.py
+++ b/modules/metadata.py
@@ -1,9 +1,9 @@
-from typing import TypeVar, Tuple, List, Iterator, Pattern, Match, Optional, Union, Callable, NamedTuple
+from typing import TypeVar, Tuple, List, Iterator, Iterable, Pattern, Match, Optional, Union, Callable, NamedTuple
 import re
 from string import Template
 from functools import reduce
-from utilities import A, B, first, second, isSomething
-import warnings
+import itertools
+from modules.utilities import first, second, isSomething
 
 class MetadataError(Exception):
     def __init__(self,*args,**kwargs):
@@ -39,21 +39,21 @@ class Tag_boolean(NamedTuple):
 BLOCK_START: str = "==UserScript=="
 BLOCK_END: str = "==/UserScript=="
 
-REGEX_EMPTY_LINE_COMMENT: Pattern = re.compile(r"^(?:\/\/)?\s*$")
+REGEXGROUP_CONTENT: str = "content"
 REGEX_METADATA_BLOCK: Pattern = re.compile(
     PREFIX_COMMENT + r"\s*" + BLOCK_START + r"\n"
-    + r"(.*)"
+    + r"(?P<" + REGEXGROUP_CONTENT + r">.*)"
     + PREFIX_COMMENT + r"\s*" + BLOCK_END,
     re.DOTALL
 )
-INDEX_GROUP_BLOCK_CONTENT: int = 1
+REGEXGROUP_TAGNAME: str = "tagname"
+REGEXGROUP_TAGVALUE: str = "tagvalue"
 REGEX_METADATA_LINE: Pattern = re.compile(
     r"^\s*" + PREFIX_COMMENT
     + r"\s*" + PREFIX_TAG
-    + r"([^\s]+)(?:\s+?(\S.*)?)?$"
+    + r"(?P<" + REGEXGROUP_TAGNAME + r">[^\s]+)"
+    + r"(?:\s+?(?P<" + REGEXGROUP_TAGVALUE + r">\S.*)?)?$"
 )
-INDEX_GROUP_TAGNAME: int = 1
-INDEX_GROUP_TAGVALUE: int = 2
 
 STRING_ERROR_MISSING_BLOCK: str = f"""No metadata block found. The metadata block must follow this format:
 
@@ -92,12 +92,6 @@ class Tag_boolean(NamedTuple):
 
 """)
 
-STRING_WARNING_NO_MATCH: Template = Template(f"""This metadata line did not match the expected pattern and was ignored:
-
-    $line
-
-""")
-
 
 def isWhitespaceLine(s: str) -> bool:
     return isSomething(re.compile(r"^\s*$").match(s))
@@ -107,9 +101,9 @@ def isCommentLine(s: str) -> bool:
 
 def extract(userscriptContent: str) -> str: # raises MetadataError
     match_metadataBlock: Optional[Match] = REGEX_METADATA_BLOCK.search(userscriptContent)
-    if (match_metadataBlock == None):
+    if (match_metadataBlock is None):
         raise MetadataError(STRING_ERROR_MISSING_BLOCK)
-    block: str = match_metadataBlock.group(INDEX_GROUP_BLOCK_CONTENT)
+    block: str = match_metadataBlock.group(REGEXGROUP_CONTENT)
     for line in block.splitlines():
         if not isWhitespaceLine(line) and not isCommentLine(line) and not REGEX_METADATA_LINE.match(line):
             raise MetadataError(STRING_ERROR_INVALID_BLOCK.substitute(line=line))
@@ -119,18 +113,23 @@ def extract(userscriptContent: str) -> str: # raises MetadataError
 def parse(metadataContent: str) -> Metadata:
     def parseLine(line: str) -> Optional[MetadataItem]:
         match: Optional[Match] = REGEX_METADATA_LINE.search(line)
-        if match == None:
-            # if not REGEX_EMPTY_LINE_COMMENT.match(line): # TODO: uncomment when we can handle warnings
-            #     warnings.warn(STRING_WARNING_NO_MATCH.substitute(line=line))
+        if match is None:
             return None
         else:
-            tagName: str = match.group(INDEX_GROUP_TAGNAME)
-            tagValue: Optional[str] = match.group(INDEX_GROUP_TAGVALUE)
-            return (tagName, True if tagValue == None else tagValue) # Boolean metadata tags have no explicit value; if they are present, they are true.
-
-    return list(filter(isSomething,
-        map(parseLine, metadataContent.splitlines())
-    ))
+            tagName: str = match.group(REGEXGROUP_TAGNAME)
+            tagValue: Optional[str] = match.group(REGEXGROUP_TAGVALUE)
+            # Boolean tags have no explicit value; if they are present, they are true:
+            if tagValue is None:
+                return (tagName, True)
+            else:
+                return (tagName, tagValue)
+
+    # filter did not play well with mypy:
+    parsedItems: Metadata = []
+    for item in map(parseLine, metadataContent.splitlines()):
+        if item is not None:
+            parsedItems.append(item)
+    return parsedItems
 
 
 def tagByName(tags: List[Tag], tagName: str) -> Optional[Tag]:
@@ -139,8 +138,8 @@ def tagByName(tags: List[Tag], tagName: str) -> Optional[Tag]:
 
 def validatePair(tags: List[Tag], pair: MetadataItem) -> MetadataItem:
     (tagName, tagValue) = pair
-    tag: Tag = tagByName(tags, tagName)
-    if tag == None:
+    tag: Optional[Tag] = tagByName(tags, tagName)
+    if tag is None:
         # Unrecognized key.
         return (tagName, tagValue)
     else:
@@ -148,64 +147,66 @@ def validatePair(tags: List[Tag], pair: MetadataItem) -> MetadataItem:
         tagPredicate: Optional[Predicate] = tag.predicate
         if type(tag) is Tag_string and type(tagValue) is not str:
             raise MetadataError(STRING_ERROR_MISSING_VALUE.substitute(tagName=tagName))
-        if type(tag) is Tag_boolean and type(tagValue) is not bool:
-            tagValue = True # because a boolean directive which is present is true no matter what comes after it
-        if isSomething(tagPredicate):
+        if type(tag) is Tag_boolean:
+            tagValue = tagValue is not False # This handles cases like `@noframes blabla`; a boolean directive is true no matter what comes after it.
+        if tagPredicate is not None:
             if not tagPredicate(tagValue):
                 raise MetadataError(STRING_ERROR_PREDICATE_FAILED.substitute(tagName=tagName, tagValue=str(tagValue)))
         return (tagName, tagValue)
 
 
 def validate(tags: List[Tag], metadata: Metadata) -> Metadata: # raises MetadataError
-    def handleDuplicate(acc: Metadata, pair: MetadataItem) -> Metadata:
-        (name, val) = pair
-        tag: Tag = tagByName(tags, name)
-        if tag == None:
-            # Unrecognized tag. Just let it pass.
-            return acc + [pair]
-        else:
-            # Recognized tag! Skip it if it is a duplicate of a unique key.
-            seenTagNames: Iterator[str] = map(first, acc)
-            return acc if tag.unique and name in seenTagNames else acc + [pair]
+    def handleDuplicate(acc: Iterable[MetadataItem], pair: MetadataItem) -> Iterable[MetadataItem]:
+        name: str = first(pair)
+        tag: Optional[Tag] = tagByName(tags, name)
+        seenTagNames: Iterator[str] = map(first, acc)
+        # Throw away pair if it has the same tag name as some already seen, known, unique directive:
+        return acc if tag is not None and tag.unique and name in seenTagNames else list(acc) + [pair]
 
     def withoutDuplicates(metadata: Metadata) -> Metadata:
-        return reduce(handleDuplicate, metadata, [])
+        empty: Iterable[Tuple[str, Union[str, bool]]] = [] # to satisfy mypy
+        return list(reduce(handleDuplicate, metadata, empty))
 
+    # Awkwardly written to satisfy mypy:
     def withDefaults(metadata: Metadata) -> Metadata:
         tagNamesThatWeHave: List[str] = list(map(first, metadata))
-        def hasDefaultAndNotAlreadyParsed(tag: Tag) -> bool:
-            return isSomething(tag.default) and tag.name not in tagNamesThatWeHave
-        neededDefaults: Metadata = list(map(
+        unseenItems = map(
             lambda tag: (tag.name, tag.default),
             filter(
-                hasDefaultAndNotAlreadyParsed,
+                lambda tag: tag.name not in tagNamesThatWeHave,
                 tags
             )
-        ))
+        )
+        neededDefaults: Metadata = []
+        for (tagName, default) in unseenItems:
+            if default is not None:
+                neededDefaults.append((tagName, default))
         return metadata + neededDefaults
 
     def assertRequiredPresent(metadata: Metadata) -> Metadata:
         ourTagNames: Iterator[str] = map(first, metadata)
-        requiredTags: Iterator[Tag] = filter(lambda tag: tag.required== True, tags)
+        requiredTags: Iterator[Tag] = filter(lambda tag: tag.required, tags)
         for tag in requiredTags:
             if (tag.name not in ourTagNames):
                 raise MetadataError(STRING_ERROR_MISSING_TAG.substitute(tagName=tag.name))
         return metadata
 
-    return list(map(lambda *args: validatePair(tags, *args),
+    return list(map(
+        lambda *args: validatePair(tags, *args),
         withDefaults(withoutDuplicates(
             assertRequiredPresent(metadata)
         ))
     ))
 
 
-def validateWith(tags: List[Tag]):
+def validator(tags: List[Tag]) -> Callable[[Metadata], Metadata]:
     return lambda metadata: validate(tags, metadata)
 
 
 def valueGetter_all(metadata: Metadata) -> Callable[[Tag], List[TagValue]]:
     return lambda tag: [second(pair) for pair in metadata if first(pair) == tag.name]
 
+
 def valueGetter_one(metadata: Metadata) -> Callable[[Tag], Optional[TagValue]]:
     v = valueGetter_all(metadata)
     return lambda tag: None if len(v(tag)) == 0 else v(tag)[0]
diff --git a/modules/misc.py b/modules/misc.py
new file mode 100644
index 0000000..67ad9fe
--- /dev/null
+++ b/modules/misc.py
@@ -0,0 +1,3 @@
+# mitm[dump|proxy] cannot have hyphens in option keys.
+def sanitize(optionName: str) -> str:
+    return optionName.replace("-", "_")
diff --git a/modules/patterns.py b/modules/patterns.py
new file mode 100644
index 0000000..1c70be1
--- /dev/null
+++ b/modules/patterns.py
@@ -0,0 +1,81 @@
+from typing import Optional, Pattern, Match
+import re
+from modules.utilities import first, isSomething
+
+REGEX_MATCH_ALL = r"<all_urls>"
+REGEX_MATCH_SCHEME = r"\*|https?"
+REGEXGROUP_MATCH_SCHEME = r"scheme"
+REGEX_MATCH_HOST = r"(\*\.)*[^\/\*]+|\*"
+REGEXGROUP_MATCH_HOST = r"host"
+REGEX_MATCH_PATH = r"\/.*"
+REGEXGROUP_MATCH_PATH = r"path"
+MATCH_PATTERN_ALL_NORMALIZED = "*://*/*"
+
+# Outer parentheses necessary to enclose `|`:
+REGEX_MATCH_PATTERN = re.compile(
+      r"^(?:" + REGEX_MATCH_ALL + r"|"
+    + r"(?P<" + REGEXGROUP_MATCH_SCHEME + r">" + REGEX_MATCH_SCHEME + r"):\/\/"
+    + r"(?P<" + REGEXGROUP_MATCH_HOST   + r">" + REGEX_MATCH_HOST   + r")"
+    + r"(?P<" + REGEXGROUP_MATCH_PATH   + r">" + REGEX_MATCH_PATH   + r")"
+    + r")$"
+)
+
+REGEX_INCLUDE_REGULAR = r"^(.+)$"
+REGEX_INCLUDE_REGEX = r"^\/(.+)\/$"
+
+REGEX_INCLUDE_PATTERN = re.compile(
+    REGEX_INCLUDE_REGEX + "|" + REGEX_INCLUDE_REGULAR
+)
+
+
+def normalizeMatchPattern(pattern: str) -> str:
+    return MATCH_PATTERN_ALL_NORMALIZED if pattern == REGEX_MATCH_ALL else pattern
+
+
+def isMatchPattern(pattern: str) -> bool:
+    return isSomething(REGEX_MATCH_PATTERN.match(pattern))
+
+
+def isIncludePattern(pattern: str) -> bool:
+    return isSomething(REGEX_INCLUDE_PATTERN.match(pattern))
+
+
+def isIncludePattern_regex(pattern: str) -> bool:
+    return isSomething(re.compile(REGEX_INCLUDE_REGEX).match(pattern))
+
+
+def withoutSurroundingSlashes(s: str) -> str:
+    return first(re.subn(re.compile(r"^\/|\/$"), "", s))
+
+
+def regexFromIncludePattern(pattern: str) -> Pattern: # raises re.error
+    return (
+        re.compile(withoutSurroundingSlashes(pattern), re.IGNORECASE)
+        if isIncludePattern_regex(pattern)
+        else re.compile(r"^" + regexify(pattern) + r"$", re.IGNORECASE)
+    )
+
+
+def regexify(segment: str) -> str:
+    return re.escape(segment).replace(r"\*", ".*")
+
+
+# Returns None if the pattern is invalid:
+def extractGroup(group: str, matchPattern: str) -> Optional[str]:
+    try:
+        match: Optional[Match] = REGEX_MATCH_PATTERN.search(normalizeMatchPattern(matchPattern))
+        return None if match is None else match.group(group)
+    except:
+        return None
+
+
+def schemeIn(matchPattern: str) -> Optional[str]:
+    return extractGroup(REGEXGROUP_MATCH_SCHEME, matchPattern)
+
+
+def hostIn(matchPattern: str) -> Optional[str]:
+    return extractGroup(REGEXGROUP_MATCH_HOST, matchPattern)
+
+
+def pathIn(matchPattern: str) -> Optional[str]:
+    return extractGroup(REGEXGROUP_MATCH_PATH, matchPattern)
diff --git a/modules/requests.py b/modules/requests.py
new file mode 100644
index 0000000..f988898
--- /dev/null
+++ b/modules/requests.py
@@ -0,0 +1,18 @@
+# Due to its mitmproxy dependency, this module can only be imported by files run
+# "in" mitm[dump|proxy], e.g. not in the launcher script.
+
+import re
+from typing import Callable, Optional, Pattern
+from mitmproxy import http
+from modules.utilities import equals
+
+CONTENT_TYPE: str = "Content-Type"
+REGEX_CHARSET: Pattern = re.compile(r"charset=([^;\s]+)")
+
+def inferEncoding(response: http.HTTPResponse) -> Optional[str]:
+    httpHeaderValue = response.headers.get(CONTENT_TYPE, "").lower()
+    match = REGEX_CHARSET.search(httpHeaderValue)
+    return match.group(1) if match else None
+
+def requestContainsQueryParam(param: str, request: http.HTTPRequest) -> bool:
+    return any(map(equals(param), request.query))
diff --git a/modules/text.py b/modules/text.py
new file mode 100644
index 0000000..0ca6b8d
--- /dev/null
+++ b/modules/text.py
@@ -0,0 +1,47 @@
+from modules.constants import DEFAULT_PORT, APP_NAME, VERSION, VERSION_PREFIX, DEFAULT_QUERY_PARAM_TO_DISABLE
+
+metavar_file = "FILE"
+metavar_dir = "DIR"
+metavar_param = "PARAM"
+matching = f"matching any of the rules specified in {metavar_file} (file name or glob pattern)"
+
+description = "Inject userscripts using mitmproxy."
+
+option_ignore = "ignore"
+help_ignore = "Intercept all traffic except from hosts " + matching
+
+option_intercept = "intercept"
+help_intercept = "Intercept only traffic from hosts " + matching
+
+option_inline_short = "i"
+option_inline = "inline"
+help_inline = "Always insert userscripts inline, never linked"
+
+option_port_short = "p"
+option_port = "port"
+help_port = f"""mitmproxy port (default: {DEFAULT_PORT})"""
+
+option_query_param_to_disable_short = "q"
+option_query_param_to_disable = "query-param-to-disable"
+help_query_param_to_disable = f"""Disable userscripts when the request URL contains a PARAM query parameter, for example "foo" to disable userscripts for http://example.com?foo (default: {DEFAULT_QUERY_PARAM_TO_DISABLE})"""
+
+option_recursive_short = "r"
+option_recursive = "recursive"
+help_recursive = f"""Recurse into directories when looking for userscripts"""
+
+option_transparent_short = "t"
+option_transparent = "transparent"
+help_transparent = "Transparent mode"
+
+option_userscripts_short = "u"
+option_userscripts = "userscripts"
+help_userscripts = f"Load userscripts from directory {metavar_dir}"
+
+option_list_injected_short = "l"
+option_list_injected = "list-injected"
+help_list_injected = "Insert an HTML comment with a list of injected userscripts"
+
+def stringifyVersion(version: str) -> str:
+    return VERSION_PREFIX + version
+
+INFO_MESSAGE: str = APP_NAME + " " + stringifyVersion(VERSION)
diff --git a/userscript.py b/modules/userscript.py
similarity index 63%
rename from userscript.py
rename to modules/userscript.py
index a9c5653..1f48e70 100644
--- a/userscript.py
+++ b/modules/userscript.py
@@ -1,28 +1,32 @@
 from typing import Optional, Tuple, List, NamedTuple, Callable, Pattern
 import re
-import metadata
 import warnings
 from string import Template
-from utilities import first, second, isSomething, strs, compose2
-from metadata import Metadata, TagValue, PREFIX_TAG, Tag, Tag_string, Tag_boolean
 from urlmatch import urlmatch
-from patterns import isMatchPattern, isIncludePattern, regexFromIncludePattern
+import modules.metadata as metadata
+import modules.inline as inline
+from modules.utilities import first, second, isSomething, strs, compose2, stripIndentation
+from modules.metadata import Metadata, PREFIX_TAG, Tag, Tag_string, Tag_boolean
+from modules.patterns import isMatchPattern, isIncludePattern, regexFromIncludePattern
 
 class UserscriptError(Exception):
     def __init__(self,*args,**kwargs):
         Exception.__init__(self,*args,**kwargs)
 
-directive_name: str = "name"
-directive_version: str = "version"
-directive_run_at: str = "run-at"
-directive_match: str = "match"
-directive_include: str = "include"
-directive_exclude: str = "exclude"
-directive_noframes: str = "noframes"
+REGEX_URL: Pattern = re.compile(r"^https?://")
 
-document_end: str = "document-end"
-document_start: str = "document-start"
-document_idle: str = "document-idle"
+directive_name     : str = "name"
+directive_version  : str = "version"
+directive_run_at   : str = "run-at"
+directive_match    : str = "match"
+directive_include  : str = "include"
+directive_exclude  : str = "exclude"
+directive_noframes : str = "noframes"
+directive_downloadURL : str = "downloadURL"
+
+document_end   : str = "document-end"
+document_start : str = "document-start"
+document_idle  : str = "document-idle"
 
 tag_name: Tag_string = Tag_string(
     name = directive_name,
@@ -66,6 +70,20 @@ def __init__(self,*args,**kwargs):
     required = False,
     predicate = None,
 )
+tag_version: Tag_string = Tag_string(
+    name = directive_version,
+    unique = True,
+    default = None,
+    required = False,
+    predicate = None,
+)
+tag_downloadURL: Tag_string = Tag_string(
+    name = directive_downloadURL,
+    unique = True,
+    default = None,
+    required = False,
+    predicate = lambda val: isSomething(REGEX_URL.match(val)),
+)
 
 METADATA_TAGS: List[Tag] = [
     tag_name,
@@ -74,15 +92,12 @@ def __init__(self,*args,**kwargs):
     tag_noframes,
     tag_include,
     tag_exclude,
-    Tag_string(
-        name = directive_version,
-        unique = True,
-        default = "0.0.0",
-        required = False,
-        predicate = None,
-    ),
+    tag_version,
+    tag_downloadURL,
 ]
 
+validateMetadata: Callable[[Metadata], Metadata] = metadata.validator(METADATA_TAGS)
+
 
 STRING_WARNING_INVALID_REGEX: Template = Template(f"""{PREFIX_TAG}{directive_include}/{PREFIX_TAG}{directive_exclude} patterns starting and ending with `/` are interpreted as regular expressions, and this pattern is not a valid regex:
 
@@ -97,19 +112,22 @@ def __init__(self,*args,**kwargs):
 
 class Userscript(NamedTuple):
     name: str
+    version: Optional[str]
     content: str
     runAt: str
     noframes: bool
     matchPatterns: List[str]
     includePatternRegexes: List[Pattern]
     excludePatternRegexes: List[Pattern]
+    downloadURL: Optional[str]
+    unsafeSequences: List[str] # in <script> tag
 
     def __str__(self) -> str:
         return self.name
 
 
 def create(content: str) -> Userscript:
-    validMetadata: Metadata = metadata.validate(METADATA_TAGS, metadata.parse(metadata.extract(content)))
+    validMetadata: Metadata = validateMetadata(metadata.parse(metadata.extract(content)))
     valueOf = metadata.valueGetter_one(validMetadata)
     allValuesOf = metadata.valueGetter_all(validMetadata)
     includePatternRegexes: List[Pattern] = list(filter(
@@ -128,12 +146,15 @@ def create(content: str) -> Userscript:
     ))
     return Userscript(
         name = str(valueOf(tag_name)),
+        version = None if valueOf(tag_version) is None else str(valueOf(tag_version)),
         content = content,
         runAt = str(valueOf(tag_run_at)),
         noframes = bool(valueOf(tag_noframes)),
         matchPatterns = strs(allValuesOf(tag_match)),
         includePatternRegexes = includePatternRegexes,
         excludePatternRegexes = excludePatternRegexes,
+        downloadURL = None if valueOf(tag_downloadURL) is None else str(valueOf(tag_downloadURL)),
+        unsafeSequences = inline.unsafeSequencesIn(content),
     )
 
 
@@ -152,8 +173,20 @@ def isApplicable(userscript: Userscript) -> bool:
     return isApplicable
 
 
-def wrapInEventListener(event: str, scriptContent: str) -> str:
-    return f"""window.addEventListener("{event}", function() {{\n{scriptContent}\n}});"""
+def withEventListener(event: str) -> Callable[[str], str]:
+    return lambda scriptContent: f"""window.addEventListener("{event}", function() {{\n{scriptContent}\n}});"""
+
+
+def withNoframes(scriptContent: str) -> str:
+    return stripIndentation(f"""
+        if (window.top === window) {{ // {PREFIX_TAG + directive_noframes}
+        {scriptContent}
+        }}
+    """)
+
+
+def withVersionSuffix(url: str, version: Optional[str]) -> str:
+    return url + ("" if version is None else "?v=" + version)
 
 
 def regexFromIncludePattern_safe(pattern: str) -> Optional[Pattern]:
diff --git a/modules/utilities.py b/modules/utilities.py
new file mode 100644
index 0000000..fc5a4e3
--- /dev/null
+++ b/modules/utilities.py
@@ -0,0 +1,55 @@
+from typing import Optional, Iterable, List, Callable, Any, TypeVar, Tuple
+
+A = TypeVar('A')
+B = TypeVar('B')
+C = TypeVar('C')
+
+
+def idem(x: A) -> A:
+    return x
+
+
+def equals(x: A) -> Callable[[A], bool]:
+    return lambda y: x == y
+
+
+def first(tuple: Tuple[A, B]) -> A:
+    (a, b) = tuple
+    return a
+
+
+def second(tuple: Tuple[A, B]) -> B:
+    (a, b) = tuple
+    return b
+
+
+def isSomething(x: Optional[A]) -> bool:
+    return x is not None
+
+
+def strs(xs: Any) -> List[str]:
+    return list(map(str, xs))
+
+
+def compose2(f: Callable[[B], C], g: Callable[[A], B]) -> Callable[[A], C]:
+    return lambda x: f(g(x))
+
+
+def fromOptional(value: Optional[A], fallback: A) -> A:
+    return value if value is not None else fallback
+
+
+def itemList(prefix: str, strs: Iterable[str]) -> str:
+    return "\n".join(map(lambda s: prefix + s, strs))
+
+
+def stripIndentation(string: str) -> str:
+    return "\n".join(map(lambda line: line.lstrip(), string.split("\n")))
+
+
+def flag(name: str) -> str:
+    return "--" + name
+
+
+def shortFlag(name: str) -> str:
+    return "-" + name
diff --git a/patterns.py b/patterns.py
deleted file mode 100644
index 312c82b..0000000
--- a/patterns.py
+++ /dev/null
@@ -1,40 +0,0 @@
-from typing import Pattern
-import re
-from utilities import first, isSomething
-
-REGEX_MATCH_ALL = r"<all_urls>"
-REGEX_MATCH_SCHEME = r"\*|https?"
-REGEX_MATCH_HOST = r"(\*\.)*[^\/\*]+|\*"
-REGEX_MATCH_PATH = r"\/.*"
-
-# Outer parentheses necessary to enclose `|`:
-REGEX_MATCH_PATTERN = re.compile(
-	r"^(?:" + REGEX_MATCH_ALL + r"|(" + REGEX_MATCH_SCHEME + r"):\/\/(" + REGEX_MATCH_HOST + r")(" + REGEX_MATCH_PATH + r"))$"
-)
-
-REGEX_INCLUDE_REGULAR = r"^(.+)$"
-REGEX_INCLUDE_REGEX = r"^\/(.+)\/$"
-
-REGEX_INCLUDE_PATTERN = re.compile(
-	REGEX_INCLUDE_REGEX + "|" + REGEX_INCLUDE_REGULAR
-)
-
-
-def isMatchPattern(pattern: str) -> bool:
-	return isSomething(REGEX_MATCH_PATTERN.match(pattern))
-
-def isIncludePattern(pattern: str) -> bool:
-	return isSomething(REGEX_INCLUDE_PATTERN.match(pattern))
-
-def isIncludePattern_regex(pattern: str) -> bool:
-	return isSomething(re.compile(REGEX_INCLUDE_REGEX).match(pattern))
-
-def withoutSurroundingSlashes(s: str) -> str:
-	return first(re.subn(re.compile(r"^\/|\/$"), "", s))
-
-def regexFromIncludePattern(pattern: str) -> Pattern: # raises re.error
-	return (
-		re.compile(withoutSurroundingSlashes(pattern), re.IGNORECASE)
-        if isIncludePattern_regex(pattern)
-		else re.compile(r"^" + re.escape(pattern).replace(r"\*", ".*") + r"$", re.IGNORECASE)
-	)
diff --git a/shell.nix b/shell.nix
new file mode 100644
index 0000000..8ed5d80
--- /dev/null
+++ b/shell.nix
@@ -0,0 +1,29 @@
+{ pkgs ? import <nixpkgs> {} }:
+
+with pkgs;
+
+let
+  thePythonPackages = pkgs.python37Packages;
+
+  urlmatch = thePythonPackages.buildPythonPackage rec {
+    pname = "urlmatch";
+    version = "1.0.1";
+    name = "${pname}-${version}";
+    src = thePythonPackages.fetchPypi {
+      inherit pname version;
+      sha256 = "0bgb2snkc5jv6nngdxv1pwa5gzqjcm7f8z2lqkpk2frzy0lka31z";
+    };
+    doCheck = false;
+  };
+in
+
+stdenv.mkDerivation {
+  name = "userscript-proxy";
+  buildInputs = [
+    mitmproxy
+    mypy
+    (with thePythonPackages; [
+      beautifulsoup4 urlmatch lxml
+    ])
+  ];
+}
diff --git a/typecheck b/typecheck
old mode 100644
new mode 100755
index bbde462..3651802
--- a/typecheck
+++ b/typecheck
@@ -1,9 +1,10 @@
-#!/bin/bash
+#!/usr/bin/env bash
 
 export MYPYPATH=/usr/local/lib/python3.6/dist-packages/
 
 if [ "$1" == "" ]; then
 	mypy *.py --ignore-missing-imports --follow-imports skip
+	mypy modules/*.py --ignore-missing-imports --follow-imports skip
 else
 	mypy $1 --ignore-missing-imports --follow-imports skip
 fi
diff --git a/userscript-proxy.py b/userscript-proxy.py
deleted file mode 100644
index 02cfcb0..0000000
--- a/userscript-proxy.py
+++ /dev/null
@@ -1,116 +0,0 @@
-from typing import List, Callable, Pattern
-import glob, os, fnmatch, re
-from bs4 import BeautifulSoup
-from mitmproxy import ctx, http
-from metadata import MetadataError
-import userscript
-from userscript import Userscript, UserscriptError, document_end, document_start, document_idle
-from warnings import warn
-from utilities import first, second
-import shlex
-import warnings
-
-def stringifyVersion(version: str) -> str:
-    return VERSION_PREFIX + version
-
-VERSION: str = "0.1.0"
-VERSION_PREFIX: str = "v"
-WELCOME_MESSAGE: str = "Userscript Proxy " + stringifyVersion(VERSION)
-DIRS_USERSCRIPTS: List[str] = ["userscripts"]
-PATTERN_USERSCRIPT: str = "*.user.js"
-RELEVANT_CONTENT_TYPES: List[str] = ["text/html"]
-REGEX_TEXT_HTML: Pattern = re.compile(r"text/html")
-TAB: str = "    "
-
-def logInfo(s: str) -> None:
-    try:
-        ctx.log.info(s)
-    except Exception:
-        print(s)
-
-def logWarning(s: str) -> None:
-    try:
-        ctx.log.warn(s)
-    except Exception:
-        print(s)
-
-def logError(s: str) -> None:
-    try:
-        ctx.log.error(s)
-    except Exception:
-        print(s)
-
-class UserscriptInjector:
-    def __init__(self):
-        self.userscripts: List[Userscript] = []
-        logInfo("")
-        logInfo("╔═" + "═" * len(WELCOME_MESSAGE) + "═╗")
-        logInfo("║ " +           WELCOME_MESSAGE  + " ║")
-        logInfo("╚═" + "═" * len(WELCOME_MESSAGE) + "═╝")
-        logInfo("")
-        logInfo("Loading userscripts ...")
-        loadedUserscripts: List[Tuple[Userscript, str]] = []
-        for directory in DIRS_USERSCRIPTS:
-            logInfo("Looking for userscripts (`"+PATTERN_USERSCRIPT+"`) in directory `"+directory+"` ...")
-            try:
-                os.chdir(directory)
-            except FileNotFoundError:
-                logWarning("Directory `"+directory+"` does not exist.")
-                continue
-            except PermissionError:
-                logError("Permission was denied when trying to read directory `"+DIR_USERSCRIPTS+"`.")
-                continue
-
-            for unsafe_filename in glob.glob(PATTERN_USERSCRIPT):
-                filename = shlex.quote(unsafe_filename)
-                logInfo("Found " + filename + ".")
-                try:
-                    content = open(filename).read()
-                except PermissionError:
-                    logError("Could not read file `"+filename+"`: Permission denied.")
-                    continue
-                except Exception as e:
-                    logError("Could not read file `"+filename+"`: " + str(e))
-                    continue
-                try:
-                    loadedUserscripts.append((userscript.create(content), filename))
-                except MetadataError as err:
-                    logError("Metadata error:")
-                    logError(str(err))
-                    continue
-                except UserscriptError as err:
-                    logError("Userscript error:")
-                    logError(str(err))
-                    continue
-
-        logInfo("")
-        logInfo(str(len(loadedUserscripts)) + " userscript(s) loaded:")
-        for s in loadedUserscripts:
-            logInfo(TAB + "• "+first(s).name+" ("+second(s)+")")
-        logInfo("")
-        self.userscripts = list(map(first, loadedUserscripts))
-
-
-    def response(self, flow: http.HTTPFlow):
-        if "Content-Type" in flow.response.headers:
-            if REGEX_TEXT_HTML.match(flow.response.headers["Content-Type"]):
-                soup = BeautifulSoup(flow.response.content, "html.parser") # TODO: maybe change parser
-                isApplicable: Callable[[Userscript], bool] = userscript.applicableChecker(flow.request.url)
-                for script in self.userscripts:
-                    if isApplicable(script):
-                        logInfo("Injecting %s into %s ..." % (script.name, flow.request.url))
-                        tag = soup.new_tag("script")
-                        if script.runAt == document_start:
-                            tag.string = script.content
-                            soup.head.append(tag)
-                        elif script.runAt == document_idle:
-                            tag.string = userscript.wrapInEventListener("load", script.content)
-                            soup.head.append(tag)
-                        elif script.runAt == document_end:
-                            tag.string = script.content
-                            soup.body.append(tag)
-                flow.response.content = str(soup).encode("utf8")
-
-
-def start():
-    return UserscriptInjector()
diff --git a/userscripts/test.user.js b/userscripts/test.user.js
deleted file mode 100644
index b6b56ca..0000000
--- a/userscripts/test.user.js
+++ /dev/null
@@ -1,14 +0,0 @@
-// ==UserScript==
-// @name         Example Userscript
-// @version      0.1.0
-// @description  A basic example userscript.
-// @author       John Smith
-// @match        *://example.com/*
-// @match        *://www.example.com/*
-// @namespace    mywebsite.example
-// @run-at       document-start
-// ==/UserScript==
-
-var styleElement = document.createElement("style");
-styleElement.textContent = "body { color: red !important; }";
-document.head.appendChild(styleElement);
diff --git a/userscripts/userscript-proxy-test.user.js b/userscripts/userscript-proxy-test.user.js
new file mode 100644
index 0000000..d170b4c
--- /dev/null
+++ b/userscripts/userscript-proxy-test.user.js
@@ -0,0 +1,16 @@
+// ==UserScript==
+// @name         Userscript Proxy Test
+// @version      1.0.0
+// @match        *://example.com/*
+// @match        *://www.example.com/*
+// @run-at       document-start
+// ==/UserScript==
+
+(d => {
+  "use strict";
+  const CSS = "html body { color: green; background-color: #9E9; }";
+  const T = "Userscript Proxy working!";
+  d.head.appendChild(d.createElement("style")).textContent = CSS;
+  d.addEventListener("DOMContentLoaded", _ => (d.querySelector("h1") || d.body).textContent = T);
+})(document);
+
diff --git a/utilities.py b/utilities.py
deleted file mode 100644
index 31362fa..0000000
--- a/utilities.py
+++ /dev/null
@@ -1,26 +0,0 @@
-from typing import List, Callable, Any, TypeVar, Tuple
-
-A = TypeVar('A')
-B = TypeVar('B')
-C = TypeVar('C')
-
-def first(tuple: Tuple[A, B]) -> A:
-    (a, b) = tuple
-    return a
-
-
-def second(tuple: Tuple[A, B]) -> B:
-    (a, b) = tuple
-    return b
-
-
-def isSomething(x: Any) -> bool:
-    return x != None
-
-
-def strs(xs: Any) -> List[str]:
-	return list(map(str, xs))
-
-
-def compose2(f: Callable[[B], C], g: Callable[[A], B]) -> Callable[[A], C]:
-    return lambda x: f(g(x))