@freedomofpress/webcat 0.0.0-stage → 3.0.0

package/dist/lib/browser/requests.js

@@ -0,0 +1,292 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var _resolve, _reject, _promise, _resolve2, _details, _responses, _details2, _currentListeners, _RequestHandler_instances, beforeRequest_fn, beforeHeaders_fn, headersReceived_fn, errorOccurred_fn, completed_fn;
+import permissions from "./permissions.js";
+import { buildUrlPatterns } from "./utils.js";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError2 = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __decoratorStart = (base) => [, , , __create(base?.[__knownSymbol("metadata")] ?? null)];
+var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError2("Function expected") : fn;
+var __decoratorContext = (kind, name, done, metadata, fns) => ({ kind: __decoratorStrings[kind], name, metadata, addInitializer: (fn) => done._ ? __typeError2("Already initialized") : fns.push(__expectFn(fn || null)) });
+var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
+var __runInitializers = (array, flags, self, value) => {
+  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) fns[i].call(self);
+  return value;
+};
+var __decorateElement = (array, flags, name, decorators, target, extra) => {
+  var it, done, ctx, k = flags & 7, p = false;
+  var j = 0;
+  var extraInitializers = array[j] || (array[j] = []);
+  var desc = k && (target = target.prototype, k < 5 && (k > 3 || !p) && __getOwnPropDesc(target, name));
+  __name(target, name);
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
+    it = (0, decorators[i])(target, ctx), done._ = 1;
+    __expectFn(it) && (target = it);
+  }
+  return __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
+};
+var _RequestHandler_decorators, _init, _a;
+class RequestDetailsBase {
+  constructor() {
+    __privateAdd(this, _resolve);
+    __privateAdd(this, _reject);
+    const { promise, resolve, reject } = Promise.withResolvers();
+    promise.catch(() => {
+    });
+    this.completed = promise;
+    __privateSet(this, _resolve, resolve);
+    __privateSet(this, _reject, reject);
+  }
+  /** @internal */
+  complete() {
+    __privateGet(this, _resolve).call(this);
+  }
+  /** @internal */
+  fail() {
+    __privateGet(this, _reject).call(this);
+  }
+}
+_resolve = new WeakMap();
+_reject = new WeakMap();
+const dispose = Symbol.dispose ?? Symbol.for("Symbol.dispose");
+class BlockingResponse {
+  constructor(details) {
+    __privateAdd(this, _promise);
+    __privateAdd(this, _resolve2);
+    __privateAdd(this, _details);
+    this.cancel = true;
+    const { promise, resolve } = Promise.withResolvers();
+    __privateSet(this, _promise, promise);
+    __privateSet(this, _resolve2, resolve);
+    __privateSet(this, _details, details);
+  }
+  /**
+   * Implements the {@link Disposable} interface.
+   */
+  [dispose]() {
+    __privateGet(this, _resolve2).call(this, this);
+  }
+  /**
+   * @returns A Promise that resolves to this BlockingResponse after disposal.
+   */
+  ready() {
+    return __privateGet(this, _promise);
+  }
+  /**
+   * @param value An object whose properties are copied to this BlockingResponse.
+   */
+  set(value) {
+    Object.assign(this, value);
+  }
+  /**
+   * Sets the response header `name` to `value`, replacing any existing
+   * occurrences. Starts from the response's original headers, so the rest
+   * pass through unchanged.
+   */
+  setHeader(name, value) {
+    const lower = name.toLowerCase();
+    const original = __privateGet(this, _details) && "responseHeaders" in __privateGet(this, _details) ? __privateGet(this, _details).responseHeaders : void 0;
+    this.responseHeaders = [
+      ...(this.responseHeaders ?? original ?? []).filter(
+        (h) => h.name.toLowerCase() !== lower
+      ),
+      { name, value }
+    ];
+  }
+}
+_promise = new WeakMap();
+_resolve2 = new WeakMap();
+_details = new WeakMap();
+class RequestEvent extends Event {
+  /** @internal */
+  constructor(type, details) {
+    super(type);
+    __privateAdd(this, _responses, []);
+    this.details = details;
+  }
+  /**
+   * Creates a {@link BlockingResponse} for this event. Each listener creates
+   * its own before its first await expression, so that listeners respond
+   * independently of each other; see {@link ready} for how the responses are
+   * combined.
+   *
+   * @returns A new BlockingResponse that cancels the request unless the
+   *   listener sets {@link BlockingResponse.cancel} to false.
+   */
+  createBlockingResponse() {
+    const response = new BlockingResponse(this.details);
+    __privateGet(this, _responses).push(response);
+    return response;
+  }
+  /**
+   * Awaits all BlockingResponses created for this event and merges them into
+   * a single response. If any of them cancels the request, so does the
+   * result; otherwise, their other properties are combined. With no
+   * BlockingResponses, the request proceeds unchanged.
+   *
+   * @returns A Promise that resolves to the merged response.
+   * @internal
+   */
+  async ready() {
+    const responses = await Promise.all(__privateGet(this, _responses).map((r) => r.ready()));
+    const merged = Object.assign(
+      {},
+      ...responses
+    );
+    merged.cancel = responses.some((response) => response.cancel !== false);
+    return merged;
+  }
+}
+_responses = new WeakMap();
+_RequestHandler_decorators = [permissions.require("webRequest"), permissions.require("webRequestBlocking")];
+class RequestHandler extends (_a = EventTarget) {
+  constructor() {
+    super(...arguments);
+    __privateAdd(this, _RequestHandler_instances);
+    __privateAdd(this, _details2, /* @__PURE__ */ new Map());
+    __privateAdd(this, _currentListeners, {});
+  }
+  /**
+   * Binds the handler to the given list of FQDNs. When called, the handler
+   * starts handling requests for the FQDNs in the list and stops handling
+   * requests for any previously bound FQDNs that are not in the new list.
+   *
+   * @param fqdns A list of fully-qualified domain names to bind to.
+   */
+  bind(fqdns) {
+    const before = (details) => __privateMethod(this, _RequestHandler_instances, beforeRequest_fn).call(this, details);
+    const beforeHeaders = (details) => __privateMethod(this, _RequestHandler_instances, beforeHeaders_fn).call(this, details);
+    const headers = (details) => __privateMethod(this, _RequestHandler_instances, headersReceived_fn).call(this, details);
+    const errorOccurred = (details) => __privateMethod(this, _RequestHandler_instances, errorOccurred_fn).call(this, details);
+    const completed = (details) => __privateMethod(this, _RequestHandler_instances, completed_fn).call(this, details);
+    browser.webRequest.onBeforeRequest.addListener(
+      before,
+      ...this.getListenerOptions(fqdns, "beforerequest")
+    );
+    browser.webRequest.onBeforeSendHeaders.addListener(
+      beforeHeaders,
+      ...this.getListenerOptions(fqdns, "beforeheaders")
+    );
+    browser.webRequest.onHeadersReceived.addListener(
+      headers,
+      ...this.getListenerOptions(fqdns, "headersreceived")
+    );
+    browser.webRequest.onErrorOccurred.addListener(
+      errorOccurred,
+      ...this.getListenerOptions(fqdns, "erroroccurred")
+    );
+    browser.webRequest.onCompleted.addListener(
+      completed,
+      ...this.getListenerOptions(fqdns, "completed")
+    );
+    const previous = __privateGet(this, _currentListeners);
+    __privateSet(this, _currentListeners, {
+      before,
+      beforeHeaders,
+      headers,
+      errorOccurred,
+      completed
+    });
+    if (previous.before) {
+      browser.webRequest.onBeforeRequest.removeListener(previous.before);
+    }
+    if (previous.beforeHeaders) {
+      browser.webRequest.onBeforeSendHeaders.removeListener(
+        previous.beforeHeaders
+      );
+    }
+    if (previous.headers) {
+      browser.webRequest.onHeadersReceived.removeListener(previous.headers);
+    }
+    if (previous.errorOccurred) {
+      browser.webRequest.onErrorOccurred.removeListener(previous.errorOccurred);
+    }
+    if (previous.completed) {
+      browser.webRequest.onCompleted.removeListener(previous.completed);
+    }
+    console.log(
+      `[webcat] RequestHandler.bind: registered listeners for ${fqdns.length} URL(s)`
+    );
+  }
+  // prettier-ignore
+  getListenerOptions(fqdns, type) {
+    const urls = buildUrlPatterns(fqdns);
+    switch (type) {
+      case "beforerequest":
+        return [{ urls }, ["blocking"]];
+      case "beforeheaders":
+        return [{ urls }, ["blocking", "requestHeaders"]];
+      case "headersreceived":
+        return [{ urls }, ["blocking", "responseHeaders"]];
+      case "erroroccurred":
+      case "completed":
+        return [{ urls }];
+      default:
+        throw new TypeError(`unrecognized handler type '${type}'`);
+    }
+  }
+}
+_details2 = new WeakMap();
+_currentListeners = new WeakMap();
+_RequestHandler_instances = new WeakSet();
+beforeRequest_fn = async function(d) {
+  const details = Object.assign(new RequestDetailsBase(), d);
+  __privateGet(this, _details2).set(details.requestId, details);
+  const event = new RequestEvent("beforerequest", details);
+  this.dispatchEvent(event);
+  return await event.ready();
+};
+beforeHeaders_fn = async function(d) {
+  const base = __privateGet(this, _details2).get(d.requestId) ?? new RequestDetailsBase();
+  const details = Object.assign(base, d);
+  const event = new RequestEvent("beforeheaders", details);
+  this.dispatchEvent(event);
+  return await event.ready();
+};
+headersReceived_fn = async function(d) {
+  const base = __privateGet(this, _details2).get(d.requestId) ?? new RequestDetailsBase();
+  const details = Object.assign(base, d);
+  const event = new RequestEvent("headersreceived", details);
+  this.dispatchEvent(event);
+  return await event.ready();
+};
+errorOccurred_fn = function(d) {
+  const base = __privateGet(this, _details2).get(d.requestId) ?? new RequestDetailsBase();
+  const details = Object.assign(base, d);
+  details.fail();
+  const event = new RequestEvent("erroroccurred", details);
+  this.dispatchEvent(event);
+  __privateGet(this, _details2).delete(details.requestId);
+};
+completed_fn = function(d) {
+  const base = __privateGet(this, _details2).get(d.requestId) ?? new RequestDetailsBase();
+  const details = Object.assign(base, d);
+  details.complete();
+  const event = new RequestEvent("completed", details);
+  this.dispatchEvent(event);
+  __privateGet(this, _details2).delete(details.requestId);
+};
+_init = __decoratorStart(_a);
+RequestHandler = __decorateElement(_init, 0, "RequestHandler", _RequestHandler_decorators, RequestHandler);
+__runInitializers(_init, 1, RequestHandler);
+export {
+  BlockingResponse,
+  RequestDetailsBase,
+  RequestEvent,
+  RequestHandler
+};

