Haketilo

 * IMPORT start_page_info_server

start_page_info_server();

function send_actions(url, port)

    port.postMessage(["settings", [pattern, settings]]);

	send_scripts([components], port, processed_bags);

async function send_scripts(components, port, processed_bags)

	    await send_scripts(bag, port, processed_bags);

	    port.postMessage(["inject", [script_text]]);

    send_actions(url, port);

/**

 * part of Hachette

 * Serving of storage data corresponding to requested urls (server side).

 *

 * Copyright (C) 2021 Wojtek Kosior

 * Redistribution terms are gathered in the `copyright' file.

 */

/*

 * IMPORTS_START

 * IMPORT listen_for_connection

 * IMPORT get_storage

 * IMPORT get_query_all

 * IMPORT TYPE_PREFIX

 * IMPORT CONNECTION_TYPE

 * IMPORT url_matches

 * IMPORTS_END

 */

var storage;

var query_all;

function handle_change(connection_data, change)

{

    if (change.prefix !== TYPE_PREFIX.PAGE)

	return;

    connection_data.port.postMessage(["change", change]);

}

async function handle_subscription(connection_data, message)

{

    const [action, url] = message;

    if (action === "unsubscribe") {

	connection_data.subscribed.delete(url);

	return;

    }

    connection_data.subscribed.add(url);

    connection_data.port.postMessage(["new_url", query_all(url)]);

}

function remove_storage_listener(cb)

{

    storage.remove_change_listener(cb);

}

function new_connection(port)

{

    console.log("new page info connection!");

    const connection_data = {

	subscribed : new Set(),

	port

    };

    let _handle_change = change => handle_change(connection_data, change);

    storage.add_change_listener(_handle_change);

    port.onMessage.addListener(m => handle_subscription(connection_data, m));

    port.onDisconnect.addListener(() => remove_storage_listener(handle_change));

}

async function start_page_info_server()

{

    storage = await get_storage();

    query_all = await get_query_all();

    listen_for_connection(CONNECTION_TYPE.PAGE_INFO, new_connection);

}

/*

 * EXPORTS_START

 * EXPORT start_page_info_server

 * EXPORTS_END

 */

 * IMPORT for_each_possible_pattern

function check_pattern(pattern, multiple, matched)

    const settings = storage.get(TYPE_PREFIX.PAGE, pattern);

    if (settings === undefined)

	return;

    matched.push([pattern, settings]);

    if (!multiple)

	return false;

}

function query(url, multiple)

