Injecting A Script At The Top Of Your HTML Page
By Strictly-Software
If you are developing an extension for either Firefox, Opera or Chrome, Brave, Edge, and Chromium, then you might come across the need to be able to inject some code into the top of your HTML page so that it runs before any other code.
When developing extensions for Chromium based browsers such as Chrome, Brave and Edge, you will most likely do this from your content.js file which is one of the main files that holds code to be run at certain stages of a pages lifetime.
As the Chrome Knowledge Base says the property values for the "run_at" property include;
document_idle, the preferred setting where scripts are guaranteed to run after the DOM is complete and after the window.onload event has loaded all resources which can include other scripts. document_end, content.js scripts are injected immediately after the DOM is complete, but before subresources like images and frames have loaded. So after the DOM is loaded but before window.onload has finished loading external resources. document_start, ensures scripts are injected after any CSS files are loaded but before any other DOM is constructed or any other script is run.
There is of course the "run_at" property in the manifest.json file, which can be set to "document_start", to enable the codes running before other code does. This is especially useful if you need to change header values before a web page loads so that modified values such as the Referer or User-Agent can be modified. However, there may also be a need for you to set up an object or variable that is inserted into the DOM for code within the HTML page to access.
For example in a User-Agent switcher where you need to both overwrite the Navigator object in JavaScript and the Request header, you may want to create an object or variable that holds the original REAL navigator object or its user-agent so that any page you may create yourself or offer to your users the ability to see the REAL user-agent, browser, language, and other properties if they wanted to.
For example, I have my own page that I use to show me the current user-agent and list the navigator properties.
However, if they have been modified by my own user-agent switcher extension I also offer up a variable holding the original REAL user-agent so that it can be shown and compared with the spoofed version to see what has changed. I also have a variable that holds the original navigator object in case I want to look at the properties.
Therefore my HTML page may want to inspect this object if it exists with some code on the page.
// check to see if I can access the original Navigator object and the user agent string
if(typeof(origNavigator) !== 'undefined' && origUserAgent !== null)
{
// get the real Browser name with my Detect Browser function using the original Navigator user-agent
let realBrowser = Browser.DetectBrowser(origUserAgent);
// output on the page in a DIV I have
G("#RealBrowser").innerHTML = "<b>Real Browser: " + realBrowser "</b>";
}This code just uses a generic Browser detection function for taking a user-agent and finding the Browser name. It even detects Brave by ruling out other browsers and if it is Chrome at the end I check for the Brave properties or mention of the word in the string, which they used to have but newer versions have removed it.
However there is hope in the community that they will create a unique user-agent with the word Brave in as at the moment people are having to do object detection which is the better method, and as Brave tries to hide, there are plenty of query strings and other API calls which can be made to find out whether the result indicates Brave rather than Chrome.
However, at the moment, I am just using a simple detection on the window.navigator object that if TRUE indicates that it is actually Brave NOT Chrome.
A later article shows a longer function I developed with fallbacks in case the objects do not exist anymore as there used to be a brave object on the window e.g window.brave that no longer exists, so did many objects for Chrome such as window.google and window.googletag that no longer exist. However, this article explains all that.
This is just the one line test you can do, it ensures it is not FireFox with a test for a Mozilla only object window.mozInnerScreenX and then checks that it is a Chromium browser with tests for window.chrome and that it's also webkit with a test for window.webkitStorageInfo before some tests for navigator.brave and navigator.brave.isBrave to ensure it's Brave not Chrome e.g:
// ensure that a Chrome user-agent is not actually Brave by checking some properties that seem to work to identify the browser at the moment anyway...
let isBrave = !("mozInnerScreenX" in window) && ("chrome" in window && "webkitStorageInfo" in window && "brave" in navigator && "isBrave" in navigator.brave) ? true : false
However, this article is more about injecting a script into the HEAD of your HTML so that code on the page can access any properties within it.
As my extension offers an Original Navigator object and a string holding the original/real user-agent before I overwrite it, then I want this code to be the first piece of JavaScript on the page.
This doesn't have to be limited to extensions and you may have code you want to inject in the HEAD when the DOMLoads before any other code.
This is a function I wrote that attempts to place a string holding your JavaScript into a new Script block I create on the fly and then insert before any other SCRIPT in the document.head.
However, if the page is malformed, or has no defined head area it falls back to just appending the script to the document.documentElement object.
If you pass false in for the 2nd parameter which tells the function whether or not to remove the script after inserting it then if you view the generated source code for the page you will see the injected script code in the DOM.
The code looks within the HEAD for another script block and if found it inserts it before the first one using insertBefore() however if there is NO script block in the HEAD then the function will just insert the script into the HEAD anyway using the appendChild() method.
An example of the function in action with a simple bit of JavaScript that stores the original navigator object and user-agent is below. You might find multiple uses for such code in your own work.
// store the JavaScript in a string
var code = 'var origNavigator = window.navigator; var origUserAgent = origNavigator.userAgent;";
// now call my function that will append the script in the head before any other and then remove it if required. For testing you may want to not remove it so you can view it in the generated DOM.
appendScript(code,true);
// function to append a script first in the DOM in the HEAD, with a true/false parameter that determines whether to remove it after sppending it.
function appendScript(s,r=true){
// build script element up
var script = document.createElement('script');
script.type = 'text/javascript';
script.textContent = s;
// we want our script to run 1st incase the page contains another script e.g we want our code that stores the orig navigator to run before we overwrite it
// check page has a head as it might be old badly written HTML
if(typeof(document.head) !== 'undefined' && document.head !== null)
{
// get a reference to the document.head and also to any first script in the head
let head = document.head;
let scriptone = document.head.getElementsByTagName('script')[0];
// if a script exists then insert it before 1st one so we dont have code referencing navigator before we can overwrite it
if(typeof(scriptone) !== 'undefined' && scriptone !== null){
// add our script before the first script
head.insertBefore(script, scriptone);
// if no script exists then we insert it at the end of the head
}else{
// no script so just append to the HEAD object
document.head.appendChild(script);
}
// no HEAD so fall back to appending the code to the document.documentElement
}else{
// fallback for old HTML just append at end of document and hope no navigator reference is made before this runs
document.documentElement.appendChild(script);
}
// do we remove the script from the DOM
if(r){
// if so remove the script from the DOM
script.remove();
}
}
I find this function very useful for both writing extensions and also when I need to inject code on the fly and ensure it runs before any other scripts by using a onDOMLoad method.
Let me know of any uses you find for it.
Useful Resource: Content Scripts for Chrome Extension Development.
By Strictly-Software
Posts
