chemicaljs 2.6.3 → 3.0.0

package/.gitignore

@@ -0,0 +1,23 @@
+node_modules
+
+# Output
+.output
+.vercel
+.netlify
+.wrangler
+/.svelte-kit
+/build
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Env
+.env
+.env.*
+!.env.example
+!.env.test
+
+# Vite
+vite.config.js.timestamp-*
+vite.config.ts.timestamp-*

package/AdblockPlugin.js

@@ -0,0 +1,166 @@
+import * as Scramjet from "@mercuryworkshop/scramjet";
+import * as ScramjetController from "@mercuryworkshop/scramjet-controller";
+
+const { BareResponse } = Scramjet;
+const { ManagedPlugin } = ScramjetController;
+
+export class AdblockPlugin extends ManagedPlugin {
+  constructor(options = {}) {
+    super("scramjet-adblock", []);
+    this.enabled = options.enabled ?? true;
+    this.blockedStatus = options.blockedStatus ?? 204;
+    this.onBlock = options.onBlock;
+    this._blockedCount = 0;
+    this.blockedDomains = new Set();
+    this.patternRules = [];
+
+    if (options.rules) {
+      this.addRules(options.rules);
+    }
+
+    if (options.rawRulesets) {
+      for (const raw of options.rawRulesets) {
+        this.parseAndAddRawRuleset(raw);
+      }
+    }
+  }
+
+  get blockedCount() {
+    return this._blockedCount;
+  }
+
+  resetCount() {
+    this._blockedCount = 0;
+  }
+
+  addRules(rules) {
+    for (const rawRule of rules) {
+      const rule = rawRule.trim().toLowerCase();
+      if (!rule || rule.startsWith("#") || rule.startsWith("!")) continue;
+
+      if (rule.startsWith("/") && rule.endsWith("/") && rule.length > 2) {
+        try {
+          this.patternRules.push({
+            raw: rule,
+            regex: new RegExp(rule.slice(1, -1), "i"),
+          });
+        } catch (err) {
+          console.warn(`[scramjet-adblock] Invalid regex rule "${rule}":`, err);
+        }
+        continue;
+      }
+
+      if (rule.includes("*") || rule.includes("?")) {
+        const regexStr = rule
+          .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+          .replace(/\*/g, ".*")
+          .replace(/\?/g, ".");
+        this.patternRules.push({
+          raw: rule,
+          regex: new RegExp(`^${regexStr}$`, "i"),
+        });
+        continue;
+      }
+
+      this.blockedDomains.add(rule);
+    }
+  }
+
+  parseAndAddRawRuleset(content) {
+    const lines = content.split(/\r?\n/);
+    const extracted = [];
+
+    for (let line of lines) {
+      line = line.trim();
+      if (!line || line.startsWith("#") || line.startsWith("!")) continue;
+
+      if (line.startsWith("127.0.0.1") || line.startsWith("0.0.0.0")) {
+        const parts = line.split(/\s+/);
+        if (parts.length >= 2 && parts[1] !== "localhost") {
+          extracted.push(parts[1]);
+        }
+        continue;
+      }
+
+      if (line.startsWith("||")) {
+        const domain = line.slice(2).replace(/\^.*$/, "");
+        if (domain) extracted.push(domain);
+        continue;
+      }
+
+      extracted.push(line);
+    }
+
+    this.addRules(extracted);
+  }
+
+  removeRule(rule) {
+    const clean = rule.trim().toLowerCase();
+    this.blockedDomains.delete(clean);
+    this.patternRules = this.patternRules.filter((r) => r.raw !== clean);
+  }
+
+  clearRules() {
+    this.blockedDomains.clear();
+    this.patternRules = [];
+  }
+
+  isBlocked(url) {
+    try {
+      const parsed = new URL(url);
+      const hostname = parsed.hostname.toLowerCase();
+      const fullUrl = parsed.href.toLowerCase();
+
+      if (this.blockedDomains.has(hostname)) {
+        return { blocked: true, matchedRule: hostname };
+      }
+
+      const parts = hostname.split(".");
+      for (let i = 1; i < parts.length - 1; i++) {
+        const parentDomain = parts.slice(i).join(".");
+        if (this.blockedDomains.has(parentDomain)) {
+          return { blocked: true, matchedRule: parentDomain };
+        }
+      }
+
+      for (const { raw, regex } of this.patternRules) {
+        if (regex.test(hostname) || regex.test(fullUrl)) {
+          return { blocked: true, matchedRule: raw };
+        }
+      }
+    } catch {}
+
+    return { blocked: false };
+  }
+
+  install(frame) {
+    super.install(frame);
+
+    const hooks = frame.fetchHandler.hooks.fetch;
+
+    this.tap(hooks.request, async (ctx, props) => {
+      if (!this.enabled) return;
+      if (props.earlyResponse) return;
+
+      const targetUrl = ctx.parsed.url.href;
+      const { blocked, matchedRule } = this.isBlocked(targetUrl);
+
+      if (blocked) {
+        this._blockedCount++;
+        if (this.onBlock && matchedRule) {
+          this.onBlock(targetUrl, matchedRule);
+        }
+
+        props.earlyResponse = BareResponse.fromNativeResponse(
+          new Response(null, {
+            status: this.blockedStatus,
+            statusText: "Blocked by Scramjet Adblock",
+            headers: new Headers({
+              "x-scramjet-blocked-by": "adblock-plugin",
+            }),
+          }),
+        );
+      }
+    });
+  }
+}

