FastForward

Don't waste your time with compliance. FastForward automatically skips annoying link shorteners.

Here is a list of all functions that FastForward has to offer. If you want to know more about a specific function, click on the name of the function.

domainBypass
hrefBypass

ODP
setTimeout
setInterval
URL
docSetAttribute
insertInfoBox
transparentProperty
unsafelyAssign
safelyAssign
unsafelyNavigate
safelyNavigate
isGoodLink
unsafelyAssignWithReferrer
decodeURIComponentMod
ensureDomLoaded
ifElement
awaitElement
parseTarget
bypassRequests
persistHash
finish
keepLooking

crowdquery crowdContribute followAndContribute

ffClipboard.set
ffClipboard.get
ffClipboard.free

backgroundScriptBypassClipboard
bypassClipboard
Crowd Functions

These functions allow bypasses to run. However, these have been deprecated in favor of the new MV3 system.
These are kept for reference purposes, but these will not work for making MV3 bypasses.

This function checks if the host name or any subdomain of the host name matches the given domain. If it does, it will run the given function.

Function call: domainBypass(d,f)

Example:

domainBypass("example.com", () => {
    safelyNavigate("https://example1.com")
})

This function checks if the URL matches the given URL. If it does, it will run the given function. Function call: hrefBypass(u,f)

Example:

hrefBypass("https://scarysite.com/thisisavirus", () => {
    safelyNavigate("https://safesite.com/safenow")
})

Defines the property of an object with the given name and options. This can be used to find a part of the DOM needed for bypassing. If it fails, it will throw an error.

Function call (MV2): ODP(t,p,o)
Function call (MV3): this.helpers.ODP(t,p,o)

Example:

ODP(window, "timer", {
    value: 0,
    writable: false
})

Sets a timeout for a function. This is used to bypass link shorteners that use a timer to redirect you.

Function call (MV2): setTimeout(f,t)
Function call (MV3): this.helpers.setTimeout(f,t)

Example:

ifElement("#skip_form", () => {
    Math.random = () => 1
    **setTimeout(() => $("#skip_form").trigger("submit"), 50)** // This is the important part
})

Sets an interval for a function. Will be called every t milliseconds and will go on forever until clearInterval is called.

Function call (MV2): setInterval(f,t)
Function call (MV3): this.helpers.setInterval(f,t)

Example:

 window.setInterval = f => setInterval(f, 1)
 awaitElement(".skip > .wait > .skip > .btn > a[href]", safelyNavigate)

Returns a URL object. Used to find the full URL; useful if the final URL is in the URL.

Function call (MV2): URL
Function call (MV3): this.helpers.URL

Example:

if (URL.pathname.includes("/skip")) {
    // Do something
}

Sets an attribute of the document. This is used to edit the value of a property of an element or create a new element.

Function call (MV2): docSetAttribute(n,v)
Function call (MV3): this.helpers.docSetAttribute(n,v)

Example:

 docSetAttribute("{{channel.adlinkfly_info}}", "")

Inserts an info box into the DOM. This is used to show the user information or to complete a specific step (do a captcha, for example)
In the MV3 version, you will need to import .\helpers\infoBox.js to use this function.

Function call (MV2): insertInfoBox(t)
Function call (MV3): this.helpers.insertInfoBox(t)

Example:

insertInfoBox("{{msg.infoFileHoster}}")) //Not allowed to bypass these sites due to copyright

Sets a property of an object to be transparent. This is used to allow the user to access properties that are normally not accessible. This is useful for sites that lock access to the final site for a predefined amount of time.

Function call (MV2): transparentProperty(na,fun)
Function call (MV3): this.helpers.transparentProperty(na, fun)

Example:

transparentProperty("downloadButton", safelyNavigate)) //Makes the download button clickable

Will directly change the URL of the page. This is the most barebones way to bypass a link shortener.
All other bypassing methods are built on top of this function.

Function call (MV2): unsafelyAssign(u)
Function call (MV3): this.helpers.unsafelyAssign(u)

Example:

unsafelyAssign("https://example.com") //Directly changes the URL

Will check if the URL is safe to navigate to before calling unsafelyAssign. This is used to prevent the user from navigating to a malicious or nonexistent site.

Function call (MV2): safelyAssign(u)
Function call (MV3): this.helpers.safelyAssign(u)

Example:

safelyAssign("https://example.com")  //Checks if the URL is safe to navigate to before changing the URL

