async (a: HTMLAnchorElement) => {
                const section = a.parentNode

                const settingName = a.name.split(".")
                const value = await config.getAsyncDynamic(...settingName)
                if (!value) return console.log("Failed to grab value of ", a)
                if (!["number", "boolean", "string"].includes(typeof value))
                    return console.log(
                        "Not embedding value of ",
                        a,
                        value,
                        " because not easily represented as string",
                    )

                const input = document.createElement("input")
                input.name = a.name
                input.value = value
                input.id = "TridactylSettingInput_" + input.name
                input.className = inputClassName
                input.addEventListener("keyup", onKeyUp)

                const div = document.createElement("div")
                div.appendChild(document.createTextNode("Current value:"))
                div.appendChild(input)

                section.appendChild(div)

                config.addChangeListener(input.name as any, (_, newValue) => {
                    input.value = newValue
                    input.className = inputClassName
                })
            },

    ) {
        THEMED_ELEMENTS.push(element)
    }
}

function retheme() {
    THEMED_ELEMENTS.forEach(element => {
        theme(element).catch(e => {
            logger.warning(
                `Failed to retheme element "${element}". Error: ${e}`,
            )
        })
    })
}

config.addChangeListener("theme", retheme)

// Sometimes pages will overwrite class names of elements. We use a MutationObserver to make sure that the HTML element always has a TridactylTheme class
// We can't just call theme() because it would first try to remove class names from the element, which would trigger the MutationObserver before we had a chance to add the theme class and thus cause infinite recursion
const cb = async mutationList => {
    const theme = await config.getAsync("theme")
    mutationList
        .filter(m => m.target.className.search(prefixTheme("")) === -1)
        .forEach(m => m.target.classList.add(prefixTheme(theme)))
}

new MutationObserver(cb).observe(document.documentElement, {
    attributes: true,
    childList: false,
    characterData: false,
    subtree: false,

        request.clobberCSP,
        { urls: ["<all_urls>"], types: ["main_frame"] },
        ["blocking", "responseHeaders"],
    )
}

function removeCSPListener() {
    browser.webRequest.onHeadersReceived.removeListener(request.clobberCSP)
}

config.getAsync("csp").then(csp => csp === "clobber" && addCSPListener())

config.addChangeListener("csp", (old, cur) => {
    if (cur === "clobber") {
        addCSPListener()
    } else {
        removeCSPListener()
    }
})

// }}}

// Prevent Tridactyl from being updated while it is running in the hope of fixing #290
browser.runtime.onUpdateAvailable.addListener(_ => undefined)

browser.runtime.onStartup.addListener(_ => {
    config.getAsync("autocmds", "TriStart").then(aucmds => {
        const hosts = Object.keys(aucmds)
        // If there's only one rule and it's "all", no need to check the hostname
        if (hosts.length === 1 && hosts[0] === ".*") {
            controller.acceptExCmd(aucmds[hosts[0]])

// Disk operations are extremely slow on windows, let's cache our profile info
let cachedProfile
export async function getProfile() {
    if (cachedProfile === undefined)
        cachedProfile = await getProfileUncached()
    return cachedProfile
}
// It makes sense to pre-fetch this value in the background script because it's
// long-lived. Other contexts are created and destroyed all the time so we
// don't want to pre-fetch in these.
if (getContext() === "background") {
    getProfile()
}
config.addChangeListener("profiledir", (prev, cur) => {
    cachedProfile = undefined
    getProfile()
})

export function getProfileName() {
    return getProfile().then(p => p.Name)
}

export async function getProfileDir() {
    const profiledir = config.get("profiledir")
    if (profiledir !== "auto") return Promise.resolve(profiledir)
    return getProfile().then(p => p.absolutePath)
}

export async function parsePrefs(prefFileContent: string) {
    //  This RegExp currently only deals with " but for correctness it should
    //  also deal with ' and `