package/Chemical.svelte

@@ -0,0 +1,248 @@
+<script>
+  import EpoxyTransport from "@mercuryworkshop/epoxy-transport";
+  import LibcurlClient from "@mercuryworkshop/libcurl-transport";
+
+  let {
+    transport = $bindable("epoxy"),
+    wisp = $bindable(
+      (location.protocol === "https:" ? "wss" : "ws") +
+        "://" +
+        location.host +
+        "/wisp/",
+    ),
+    ready = $bindable(false),
+    onready,
+  } = $props();
+
+  let defaultConfig;
+  let rewriteUrl;
+  let Controller;
+  let HttpCachePlugin;
+  let UrlWatcherPlugin;
+  let CatchEscapedLinksPlugin;
+  let EventHandlerPlugin;
+  let LinkHandlerPlugin;
+  let AdblockPlugin;
+
+  let controller = $state();
+  let scramjetLoaded = $state(false);
+  let controllerLoaded = $state(false);
+  let currentTransport = transport;
+  let currentWisp = wisp;
+
+  $effect(() => {
+    if (scramjetLoaded && controllerLoaded) {
+      initialize();
+    }
+  });
+
+  async function createTransport() {
+    let newTransport;
+
+    switch (transport) {
+      case "epoxy":
+        newTransport = new EpoxyTransport({
+          wisp,
+        });
+        break;
+      case "libcurl":
+        newTransport = new LibcurlClient({
+          wisp,
+        });
+        break;
+      default:
+        throw new Error("Invalid transport");
+        break;
+    }
+
+    await newTransport.init();
+
+    return newTransport;
+  }
+
+  $effect(async () => {
+    if (ready) {
+      if (transport !== currentTransport || wisp !== currentWisp) {
+        let newTransport = await createTransport();
+
+        controller.transport = newTransport;
+        currentTransport = transport;
+        currentWisp = wisp;
+      }
+    }
+  });
+
+  async function initialize() {
+    [
+      { defaultConfig, rewriteUrl },
+      { Controller },
+      {
+        HttpCachePlugin,
+        UrlWatcherPlugin,
+        CatchEscapedLinksPlugin,
+        EventHandlerPlugin,
+        LinkHandlerPlugin,
+      },
+      { AdblockPlugin },
+    ] = await Promise.all([
+      import("@mercuryworkshop/scramjet"),
+      import("@mercuryworkshop/scramjet-controller"),
+      import("@mercuryworkshop/scramjet-utils"),
+      import("./AdblockPlugin.js"),
+    ]);
+
+    await navigator.serviceWorker.register("/sw.js");
+
+    const registration = await navigator.serviceWorker.ready;
+
+    const serviceworker =
+      navigator.serviceWorker.controller ?? registration.active;
+
+    let newTransport = await createTransport();
+
+    controller = new Controller({
+      serviceworker,
+      transport: newTransport,
+      scramjetConfig: defaultConfig,
+    });
+
+    await controller.wait();
+
+    ready = true;
+
+    if (onready) {
+      onready();
+    }
+  }
+
+  export function url(url, plugins = []) {
+    if (ready) {
+      let newFrame = controller.createFrame(null, plugins);
+
+      return rewriteUrl(url, newFrame.context, {
+        origin: new URL(location.href),
+        base: new URL(location.href),
+      });
+    }
+  }
+
+  export function createFrame(...props) {
+    return controller.createFrame(...props);
+  }
+
+  export const plugins = {
+    get HttpCachePlugin() {
+      return HttpCachePlugin;
+    },
+    get UrlWatcherPlugin() {
+      return UrlWatcherPlugin;
+    },
+    get CatchEscapedLinksPlugin() {
+      return CatchEscapedLinksPlugin;
+    },
+    get EventHandlerPlugin() {
+      return EventHandlerPlugin;
+    },
+    get LinkHandlerPlugin() {
+      return LinkHandlerPlugin;
+    },
+    get AdblockPlugin() {
+      return AdblockPlugin;
+    },
+  };
+
+  function fetch(...props) {
+    if (transport === "epoxy") {
+      return controller.transport.client.fetch(...props);
+    } else if (transport === "libcurl") {
+      return controller.transport.session.fetch(...props);
+    }
+  }
+
+  async function autocomplete(query, engine = "google") {
+    if (!query || !query.trim()) return [];
+
+    const q = encodeURIComponent(query.trim());
+
+    const endpoints = {
+      google: `https://suggestqueries.google.com/complete/search?client=firefox&q=${q}`,
+      duckduckgo: `https://duckduckgo.com/ac/?q=${q}`,
+      bing: `https://api.bing.com/osjson.aspx?query=${q}`,
+      brave: `https://search.brave.com/api/suggest?q=${q}`,
+      yahoo: `https://ff.search.yahoo.com/gossip?output=fxjson&command=${q}`,
+    };
+
+    const url = endpoints[engine];
+
+    if (!url) {
+      throw new Error(
+        `Unsupported engine "${engine}". Supported: google, duckduckgo, bing, brave, yahoo`,
+      );
+    }
+
+    try {
+      const response = await fetch(url);
+      if (!response.ok) throw new Error(`HTTP ${response.status}`);
+
+      const data = await response.json();
+
+      switch (engine) {
+        case "google":
+          return data[1];
+        case "duckduckgo":
+          return data.map((item) => item.phrase);
+        case "bing":
+          return data[1];
+        case "brave":
+          return data[1];
+        case "yahoo":
+          return data[1];
+      }
+    } catch (error) {
+      console.error(`Autocomplete error (${engine}):`, error);
+      return [];
+    }
+  }
+
+  async function createDataURL(url) {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const response = await fetch(url);
+        const blob = await response.blob();
+        const reader = new FileReader();
+
+        reader.onloadend = function () {
+          resolve(reader.result);
+        };
+
+        reader.readAsDataURL(blob);
+      } catch {
+        resolve(undefined);
+      }
+    });
+  }
+
+  const searchEngines = {
+    google: "https://www.google.com/search?q=%s",
+    duckduckgo: "https://duckduckgo.com/?q=%s",
+    ddg: "https://duckduckgo.com/?q=%s",
+    bing: "https://www.bing.com/search?q=%s",
+    brave: "https://search.brave.com/search?q=%s",
+    yahoo: "https://search.yahoo.com/search?p=%s",
+  };
+
+  export { fetch, autocomplete, createDataURL, searchEngines };
+</script>
+
+<svelte:head>
+  <script
+    src="./scramjet/scramjet.js"
+    onload={() => (scramjetLoaded = true)}
+  ></script>
+  {#if scramjetLoaded}
+    <script
+      src="./controller/controller.api.js"
+      onload={() => (controllerLoaded = true)}
+    ></script>
+  {/if}
+</svelte:head>

package/Frame.svelte

@@ -0,0 +1,102 @@
+<script>
+  import blacklistText from "./blacklist.txt?raw";
+
+  let {
+    ready = $bindable(),
+    chemical = $bindable(),
+    class: className,
+    src = $bindable(),
+    onchange,
+    cache = false,
+    linkhandler,
+    catchlinks,
+    adblock = false,
+    ...restProps
+  } = $props();
+
+  let newSrc = $state();
+
+  let frame;
+  let frameRef = $state();
+
+  $effect(() => {
+    if (ready && chemical) {
+      let plugins = [];
+
+      if (onchange) {
+        const urlWatcher = new chemical.plugins.UrlWatcherPlugin((url) =>
+          onchange(url),
+        );
+        plugins.push(urlWatcher);
+      }
+
+      if (cache) {
+        const cachePlugin = new chemical.plugins.HttpCachePlugin();
+        plugins.push(cachePlugin);
+      }
+
+      if (linkhandler) {
+        plugins.push(new chemical.plugins.EventHandlerPlugin());
+        const linkHandler = new chemical.plugins.LinkHandlerPlugin((url) =>
+          linkhandler(url),
+        );
+        plugins.push(linkHandler);
+      }
+
+      if (catchlinks) {
+        const catchEscapedLinks = new chemical.plugins.CatchEscapedLinksPlugin(
+          (url) => catchlinks(url),
+        );
+        plugins.push(catchEscapedLinks);
+      }
+
+      if (adblock) {
+        const adblocker = new chemical.plugins.AdblockPlugin({
+          rawRulesets: [blacklistText],
+          onBlock: (url, rule) => {
+            console.log(`[AdBlock] Blocked ${url} matching rule: ${rule}`);
+          },
+        });
+        plugins.push(adblocker);
+      }
+
+      frame = chemical.createFrame(frameRef, {
+        plugins,
+      });
+      frame.go(src);
+    }
+  });
+
+  export function go(src, options = {}) {
+    let autoHttps = options.autoHttps || false;
+    let searchEngine = options.searchEngine;
+
+    if (frame) {
+      if (src.match(/^https?:\/\//)) {
+        frame.go(src);
+      } else if (
+        autoHttps === true &&
+        src.includes(".") &&
+        !src.includes(" ")
+      ) {
+        frame.go("https://" + src);
+      } else if (searchEngine) {
+        frame.go(searchEngine.replace("%s", encodeURIComponent(src)));
+      } else {
+        frame.go(src);
+      }
+    }
+  }
+
+  export function reload() {
+    frameRef.contentWindow.location.reload();
+  }
+   export function forward() {
+    frameRef.contentWindow.history.forward();
+  }
+   export function back() {
+    frameRef.contentWindow.history.back();
+  }
+</script>
+
+<iframe bind:this={frameRef} class={className} {...restProps}></iframe>

package/LICENSE

@@ -658,4 +658,4 @@ specific requirements.
   You should also get your employer (if you work as a programmer) or school,
 if any, to sign a "copyright disclaimer" for the program, if necessary.
 For more information on this, and how to apply and follow the GNU AGPL, see
-<https://www.gnu.org/licenses/>.
+<https://www.gnu.org/licenses/>.

package/README.md

@@ -1,8 +1,8 @@
 # Chemical
-Easily create your own web proxy with no experience required.
+Easily create your own web proxy with no experience required. V3 has been simplified to just Scramjet and is now Svelte only.
 
 ## Docs
 You can find documentation for Chemical on our website https://chemicaljs.github.io.
 
 ## License
-Chemical uses the AGPL 3.0 license.
+Chemical uses the AGPL 3.0 license.