{

    const matched = [];

    for_each_possible_pattern(url, p => check_pattern(p, multiple, matched));

    return multiple ? matched : (matched[0] || [undefined, undefined]);

    PAGE_ACTIONS : "1",

    PAGE_INFO : "2",

    ACTIVITY_INFO : "3"

 * IMPORT TYPE_NAME

/*

 * Print item together with type, e.g.

 * nice_name("s", "hello") → "hello (script)"

 */

function nice_name(prefix, name)

{

    return `${name} (${TYPE_NAME[prefix]})`;

}

/* Open settings tab with given item's editing already on. */

function open_in_settings(prefix, name)

{

    name = encodeURIComponent(name);

    const url = browser.runtime.getURL("html/options.html#" + prefix + name);

    window.open(url, "_blank");

}

/* Check if url corresponds to a browser's special page */

function is_privileged_url(url)

{

    return !!/^(chrome(-extension)?|moz-extension):\/\/|^about:/i.exec(url);

}

 * EXPORT nice_name

 * EXPORT open_in_settings

 * EXPORT is_privileged_url

/**

 * Hydrilla/Lernette operations on page url patterns

 *

 * Copyright (C) 2021 Wojtek Kosior

 * Redistribution terms are gathered in the `copyright' file.

 */

const proto_re = "[a-zA-Z]*:\/\/";

const domain_re = "[^/?#]+";

const segments_re = "/[^?#]*";

const query_re = "\\?[^#]*";

const url_regex = new RegExp(`\

^\

(${proto_re})\

(${domain_re})\

(${segments_re})?\

(${query_re})?\

#?.*\$\

`);

function deconstruct_url(url)

{

    const regex_match = url_regex.exec(url);

    if (regex_match === null)

	return undefined;

    let [_, proto, domain, path, query] = regex_match;

    domain = domain.split(".");

    let path_trailing_dash =

	path && path[path.length - 1] === "/";

    path = (path || "").split("/").filter(s => s !== "");

    path.unshift("");

    return {proto, domain, path, query, path_trailing_dash};

}

/* Be sane: both arguments should be arrays of length >= 2 */

function domain_matches(url_domain, pattern_domain)

{

    const length_difference = url_domain.length - pattern_domain.length;

    for (let i = 1; i <= url_domain.length; i++) {

	const url_part = url_domain[url_domain.length - i];

	const pattern_part = pattern_domain[pattern_domain.length - i];

	if (pattern_domain.length === i) {

	    if (pattern_part === "*")

		return length_difference === 0;

	    if (pattern_part === "**")

		return length_difference > 0;

	    if (pattern_part === "***")

		return true;

	    return length_difference === 0 && pattern_part === url_part;

	}

	if (pattern_part !== url_part)

	    return false;

    }

    return pattern_domain.length === url_domain.length + 1 &&

	pattern_domain[0] === "***";

}

function path_matches(url_path, url_trailing_dash,

		      pattern_path, pattern_trailing_dash)

{

    const dashes_ok = !(pattern_trailing_dash && !url_trailing_dash);

    if (pattern_path.length === 0)

	return url_path.length === 0 && dashes_ok;

    const length_difference = url_path.length - pattern_path.length;

    for (let i = 0; i < url_path.length; i++) {

	if (pattern_path.length === i + 1) {

	    if (pattern_path[i] === "*")

		return length_difference === 0;

	    if (pattern_path[i] === "**") {

		return length_difference > 0 ||

		    (url_path[i] === "**" && dashes_ok);

	    }

	    if (pattern_path[i] === "***")

		return length_difference >= 0;

	    return length_difference === 0 &&

		pattern_path[i] === url_path[i] && dashes_ok;

	}

	if (pattern_path[i] !== url_path[i])

	    return false;

    }

    return false;

}

function url_matches(url, pattern)

{

    const url_deco = deconstruct_url(url);

    const pattern_deco = deconstruct_url(pattern);

    if (url_deco === undefined || pattern_deco === undefined) {

	console.log(`bad comparison: ${url} and ${pattern}`);

	return false

    }

    if (pattern_deco.proto !== url_deco.proto)

	return false;

    return domain_matches(url_deco.domain, pattern_deco.domain) &&

	path_matches(url_deco.path, url_deco.path_trailing_dash,

		     pattern_deco.path, pattern_deco.path_trailing_dash);

}

/*

 * Call callback for every possible pattern that matches url. Return when there

 * are no more patterns or callback returns false.

 */

function for_each_possible_pattern(url, callback)

{

    const deco = deconstruct_url(url);

    if (deco === undefined) {

	console.log("bad url format", url);

	return;

    }

    for (let d_slice = 0; d_slice < deco.domain.length; d_slice++) {

	const domain_part = deco.domain.slice(d_slice).join(".");

	const domain_wildcards = [];

	if (d_slice === 0)

	    domain_wildcards.push("");

	if (d_slice === 1)

	    domain_wildcards.push("*.");

	if (d_slice > 0)

	    domain_wildcards.push("**.");

	domain_wildcards.push("***.");

	for (const domain_wildcard of domain_wildcards) {

	    const domain_pattern = domain_wildcard + domain_part;

	    for (let s_slice = deco.path.length; s_slice > 0; s_slice--) {

		const path_part = deco.path.slice(0, s_slice).join("/");

		const path_wildcards = [];

		if (s_slice === deco.path.length) {

		    if (deco.path_trailing_dash)

			path_wildcards.push("/");

		    path_wildcards.push("");

		}

		if (s_slice === deco.path.length - 1 &&

		    deco.path[s_slice] !== "*")

		    path_wildcards.push("/*");

		if (s_slice < deco.path.length &&

		    (deco.path[s_slice] !== "**" ||

		     s_slice < deco.path.length - 1))

		    path_wildcards.push("/**");

		if (deco.path[s_slice] !== "***" || s_slice < deco.path.length)

		    path_wildcards.push("/***");

		for (const path_wildcard of path_wildcards) {

		    const path_pattern = path_part + path_wildcard;

		    const pattern = deco.proto + domain_pattern + path_pattern;

		    if (callback(pattern) === false)

			return;

		}

	    }

	}

    }

}

function possible_patterns(url)

{

    const patterns = [];

    for_each_possible_pattern(url, patterns.push);

    return patterns;

}

/*

 * EXPORTS_START

 * EXPORT url_matches

 * EXPORT for_each_possible_pattern

 * EXPORT possible_patterns

 * EXPORTS_END

 */

/**

 * part of Hachette

 * Informing about activities performed by content script (script injection,

 * script blocking).

 *

 * Copyright (C) 2021 Wojtek Kosior

 * Redistribution terms are gathered in the `copyright' file.

 */

/*

 * IMPORTS_START

 * IMPORT listen_for_connection

 * IMPORT CONNECTION_TYPE

 * IMPORTS_END

 */

var activities = [];

var ports = new Set();

function report_activity(name, data)

{

    const activity = [name, data];

    activities.push(activity);

    for (const port of ports)

	port.postMessage(activity);

}

function report_script(script_data)

{

    report_activity("script", script_data);

}

function report_settings(settings)

{

    report_activity("settings", settings);

}

function new_connection(port)

{

    console.log("new activity info connection!");

    ports.add(port);

    for (const activity of activities)

	port.postMessage(activity);

}

function start_activity_info_server()

{

    listen_for_connection(CONNECTION_TYPE.ACTIVITY_INFO, new_connection);

}

/*

 * EXPORTS_START

 * EXPORT start_activity_info_server

 * EXPORT report_script

 * EXPORT report_settings

 * EXPORTS_END

 */

 * IMPORT is_privileged_url

 * IMPORT start_activity_info_server

function is_http()

    return !!/^https?:\/\//i.exec(document.URL);

}