package/dist/lib/browser/scripting.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Represents a single content script in a static file.
+ */
+export declare class ContentScript {
+    #private;
+    /**
+     * @param path Path to a script file.
+     */
+    constructor(path: string);
+    /**
+     * Binds the content script to the given list of FQDNs. When called, the
+     * content script is registered for the FQDNs in the list and unregistered
+     * for all other FQDNS.
+     *
+     * @param fqdns A list of fully-qualified domain names to bind the script to.
+     * @returns A list of the FQDNs that the script was not yet bound to.
+     */
+    bind(fqdns: string[]): Promise<string[]>;
+}

package/dist/lib/browser/scripting.js

@@ -0,0 +1,92 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var _idPrefix, _path;
+import permissions from "./permissions.js";
+import { buildUrlPatterns } from "./utils.js";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError2 = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __decoratorStart = (base) => [, , , __create(null)];
+var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError2("Function expected") : fn;
+var __decoratorContext = (kind, name, done, metadata, fns) => ({ kind: __decoratorStrings[kind], name, metadata, addInitializer: (fn) => done._ ? __typeError2("Already initialized") : fns.push(__expectFn(fn || null)) });
+var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
+var __runInitializers = (array, flags, self, value) => {
+  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) fns[i].call(self);
+  return value;
+};
+var __decorateElement = (array, flags, name, decorators, target, extra) => {
+  var it, done, ctx, k = flags & 7, p = false;
+  var j = 0;
+  var extraInitializers = array[j] || (array[j] = []);
+  var desc = k && (target = target.prototype, k < 5 && (k > 3 || !p) && __getOwnPropDesc(target, name));
+  __name(target, name);
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
+    it = (0, decorators[i])(target, ctx), done._ = 1;
+    __expectFn(it) && (target = it);
+  }
+  return __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
+};
+var _ContentScript_decorators, _init;
+_ContentScript_decorators = [permissions.require("scripting")];
+class ContentScript {
+  /**
+   * @param path Path to a script file.
+   */
+  constructor(path) {
+    __privateAdd(this, _idPrefix);
+    __privateAdd(this, _path);
+    __privateSet(this, _path, path);
+    __privateSet(this, _idPrefix, `webcat-script:${path}:`);
+  }
+  /**
+   * Binds the content script to the given list of FQDNs. When called, the
+   * content script is registered for the FQDNs in the list and unregistered
+   * for all other FQDNS.
+   *
+   * @param fqdns A list of fully-qualified domain names to bind the script to.
+   * @returns A list of the FQDNs that the script was not yet bound to.
+   */
+  async bind(fqdns) {
+    const registeredFqdns = (await browser.scripting.getRegisteredContentScripts()).filter((script) => script.id.startsWith(__privateGet(this, _idPrefix))).map((script) => script.id.substring(__privateGet(this, _idPrefix).length));
+    const newFqdns = fqdns.filter((fqdn) => {
+      return !registeredFqdns.includes(fqdn);
+    });
+    await browser.scripting.registerContentScripts(
+      newFqdns.map((fqdn) => {
+        return {
+          id: __privateGet(this, _idPrefix) + fqdn,
+          js: [__privateGet(this, _path)],
+          matches: buildUrlPatterns([fqdn]),
+          matchOriginAsFallback: true,
+          allFrames: true,
+          runAt: "document_start"
+        };
+      })
+    );
+    await browser.scripting.unregisterContentScripts({
+      ids: registeredFqdns.filter((fqdn) => !fqdns.includes(fqdn)).map((fqdn) => __privateGet(this, _idPrefix) + fqdn)
+    });
+    return newFqdns;
+  }
+}
+_idPrefix = new WeakMap();
+_path = new WeakMap();
+_init = __decoratorStart();
+ContentScript = __decorateElement(_init, 0, "ContentScript", _ContentScript_decorators, ContentScript);
+__runInitializers(_init, 1, ContentScript);
+export {
+  ContentScript
+};

