2022-09-08 22:04:25 +02:00
|
|
|
window.browser = window.browser || window.chrome
|
|
|
|
|
|
|
|
import utils from "./utils.js"
|
|
|
|
|
2022-10-11 17:11:39 +02:00
|
|
|
let config, options, redirects, targets
|
2022-09-08 22:04:25 +02:00
|
|
|
|
|
|
|
function init() {
|
2022-09-25 20:24:40 +02:00
|
|
|
return new Promise(async resolve => {
|
2022-10-11 17:11:39 +02:00
|
|
|
browser.storage.local.get(["options", "redirects", "targets"], r => {
|
2022-10-02 16:10:36 +02:00
|
|
|
options = r.options
|
|
|
|
redirects = r.redirects
|
2022-10-11 17:11:39 +02:00
|
|
|
targets = r.targets
|
2022-10-02 16:10:36 +02:00
|
|
|
fetch("/config/config.json")
|
|
|
|
.then(response => response.text())
|
|
|
|
.then(configData => {
|
|
|
|
config = JSON.parse(configData)
|
|
|
|
resolve()
|
|
|
|
})
|
2022-09-08 22:04:25 +02:00
|
|
|
})
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2022-10-02 16:10:36 +02:00
|
|
|
init()
|
|
|
|
browser.storage.onChanged.addListener(init)
|
2022-09-27 21:59:25 +02:00
|
|
|
|
2022-10-02 16:10:36 +02:00
|
|
|
function fetchFrontendInstanceList(service, frontend, redirects, options, config) {
|
2022-09-10 21:48:57 +02:00
|
|
|
let tmp = []
|
2022-09-28 21:18:32 +02:00
|
|
|
if (config.services[service].frontends[frontend].instanceList) {
|
2022-09-27 21:59:25 +02:00
|
|
|
for (const network in config.networks) {
|
2022-10-02 16:10:36 +02:00
|
|
|
tmp.push(...redirects[network], ...options[frontend][network].custom)
|
2022-09-27 21:59:25 +02:00
|
|
|
}
|
2022-09-28 21:18:32 +02:00
|
|
|
} else if (config.services[service].frontends[frontend].singleInstance) tmp = config.services[service].frontends[frontend].singleInstance
|
2022-09-11 15:41:06 +02:00
|
|
|
return tmp
|
2022-09-10 21:48:57 +02:00
|
|
|
}
|
|
|
|
|
2022-10-02 16:10:36 +02:00
|
|
|
function all(service, frontend, options, config, redirects) {
|
2022-09-27 21:59:25 +02:00
|
|
|
let instances = []
|
|
|
|
if (!frontend) {
|
|
|
|
for (const frontend in config.services[service].frontends) {
|
2022-10-02 16:10:36 +02:00
|
|
|
instances.push(...fetchFrontendInstanceList(service, frontend, redirects[frontend], options, config))
|
2022-09-27 21:59:25 +02:00
|
|
|
}
|
|
|
|
} else {
|
2022-10-02 16:10:36 +02:00
|
|
|
instances.push(...fetchFrontendInstanceList(service, frontend, redirects[frontend], options, config))
|
2022-09-27 21:59:25 +02:00
|
|
|
}
|
|
|
|
return instances
|
|
|
|
}
|
|
|
|
|
2022-10-02 16:10:36 +02:00
|
|
|
function regexArray(service, url, config) {
|
2022-10-11 17:11:39 +02:00
|
|
|
let targetList
|
|
|
|
if (config.services[service].targets == "datajson") targetList = targets[service]
|
|
|
|
else targetList = config.services[service].targets
|
|
|
|
for (const targetString in targetList) {
|
|
|
|
const target = new RegExp(targetList[targetString])
|
2022-09-23 21:57:25 +02:00
|
|
|
if (target.test(url.href)) return true
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2022-10-08 17:33:39 +02:00
|
|
|
function redirect(url, type, initiator, forceRedirection) {
|
2022-10-05 20:27:27 +02:00
|
|
|
if (type != "main_frame" && type != "sub_frame") return
|
2022-09-11 15:41:06 +02:00
|
|
|
let randomInstance
|
2022-09-19 18:30:39 +02:00
|
|
|
let frontend
|
2022-09-09 23:08:40 +02:00
|
|
|
for (const service in config.services) {
|
2022-10-08 17:33:39 +02:00
|
|
|
if (!forceRedirection && !options[service].enabled) continue
|
2022-09-24 12:44:18 +02:00
|
|
|
if (config.services[service].embeddable && type != options[service].redirectType && options[service].redirectType != "both") continue
|
|
|
|
if (!config.services[service].embeddable && type != "main_frame") continue
|
2022-10-08 12:37:45 +02:00
|
|
|
// let targets = new RegExp(config.services[service].targets.join("|"), "i")
|
2022-09-09 16:55:33 +02:00
|
|
|
|
2022-10-02 16:10:36 +02:00
|
|
|
if (!regexArray(service, url, config)) continue
|
2022-10-08 12:37:45 +02:00
|
|
|
// if (initiator) {
|
|
|
|
// console.log(initiator.host)
|
|
|
|
// if (targets.test(initiator.host)) continue
|
|
|
|
// //if (all(service, null, options, config, redirects).includes(initiator.origin) && reverse(initiator) == url) return "BYPASSTAB"
|
|
|
|
// }
|
2022-09-19 18:30:39 +02:00
|
|
|
|
2022-09-24 12:44:18 +02:00
|
|
|
if (Object.keys(config.services[service].frontends).length > 1) {
|
2022-10-03 20:49:12 +02:00
|
|
|
if (type == "sub_frame" && config.services[service].embeddable && !config.services[service].frontends[options[service].frontend].embeddable) frontend = options[service].embedFrontend
|
2022-10-01 12:17:32 +02:00
|
|
|
else frontend = options[service].frontend
|
|
|
|
} else frontend = Object.keys(config.services[service].frontends)[0]
|
2022-09-19 18:30:39 +02:00
|
|
|
|
|
|
|
if (config.services[service].frontends[frontend].instanceList) {
|
2022-10-02 16:10:36 +02:00
|
|
|
let instanceList = [...options[frontend][options.network].enabled, ...options[frontend][options.network].custom]
|
2022-09-27 21:59:25 +02:00
|
|
|
if (instanceList.length === 0 && options.networkFallback) instanceList = [...options[frontend].clearnet.enabled, ...options[frontend].clearnet.custom]
|
2022-09-24 12:44:18 +02:00
|
|
|
if (instanceList.length === 0) return
|
2022-09-19 18:30:39 +02:00
|
|
|
randomInstance = utils.getRandomInstance(instanceList)
|
2022-09-24 12:44:18 +02:00
|
|
|
} else if (config.services[service].frontends[frontend].singleInstance) randomInstance = config.services[service].frontends[frontend].singleInstance
|
|
|
|
break
|
2022-09-08 22:04:25 +02:00
|
|
|
}
|
2022-10-01 12:17:32 +02:00
|
|
|
if (!frontend) return
|
2022-09-09 16:55:33 +02:00
|
|
|
|
|
|
|
// Here is a (temperory) space for defining constants required in 2 or more switch cases.
|
|
|
|
// When possible, try have the two switch cases share all their code as done with searx and searxng.
|
|
|
|
// Do not do that when they do not share 100% of their code.
|
|
|
|
|
|
|
|
const mapCentreRegex = /@(-?\d[0-9.]*),(-?\d[0-9.]*),(\d{1,2})[.z]/
|
|
|
|
const dataLatLngRegex = /!3d(-?[0-9]{1,}.[0-9]{1,})!4d(-?[0-9]{1,}.[0-9]{1,})/
|
|
|
|
const placeRegex = /\/place\/(.*)\//
|
|
|
|
function convertMapCentre() {
|
2022-09-24 12:44:18 +02:00
|
|
|
let [lat, lon, zoom] = [null, null, null]
|
2022-09-09 16:55:33 +02:00
|
|
|
if (url.pathname.match(mapCentreRegex)) {
|
|
|
|
// Set map centre if present
|
2022-09-24 12:44:18 +02:00
|
|
|
;[lat, lon, zoom] = url.pathname.match(mapCentreRegex)
|
2022-09-09 16:55:33 +02:00
|
|
|
} else if (url.searchParams.has("center")) {
|
|
|
|
;[lat, lon] = url.searchParams.get("center").split(",")
|
|
|
|
zoom = url.searchParams.get("zoom") ?? "17"
|
|
|
|
}
|
|
|
|
return [zoom, lon, lat]
|
|
|
|
}
|
|
|
|
|
2022-09-08 22:04:25 +02:00
|
|
|
switch (frontend) {
|
|
|
|
// This is where all instance-specific code must be ran to convert the service url to one that can be understood by the frontend.
|
|
|
|
case "beatbump":
|
|
|
|
return `${randomInstance}${url.pathname}${url.search}`
|
|
|
|
.replace("/watch?v=", "/listen?id=")
|
|
|
|
.replace("/channel/", "/artist/")
|
|
|
|
.replace("/playlist?list=", "/playlist/VL")
|
2022-09-19 18:30:39 +02:00
|
|
|
.replace(/\/search\?q=.*/, searchQuery => searchQuery.replace("?q=", "/") + "?filter=all")
|
2022-09-08 22:04:25 +02:00
|
|
|
case "hyperpipe":
|
|
|
|
return `${randomInstance}${url.pathname}${url.search}`.replace(/\/search\?q=.*/, searchQuery => searchQuery.replace("?q=", "/"))
|
|
|
|
case "bibliogram":
|
|
|
|
const reservedPaths = ["u", "p", "privacy"]
|
|
|
|
if (url.pathname === "/" || reservedPaths.includes(url.pathname.split("/")[1])) return `${randomInstance}${url.pathname}${url.search}`
|
|
|
|
if (url.pathname.startsWith("/reel") || url.pathname.startsWith("/tv")) return `${randomInstance}/p${url.pathname.replace(/\/reel|\/tv/i, "")}${url.search}`
|
|
|
|
else return `${randomInstance}/u${url.pathname}${url.search}` // Likely a user profile, redirect to '/u/...'
|
|
|
|
case "lbryDesktop":
|
|
|
|
return url.href.replace(/^https?:\/{2}odysee\.com\//, "lbry://").replace(/:(?=[a-zA-Z0-9])/g, "#")
|
|
|
|
case "neuters":
|
|
|
|
if (url.pathname.startsWith("/article/") || url.pathname.startsWith("/pf/") || url.pathname.startsWith("/arc/") || url.pathname.startsWith("/resizer/")) return null
|
|
|
|
else if (url.pathname.endsWith("/")) return `${randomInstance}${url.pathname}`
|
|
|
|
else return `${randomInstance}${url.pathname}/`
|
|
|
|
case "searx":
|
|
|
|
case "searxng":
|
|
|
|
return `${randomInstance}/?q=${encodeURIComponent(url.searchParams.get("q"))}`
|
|
|
|
case "whoogle":
|
|
|
|
return `${randomInstance}/search${encodeURIComponent(url.searchParams.get("q"))}`
|
|
|
|
case "librex":
|
2022-09-24 12:44:18 +02:00
|
|
|
return `${randomInstance}/search.php?q=${encodeURIComponent(url.searchParams.get("q"))}`
|
2022-09-08 22:04:25 +02:00
|
|
|
case "send":
|
|
|
|
return randomInstance
|
|
|
|
case "nitter":
|
2022-10-04 20:10:07 +02:00
|
|
|
let search = new URLSearchParams(url.search)
|
|
|
|
|
|
|
|
search.delete("ref_src")
|
|
|
|
search.delete("ref_url")
|
|
|
|
|
|
|
|
search = search.toString()
|
|
|
|
if (search !== "") search = `?${search}`
|
|
|
|
|
2022-09-08 22:04:25 +02:00
|
|
|
if (url.host.split(".")[0] === "pbs" || url.host.split(".")[0] === "video") {
|
2022-10-06 15:19:05 +02:00
|
|
|
try {
|
|
|
|
const [, id, format, extra] = search.match(/(.*)\?format=(.*)&(.*)/)
|
|
|
|
const query = encodeURIComponent(`${id}.${format}?${extra}`)
|
|
|
|
return `${randomInstance}/pic${url.pathname}${query}`
|
|
|
|
} catch {
|
|
|
|
return `${randomInstance}/pic${url.pathname}${search}`
|
|
|
|
}
|
2022-10-04 20:10:07 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (url.pathname.split("/").includes("tweets")) return `${randomInstance}${url.pathname.replace("/tweets", "")}${search}`
|
|
|
|
if (url.host == "t.co") return `${randomInstance}/t.co${url.pathname}`
|
|
|
|
return `${randomInstance}${url.pathname}${search}`
|
2022-09-26 19:32:32 +02:00
|
|
|
case "yattee":
|
2022-09-08 22:04:25 +02:00
|
|
|
return url.href.replace(/^https?:\/{2}/, "yattee://")
|
|
|
|
case "freetube":
|
2022-09-26 19:32:32 +02:00
|
|
|
return `freetube://https://youtu.be${url.pathname}${url.search}`.replace(/watch\?v=/, "")
|
2022-09-08 22:04:25 +02:00
|
|
|
case "simplyTranslate":
|
|
|
|
return `${randomInstance}/${url.search}`
|
2022-10-04 22:45:39 +02:00
|
|
|
case "libreTranslate":
|
|
|
|
return `${randomInstance}/${url.search}`
|
|
|
|
.replace(/(?<=\/?)sl/, "source")
|
|
|
|
.replace(/(?<=&)tl/, "target")
|
|
|
|
.replace(/(?<=&)text/, "q")
|
2022-09-09 16:55:33 +02:00
|
|
|
case "osm": {
|
|
|
|
if (initiator && initiator.host === "earth.google.com") return
|
2022-09-24 12:44:18 +02:00
|
|
|
const travelModes = {
|
2022-09-09 16:55:33 +02:00
|
|
|
driving: "fossgis_osrm_car",
|
|
|
|
walking: "fossgis_osrm_foot",
|
|
|
|
bicycling: "fossgis_osrm_bike",
|
|
|
|
transit: "fossgis_osrm_car", // not implemented on OSM, default to car.
|
|
|
|
}
|
|
|
|
|
|
|
|
function addressToLatLng(address) {
|
|
|
|
const xmlhttp = new XMLHttpRequest()
|
|
|
|
xmlhttp.open("GET", `https://nominatim.openstreetmap.org/search/${address}?format=json&limit=1`, false)
|
|
|
|
xmlhttp.send()
|
|
|
|
if (xmlhttp.status === 200) {
|
|
|
|
const json = JSON.parse(xmlhttp.responseText)[0]
|
|
|
|
if (json) {
|
|
|
|
console.log("json", json)
|
|
|
|
return [`${json.lat},${json.lon}`, `${json.boundingbox[2]},${json.boundingbox[1]},${json.boundingbox[3]},${json.boundingbox[0]}`]
|
|
|
|
}
|
|
|
|
}
|
|
|
|
console.info("Error: Status is " + xmlhttp.status)
|
|
|
|
}
|
|
|
|
|
|
|
|
let mapCentre = "#"
|
|
|
|
let prefs = {}
|
|
|
|
|
|
|
|
const mapCentreData = convertMapCentre()
|
|
|
|
if (mapCentreData[0] && mapCentreData[1] && mapCentreData[2]) mapCentre = `#map=${mapCentreData[0]}/${mapCentreData[1]}/${mapCentreData[2]}`
|
|
|
|
if (url.searchParams.get("layer")) prefs.layers = osmLayers[url.searchParams.get("layer")]
|
|
|
|
|
|
|
|
if (url.pathname.includes("/embed")) {
|
|
|
|
// Handle Google Maps Embed API
|
|
|
|
// https://www.google.com/maps/embed/v1/place?key=AIzaSyD4iE2xVSpkLLOXoyqT-RuPwURN3ddScAI&q=Eiffel+Tower,Paris+France
|
|
|
|
//console.log("embed life")
|
|
|
|
|
|
|
|
let query = ""
|
|
|
|
if (url.searchParams.has("q")) query = url.searchParams.get("q")
|
|
|
|
else if (url.searchParams.has("query")) query = url.searchParams.has("query")
|
|
|
|
else if (url.searchParams.has("pb"))
|
|
|
|
try {
|
|
|
|
query = url.searchParams.get("pb").split(/!2s(.*?)!/)[1]
|
|
|
|
} catch (error) {
|
|
|
|
console.error(error)
|
|
|
|
} // Unable to find map marker in URL.
|
|
|
|
|
|
|
|
let [coords, boundingbox] = addressToLatLng(query)
|
|
|
|
prefs.bbox = boundingbox
|
|
|
|
prefs.marker = coords
|
|
|
|
prefs.layer = "mapnik"
|
|
|
|
let prefsEncoded = new URLSearchParams(prefs).toString()
|
|
|
|
return `${randomInstance}/export/embed.html?${prefsEncoded}`
|
|
|
|
} else if (url.pathname.includes("/dir")) {
|
|
|
|
// Handle Google Maps Directions
|
|
|
|
// https://www.google.com/maps/dir/?api=1&origin=Space+Needle+Seattle+WA&destination=Pike+Place+Market+Seattle+WA&travelmode=bicycling
|
|
|
|
|
|
|
|
let travMod = url.searchParams.get("travelmode")
|
|
|
|
if (url.searchParams.has("travelmode")) prefs.engine = travelModes[travMod]
|
|
|
|
|
|
|
|
let orgVal = url.searchParams.get("origin")
|
|
|
|
let destVal = url.searchParams.get("destination")
|
|
|
|
|
2022-09-24 12:44:18 +02:00
|
|
|
let org = addressToLatLng(orgVal)
|
|
|
|
let dest = addressToLatLng(destVal)
|
2022-09-09 16:55:33 +02:00
|
|
|
prefs.route = `${org};${dest}`
|
|
|
|
|
|
|
|
let prefsEncoded = new URLSearchParams(prefs).toString()
|
|
|
|
return `${randomInstance}/directions?${prefsEncoded}${mapCentre}`
|
|
|
|
} else if (url.pathname.includes("data=") && url.pathname.match(dataLatLngRegex)) {
|
|
|
|
// Get marker from data attribute
|
|
|
|
// https://www.google.com/maps/place/41%C2%B001'58.2%22N+40%C2%B029'18.2%22E/@41.032833,40.4862063,17z/data=!3m1!4b1!4m6!3m5!1s0x0:0xf64286eaf72fc49d!7e2!8m2!3d41.0328329!4d40.4883948
|
|
|
|
//console.log("data life")
|
|
|
|
|
|
|
|
let [, mlat, mlon] = url.pathname.match(dataLatLngRegex)
|
|
|
|
|
|
|
|
return `${randomInstance}/search?query=${mlat}%2C${mlon}`
|
|
|
|
} else if (url.searchParams.has("ll")) {
|
|
|
|
// Get marker from ll param
|
|
|
|
// https://maps.google.com/?ll=38.882147,-76.99017
|
|
|
|
//console.log("ll life")
|
|
|
|
|
|
|
|
const [mlat, mlon] = url.searchParams.get("ll").split(",")
|
|
|
|
|
|
|
|
return `${randomInstance}/search?query=${mlat}%2C${mlon}`
|
|
|
|
} else if (url.searchParams.has("viewpoint")) {
|
|
|
|
// Get marker from viewpoint param.
|
|
|
|
// https://www.google.com/maps/@?api=1&map_action=pano&viewpoint=48.857832,2.295226&heading=-45&pitch=38&fov=80
|
|
|
|
//console.log("viewpoint life")
|
|
|
|
|
|
|
|
const [mlat, mlon] = url.searchParams.get("viewpoint").split(",")
|
|
|
|
|
|
|
|
return `${randomInstance}/search?query=${mlat}%2C${mlon}`
|
|
|
|
} else {
|
|
|
|
// Use query as search if present.
|
|
|
|
//console.log("normal life")
|
|
|
|
|
|
|
|
let query
|
|
|
|
if (url.searchParams.has("q")) query = url.searchParams.get("q")
|
|
|
|
else if (url.searchParams.has("query")) query = url.searchParams.get("query")
|
|
|
|
else if (url.pathname.match(placeRegex)) query = url.pathname.match(placeRegex)[1]
|
|
|
|
|
|
|
|
let prefsEncoded = new URLSearchParams(prefs).toString()
|
|
|
|
if (query) return `${randomInstance}/search?query="${query}${mapCentre}&${prefsEncoded}`
|
|
|
|
}
|
|
|
|
|
|
|
|
let prefsEncoded = new URLSearchParams(prefs).toString()
|
|
|
|
console.log("mapCentre", mapCentre)
|
|
|
|
console.log("prefs", prefs)
|
|
|
|
console.log("prefsEncoded", prefsEncoded)
|
|
|
|
return `${randomInstance}/${mapCentre}&${prefsEncoded}`
|
|
|
|
}
|
|
|
|
case "facil": {
|
|
|
|
if (initiator && initiator.host === "earth.google.com") return
|
2022-09-24 12:44:18 +02:00
|
|
|
const travelModes = {
|
2022-09-09 16:55:33 +02:00
|
|
|
driving: "car",
|
|
|
|
walking: "pedestrian",
|
|
|
|
bicycling: "bicycle",
|
|
|
|
transit: "car", // not implemented on Facil, default to car.
|
|
|
|
}
|
|
|
|
const mapCentreData = convertMapCentre()
|
|
|
|
let mapCentre = "#"
|
|
|
|
if (mapCentreData[0] && mapCentreData[1] && mapCentreData[2]) mapCentre = `#${mapCentreData[0]}/${mapCentreData[1]}/${mapCentreData[2]}`
|
|
|
|
|
|
|
|
if (url.pathname.includes("/embed")) {
|
|
|
|
// Handle Google Maps Embed API
|
|
|
|
// https://www.google.com/maps/embed/v1/place?key=AIzaSyD4iE2xVSpkLLOXoyqT-RuPwURN3ddScAI&q=Eiffel+Tower,Paris+France
|
|
|
|
//console.log("embed life")
|
|
|
|
|
|
|
|
let query = ""
|
|
|
|
if (url.searchParams.has("q")) query = url.searchParams.get("q")
|
|
|
|
else if (url.searchParams.has("query")) query = url.searchParams.has("query")
|
|
|
|
else if (url.searchParams.has("pb"))
|
|
|
|
try {
|
|
|
|
query = url.searchParams.get("pb").split(/!2s(.*?)!/)[1]
|
|
|
|
} catch (error) {
|
|
|
|
console.error(error)
|
|
|
|
} // Unable to find map marker in URL.
|
|
|
|
|
|
|
|
return `${randomInstance}/#q=${query}`
|
|
|
|
} else if (url.pathname.includes("/dir")) {
|
|
|
|
// Handle Google Maps Directions
|
|
|
|
// https://www.google.com/maps/dir/?api=1&origin=Space+Needle+Seattle+WA&destination=Pike+Place+Market+Seattle+WA&travelmode=bicycling
|
|
|
|
|
|
|
|
let travMod = url.searchParams.get("travelmode")
|
|
|
|
|
|
|
|
let orgVal = url.searchParams.get("origin")
|
|
|
|
let destVal = url.searchParams.get("destination")
|
|
|
|
|
|
|
|
return `${randomInstance}/#q=${orgVal}%20to%20${destVal}%20by%20${travelModes[travMod]}`
|
|
|
|
} else if (url.pathname.includes("data=") && url.pathname.match(dataLatLngRegex)) {
|
|
|
|
// Get marker from data attribute
|
|
|
|
// https://www.google.com/maps/place/41%C2%B001'58.2%22N+40%C2%B029'18.2%22E/@41.032833,40.4862063,17z/data=!3m1!4b1!4m6!3m5!1s0x0:0xf64286eaf72fc49d!7e2!8m2!3d41.0328329!4d40.4883948
|
|
|
|
//console.log("data life")
|
|
|
|
|
|
|
|
let [, mlat, mlon] = url.pathname.match(dataLatLngRegex)
|
|
|
|
|
|
|
|
return `${randomInstance}/#q=${mlat}%2C${mlon}`
|
|
|
|
} else if (url.searchParams.has("ll")) {
|
|
|
|
// Get marker from ll param
|
|
|
|
// https://maps.google.com/?ll=38.882147,-76.99017
|
|
|
|
//console.log("ll life")
|
|
|
|
|
|
|
|
const [mlat, mlon] = url.searchParams.get("ll").split(",")
|
|
|
|
|
|
|
|
return `${randomInstance}/#q=${mlat}%2C${mlon}`
|
|
|
|
} else if (url.searchParams.has("viewpoint")) {
|
|
|
|
// Get marker from viewpoint param.
|
|
|
|
// https://www.google.com/maps/@?api=1&map_action=pano&viewpoint=48.857832,2.295226&heading=-45&pitch=38&fov=80
|
|
|
|
//console.log("viewpoint life")
|
|
|
|
|
|
|
|
const [mlat, mlon] = url.searchParams.get("viewpoint").split(",")
|
|
|
|
|
|
|
|
return `${randomInstance}/#q=${mlat}%2C${mlon}`
|
|
|
|
} else {
|
|
|
|
// Use query as search if present.
|
|
|
|
//console.log("normal life")
|
|
|
|
|
|
|
|
let query
|
|
|
|
if (url.searchParams.has("q")) query = url.searchParams.get("q")
|
|
|
|
else if (url.searchParams.has("query")) query = url.searchParams.get("query")
|
|
|
|
else if (url.pathname.match(placeRegex)) query = url.pathname.match(placeRegex)[1]
|
|
|
|
|
|
|
|
if (query) return `${randomInstance}/${mapCentre}/Mpnk/${query}`
|
|
|
|
}
|
|
|
|
}
|
|
|
|
case "wikiless":
|
|
|
|
let GETArguments = []
|
|
|
|
if (url.search.length > 0) {
|
|
|
|
let search = url.search.substring(1) //get rid of '?'
|
|
|
|
let argstrings = search.split("&")
|
|
|
|
for (let i = 0; i < argstrings.length; i++) {
|
|
|
|
let args = argstrings[i].split("=")
|
|
|
|
GETArguments.push([args[0], args[1]])
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
let link = `${randomInstance}${url.pathname}`
|
|
|
|
let urlSplit = url.host.split(".")
|
|
|
|
if (urlSplit[0] != "wikipedia" && urlSplit[0] != "www") {
|
|
|
|
if (urlSplit[0] == "m") GETArguments.push(["mobileaction", "toggle_view_mobile"])
|
|
|
|
else GETArguments.push(["lang", urlSplit[0]])
|
|
|
|
if (urlSplit[1] == "m") GETArguments.push(["mobileaction", "toggle_view_mobile"])
|
|
|
|
// wikiless doesn't have mobile view support yet
|
|
|
|
}
|
|
|
|
for (let i = 0; i < GETArguments.length; i++) link += (i == 0 ? "?" : "&") + GETArguments[i][0] + "=" + GETArguments[i][1]
|
|
|
|
return link
|
|
|
|
|
|
|
|
case "lingva":
|
|
|
|
let params_arr = url.search.split("&")
|
|
|
|
params_arr[0] = params_arr[0].substring(1)
|
|
|
|
let params = {}
|
|
|
|
for (let i = 0; i < params_arr.length; i++) {
|
|
|
|
let pair = params_arr[i].split("=")
|
|
|
|
params[pair[0]] = pair[1]
|
|
|
|
}
|
|
|
|
if (params.sl && params.tl && params.text) {
|
|
|
|
return `${randomInstance}/${params.sl}/${params.tl}/${params.text}`
|
|
|
|
}
|
|
|
|
return randomInstance
|
2022-10-05 18:29:27 +02:00
|
|
|
case "breezeWiki":
|
2022-10-10 04:32:20 +02:00
|
|
|
let wiki = url.hostname.match(/^[a-zA-Z0-9-]+(?=\.fandom\.com)/)
|
2022-10-05 18:29:27 +02:00
|
|
|
if (wiki == "www" || !wiki) wiki = ""
|
|
|
|
else wiki = "/" + wiki
|
2022-10-05 19:00:27 +02:00
|
|
|
if (url.href.search(/Special:Search\?query/) > -1) return `${randomInstance}${wiki}${url.pathname}${url.search}`.replace(/Special:Search\?query/, "search?q").replace(/\/wiki/, "")
|
|
|
|
else return `${randomInstance}${wiki}${url.pathname}${url.search}`
|
2022-10-05 20:27:27 +02:00
|
|
|
case "rimgo":
|
|
|
|
if (url.href.search(/^https?:\/{2}(?:[im]\.)?stack\./) > -1) return `${randomInstance}/stack${url.pathname}${url.search}`
|
|
|
|
else return `${randomInstance}${url.pathname}${url.search}`
|
2022-10-15 06:28:04 +02:00
|
|
|
case "libreddit":
|
|
|
|
if (url.hostname.match(/^(i|preview)\.redd\.it/)) {
|
|
|
|
return `${randomInstance}/img${url.pathname}`
|
|
|
|
}
|
|
|
|
return `${randomInstance}${url.pathname}${url.search}`
|
2022-09-08 22:04:25 +02:00
|
|
|
default:
|
|
|
|
return `${randomInstance}${url.pathname}${url.search}`
|
2022-09-09 16:55:33 +02:00
|
|
|
}
|
2022-09-08 22:04:25 +02:00
|
|
|
}
|
|
|
|
|
2022-10-02 17:23:17 +02:00
|
|
|
function computeService(url, returnFrontend) {
|
|
|
|
return new Promise(resolve => {
|
|
|
|
fetch("/config/config.json")
|
|
|
|
.then(response => response.text())
|
|
|
|
.then(configData => {
|
|
|
|
const config = JSON.parse(configData)
|
|
|
|
browser.storage.local.get(["redirects", "options"], r => {
|
|
|
|
const redirects = r.redirects
|
|
|
|
const options = r.options
|
|
|
|
for (const service in config.services) {
|
|
|
|
if (regexArray(service, url, config)) {
|
2022-10-06 15:19:05 +02:00
|
|
|
resolve(service)
|
2022-10-02 17:23:17 +02:00
|
|
|
return
|
|
|
|
} else {
|
|
|
|
for (const frontend in config.services[service].frontends) {
|
|
|
|
if (all(service, frontend, options, config, redirects).includes(utils.protocolHost(url))) {
|
2022-10-09 14:11:05 +02:00
|
|
|
if (returnFrontend) resolve([service, frontend, utils.protocolHost(url)])
|
2022-10-06 15:19:05 +02:00
|
|
|
else resolve(service)
|
2022-10-02 17:23:17 +02:00
|
|
|
return
|
|
|
|
}
|
2022-10-02 16:10:36 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2022-10-03 07:44:49 +02:00
|
|
|
resolve()
|
2022-10-02 17:23:17 +02:00
|
|
|
})
|
2022-10-02 16:10:36 +02:00
|
|
|
})
|
2022-10-02 17:23:17 +02:00
|
|
|
})
|
2022-09-23 21:57:25 +02:00
|
|
|
}
|
|
|
|
|
2022-10-03 07:44:49 +02:00
|
|
|
function switchInstance(url) {
|
|
|
|
return new Promise(async resolve => {
|
|
|
|
await init()
|
|
|
|
const protocolHost = utils.protocolHost(url)
|
|
|
|
for (const service in config.services) {
|
|
|
|
if (!all(service, null, options, config, redirects).includes(protocolHost)) continue
|
|
|
|
|
2022-10-05 20:27:27 +02:00
|
|
|
let instancesList
|
|
|
|
if (Object.keys(config.services[service].frontends).length == 1) {
|
|
|
|
const frontend = Object.keys(config.services[service].frontends)[0]
|
|
|
|
instancesList = [...options[frontend][options.network].enabled, ...options[frontend][options.network].custom]
|
|
|
|
if (instancesList.length === 0 && options.networkFallback) instancesList = [...options[frontend].clearnet.enabled, ...options[frontend].clearnet.custom]
|
|
|
|
} else {
|
|
|
|
const frontend = options[service].frontend
|
|
|
|
instancesList = [...options[frontend][options.network].enabled, ...options[frontend][options.network].custom]
|
|
|
|
if (instancesList.length === 0 && options.networkFallback) instancesList = [...options[frontend].clearnet.enabled, ...options[frontend].clearnet.custom]
|
|
|
|
}
|
2022-10-03 07:44:49 +02:00
|
|
|
|
|
|
|
let oldInstance
|
|
|
|
const i = instancesList.indexOf(protocolHost)
|
|
|
|
if (i > -1) {
|
|
|
|
oldInstance = instancesList[i]
|
|
|
|
instancesList.splice(i, 1)
|
|
|
|
}
|
|
|
|
if (instancesList.length === 0) {
|
|
|
|
resolve()
|
|
|
|
return
|
|
|
|
}
|
|
|
|
const randomInstance = utils.getRandomInstance(instancesList)
|
|
|
|
const oldUrl = `${oldInstance}${url.pathname}${url.search}`
|
|
|
|
// This is to make instance switching work when the instance depends on the pathname, eg https://darmarit.org/searx
|
|
|
|
// Doesn't work because of .includes array method, not a top priotiry atm
|
|
|
|
resolve(oldUrl.replace(oldInstance, randomInstance))
|
|
|
|
return
|
|
|
|
}
|
|
|
|
resolve()
|
|
|
|
})
|
2022-09-25 18:27:43 +02:00
|
|
|
}
|
|
|
|
|
2022-10-08 12:37:45 +02:00
|
|
|
function reverse(url, urlString) {
|
2022-10-03 07:44:49 +02:00
|
|
|
return new Promise(async resolve => {
|
|
|
|
await init()
|
2022-10-08 12:37:45 +02:00
|
|
|
let protocolHost
|
|
|
|
if (!urlString) protocolHost = utils.protocolHost(url)
|
|
|
|
else protocolHost = url.match(/https?:\/{2}(?:[^\s\/]+\.)+[a-zA-Z0-9]+/)[0]
|
2022-10-03 07:44:49 +02:00
|
|
|
for (const service in config.services) {
|
|
|
|
if (!all(service, null, options, config, redirects).includes(protocolHost)) continue
|
|
|
|
|
|
|
|
switch (service) {
|
|
|
|
case "instagram":
|
|
|
|
case "youtube":
|
|
|
|
case "imdb":
|
|
|
|
case "imgur":
|
|
|
|
case "tiktok":
|
|
|
|
case "twitter":
|
|
|
|
case "reddit":
|
2022-10-08 12:37:45 +02:00
|
|
|
case "imdb":
|
|
|
|
case "reuters":
|
|
|
|
case "quora":
|
|
|
|
case "medium":
|
|
|
|
if (!urlString) resolve(config.services[service].url + url.pathname + url.search)
|
|
|
|
else resolve(url.replace(/https?:\/{2}(?:[^\s\/]+\.)+[a-zA-Z0-9]+/, config.services[service].url))
|
2022-10-03 07:44:49 +02:00
|
|
|
return
|
|
|
|
default:
|
|
|
|
resolve()
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
resolve()
|
|
|
|
})
|
2022-09-26 19:32:32 +02:00
|
|
|
}
|
|
|
|
|
2022-10-03 07:44:49 +02:00
|
|
|
function unifyPreferences(url, tabId) {
|
|
|
|
return new Promise(async resolve => {
|
|
|
|
await init()
|
|
|
|
const protocolHost = utils.protocolHost(url)
|
|
|
|
for (const service in config.services) {
|
|
|
|
for (const frontend in config.services[service].frontends) {
|
|
|
|
if (all(service, frontend, options, config, redirects).includes(protocolHost)) {
|
|
|
|
let instancesList = [...options[frontend][options.network].enabled, ...options[frontend][options.network].custom]
|
|
|
|
if (options.networkFallback && options.network != "clearnet") instancesList.push(...options[frontend].clearnet.enabled, ...options[frontend].clearnet.custom)
|
|
|
|
|
|
|
|
const frontendObject = config.services[service].frontends[frontend]
|
|
|
|
if ("cookies" in frontendObject.preferences) {
|
|
|
|
for (const cookie of frontendObject.preferences.cookies) {
|
2022-10-15 17:02:59 +02:00
|
|
|
await utils.copyCookie(url, instancesList, cookie)
|
2022-10-03 07:44:49 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if ("localstorage" in frontendObject.preferences) {
|
|
|
|
browser.storage.local.set({ tmp: [frontend, frontendObject.preferences.localstorage] })
|
|
|
|
browser.tabs.executeScript(tabId, {
|
|
|
|
file: "/assets/javascripts/get-localstorage.js",
|
|
|
|
runAt: "document_start",
|
|
|
|
})
|
|
|
|
for (const instance of instancesList)
|
|
|
|
browser.tabs.create({ url: instance }, tab =>
|
|
|
|
browser.tabs.executeScript(tab.id, {
|
|
|
|
file: "/assets/javascripts/set-localstorage.js",
|
2022-10-02 16:10:36 +02:00
|
|
|
runAt: "document_start",
|
|
|
|
})
|
2022-10-03 07:44:49 +02:00
|
|
|
)
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
if ("indexeddb" in frontendObject.preferences) {
|
2022-10-02 16:10:36 +02:00
|
|
|
}
|
2022-10-03 07:44:49 +02:00
|
|
|
if ("token" in frontendObject.preferences) {
|
|
|
|
}
|
|
|
|
*/
|
|
|
|
resolve(true)
|
|
|
|
return
|
2022-09-27 21:59:25 +02:00
|
|
|
}
|
2022-10-03 07:44:49 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
})
|
2022-10-02 16:10:36 +02:00
|
|
|
}
|
2022-09-27 21:59:25 +02:00
|
|
|
|
2022-10-02 16:10:36 +02:00
|
|
|
async function setRedirects(redirects) {
|
|
|
|
fetch("/config/config.json")
|
|
|
|
.then(response => response.text())
|
|
|
|
.then(configData => {
|
|
|
|
//browser.storage.local.get(["options", "blacklists"], async r => {
|
|
|
|
//const options = r.options
|
|
|
|
const config = JSON.parse(configData)
|
|
|
|
let targets = {}
|
|
|
|
for (const service in config.services) {
|
|
|
|
if (config.services[service].targets == "datajson") {
|
|
|
|
targets[service] = redirects[service]
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
for (const frontend in config.services[service].frontends) {
|
|
|
|
if (config.services[service].frontends[frontend].instanceList) {
|
|
|
|
for (const network in config.networks) {
|
|
|
|
options[frontend][network].enabled = redirects[frontend][network]
|
|
|
|
}
|
|
|
|
for (const blacklist in r.blacklists) {
|
|
|
|
for (const instance of blacklist) {
|
|
|
|
let i = options[frontend].clearnet.enabled.indexOf(instance)
|
|
|
|
if (i > -1) options[frontend].clearnet.enabled.splice(i, 1)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
*/
|
|
|
|
// The above will be implemented with https://github.com/libredirect/libredirect/issues/334
|
2022-09-27 21:59:25 +02:00
|
|
|
}
|
2022-10-02 16:10:36 +02:00
|
|
|
browser.storage.local.set({ redirects, targets /*, options*/ })
|
|
|
|
//})
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
function initDefaults() {
|
|
|
|
return new Promise(resolve => {
|
|
|
|
fetch("/instances/data.json")
|
|
|
|
.then(response => response.text())
|
|
|
|
.then(data => {
|
|
|
|
fetch("/config/config.json")
|
|
|
|
.then(response => response.text())
|
|
|
|
.then(configData => {
|
|
|
|
browser.storage.local.get(["options", "blacklists"], r => {
|
|
|
|
let redirects = JSON.parse(data)
|
|
|
|
let options = r.options
|
|
|
|
let targets = {}
|
|
|
|
let config = JSON.parse(configData)
|
|
|
|
const localstorage = {}
|
|
|
|
const latency = {}
|
|
|
|
for (const service in config.services) {
|
|
|
|
options[service] = {}
|
2022-10-06 15:19:05 +02:00
|
|
|
if (config.services[service].targets == "datajson") targets[service] = redirects[service]
|
|
|
|
for (const defaultOption in config.services[service].options) options[service][defaultOption] = config.services[service].options[defaultOption]
|
2022-10-02 16:10:36 +02:00
|
|
|
for (const frontend in config.services[service].frontends) {
|
|
|
|
if (config.services[service].frontends[frontend].instanceList) {
|
|
|
|
options[frontend] = {}
|
|
|
|
for (const network in config.networks) {
|
|
|
|
options[frontend][network] = {}
|
|
|
|
options[frontend][network].enabled = JSON.parse(data)[frontend][network]
|
|
|
|
options[frontend][network].custom = []
|
|
|
|
}
|
|
|
|
for (const blacklist in r.blacklists) {
|
|
|
|
for (const instance of r.blacklists[blacklist]) {
|
|
|
|
let i = options[frontend].clearnet.enabled.indexOf(instance)
|
|
|
|
if (i > -1) options[frontend].clearnet.enabled.splice(i, 1)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
browser.storage.local.set({ redirects, options, targets, latency, localstorage })
|
|
|
|
resolve()
|
|
|
|
})
|
2022-09-30 15:54:56 +02:00
|
|
|
})
|
2022-10-02 16:10:36 +02:00
|
|
|
})
|
2022-09-27 21:59:25 +02:00
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2022-10-02 16:10:36 +02:00
|
|
|
function upgradeOptions() {
|
|
|
|
return new Promise(resolve => {
|
|
|
|
fetch("/config/config.json")
|
|
|
|
.then(response => response.text())
|
|
|
|
.then(configData => {
|
2022-10-03 07:44:49 +02:00
|
|
|
browser.storage.local.get(null, r => {
|
2022-10-02 16:10:36 +02:00
|
|
|
let options = r.options
|
|
|
|
let latency = {}
|
|
|
|
const config = JSON.parse(configData)
|
|
|
|
options.exceptions = r.exceptions
|
|
|
|
if (r.theme != "DEFAULT") options.theme = r.theme
|
|
|
|
options.popupServices = r.popupFrontends
|
2022-10-03 07:44:49 +02:00
|
|
|
let tmp = options.popupServices.indexOf("tikTok")
|
|
|
|
if (tmp > -1) {
|
|
|
|
options.popupServices.splice(tmp, 1)
|
|
|
|
options.popupServices.push("tiktok")
|
|
|
|
}
|
|
|
|
tmp = options.popupServices.indexOf("sendTarget")
|
|
|
|
if (tmp > -1) {
|
|
|
|
options.popupServices.splice(tmp, 1)
|
|
|
|
options.popupServices.push("sendFiles")
|
|
|
|
}
|
2022-10-02 16:10:36 +02:00
|
|
|
options.autoRedirect = r.autoRedirect
|
2022-10-03 07:44:49 +02:00
|
|
|
switch (r.onlyEmbeddedVideo) {
|
|
|
|
case "onlyNotEmbedded":
|
|
|
|
options.youtube.redirectType = "main_frame"
|
|
|
|
case "onlyEmbedded":
|
|
|
|
options.youtube.redirectType = "sub_frame"
|
|
|
|
case "both":
|
|
|
|
options.youtube.redirectType = "both"
|
|
|
|
}
|
2022-10-02 16:10:36 +02:00
|
|
|
for (const service in config.services) {
|
2022-10-03 07:44:49 +02:00
|
|
|
let oldService
|
|
|
|
switch (service) {
|
|
|
|
case "tiktok":
|
|
|
|
oldService = "tikTok"
|
|
|
|
break
|
|
|
|
case "sendFiles":
|
|
|
|
oldService = "sendTarget"
|
|
|
|
break
|
|
|
|
default:
|
|
|
|
oldService = service
|
|
|
|
}
|
|
|
|
options[service].enabled = !r["disable" + utils.camelCase(oldService)]
|
|
|
|
if (r[oldService + "Frontend"]) {
|
|
|
|
if (r[oldService + "Frontend"] == "yatte") options[service].frontend = "yattee"
|
|
|
|
else options[service].frontend = r[oldService + "Frontend"]
|
|
|
|
}
|
|
|
|
if (r[oldService + "RedirectType"]) options[service].redirectType = r[oldService + "RedirectType"]
|
|
|
|
if (r[oldService + "EmbedFrontend"] && (service != "youtube" || r[oldService + "EmbedFrontend"] == "invidious" || r[oldService + "EmbedFrontend"] == "piped"))
|
|
|
|
options[service].embedFrontend = r[oldService + "EmbedFrontend"]
|
|
|
|
for (const frontend in config.services[service].frontends) {
|
|
|
|
if (r[frontend + "Latency"]) latency[frontend] = r[frontend + "Latency"]
|
|
|
|
for (const network in config.networks) {
|
|
|
|
let protocol
|
|
|
|
if (network == "clearnet") protocol = "normal"
|
|
|
|
else protocol = network
|
|
|
|
if (r[frontend + utils.camelCase(protocol) + "RedirectsChecks"]) {
|
|
|
|
options[frontend][network].enabled = r[frontend + utils.camelCase(protocol) + "RedirectsChecks"]
|
|
|
|
options[frontend][network].custom = r[frontend + utils.camelCase(protocol) + "CustomRedirects"]
|
2022-10-02 16:10:36 +02:00
|
|
|
}
|
|
|
|
}
|
2022-10-03 07:44:49 +02:00
|
|
|
}
|
2022-09-27 21:59:25 +02:00
|
|
|
}
|
2022-10-03 07:44:49 +02:00
|
|
|
browser.storage.local.set({ options, latency }, () => resolve())
|
2022-10-02 16:10:36 +02:00
|
|
|
})
|
|
|
|
})
|
|
|
|
})
|
2022-09-27 21:59:25 +02:00
|
|
|
}
|
|
|
|
|
2022-10-05 18:29:27 +02:00
|
|
|
function processUpdate() {
|
|
|
|
return new Promise(resolve => {
|
|
|
|
fetch("/instances/data.json")
|
|
|
|
.then(response => response.text())
|
|
|
|
.then(data => {
|
|
|
|
fetch("/config/config.json")
|
|
|
|
.then(response => response.text())
|
|
|
|
.then(configData => {
|
|
|
|
browser.storage.local.get(["options", "blacklists", "targets"], r => {
|
|
|
|
let redirects = JSON.parse(data)
|
|
|
|
let options = r.options
|
|
|
|
let targets = r.targets
|
|
|
|
let config = JSON.parse(configData)
|
|
|
|
for (const service in config.services) {
|
2022-10-06 15:19:05 +02:00
|
|
|
if (!options[service]) options[service] = {}
|
|
|
|
if (config.services[service].targets == "datajson") targets[service] = redirects[service]
|
|
|
|
for (const defaultOption in config.services[service].options) if (!options[service][defaultOption]) options[service][defaultOption] = config.services[service].options[defaultOption]
|
2022-10-05 18:29:27 +02:00
|
|
|
for (const frontend in config.services[service].frontends) {
|
2022-10-06 15:19:05 +02:00
|
|
|
if (config.services[service].frontends[frontend].instanceList) {
|
2022-10-06 22:12:51 +02:00
|
|
|
if (!options[frontend]) options[frontend] = {}
|
2022-10-06 15:19:05 +02:00
|
|
|
for (const network in config.networks) {
|
|
|
|
if (!options[frontend][network]) {
|
2022-10-05 18:29:27 +02:00
|
|
|
options[frontend][network] = {}
|
|
|
|
options[frontend][network].enabled = JSON.parse(data)[frontend][network]
|
|
|
|
options[frontend][network].custom = []
|
2022-10-06 22:12:51 +02:00
|
|
|
if (network == "clearnet") {
|
|
|
|
for (const blacklist in r.blacklists) {
|
|
|
|
for (const instance of r.blacklists[blacklist]) {
|
|
|
|
let i = options[frontend].clearnet.enabled.indexOf(instance)
|
|
|
|
if (i > -1) options[frontend].clearnet.enabled.splice(i, 1)
|
|
|
|
}
|
|
|
|
}
|
2022-10-05 18:29:27 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
browser.storage.local.set({ redirects, options, targets })
|
|
|
|
resolve()
|
|
|
|
})
|
|
|
|
})
|
|
|
|
})
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2022-10-13 17:52:16 +02:00
|
|
|
// For websites that have a strict policy that would not normally allow these frontends to be embedded within the website.
|
|
|
|
function modifyContentSecurityPolicy(details) {
|
|
|
|
let isChanged = false
|
|
|
|
if (details.type == "main_frame") {
|
|
|
|
for (const header in details.responseHeaders) {
|
|
|
|
if (details.responseHeaders[header].name == "content-security-policy") {
|
|
|
|
let instancesList = []
|
|
|
|
for (const service in config.services) {
|
|
|
|
if (config.services[service].embeddable) {
|
|
|
|
for (const frontend in config.services[service].frontends) {
|
|
|
|
if (config.services[service].frontends[frontend].embeddable) {
|
|
|
|
for (const network in config.networks) {
|
|
|
|
instancesList.push(...options[frontend][network].enabled, ...options[frontend][network].custom)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
let securityPolicyList = details.responseHeaders[header].value.split(";")
|
|
|
|
for (const i in securityPolicyList) securityPolicyList[i] = securityPolicyList[i].trim()
|
|
|
|
let newSecurity = ""
|
|
|
|
for (const item of securityPolicyList) {
|
|
|
|
if (item.trim() == "") continue
|
|
|
|
let regex = item.match(/([a-z-]{0,}) (.*)/)
|
|
|
|
if (regex == null) continue
|
|
|
|
let [, key, vals] = regex
|
|
|
|
if (key == "frame-src") vals = vals + " " + instancesList.join(" ")
|
|
|
|
newSecurity += key + " " + vals + "; "
|
|
|
|
}
|
|
|
|
|
|
|
|
details.responseHeaders[header].value = newSecurity
|
|
|
|
isChanged = true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (isChanged) return { responseHeaders: details.responseHeaders }
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-09-08 22:04:25 +02:00
|
|
|
export default {
|
|
|
|
redirect,
|
2022-09-23 21:57:25 +02:00
|
|
|
computeService,
|
2022-09-25 18:27:43 +02:00
|
|
|
switchInstance,
|
2022-09-26 19:32:32 +02:00
|
|
|
reverse,
|
2022-09-27 21:59:25 +02:00
|
|
|
unifyPreferences,
|
|
|
|
setRedirects,
|
2022-10-02 16:10:36 +02:00
|
|
|
initDefaults,
|
|
|
|
upgradeOptions,
|
2022-10-05 18:29:27 +02:00
|
|
|
processUpdate,
|
2022-10-13 17:52:16 +02:00
|
|
|
modifyContentSecurityPolicy,
|
2022-09-08 22:04:25 +02:00
|
|
|
}
|