Will change the URL of the page directly by routing it through our servers. This is a more secure way to bypass a link shortener, but not as fast as unsafelyAssign. This also prevents the user's IP address from being leaked if the option is turned on in the extension settings.

Function call (MV2): unsafelyNavigate(u)
Function call (MV3): this.helpers.unsafelyNavigate(u)

Example:

unsafelyNavigate("https://example.com") //Changes the URL directly by routing it through our servers

Will check if the URL is safe to navigate to before calling unsafelyNavigate. This is used to prevent the user from navigating to a malicious or nonexistent site. It also routes the URL through our servers to prevent the user's IP address from being leaked.

Function call (MV2): safelyNavigate(u)
Function call (MV3): this.helpers.safelyNavigate(u)

Example:

safelyNavigate("https://example.com") //Checks if URL is safe to navigate before changing the URL through our servers

Checks if the URL is safe to navigate to. Checks if site exists and if it uses safe protocols.

Function call (MV2): isGoodLink(u)
Function call (MV3): this.helpers.isGoodLink(u)

Example:

if (isGoodLink("https://example.com")) {
    // Do something
}

Will change the URL of the page directly by routing it through our servers and setting the referer to the current URL. This is used when the site checks the referer to prevent the user from bypassing the link shortener.

Function call (MV2): unsafelyAssignWithReferer(t, r)
Function call (MV3): this.helpers.unsafelyAssignWithReferer(t, r)

Example:

domainBypass("adbull.me", () => ifElement("form#setc", ({ action }) => {
    unsafelyAssignWithReferer(location.href, action)
}))

Decodes a URI component using a custom script to unescape more character. This is used to decode the URL of a link shortener if needed. This will not usually be needed, as the built-in decodeURIComponent function will usually be enough.

Function call (MV2): decodeURIComponentMod(u)
Function call (MV3): this.helpers.decodeURIComponentMod(u)

Example:

decodeURIComponentMod("https%3A%2F%2Fexample.com") //Decodes the URL

Waits for the DOM to be loaded before calling a function. This is used to prevent the script from running before the DOM is loaded. In mv3, this is not needed, as inserting this.ensure_dom = true in the constructor works in the same manner. However, the function is still available for backwards compatibility and for allowing other functions to work.

Function call (MV2): ensureDomLoaded(f)
Function call (MV3): this.helpers.ensureDomLoaded(f)(Outdated)           this.ensure_dom = true (Recommended)

Example:

ensureDomLoaded(() => {
    domainBypass("srt.am", () => {
    if (document.querySelector(".skip-container")) {
        let f = document.createElement("form")
        f.method = "POST"
        f.innerHTML = '<input type="hidden" name="_image" value="Continue">'
        f = document.documentElement.appendChild(f)
        countIt(() => f.submit())
    }
})
})

For MV3, use this.ensure_dom = true in the constructor instead.

constructor() {
    super()
    this.ensure_dom = true
}

Will set a timer to count down from a specified time and then call a function. This is used to prevent the user from bypassing the link shortener too quickly. By default, this is 10 seconds, you'll need to use setTimeout to use a different time.

Function call (MV2): countIt(f)
Function call (MV3): this.helpers.countIt(f)

Example:

hrefBypass(/(4snip\.pw|flare\.icu)\/(out|decode)\//, () => {
    let f = document.querySelector("form[action^='../out2/']")
    f.setAttribute("action", f.getAttribute("action").replace("../out2/", "../outlink/"))
    countIt(() => f.submit()) //Waiting
})

Will check if an element exists on the page and then call a function by calling ensureDomLoaded. If the element doesn't exist, the function will check if another function is passed and call it if it is. This is used to prevent the script from running if the element doesn't exist. Generally, you will not need to add a second function, but it can be useful at times.

Function call (MV2): ifElement(e, f, f2)
Function call (MV3): this.helpers.ifElement(e, f, f2)

Example:

ifElement("a[href^='https://www.shrinkme.io/']", () => {
    // Do something
})

Will wait for an element to appear on the page and then call a function. This does depend on ensureDomLoaded to make sure it will work. This is used to prevent the script from running if the element doesn't exist.

Function call (MV2): awaitElement(e, f)
Function call (MV3): this.helpers.awaitElement(e, f)

Example:

domainBypass(/bc\.vc|bcvc\.live/, () => {
    window.setInterval = f => setInterval(f, 1)
    awaitElement("a#getLink:not([style^='display'])", a => a.click())
})