package/dist/lib/browser/sync.d.ts

@@ -0,0 +1,68 @@
+/**
+ * An object that can be held and released by a {@link Lock}.
+ */
+export type Releasable = {
+    release(): void;
+};
+/**
+ * A {@link Disposable} that holds a {@link Releasable} (e.g. a {@link Mutex})
+ * and releases it when disposed. When multiple scopes hold the same Lock, the
+ * Releasable is only released when all holders have disposed.
+ */
+export declare class Lock implements Disposable {
+    #private;
+    /**
+     * The object held by this Lock; usually a {@link Mutex}.
+     */
+    readonly mutex: Releasable;
+    /**
+     * @param mutex The object held by this Lock; usually a {@link Mutex}.
+     */
+    constructor(mutex: Releasable);
+    /**
+     * Implements the {@link Disposable} interface.
+     */
+    get [Symbol.dispose](): () => void;
+}
+/**
+ * A mutex for enforcing execution order in asynchronous code.
+ *
+ * @example
+ * class AsyncThing {
+ *   #mutex = new Mutex();
+ *   async doSomeThings(x) {                    // Guaranteed execution order:
+ *     using _ = await this.#mutex.acquire();   //
+ *     await thingNumberOne(x);                 // 1.   t.doSomeThings(1)
+ *     await thingNumberTwo(x);                 // 1.1. thingNumberOne(1)
+ *   }                                          // 1.2. thingNumberTwo(1)
+ * }                                            // 2.   t.doSomethings(2)
+ *                                              // 2.1. thingNumberOne(2)
+ * const t = new AsyncThing();                  // 2.2. thingNumberTwo(2)
+ * t.doSomeThings(1);                           // 3.   t.doSomethings(3)
+ * t.doSomeThings(2);                           // 3.1. thingNumberOne(3)
+ * t.doSomeThings(3);                           // 3.2. thingNumberTwo(3)
+ */
+export declare class Mutex implements Releasable {
+    #private;
+    /**
+     * Locks this Mutex. Calling `await mutex.acquire()` on an unlocked Mutex
+     * returns immediately. Calling it on a locked Mutex awaits until the Mutex
+     * is released. Calling `await mutex.acquire(lock)` with the lock that is
+     * holding the Mutex returns immediately and returns the same lock, which is
+     * useful, for example, in recursive algorithms.
+     *
+     * @param lock An optional Lock that will be used to hold the Mutex.
+     * @returns The Lock currently holding the locked Mutex.
+     */
+    acquire(lock?: Lock): Promise<Lock>;
+    /**
+     * Releases this Mutex. Called either directly or by the {@link Lock} holding
+     * the Mutex as it gets disposed.
+     */
+    release(): void;
+    /**
+     * @returns A new {@link Lock} for this Mutex. Unlike {@link acquire}, does
+     * not lock the Mutex; to use the Lock, pass it to acquire.
+     */
+    createLock(): Lock;
+}