function is_whitelisted()

{

	return true;

    return false;

if (!is_privileged_url(document.URL)) {

    start_activity_info_server();

    handle_page_actions(unique);

    if (is_http()) {

	/* rely on CSP injected through webRequest */

    } else if (is_whitelisted()) {

	/* do not block scripts at all */

    } else {

	block_nodes_recursively(document.documentElement);

	if (is_chrome) {

	    var observer = new MutationObserver(handle_mutation);

	    observer.observe(document.documentElement, {

		attributes: true,

		childList: true,

		subtree: true

	    });

	}

	if (is_mozilla)

	    addEventListener('beforescriptexecute', suppressor, true);

 * IMPORT report_script

 * IMPORT report_settings

    const [action, data] = message;

    if (action === "inject") {

	for (let script_text of data) {

	    if (loaded)

		add_script(script_text);

	    else

		scripts_awaiting.push(script_text);

	}

    if (action === "settings")

	report_settings(data);

    report_script(script_text);

    <title>Hachette - page settings</title>

    <style>

      input[type="radio"], input[type="checkbox"] {

	  display: none;

      }

      body {

	  width: 300px;

	  height: 300px;

      }

      .show_next:not(:checked)+* {

	  display: none;

      }

      .hide {

	  display: none;

      }

      #possible_patterns_chbx:not(:checked)+label span#triangle:first-child+span,

      #possible_patterns_chbx:not(:checked)+label+*,

      #possible_patterns_chbx:checked+label span#triangle:first-child {

	  display: none;

      }

      #container_for_injected>#none_injected:not(:last-child) {

	  display: none;

      }

      input#connected_chbx:checked+div+h3 {

	  display: none;

      }

    </style>

    <!-- The invisible div below is for elements that will be cloned. -->

    <div class="hide">

      <li id="pattern_li_template">

	<span></span>

	<button>View in settings</button>

      </li>

    </div>

    <h2 id="page_url_heading"></h2>

    <input id="show_privileged_notice_chbx" type="checkbox" class="show_next"></input>

    <h3>Privileged page</h3>

    <input id="show_page_state_chbx" type="checkbox" class="show_next"></input>

    <div>

      <input id="possible_patterns_chbx" type="checkbox"></input>

      <label for="possible_patterns_chbx">

	<h3>

	  <span id="triangle">&#x23F5;</span><span>&#x23F7;</span>

	  Possible patterns

	</h3>

      </label>

      <ul id="possible_patterns"></ul>

      <input id="connected_chbx" type="checkbox" class="show_next"></input>

      <div>

	<h3>

	  Matched pattern: <span id="pattern">...</span>

	  <button id="view_pattern" class="hide">

	  View in settings

	  </button>

	</h3>

	<h3>

	  Blocked: <span id="blocked">...</span>

	</h3>

	<h3>

	  Payload: <span id="payload">...</span>

	  <button id="view_payload" class="hide">

	    View in settings

	  </button>

	</h3>

	<h3>Injected</h3>

	<div id="container_for_injected">

	  <span id="none_injected">None</span>

	</div>

      </div>

      <h3>Trying to connect..<input id="loading_chbx" type="checkbox" class="show_next"></input><span>.</span></h3>

    </div>

    <button id="settings_but" type="button" style="margin-top: 20px;">Settings</button>_POPUPSCRIPTS_

 * IMPORT is_chrome

 * IMPORT is_mozilla

 * IMPORT CONNECTION_TYPE

 * IMPORT url_item

 * IMPORT is_privileged_url

 * IMPORT TYPE_PREFIX

 * IMPORT nice_name

 * IMPORT open_in_settings

 * IMPORT for_each_possible_pattern

function by_id(id)

{

    return document.getElementById(id);

}

const tab_query = {currentWindow: true, active: true};

async function get_current_tab()

{

    /* Fix for fact that Chrome does not use promises here */

    const promise = is_chrome ?

	  new Promise((resolve, reject) =>

		      browser.tabs.query(tab_query, tab => resolve(tab))) :

	  browser.tabs.query(tab_query);

    try {

	return (await promise)[0];

    } catch(e) {

	console.log(e);

    }

}

const page_url_heading = by_id("page_url_heading");

const show_privileged_notice_chbx = by_id("show_privileged_notice_chbx");

const show_page_state_chbx = by_id("show_page_state_chbx");

async function show_page_activity_info()

{

    const tab = await get_current_tab();

    if (tab === undefined) {

	page_url_heading.textContent = "unknown page";

	return;

    }

    const url = url_item(tab.url);

    page_url_heading.textContent = url;

    if (is_privileged_url(url)) {

	show_privileged_notice_chbx.checked = true;

	return;

    }

    populate_possible_patterns_list(url);

    show_page_state_chbx.checked = true;

    try_to_connect(tab.id);

}

function populate_possible_patterns_list(url)

{

    for_each_possible_pattern(url, add_pattern_to_list);

    const port = browser.runtime.connect({name: CONNECTION_TYPE.PAGE_INFO});

    port.onMessage.addListener(handle_page_info);

    port.postMessage(["subscribe", url]);

}

const possible_patterns_ul = by_id("possible_patterns");

const pattern_li_template = by_id("pattern_li_template");

pattern_li_template.removeAttribute("id");

const known_patterns = new Map();

function add_pattern_to_list(pattern)

{

    const li = pattern_li_template.cloneNode(true);

    li.id = `pattern_li_${known_patterns.size}`;

    known_patterns.set(pattern, li.id);

    const span = li.firstElementChild;

    span.textContent = pattern;

    const button = span.nextElementSibling;

    const settings_opener = () => open_in_settings(TYPE_PREFIX.PAGE, pattern);

    button.addEventListener("click", settings_opener);

    possible_patterns_ul.appendChild(li)

    return li.id;

}

function ensure_pattern_exists(pattern)

{

    let id = known_patterns.get(pattern);

    /*

     * As long as pattern computation works well, we should never get into this

     * conditional block. This is just a safety measure. To be removed as part

     * of a bigger rework when we start taking iframes into account.

     */

    if (id === undefined) {

	console.log(`unknown pattern: ${pattern}`);

	id = add_pattern_to_list(pattern);

    }

    return id;

}

function set_pattern_li_button_text(li_id, text)

{

    by_id(li_id).firstElementChild.nextElementSibling.textContent = text;

}

function handle_page_info(message)

{

    const [type, data] = message;

    if (type === "change") {

	const li_id = ensure_pattern_exists(data.item);

	if (data.old_val === undefined)

	    set_pattern_li_button_text(li_id, "Edit in settings");

	if (data.new_val === undefined)

	    set_pattern_li_button_text(li_id, "Add setting");

    }

    if (type === "new_url") {

	for (const li_id of known_patterns.values())

	    set_pattern_li_button_text(li_id, "Add setting");

	for (const [pattern, settings] of data) {

	    set_pattern_li_button_text(ensure_pattern_exists(pattern),

				       "Edit in settings")

	}

    }

}

const connected_chbx = by_id("connected_chbx");

function try_to_connect(tab_id)

{

    /* This won't connect to iframes. We'll add support for them later */

    const connect_info = {name: CONNECTION_TYPE.ACTIVITY_INFO, frameId: 0};

    const port = browser.tabs.connect(tab_id, connect_info);

    port.onDisconnect.addListener(port => handle_disconnect(tab_id));

    port.onMessage.addListener(handle_activity_report);

    if (is_mozilla)

	setTimeout(() => monitor_connecting(port, tab_id), 1000);

}

const loading_chbx = by_id("loading_chbx");

function handle_disconnect(tab_id)

{

    if (is_chrome && !browser.runtime.lastError)

	return;

    /* return if there was no connection initialization failure */

    if (connected_chbx.checked)

	return;

    loading_chbx.checked = !loading_chbx.checked;

    setTimeout(() => try_to_connect(tab_id), 1000);

}

function monitor_connecting(port, tab_id)

{

    if (connected_chbx.checked)

	return;

    port.disconnect();

    loading_chbx.checked = !loading_chbx.checked;

    try_to_connect(tab_id);

}

const pattern_span = by_id("pattern");

const view_pattern_but = by_id("view_pattern");

const blocked_span = by_id("blocked");

const payload_span = by_id("payload");

const view_payload_but = by_id("view_payload");

const container_for_injected = by_id("container_for_injected");

function handle_activity_report(message)

{

    connected_chbx.checked = true;

    const [type, data] = message;

    if (type === "settings") {

	let [pattern, settings] = data;

	settings = settings || {};

	blocked_span.textContent = settings.allow ? "no" : "yes";

	if (pattern) {

	    pattern_span.textContent = pattern;

	    const settings_opener =

		  () => open_in_settings(TYPE_PREFIX.PAGE, pattern);

	    view_pattern_but.classList.remove("hide");

	    view_pattern_but.addEventListener("click", settings_opener);

	} else {

	    pattern_span.textContent = "none";

	}

	const components = settings.components;

	if (components) {

	    payload_span.textContent = nice_name(...components);

	    const settings_opener = () => open_in_settings(...components);

	    view_payload_but.classList.remove("hide");

	    view_payload_but.addEventListener("click", settings_opener);

	} else {

	    payload_span.textContent = "none";

	}

    }

    if (type === "script") {

	const h4 = document.createElement("h4");

	const pre = document.createElement("pre");

	h4.textContent = "script";

	pre.textContent = data;

	container_for_injected.appendChild(h4);

	container_for_injected.appendChild(pre);

    }

}

by_id("settings_but")

show_page_activity_info();

 * IMPORT nice_name