@chainpatrol/sdk 0.1.1

package/dist/index.js

@@ -0,0 +1,887 @@
+'use strict';
+
+var tldts = require('tldts');
+var zod = require('zod');
+
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/events.ts
+var ContinueAtOwnRisk = "CHAINPATROL_CONTINUE_AT_OWN_RISK";
+var Events = {
+  ContinueAtOwnRisk
+};
+
+// src/logger.ts
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
+  LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
+  LogLevel2[LogLevel2["WARN"] = 2] = "WARN";
+  LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
+  LogLevel2[LogLevel2["NONE"] = 4] = "NONE";
+  return LogLevel2;
+})(LogLevel || {});
+var Logger = class _Logger {
+  constructor(meta, minLevel = 4 /* NONE */) {
+    this.meta = {};
+    if (meta) {
+      this.meta = meta;
+    }
+    this.minLevel = minLevel;
+  }
+  with(fields) {
+    return new _Logger(__spreadValues(__spreadValues({}, this.meta), fields), this.minLevel);
+  }
+  debug(message, fields) {
+    this.log(0 /* DEBUG */, message, fields);
+  }
+  info(message, fields) {
+    this.log(1 /* INFO */, message, fields);
+  }
+  warn(message, fields) {
+    this.log(2 /* WARN */, message, fields);
+  }
+  error(message, fields) {
+    this.log(3 /* ERROR */, message, fields);
+  }
+  log(level, message, fields) {
+    if (level < this.minLevel) {
+      return;
+    }
+    const logObj = __spreadValues({ message, data: __spreadValues({}, fields) }, this.meta);
+    const logString = JSON.stringify(logObj, null, 2);
+    console.log(`[${LogLevel[level].toUpperCase()}] ${logString}`);
+  }
+};
+
+// src/relay.ts
+function isExtensionHost() {
+  var _a, _b;
+  return !!((_a = globalThis.browser) == null ? void 0 : _a.runtime) || !!((_b = globalThis.chrome) == null ? void 0 : _b.runtime);
+}
+function isBrowserHost() {
+  return !!globalThis.window;
+}
+function getExtensionHandle() {
+  return {
+    addListener: (callback) => {
+      globalThis.chrome.runtime.onMessage.addListener(callback);
+    },
+    removeListener: (callback) => {
+      globalThis.chrome.runtime.onMessage.removeListener(callback);
+    },
+    postMessage: (message) => {
+      globalThis.chrome.runtime.sendMessage(message);
+    }
+  };
+}
+function getBrowserHandle() {
+  return {
+    addListener: (callback) => {
+      globalThis.window.addEventListener("message", (event) => {
+        if (event.source !== globalThis.window) {
+          return;
+        }
+        callback(event.data);
+      });
+    },
+    removeListener: (callback) => {
+      globalThis.window.removeEventListener("message", callback);
+    },
+    postMessage: (message) => {
+      globalThis.window.postMessage(message, "*");
+    }
+  };
+}
+var _Relay = class _Relay {
+  static send(type, data) {
+    const message = {
+      type,
+      data,
+      _meta: {
+        id: Math.random().toString(36).substring(2, 9),
+        origin: globalThis.location.origin
+      }
+    };
+    _Relay.logger.debug("Sending message", message);
+    for (const handle of _Relay.handles) {
+      handle.postMessage(message);
+    }
+  }
+  static run(events) {
+    const listeners = /* @__PURE__ */ new Set();
+    for (const handle of _Relay.handles) {
+      const listener = _Relay.handleMessage.bind(null, handle, events);
+      listeners.add(listener);
+      handle.addListener(listener);
+    }
+    _Relay.logger.debug("Started relay", { events });
+    return () => {
+      for (const handle of _Relay.handles) {
+        for (const listener of listeners) {
+          handle.removeListener(listener);
+        }
+      }
+      _Relay.logger.debug("Stopped relay", { events });
+    };
+  }
+  static handleMessage(sourceHandle, events, message) {
+    if (!events.includes(message.type)) {
+      _Relay.logger.debug("Ignoring message", { message });
+      return;
+    }
+    const destinationHandles = _Relay.handles.filter(
+      (handle) => handle !== sourceHandle
+    );
+    for (const destinationHandle of destinationHandles) {
+      destinationHandle.postMessage(message);
+    }
+  }
+  static on(targetEvent, callback) {
+    const listeners = /* @__PURE__ */ new Set();
+    for (const handle of _Relay.handles) {
+      const listener = (message) => {
+        if (message.type !== targetEvent) {
+          _Relay.logger.debug("Ignoring message", { message });
+          return;
+        }
+        callback(message.data);
+      };
+      listeners.add(listener);
+      handle.addListener(listener);
+    }
+    return () => {
+      for (const handle of _Relay.handles) {
+        for (const listener of listeners) {
+          handle.removeListener(listener);
+        }
+      }
+    };
+  }
+};
+_Relay.handles = [];
+_Relay.logger = new Logger({ component: "Relay" });
+(() => {
+  if (isExtensionHost()) {
+    _Relay.logger.info("Detected extension host");
+    _Relay.handles.push(getExtensionHandle());
+  }
+  if (isBrowserHost()) {
+    _Relay.logger.info("Detected browser host");
+    _Relay.handles.push(getBrowserHandle());
+  }
+})();
+var Relay = _Relay;
+
+// ../../node_modules/normalize-url/index.js
+var DATA_URL_DEFAULT_MIME_TYPE = "text/plain";
+var DATA_URL_DEFAULT_CHARSET = "us-ascii";
+var testParameter = (name, filters) => filters.some((filter) => filter instanceof RegExp ? filter.test(name) : filter === name);
+var supportedProtocols = /* @__PURE__ */ new Set([
+  "https:",
+  "http:",
+  "file:"
+]);
+var hasCustomProtocol = (urlString) => {
+  try {
+    const { protocol } = new URL(urlString);
+    return protocol.endsWith(":") && !supportedProtocols.has(protocol);
+  } catch (e) {
+    return false;
+  }
+};
+var normalizeDataURL = (urlString, { stripHash }) => {
+  var _a, _b;
+  const match = new RegExp("^data:(?<type>[^,]*?),(?<data>[^#]*?)(?:#(?<hash>.*))?$").exec(urlString);
+  if (!match) {
+    throw new Error(`Invalid URL: ${urlString}`);
+  }
+  let { type, data, hash } = match.groups;
+  const mediaType = type.split(";");
+  hash = stripHash ? "" : hash;
+  let isBase64 = false;
+  if (mediaType[mediaType.length - 1] === "base64") {
+    mediaType.pop();
+    isBase64 = true;
+  }
+  const mimeType = (_b = (_a = mediaType.shift()) == null ? void 0 : _a.toLowerCase()) != null ? _b : "";
+  const attributes = mediaType.map((attribute) => {
+    let [key, value = ""] = attribute.split("=").map((string) => string.trim());
+    if (key === "charset") {
+      value = value.toLowerCase();
+      if (value === DATA_URL_DEFAULT_CHARSET) {
+        return "";
+      }
+    }
+    return `${key}${value ? `=${value}` : ""}`;
+  }).filter(Boolean);
+  const normalizedMediaType = [
+    ...attributes
+  ];
+  if (isBase64) {
+    normalizedMediaType.push("base64");
+  }
+  if (normalizedMediaType.length > 0 || mimeType && mimeType !== DATA_URL_DEFAULT_MIME_TYPE) {
+    normalizedMediaType.unshift(mimeType);
+  }
+  return `data:${normalizedMediaType.join(";")},${isBase64 ? data.trim() : data}${hash ? `#${hash}` : ""}`;
+};
+function normalizeUrl(urlString, options) {
+  options = __spreadValues({
+    defaultProtocol: "http",
+    normalizeProtocol: true,
+    forceHttp: false,
+    forceHttps: false,
+    stripAuthentication: true,
+    stripHash: false,
+    stripTextFragment: true,
+    stripWWW: true,
+    removeQueryParameters: [/^utm_\w+/i],
+    removeTrailingSlash: true,
+    removeSingleSlash: true,
+    removeDirectoryIndex: false,
+    removeExplicitPort: false,
+    sortQueryParameters: true
+  }, options);
+  if (typeof options.defaultProtocol === "string" && !options.defaultProtocol.endsWith(":")) {
+    options.defaultProtocol = `${options.defaultProtocol}:`;
+  }
+  urlString = urlString.trim();
+  if (/^data:/i.test(urlString)) {
+    return normalizeDataURL(urlString, options);
+  }
+  if (hasCustomProtocol(urlString)) {
+    return urlString;
+  }
+  const hasRelativeProtocol = urlString.startsWith("//");
+  const isRelativeUrl = !hasRelativeProtocol && /^\.*\//.test(urlString);
+  if (!isRelativeUrl) {
+    urlString = urlString.replace(/^(?!(?:\w+:)?\/\/)|^\/\//, options.defaultProtocol);
+  }
+  const urlObject = new URL(urlString);
+  if (options.forceHttp && options.forceHttps) {
+    throw new Error("The `forceHttp` and `forceHttps` options cannot be used together");
+  }
+  if (options.forceHttp && urlObject.protocol === "https:") {
+    urlObject.protocol = "http:";
+  }
+  if (options.forceHttps && urlObject.protocol === "http:") {
+    urlObject.protocol = "https:";
+  }
+  if (options.stripAuthentication) {
+    urlObject.username = "";
+    urlObject.password = "";
+  }
+  if (options.stripHash) {
+    urlObject.hash = "";
+  } else if (options.stripTextFragment) {
+    urlObject.hash = urlObject.hash.replace(/#?:~:text.*?$/i, "");
+  }
+  if (urlObject.pathname) {
+    const protocolRegex = /\b[a-z][a-z\d+\-.]{1,50}:\/\//g;
+    let lastIndex = 0;
+    let result = "";
+    for (; ; ) {
+      const match = protocolRegex.exec(urlObject.pathname);
+      if (!match) {
+        break;
+      }
+      const protocol = match[0];
+      const protocolAtIndex = match.index;
+      const intermediate = urlObject.pathname.slice(lastIndex, protocolAtIndex);
+      result += intermediate.replace(/\/{2,}/g, "/");
+      result += protocol;
+      lastIndex = protocolAtIndex + protocol.length;
+    }
+    const remnant = urlObject.pathname.slice(lastIndex, urlObject.pathname.length);
+    result += remnant.replace(/\/{2,}/g, "/");
+    urlObject.pathname = result;
+  }
+  if (urlObject.pathname) {
+    try {
+      urlObject.pathname = decodeURI(urlObject.pathname);
+    } catch (e) {
+    }
+  }
+  if (options.removeDirectoryIndex === true) {
+    options.removeDirectoryIndex = [/^index\.[a-z]+$/];
+  }
+  if (Array.isArray(options.removeDirectoryIndex) && options.removeDirectoryIndex.length > 0) {
+    let pathComponents = urlObject.pathname.split("/");
+    const lastComponent = pathComponents[pathComponents.length - 1];
+    if (testParameter(lastComponent, options.removeDirectoryIndex)) {
+      pathComponents = pathComponents.slice(0, -1);
+      urlObject.pathname = pathComponents.slice(1).join("/") + "/";
+    }
+  }
+  if (urlObject.hostname) {
+    urlObject.hostname = urlObject.hostname.replace(/\.$/, "");
+    if (options.stripWWW && /^www\.(?!www\.)[a-z\-\d]{1,63}\.[a-z.\-\d]{2,63}$/.test(urlObject.hostname)) {
+      urlObject.hostname = urlObject.hostname.replace(/^www\./, "");
+    }
+  }
+  if (Array.isArray(options.removeQueryParameters)) {
+    for (const key of [...urlObject.searchParams.keys()]) {
+      if (testParameter(key, options.removeQueryParameters)) {
+        urlObject.searchParams.delete(key);
+      }
+    }
+  }
+  if (!Array.isArray(options.keepQueryParameters) && options.removeQueryParameters === true) {
+    urlObject.search = "";
+  }
+  if (Array.isArray(options.keepQueryParameters) && options.keepQueryParameters.length > 0) {
+    for (const key of [...urlObject.searchParams.keys()]) {
+      if (!testParameter(key, options.keepQueryParameters)) {
+        urlObject.searchParams.delete(key);
+      }
+    }
+  }
+  if (options.sortQueryParameters) {
+    urlObject.searchParams.sort();
+    try {
+      urlObject.search = decodeURIComponent(urlObject.search);
+    } catch (e) {
+    }
+  }
+  if (options.removeTrailingSlash) {
+    urlObject.pathname = urlObject.pathname.replace(/\/$/, "");
+  }
+  if (options.removeExplicitPort && urlObject.port) {
+    urlObject.port = "";
+  }
+  const oldUrlString = urlString;
+  urlString = urlObject.toString();
+  if (!options.removeSingleSlash && urlObject.pathname === "/" && !oldUrlString.endsWith("/") && urlObject.hash === "") {
+    urlString = urlString.replace(/\/$/, "");
+  }
+  if ((options.removeTrailingSlash || urlObject.pathname === "/") && urlObject.hash === "" && options.removeSingleSlash) {
+    urlString = urlString.replace(/\/$/, "");
+  }
+  if (hasRelativeProtocol && !options.normalizeProtocol) {
+    urlString = urlString.replace(/^http:\/\//, "//");
+  }
+  if (options.stripProtocol) {
+    urlString = urlString.replace(/^(?:https?:)?\/\//, "");
+  }
+  return urlString;
+}
+
+// src/client.ts
+function trimTrailingSlashes(url) {
+  return url.replace(/\/+$/, "");
+}
+var ChainPatrolClient = class {
+  constructor(options) {
+    this.logger = new Logger({ component: "ChainPatrolClient" });
+    var _a;
+    this.baseUrl = (_a = options.baseUrl) != null ? _a : "https://app.chainpatrol.io/api/";
+    if (!options.apiKey) {
+      throw new Error("ChainPatrol API key is required");
+    }
+    this.apiKey = options.apiKey;
+  }
+  fetch(req) {
+    return __async(this, null, function* () {
+      const url = `${trimTrailingSlashes(this.baseUrl)}/${req.path.join("/")}`;
+      this.logger.debug("fetch", { url, req });
+      const res = yield fetch(url, {
+        method: req.method,
+        headers: {
+          "Content-Type": "application/json",
+          "X-Api-Key": this.apiKey
+        },
+        body: JSON.stringify(req.body)
+      });
+      if (!res.ok) {
+        throw new Error(yield res.text());
+      }
+      return res.json();
+    });
+  }
+  get asset() {
+    return {
+      check: (req) => __async(this, null, function* () {
+        return yield this.fetch({
+          path: ["v2", "asset", "check"],
+          method: "POST",
+          body: req
+        });
+      }),
+      list: (req) => __async(this, null, function* () {
+        return yield this.fetch({
+          path: ["v2", "asset", "list"],
+          method: "GET",
+          body: req
+        });
+      })
+    };
+  }
+};
+
+// src/storage/index.ts
+var storage_exports = {};
+__export(storage_exports, {
+  Browser: () => Browser,
+  Extension: () => Extension,
+  Memory: () => Memory,
+  defineStorage: () => defineStorage
+});
+
+// src/storage/define-storage.ts
+function defineStorage(config) {
+  return () => config({
+    keys: Object.values(ThreatDetector.StorageKeys)
+  });
+}
+
+// src/storage/extension.ts
+var Extension = defineStorage(({ keys }) => {
+  return {
+    get: (key) => __async(void 0, null, function* () {
+      const result = yield chrome.storage.local.get(key);
+      return result[key];
+    }),
+    set: (key, value) => __async(void 0, null, function* () {
+      yield chrome.storage.local.set({ [key]: value });
+    }),
+    delete: (key) => __async(void 0, null, function* () {
+      yield chrome.storage.local.remove(key);
+    }),
+    size: () => __async(void 0, null, function* () {
+      const usageBytes = yield chrome.storage.local.getBytesInUse(keys);
+      return usageBytes;
+    })
+  };
+});
+
+// src/storage/browser.ts
+function isStorageAvailable(type) {
+  let storage;
+  try {
+    storage = window[type];
+    const x = "__storage_test__";
+    storage.setItem(x, x);
+    storage.removeItem(x);
+    return true;
+  } catch (e) {
+    return e instanceof DOMException && // everything except Firefox
+    (e.code === 22 || // Firefox
+    e.code === 1014 || // test name field too, because code might not be present
+    // everything except Firefox
+    e.name === "QuotaExceededError" || // Firefox
+    e.name === "NS_ERROR_DOM_QUOTA_REACHED") && // acknowledge QuotaExceededError only if there's something already stored
+    storage && storage.length !== 0;
+  }
+}
+var Browser = defineStorage(({ keys }) => {
+  if (!isStorageAvailable("localStorage")) {
+    throw new Error("localStorage is not available");
+  }
+  return {
+    get: (key) => __async(void 0, null, function* () {
+      return localStorage.getItem(key);
+    }),
+    set: (key, value) => __async(void 0, null, function* () {
+      localStorage.setItem(key, value);
+    }),
+    delete: (key) => __async(void 0, null, function* () {
+      localStorage.removeItem(key);
+    }),
+    size: () => __async(void 0, null, function* () {
+      var _a, _b;
+      let total = 0;
+      for (let i = 0; i < localStorage.length; i++) {
+        const key = localStorage.key(i);
+        if (key && keys.includes(key)) {
+          total += (_b = (_a = localStorage.getItem(key)) == null ? void 0 : _a.length) != null ? _b : 0;
+        }
+      }
+      return total;
+    })
+  };
+});
+
+// src/storage/memory.ts
+var Memory = defineStorage(() => {
+  const storage = /* @__PURE__ */ new Map();
+  return {
+    get: (key) => __async(void 0, null, function* () {
+      return storage.get(key) || null;
+    }),
+    set: (key, value) => __async(void 0, null, function* () {
+      storage.set(key, value);
+    }),
+    delete: (key) => __async(void 0, null, function* () {
+      storage.delete(key);
+    }),
+    size: () => __async(void 0, null, function* () {
+      let total = 0;
+      for (const value of storage.values()) {
+        total += value.length;
+      }
+      return total;
+    })
+  };
+});
+
+// src/detector.ts
+var DomainParseError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "DomainParseError";
+  }
+};
+var _ThreatDetector = class _ThreatDetector {
+  constructor({
+    mode = "cloud",
+    apiKey = "",
+    storage = Memory(),
+    proxyUrl,
+    redirectUrl
+  }) {
+    this.logger = new Logger({ component: "ThreatDetector" });
+    this.mode = mode;
+    this.storage = storage;
+    this.redirectUrl = redirectUrl;
+    if (mode === "cloud") {
+      this.client = new ChainPatrolClient({
+        apiKey,
+        baseUrl: proxyUrl
+      });
+    }
+  }
+  url(url) {
+    return __async(this, null, function* () {
+      this.logger.debug("Checking URL", { url });
+      let domains;
+      try {
+        domains = this.generateDomains(url);
+      } catch (e) {
+        this.logger.error("Unable to parse domain", { url, error: e });
+        return {
+          ok: false,
+          url,
+          error: e instanceof DomainParseError ? e.message : "Unable to parse domain"
+        };
+      }
+      this.logger.debug("Generated domains", { domains });
+      let results = (yield Promise.all(domains.map((domain) => this.urlHelper(domain)))).filter(
+        (r) => r.ok
+      );
+      if (results.length === 0) {
+        return {
+          ok: false,
+          url,
+          error: "URL does not have a valid domain"
+        };
+      }
+      this.logger.debug("Results for domains", { results });
+      if (results.some((r) => r.status === "IGNORED")) {
+        return {
+          ok: true,
+          status: "IGNORED",
+          url
+        };
+      }
+      for (const result of results) {
+        if (result.ok && result.status !== "UNKNOWN") {
+          return result;
+        }
+      }
+      return results[0];
+    });
+  }
+  generateDomains(_url) {
+    var _a, _b;
+    const domain = this.parseDomainOrThrow(_url);
+    const domains = [domain];
+    const parsedDomain = tldts.parse(domain);
+    if (!parsedDomain.subdomain) {
+      return domains;
+    }
+    const subdomainParts = (_b = (_a = parsedDomain.subdomain) == null ? void 0 : _a.split(".")) != null ? _b : [];
+    for (let i = 0; i < subdomainParts.length; i++) {
+      const subdomain = subdomainParts.slice(i).join(".");
+      domains.unshift(`${subdomain}.${domain}`);
+    }
+    return domains;
+  }
+  urlHelper(domain) {
+    return __async(this, null, function* () {
+      let status = yield this.getStatusFromCache(domain);
+      if (this.mode === "cloud" && this.client && status === "UNKNOWN") {
+        try {
+          const res = yield this.client.asset.check({
+            type: "URL",
+            content: domain
+          });
+          this.logger.debug("Updating cache", { domain, status: res.status });
+          if (res.status === "ALLOWED") {
+            this.addDomainToCache(domain, _ThreatDetector.StorageKeys.ALLOWLIST);
+          } else if (res.status === "BLOCKED") {
+            this.addDomainToCache(domain, _ThreatDetector.StorageKeys.BLOCKLIST);
+          }
+          status = res.status;
+        } catch (e) {
+          return {
+            ok: false,
+            url: domain,
+            error: "Unable to check URL"
+          };
+        }
+      }
+      let redirectUrl;
+      if (status === "BLOCKED") {
+        if (typeof this.redirectUrl === "function") {
+          redirectUrl = this.redirectUrl(domain);
+        } else if (typeof this.redirectUrl === "string") {
+          const url = new URL(this.redirectUrl);
+          url.searchParams.set("originUrl", domain);
+          redirectUrl = url.toString();
+        }
+      }
+      return {
+        ok: true,
+        status,
+        url: domain,
+        redirectUrl
+      };
+    });
+  }
+  allow(url) {
+    return __async(this, null, function* () {
+      try {
+        const domain = this.parseDomainOrThrow(url);
+        this.logger.debug("Allowing URL", { url, domain });
+        yield this.invalidateDomainInCaches(domain);
+        yield this.addDomainToCache(domain, _ThreatDetector.StorageKeys.ALLOWLIST);
+        return {
+          ok: true,
+          url: domain
+        };
+      } catch (e) {
+        this.logger.error("Unable to allow URL", { url, error: e });
+        return {
+          ok: false,
+          url,
+          error: "Unable to allow URL"
+        };
+      }
+    });
+  }
+  block(url) {
+    return __async(this, null, function* () {
+      try {
+        const domain = this.parseDomainOrThrow(url);
+        this.logger.debug("Blocking URL", { url, domain });
+        yield this.invalidateDomainInCaches(domain);
+        yield this.addDomainToCache(domain, _ThreatDetector.StorageKeys.BLOCKLIST);
+        return {
+          ok: true,
+          url: domain
+        };
+      } catch (e) {
+        this.logger.error("Unable to block URL", { url, error: e });
+        return {
+          ok: false,
+          url,
+          error: "Unable to block URL"
+        };
+      }
+    });
+  }
+  ignore(url) {
+    return __async(this, null, function* () {
+      try {
+        const domain = this.parseDomainOrThrow(url);
+        this.logger.debug("Ignoring URL", { url, domain });
+        yield this.addDomainToCache(
+          domain,
+          _ThreatDetector.StorageKeys.IGNORELIST
+        );
+        return {
+          ok: true,
+          url: domain
+        };
+      } catch (e) {
+        this.logger.error("Unable to ignore URL", { url, error: e });
+        return {
+          ok: false,
+          url,
+          error: "Unable to ignore URL"
+        };
+      }
+    });
+  }
+  parseDomainOrThrow(url) {
+    this.logger.debug("Parsing domain", { url });
+    try {
+      const normalizedUrl = normalizeUrl(url, {
+        stripWWW: false,
+        removeTrailingSlash: false
+      });
+      this.logger.debug("Normalized URL", { from: url, to: normalizedUrl });
+      const parsedURL = new URL(normalizedUrl);
+      this.logger.debug("Extract domain from URL", { url: parsedURL.hostname });
+      const parsedSubdomainResult = tldts.parse(parsedURL.hostname);
+      this.logger.debug("Parsed domain", { parsedSubdomainResult });
+      if (parsedSubdomainResult.hostname === "localhost") {
+        throw new DomainParseError("ThreatDetector does not support localhost");
+      }
+      if (parsedSubdomainResult.isIp) {
+        throw new DomainParseError(
+          "ThreatDetector does not support IP addresses"
+        );
+      }
+      if (!parsedSubdomainResult.domain) {
+        throw new DomainParseError("Unable to parse domain");
+      }
+      const domain = parsedSubdomainResult.domain;
+      return domain;
+    } catch (e) {
+      if (e instanceof DomainParseError) {
+        throw e;
+      } else {
+        this.logger.error("Unable to parse domain", { url, error: e });
+        throw new DomainParseError("Unable to parse domain");
+      }
+    }
+  }
+  invalidateDomainInCaches(domain) {
+    return __async(this, null, function* () {
+      yield this.invalidateDomainInCache(
+        domain,
+        _ThreatDetector.StorageKeys.ALLOWLIST
+      );
+      yield this.invalidateDomainInCache(
+        domain,
+        _ThreatDetector.StorageKeys.BLOCKLIST
+      );
+    });
+  }
+  invalidateDomainInCache(domain, key) {
+    return __async(this, null, function* () {
+      const data = yield this.storage.get(key);
+      if (!data) {
+        return;
+      }
+      const list = yield this.getListFromStorage(key);
+      if (!list.data.domains.includes(domain)) {
+        return;
+      }
+      list.data.domains = list.data.domains.filter((u) => u !== domain);
+      yield this.setListInStorage(key, list);
+    });
+  }
+  addDomainToCache(domain, key) {
+    return __async(this, null, function* () {
+      const list = yield this.getListFromStorage(key);
+      if (list.data.domains.includes(domain)) {
+        return;
+      }
+      list.data.domains.push(domain);
+      yield this.setListInStorage(key, list);
+    });
+  }
+  isDomainInList(domain, key) {
+    return __async(this, null, function* () {
+      const list = yield this.getListFromStorage(key);
+      return list.data.domains.includes(domain);
+    });
+  }
+  getListFromStorage(key) {
+    return __async(this, null, function* () {
+      const data = yield this.storage.get(key);
+      if (!data) {
+        const list2 = {
+          version: 1,
+          data: {
+            domains: []
+          }
+        };
+        yield this.setListInStorage(key, list2);
+        return list2;
+      }
+      const list = _ThreatDetector.Schema.parse(JSON.parse(data));
+      return list;
+    });
+  }
+  setListInStorage(key, list) {
+    return __async(this, null, function* () {
+      yield this.storage.set(key, JSON.stringify(list));
+    });
+  }
+  getStatusFromCache(domain) {
+    return __async(this, null, function* () {
+      if (yield this.isDomainInList(domain, _ThreatDetector.StorageKeys.IGNORELIST)) {
+        return "IGNORED";
+      } else if (yield this.isDomainInList(domain, _ThreatDetector.StorageKeys.BLOCKLIST)) {
+        return "BLOCKED";
+      } else if (yield this.isDomainInList(domain, _ThreatDetector.StorageKeys.ALLOWLIST)) {
+        return "ALLOWED";
+      } else {
+        return "UNKNOWN";
+      }
+    });
+  }
+};
+_ThreatDetector.StorageKeys = {
+  ALLOWLIST: "chainpatrol.allowed",
+  BLOCKLIST: "chainpatrol.blocked",
+  IGNORELIST: "chainpatrol.ignored"
+};
+_ThreatDetector.Schema = zod.z.object({
+  version: zod.z.literal(1),
+  data: zod.z.object({
+    domains: zod.z.array(zod.z.string())
+  })
+});
+var ThreatDetector = _ThreatDetector;
+
+exports.ChainPatrolClient = ChainPatrolClient;
+exports.DomainParseError = DomainParseError;
+exports.Events = Events;
+exports.Relay = Relay;
+exports.Storage = storage_exports;
+exports.ThreatDetector = ThreatDetector;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.js.map