package/dist/lib/browser/sync.js

@@ -0,0 +1,114 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateWrapper = (obj, member, setter, getter) => ({
+  set _(value) {
+    __privateSet(obj, member, value, setter);
+  },
+  get _() {
+    return __privateGet(obj, member, getter);
+  }
+});
+var _holders, _resolvers, _lock;
+class Lock {
+  /**
+   * @param mutex The object held by this Lock; usually a {@link Mutex}.
+   */
+  constructor(mutex) {
+    __privateAdd(this, _holders, 0);
+    this.mutex = mutex;
+  }
+  /**
+   * Implements the {@link Disposable} interface.
+   */
+  get [Symbol.dispose]() {
+    __privateWrapper(this, _holders)._++;
+    return () => {
+      __privateWrapper(this, _holders)._--;
+      if (__privateGet(this, _holders) === 0) {
+        this.mutex.release();
+      }
+    };
+  }
+}
+_holders = new WeakMap();
+if (!Symbol.dispose) {
+  const { get } = Object.getOwnPropertyDescriptor(
+    Lock.prototype,
+    Symbol.dispose
+  );
+  Object.defineProperty(Lock.prototype, Symbol.for("Symbol.dispose"), { get });
+  delete Lock.prototype[Symbol.dispose];
+}
+class Mutex {
+  constructor() {
+    __privateAdd(this, _resolvers, []);
+    __privateAdd(this, _lock);
+  }
+  /**
+   * Locks this Mutex. Calling `await mutex.acquire()` on an unlocked Mutex
+   * returns immediately. Calling it on a locked Mutex awaits until the Mutex
+   * is released. Calling `await mutex.acquire(lock)` with the lock that is
+   * holding the Mutex returns immediately and returns the same lock, which is
+   * useful, for example, in recursive algorithms.
+   *
+   * @param lock An optional Lock that will be used to hold the Mutex.
+   * @returns The Lock currently holding the locked Mutex.
+   */
+  async acquire(lock) {
+    if (__privateGet(this, _lock) === void 0) {
+      if (lock && lock.mutex == this) {
+        __privateSet(this, _lock, lock);
+      } else {
+        __privateSet(this, _lock, this.createLock());
+      }
+      return __privateGet(this, _lock);
+    } else if (lock && lock === __privateGet(this, _lock)) {
+      return __privateGet(this, _lock);
+    } else {
+      return new Promise((resolve) => {
+        __privateGet(this, _resolvers).push([resolve, lock ?? this.createLock()]);
+      });
+    }
+  }
+  /**
+   * Releases this Mutex. Called either directly or by the {@link Lock} holding
+   * the Mutex as it gets disposed.
+   */
+  release() {
+    if (__privateGet(this, _resolvers).length > 0) {
+      const [next, lock] = __privateGet(this, _resolvers).shift();
+      __privateSet(this, _lock, lock);
+      next(__privateGet(this, _lock));
+      while (__privateGet(this, _lock) === lock) {
+        const i = __privateGet(this, _resolvers).findIndex(([_, lock2]) => {
+          return lock2 === __privateGet(this, _lock);
+        });
+        if (i === -1) {
+          break;
+        }
+        const [[next2]] = __privateGet(this, _resolvers).splice(i, 1);
+        next2(__privateGet(this, _lock));
+      }
+    } else {
+      __privateSet(this, _lock, void 0);
+    }
+  }
+  /**
+   * @returns A new {@link Lock} for this Mutex. Unlike {@link acquire}, does
+   * not lock the Mutex; to use the Lock, pass it to acquire.
+   */
+  createLock() {
+    return new Lock(this);
+  }
+}
+_resolvers = new WeakMap();
+_lock = new WeakMap();
+export {
+  Lock,
+  Mutex
+};