Checks for the link inside an <a> tag and returns the url. This is used to get the URL of links hidden inside an <a> tag.

Function call (MV2): parseTarget(tar)
Function call (MV3): this.helpers.parseTarget(tar)

Example:

parseTarget(document.querySelector("a[href^='https://www.example.com/']")) //Returns the URL

Will add an event listener to the page to check for requests and then call a function. This is useful if you need to bypass a link shortener that uses requests to get the final URLs.

Function call (MV2): No MV2 support
Function call (MV3): this.helpers.bypassRequests(f)

Example:

this.helpers.bypassRequests(async data => {
  if (data.currentTarget?.responseText?.includes('tokens')) {
    const response = JSON.parse(data.currentTarget.responseText)

Adds a hash to all forms and links on the page.

Function call (MV2): persistHash(h)
Function call (MV3): this.helpers.persistHash(h)

Example:

if (ignoreCrowdBypass) {
    persistHash("ignoreCrowdBypass")
}

Tells the background script that the bypass is finished. This is used to prevent the script from running again if the user navigates to another page.

Function call (MV2): finish()
Function call (MV3): this.helpers.finish()

Example:

if (location.pathname.substr(0, 13) == "/redirecting/" && document.querySelector("p[style]").textContent == "For your safety, never enter your password unless you're on the real Adf.ly site.") {
    let a = document.querySelector("a[href]")
    if (a) {
        safelyNavigate(a.href)
        return finish()
    }
}

Tells the background script to keep looking for a link.
This is used to prevent the script from running if the element doesn't exist.

Function call (MV2): keepLooking()
Function call (MV3): this.helpers.keepLooking()

Example:

domainBypass(/tr\.link|movienear\.me|lewat\.club|tautan\.pro|(droidtamvan|gubukbisnis|onlinecorp)\.me|(liveshootv|modebaca|haipedia|sekilastekno|miuiku)\.com|shrink\.world|link\.mymastah\.xyz|(sportif|cararoot)\.id|(fcdot|fcc)\.lc/, () => {
    if (typeof app_vars == "undefined") {
        app_vars = {}
    }
    keepLooking()
})

Dispatches a crowdQuery event and returns a promise to get the response.

Function call (MV-3 only): this.helpers.crowdQuery(domain, path)

Returns: A promise that will resolve into the target listed on the Crowd Bypass server.

Example:

this.helpers.crowdQuery("example.com", "a?b=c").then((response) => {
  // handle response
});

This function dispatches a crowdContribute event.

Function call (MV-3 only): this.helpers.crowdContribute(domain, path, target)

Example:

this.helpers.crowdContribute(
  "example.com",
  "path/to/page?a=b",
  "https://destination.example"
);

Dispatches a followAndContribute event. To be used when target http 3xx redirects to the final destination.

Function call: this.helpers.followAndContribute(domain, path, target)

Example:

this.helpers.followAndContribute(
  "example.com",
  "path/to/page?a=b",
  "https://one-time-link.example"
);

This ffclipboard API is used for cross-domain temporary storage. It allows you to store variables that can be used on multiple sites. It provides methods for setting, clearing and getting values in the ffclipboard.

This function gets a value from the ffclipboard.

Function call (MV3): this.helpers.ffclipboard.get(key)

Returns: A promise that resolves with the value.

Example:

this.helpers.ffclipboard.get("key").then((value) => {
  console.log(value);
});

This function sets a value in the ffclipboard.

Note: Remember to clear the value from the ffclipboard as soon as you are done using it, as browser.storage is limited.

Function call (MV-3 only): this.helpers.ffclipboard.set(key, value)

Example:

this.helpers.ffclipboard.set("key", "value");

This function clears a value from the ffclipboard.

Function call (MV-3 only): this.helpers.ffclipboard.clear(key)

Note: Remember to clear the value from the ffclipboard as soon as you are done using it, as browser.storage is limited.

Example:

this.helpers.ffclipboard.clear("key");

These functions are deprecated and have been removed in the MV3 version of the extension.
They are still available for now, but you should not use them.

Helper function that utilized the custom bypass section in the extension settings.
Deprecated in MV3 due to Google no longer allowing unpackaged code in MV3 extensions.

Helped with adding bypasses from the custom bypass section in the extension settings into the main script. Deprecated in MV3 due to Google no longer allowing unpackaged code in MV3 extensions.

MV2 functions that assisted with the crowd bypass system. Their references have been removed in the MV3 extension and from the server, so they will no longer work.