package/dist/lib/browser/utils.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @param fqdns An array of fully-qualified domain names.
+ * @returns An array of {@link https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/Match_patterns | patterns} that match the FQDNs.
+ */
+export declare function buildUrlPatterns(fqdns: string[]): string[];

package/dist/lib/browser/utils.js

@@ -0,0 +1,11 @@
+function buildUrlPatterns(fqdns) {
+  const urls = [];
+  for (const fqdn of fqdns) {
+    urls.push(`http://${fqdn}/*`);
+    urls.push(`https://${fqdn}/*`);
+  }
+  return urls;
+}
+export {
+  buildUrlPatterns
+};

package/dist/lib/config.d.ts

@@ -0,0 +1,45 @@
+import { BrowserChromeControllerConfig, PathTemplateProperties } from "./browser/chrome";
+import { WebcatDatabaseConfig } from "./webcat/db";
+import { HookBuilderConfig } from "./webcat/hookbuilder";
+import { BundleFetcherConfig } from "./webcat/originstate";
+import { EnrollmentUpdaterConfig } from "./webcat/updater";
+/**
+ * Global WEBCAT configuration. See {@link defaults}.
+ *
+ * @interface
+ */
+export type WebcatConfig = BundleFetcherConfig & WebcatDatabaseConfig & HookBuilderConfig & Omit<EnrollmentUpdaterConfig, "database"> & BrowserChromeControllerConfig;
+/** Default {@link WebcatConfig} values. */
+export declare const defaults: {
+    /** {@inheritDoc WebcatConfig.namespace} */
+    readonly namespace: "WEBCAT";
+    /** {@inheritDoc WebcatConfig.originCacheSize} */
+    readonly originCacheSize: 32;
+    /** {@inheritDoc WebcatConfig.nonOriginCacheSize} */
+    readonly nonOriginCacheSize: 8192;
+    /** {@inheritDoc WebcatConfig.bundlePath} */
+    readonly bundlePath: "/.well-known/webcat/bundle.json";
+    /** {@inheritDoc WebcatConfig.bundlePrevPath} */
+    readonly bundlePrevPath: "/.well-known/webcat/bundle-prev.json";
+    /** {@inheritDoc WebcatConfig.endpoint} */
+    readonly endpoint: "https://webcat.freedom.press/";
+    /** {@inheritDoc WebcatConfig.localDataPath} */
+    readonly localDataPath: "data";
+    /** {@inheritDoc WebcatConfig.validatorSet} */
+    readonly validatorSet: import("@freedomofpress/cometbft/dist/types.js").ValidatorJson;
+    readonly chainId: "webcat-test-02";
+    /** {@inheritDoc WebcatConfig.updateInterval} */
+    readonly updateInterval: number;
+    /** {@inheritDoc WebcatConfig.checkInterval} */
+    readonly checkInterval: number;
+    /** {@inheritDoc WebcatConfig.fetchTimeout} */
+    readonly fetchTimeout: 3000;
+    /** {@inheritDoc WebcatConfig.staticHookPath} */
+    readonly staticHookPath: "dist/hooks/content.js";
+    /** {@inheritDoc WebcatConfig.iconPaths} */
+    readonly iconPaths: (p: PathTemplateProperties) => string;
+    /** {@inheritDoc WebcatConfig.pagePaths} */
+    readonly pagePaths: (p: PathTemplateProperties) => string;
+};
+/** @internal */
+export declare const test: WebcatConfig;