@addon-core/inject-css 0.3.1 → 0.4.0

package/dist/index.js

@@ -2,125 +2,589 @@
 import { isManifestVersion3 } from "@addon-core/browser";
 
 // src/InjectCssV2.ts
-import { insertCssTab } from "@addon-core/browser";
+import { browser, insertCssTab, removeCssTab } from "@addon-core/browser";
+
+// src/errors.ts
+var InjectCssBaseError = class extends Error {
+  code;
+  cause;
+  constructor(name, code, message, cause) {
+    super(message);
+    this.name = name;
+    this.code = code;
+    if (cause !== void 0) {
+      this.cause = cause;
+    }
+  }
+};
+var InvalidInjectCssTargetError = class extends InjectCssBaseError {
+  constructor(message) {
+    super("InvalidInjectCssTargetError", "ERR_INJECT_CSS_INVALID_TARGET", `Invalid InjectCss target: ${message}`);
+  }
+};
+var UnsupportedInjectCssTargetError = class extends InjectCssBaseError {
+  constructor(message, cause) {
+    super(
+      "UnsupportedInjectCssTargetError",
+      "ERR_INJECT_CSS_UNSUPPORTED_TARGET",
+      `Unsupported InjectCss target: ${message}`,
+      cause
+    );
+  }
+};
+var InvalidInjectCssOptionsError = class extends InjectCssBaseError {
+  constructor(message) {
+    super(
+      "InvalidInjectCssOptionsError",
+      "ERR_INJECT_CSS_INVALID_OPTIONS",
+      `Invalid InjectCss options: ${message}`
+    );
+  }
+};
+var UnsupportedInjectCssOptionError = class extends InjectCssBaseError {
+  constructor(message, cause) {
+    super(
+      "UnsupportedInjectCssOptionError",
+      "ERR_INJECT_CSS_UNSUPPORTED_OPTION",
+      `Unsupported InjectCss option: ${message}`,
+      cause
+    );
+  }
+};
+var UnsupportedInjectCssOperationError = class extends InjectCssBaseError {
+  operation;
+  constructor(operation, message, cause) {
+    super(
+      "UnsupportedInjectCssOperationError",
+      "ERR_INJECT_CSS_UNSUPPORTED_OPERATION",
+      `Unsupported InjectCss operation "${operation}": ${message}`,
+      cause
+    );
+    this.operation = operation;
+  }
+};
+var InvalidInjectCssCodeError = class extends InjectCssBaseError {
+  constructor(message) {
+    super("InvalidInjectCssCodeError", "ERR_INJECT_CSS_INVALID_CODE", `Invalid InjectCss code: ${message}`);
+  }
+};
+var InvalidInjectCssFilesError = class extends InjectCssBaseError {
+  constructor(message) {
+    super("InvalidInjectCssFilesError", "ERR_INJECT_CSS_INVALID_FILES", `Invalid InjectCss files: ${message}`);
+  }
+};
+var InjectCssTimeoutError = class extends InjectCssBaseError {
+  target;
+  timeoutMs;
+  operation;
+  constructor(target, timeoutMs, operation = "insert") {
+    const action = operation === "insert" ? "injection" : "removal";
+    super("InjectCssTimeoutError", "ERR_INJECT_CSS_TIMEOUT", `CSS ${action} timed out after ${timeoutMs} ms.`);
+    this.target = target;
+    this.timeoutMs = timeoutMs;
+    this.operation = operation;
+  }
+};
+var InjectCssFrameDeliveryError = class extends InjectCssBaseError {
+  tabId;
+  frameId;
+  operation;
+  constructor(tabId, frameId, cause, operation = "insert") {
+    const message = cause instanceof Error ? cause.message : String(cause);
+    const action = operation === "insert" ? "injection" : "removal";
+    super(
+      "InjectCssFrameDeliveryError",
+      "ERR_INJECT_CSS_FRAME_DELIVERY",
+      `CSS ${action} failed in frame ${frameId} of tab ${tabId}: ${message}`,
+      cause
+    );
+    this.tabId = tabId;
+    this.frameId = frameId;
+    this.operation = operation;
+  }
+};
+var InjectCssDeliveryError = class extends InjectCssBaseError {
+  target;
+  operation;
+  constructor(target, cause, operation = "insert") {
+    const causeMessage = cause instanceof Error ? cause.message : String(cause);
+    const action = operation === "insert" ? "injection" : "removal";
+    const message = cause instanceof InjectCssFrameDeliveryError ? causeMessage : `CSS ${action} failed: ${causeMessage}`;
+    super("InjectCssDeliveryError", "ERR_INJECT_CSS_DELIVERY", message, cause);
+    this.target = target;
+    this.operation = operation;
+  }
+};
+
+// src/validation.ts
+var TARGET_KEYS = /* @__PURE__ */ new Set(["tabId", "allFrames", "frameIds", "documentIds"]);
+var EXECUTION_OPTION_KEYS = /* @__PURE__ */ new Set(["matchAboutBlank", "runAt", "origin", "timeoutMs"]);
+var INJECT_CSS_OPTION_KEYS = /* @__PURE__ */ new Set(["target", ...EXECUTION_OPTION_KEYS]);
+var RUN_AT_VALUES = /* @__PURE__ */ new Set(["document_start", "document_end", "document_idle"]);
+var ORIGIN_VALUES = /* @__PURE__ */ new Set(["AUTHOR", "USER"]);
+var isObject = (value) => {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+};
+var assertKnownKeys = (value, keys, subject) => {
+  const unknownKeys = Object.keys(value).filter((key) => !keys.has(key));
+  if (unknownKeys.length > 0) {
+    throw new InvalidInjectCssOptionsError(
+      `${subject} contains unknown ${unknownKeys.length === 1 ? "field" : "fields"}: ${unknownKeys.map((key) => `"${key}"`).join(", ")}.`
+    );
+  }
+};
+var cloneTarget = (target) => {
+  if ("frameIds" in target && target.frameIds !== void 0) {
+    return { tabId: target.tabId, frameIds: [...target.frameIds] };
+  }
+  if ("documentIds" in target && target.documentIds !== void 0) {
+    return { tabId: target.tabId, documentIds: [...target.documentIds] };
+  }
+  if ("allFrames" in target && target.allFrames === true) {
+    return { tabId: target.tabId, allFrames: true };
+  }
+  return { tabId: target.tabId };
+};
+var validateInjectCssTarget = (value) => {
+  if (!isObject(value)) {
+    throw new InvalidInjectCssTargetError("target must be an object.");
+  }
+  const unknownKeys = Object.keys(value).filter((key) => !TARGET_KEYS.has(key));
+  if (unknownKeys.length > 0) {
+    throw new InvalidInjectCssTargetError(
+      `target contains unknown ${unknownKeys.length === 1 ? "field" : "fields"}: ${unknownKeys.map((key) => `"${key}"`).join(", ")}.`
+    );
+  }
+  if (!Number.isInteger(value.tabId) || value.tabId < 0) {
+    throw new InvalidInjectCssTargetError('"tabId" must be a non-negative integer.');
+  }
+  const selectors = ["allFrames", "frameIds", "documentIds"].filter((key) => value[key] !== void 0);
+  if (selectors.length > 1) {
+    throw new InvalidInjectCssTargetError('"allFrames", "frameIds", and "documentIds" are mutually exclusive.');
+  }
+  if (value.allFrames !== void 0 && value.allFrames !== true) {
+    throw new InvalidInjectCssTargetError('"allFrames" must be exactly true when provided.');
+  }
+  if (value.frameIds !== void 0) {
+    if (!Array.isArray(value.frameIds) || value.frameIds.length === 0) {
+      throw new InvalidInjectCssTargetError('"frameIds" must contain at least one frame ID.');
+    }
+    if (value.frameIds.some((frameId) => !Number.isInteger(frameId) || frameId < 0)) {
+      throw new InvalidInjectCssTargetError("frame ID must be a non-negative integer.");
+    }
+    if (new Set(value.frameIds).size !== value.frameIds.length) {
+      throw new InvalidInjectCssTargetError('"frameIds" must not contain duplicate frame IDs.');
+    }
+  }
+  if (value.documentIds !== void 0) {
+    if (!Array.isArray(value.documentIds) || value.documentIds.length === 0) {
+      throw new InvalidInjectCssTargetError('"documentIds" must contain at least one document ID.');
+    }
+    if (value.documentIds.some((documentId) => typeof documentId !== "string" || documentId.trim().length === 0)) {
+      throw new InvalidInjectCssTargetError("document ID must be a non-empty string.");
+    }
+    if (new Set(value.documentIds).size !== value.documentIds.length) {
+      throw new InvalidInjectCssTargetError('"documentIds" must not contain duplicate document IDs.');
+    }
+  }
+  return cloneTarget(value);
+};
+var validateInjectCssExecutionOptions = (value) => {
+  if (!isObject(value)) {
+    throw new InvalidInjectCssOptionsError("execution options must be an object.");
+  }
+  assertKnownKeys(value, EXECUTION_OPTION_KEYS, "execution options");
+  if (value.matchAboutBlank !== void 0 && typeof value.matchAboutBlank !== "boolean") {
+    throw new InvalidInjectCssOptionsError('"matchAboutBlank" must be a boolean.');
+  }
+  if (value.runAt !== void 0 && (typeof value.runAt !== "string" || !RUN_AT_VALUES.has(value.runAt))) {
+    throw new InvalidInjectCssOptionsError('"runAt" must be "document_start", "document_end", or "document_idle".');
+  }
+  if (value.origin !== void 0 && (typeof value.origin !== "string" || !ORIGIN_VALUES.has(value.origin))) {
+    throw new InvalidInjectCssOptionsError('"origin" must be "AUTHOR" or "USER".');
+  }
+  if (value.timeoutMs !== void 0 && (typeof value.timeoutMs !== "number" || !Number.isInteger(value.timeoutMs) || value.timeoutMs <= 0)) {
+    throw new InvalidInjectCssOptionsError('"timeoutMs" must be a positive integer.');
+  }
+  return { ...value };
+};
+var validateInjectCssOptions = (value) => {
+  if (!isObject(value)) {
+    throw new InvalidInjectCssOptionsError("options must be an object.");
+  }
+  assertKnownKeys(value, INJECT_CSS_OPTION_KEYS, "options");
+  const { target, ...execution } = value;
+  return {
+    target: validateInjectCssTarget(target),
+    execution: validateInjectCssExecutionOptions(execution)
+  };
+};
+var validateInjectCssCode = (value) => {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new InvalidInjectCssCodeError("code must be a non-empty string.");
+  }
+  return value;
+};
+var validateInjectCssFiles = (files) => {
+  const fileList = typeof files === "string" ? [files] : files;
+  if (!Array.isArray(fileList) || fileList.length === 0) {
+    throw new InvalidInjectCssFilesError("at least one file is required.");
+  }
+  if (fileList.some((file) => typeof file !== "string" || file.trim().length === 0)) {
+    throw new InvalidInjectCssFilesError("each file must be a non-empty string.");
+  }
+  return [...fileList];
+};
 
 // src/AbstractInjectCss.ts
+var DEFAULT_TIMEOUT_MS = 4e3;
 var AbstractInjectCss_default = class {
-  constructor(_options) {
-    this._options = _options;
+  _target;
+  _execution;
+  constructor(options) {
+    const normalized = validateInjectCssOptions(options);
+    this._target = normalized.target;
+    this._execution = normalized.execution;
+  }
+  target(target) {
+    const normalizedTarget = validateInjectCssTarget(target);
+    this.assertAdapterSupport(normalizedTarget, this._execution);
+    this._target = normalizedTarget;
+    return this;
   }
   options(options) {
-    this._options = { ...this._options, ...options, tabId: options.tabId ?? this._options.tabId };
+    const normalizedOptions = validateInjectCssExecutionOptions(options);
+    const nextExecution = { ...this._execution, ...normalizedOptions };
+    this.assertAdapterSupport(this._target, nextExecution);
+    this._execution = nextExecution;
     return this;
   }
-  get frameIds() {
-    const { frameId } = this._options;
-    return typeof frameId === "number" ? [frameId] : typeof frameId !== "boolean" ? frameId : void 0;
+  validateCode(css) {
+    return validateInjectCssCode(css);
+  }
+  normalizeFiles(files) {
+    return validateInjectCssFiles(files);
   }
-  get allFrames() {
-    const { frameId } = this._options;
-    return typeof frameId === "boolean" ? frameId : void 0;
+  snapshotTarget() {
+    return validateInjectCssTarget(this._target);
   }
-  get matchAboutBlank() {
-    const { matchAboutBlank } = this._options;
-    return typeof matchAboutBlank === "boolean" ? matchAboutBlank : true;
+  snapshotExecution() {
+    return { ...this._execution };
+  }
+  get timeoutMs() {
+    return this._execution.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  }
+  async withTimeout(task, target, timeoutMs, operation = "insert") {
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      const finish = (callback) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timeoutId);
+        callback();
+      };
+      const timeoutId = setTimeout(() => {
+        finish(() => reject(new InjectCssTimeoutError(target, timeoutMs, operation)));
+      }, timeoutMs);
+      task.then(
+        (value) => finish(() => resolve(value)),
+        (error) => finish(() => reject(error))
+      );
+    });
   }
+  deliveryError(target, error, operation = "insert") {
+    if (error instanceof InjectCssDeliveryError || error instanceof InjectCssTimeoutError) {
+      return error;
+    }
+    return new InjectCssDeliveryError(target, error, operation);
+  }
+};
+
+// src/native-errors.ts
+var UNSUPPORTED_API_PATTERN = /(not supported|unsupported|not (?:available|implemented)|is not a function)\b/i;
+var UNSUPPORTED_FIELD_PATTERN = /(not supported|unsupported|unexpected|unknown|unrecognized|invalid|not (?:a )?valid)\b/i;
+var UNSUPPORTED_TARGET_FIELD_PATTERN = /(not supported|unsupported|unexpected|unknown|unrecognized)\b/i;
+var getNativeErrorMessage = (error) => {
+  return error instanceof Error ? error.message : String(error);
+};
+var isUnsupportedRemovalCapabilityError = (error) => {
+  const message = getNativeErrorMessage(error);
+  return /remove\s*css/i.test(message) && UNSUPPORTED_API_PATTERN.test(message);
+};
+var isUnsupportedOriginCapabilityError = (error) => {
+  const message = getNativeErrorMessage(error);
+  return /\b(?:(?:css|style)[\s_-]*)?origin\b/i.test(message) && UNSUPPORTED_FIELD_PATTERN.test(message);
+};
+var isUnsupportedDocumentTargetCapabilityError = (error) => {
+  const message = getNativeErrorMessage(error);
+  return /documentIds?/i.test(message) && UNSUPPORTED_TARGET_FIELD_PATTERN.test(message);
 };
 
 // src/InjectCssV2.ts
 var InjectCssV2_default = class extends AbstractInjectCss_default {
-  async insert(code) {
-    const { tabId, runAt } = this._options;
-    const details = {
-      code,
-      runAt,
-      cssOrigin: this.cssOrigin,
-      matchAboutBlank: this.matchAboutBlank
-    };
-    if (this.allFrames) {
-      await insertCssTab(tabId, { ...details, allFrames: true });
-    } else if (this.frameIds) {
-      await Promise.all(this.frameIds.map((frameId) => insertCssTab(tabId, { ...details, frameId })));
-    } else {
-      await insertCssTab(tabId, details);
+  constructor(options) {
+    super(options);
+    this.assertAdapterSupport(this._target, this._execution);
+  }
+  async insert(css) {
+    const code = this.validateCode(css);
+    const target = this.snapshotTarget();
+    const execution = this.snapshotExecution();
+    const timeoutMs = this.timeoutMs;
+    const details = this.createDetails("insert", execution, { code });
+    try {
+      await this.withTimeout(this.execute("insert", target, details), target, timeoutMs);
+    } catch (error) {
+      this.throwDeliveryError("insert", target, execution, error);
     }
   }
   async file(files) {
-    const { tabId, runAt } = this._options;
-    const fileList = typeof files === "string" ? [files] : files;
-    const injectTasks = [];
-    for (const file of fileList) {
-      const details = {
-        file,
-        runAt,
-        cssOrigin: this.cssOrigin,
-        matchAboutBlank: this.matchAboutBlank
-      };
-      if (this.allFrames) {
-        injectTasks.push(insertCssTab(tabId, { ...details, allFrames: true }));
-      } else if (this.frameIds) {
-        injectTasks.push(...this.frameIds.map((frameId) => insertCssTab(tabId, { ...details, frameId })));
-      } else {
-        injectTasks.push(insertCssTab(tabId, details));
+    const fileList = this.normalizeFiles(files);
+    await this.deliverFiles("insert", fileList);
+  }
+  async remove(css) {
+    const code = this.validateCode(css);
+    await this.removeSource({ code });
+  }
+  async removeFile(files) {
+    const fileList = this.normalizeFiles(files);
+    await this.deliverFiles("remove", fileList);
+  }
+  assertAdapterSupport(target, _execution) {
+    if ("documentIds" in target && target.documentIds !== void 0) {
+      throw new UnsupportedInjectCssTargetError('"documentIds" are not supported by the MV2 adapter.');
+    }
+  }
+  createDetails(operation, execution, source) {
+    return {
+      ...source,
+      ...operation === "insert" && execution.runAt !== void 0 ? { runAt: execution.runAt } : {},
+      ...execution.origin !== void 0 ? { cssOrigin: execution.origin.toLowerCase() } : {},
+      ...execution.matchAboutBlank !== void 0 ? { matchAboutBlank: execution.matchAboutBlank } : {}
+    };
+  }
+  async execute(operation, target, details) {
+    const deliver = operation === "insert" ? insertCssTab : removeCssTab;
+    if ("allFrames" in target && target.allFrames === true) {
+      await deliver(target.tabId, { ...details, allFrames: true });
+      return;
+    }
+    if ("frameIds" in target && target.frameIds !== void 0) {
+      await Promise.all(
+        target.frameIds.map(
+          (frameId) => this.executeFrame(operation, target.tabId, frameId, { ...details, frameId })
+        )
+      );
+      return;
+    }
+    await deliver(target.tabId, details);
+  }
+  async executeFrame(operation, tabId, frameId, details) {
+    try {
+      const deliver = operation === "insert" ? insertCssTab : removeCssTab;
+      await deliver(tabId, details);
+    } catch (error) {
+      throw new InjectCssFrameDeliveryError(tabId, frameId, error, operation);
+    }
+  }
+  async removeSource(source) {
+    const target = this.snapshotTarget();
+    const execution = this.snapshotExecution();
+    const timeoutMs = this.timeoutMs;
+    this.assertRemovalSupport();
+    try {
+      await this.withTimeout(
+        this.execute("remove", target, this.createDetails("remove", execution, source)),
+        target,
+        timeoutMs,
+        "remove"
+      );
+    } catch (error) {
+      this.throwDeliveryError("remove", target, execution, error);
+    }
+  }
+  async deliverFiles(operation, fileList) {
+    const target = this.snapshotTarget();
+    const execution = this.snapshotExecution();
+    const timeoutMs = this.timeoutMs;
+    let stopped = false;
+    if (operation === "remove") {
+      this.assertRemovalSupport();
+    }
+    const task = (async () => {
+      for (const file of fileList) {
+        if (stopped) return;
+        await this.execute(operation, target, this.createDetails(operation, execution, { file }));
       }
+    })();
+    try {
+      await this.withTimeout(task, target, timeoutMs, operation);
+    } catch (error) {
+      stopped = true;
+      this.throwDeliveryError(operation, target, execution, error);
     }
-    await Promise.all(injectTasks);
   }
-  get cssOrigin() {
-    const { origin } = this._options;
-    return origin && origin.toLowerCase();
+  assertRemovalSupport() {
+    if (typeof browser().tabs?.removeCSS !== "function") {
+      throw new UnsupportedInjectCssOperationError(
+        "remove",
+        'the current MV2 browser does not expose "tabs.removeCSS".'
+      );
+    }
+  }
+  throwDeliveryError(operation, target, execution, error) {
+    if (operation === "remove" && isUnsupportedRemovalCapabilityError(error)) {
+      throw new UnsupportedInjectCssOperationError(
+        "remove",
+        'the current MV2 browser does not support "tabs.removeCSS".',
+        error
+      );
+    }
+    if (execution.origin !== void 0 && isUnsupportedOriginCapabilityError(error)) {
+      throw new UnsupportedInjectCssOptionError('"origin" is not supported by the current browser.', error);
+    }
+    throw this.deliveryError(target, error, operation);
   }
 };
 
 // src/InjectCssV3.ts
-import { insertCss } from "@addon-core/browser";
+import { browser as browser2, insertCss, removeCss } from "@addon-core/browser";
 var InjectCssV3_default = class extends AbstractInjectCss_default {
+  constructor(options) {
+    super(options);
+    this.assertAdapterSupport(this._target, this._execution);
+  }
   async insert(css) {
-    await insertCss({
-      target: this.target,
-      origin: this._options.origin,
-      css
-    });
+    const code = this.validateCode(css);
+    const target = this.snapshotTarget();
+    const execution = this.snapshotExecution();
+    const timeoutMs = this.timeoutMs;
+    await this.execute(
+      "insert",
+      target,
+      execution,
+      {
+        target: this.toNativeTarget(target),
+        css: code,
+        ...execution.origin !== void 0 ? { origin: execution.origin } : {}
+      },
+      timeoutMs
+    );
   }
-  async file(fileList) {
-    await insertCss({
-      target: this.target,
-      origin: this._options.origin,
-      files: typeof fileList === "string" ? [fileList] : fileList
-    });
+  async file(files) {
+    const fileList = this.normalizeFiles(files);
+    const target = this.snapshotTarget();
+    const execution = this.snapshotExecution();
+    const timeoutMs = this.timeoutMs;
+    await this.execute(
+      "insert",
+      target,
+      execution,
+      {
+        target: this.toNativeTarget(target),
+        files: fileList,
+        ...execution.origin !== void 0 ? { origin: execution.origin } : {}
+      },
+      timeoutMs
+    );
+  }
+  async remove(css) {
+    const code = this.validateCode(css);
+    await this.removeInjection({ css: code });
+  }
+  async removeFile(files) {
+    const fileList = this.normalizeFiles(files);
+    await this.removeInjection({ files: fileList });
   }
-  get target() {
-    const target = { tabId: this._options.tabId };
-    if (this.frameIds && this.frameIds.length > 0) {
-      return { ...target, frameIds: this.frameIds };
+  assertAdapterSupport(_target, execution) {
+    if (execution.matchAboutBlank !== void 0) {
+      throw new UnsupportedInjectCssOptionError('"matchAboutBlank" is not supported by the MV3 adapter.');
     }
-    if (this.allFrames === true) {
-      return { ...target, allFrames: true };
+    if (execution.runAt !== void 0) {
+      throw new UnsupportedInjectCssOptionError('"runAt" is not supported by the MV3 adapter.');
     }
-    let isFirefox = false;
+  }
+  async execute(operation, target, execution, injection, timeoutMs) {
     try {
-      isFirefox = !!browser().runtime.getBrowserInfo;
-    } catch (_e) {
-    }
-    if (!isFirefox) {
-      const documentIds = this.documentIds;
-      if (documentIds && documentIds.length > 0) {
-        return { ...target, documentIds };
+      const task = operation === "insert" ? insertCss(injection) : removeCss(injection);
+      await this.withTimeout(task, target, timeoutMs, operation);
+    } catch (error) {
+      if ("documentIds" in target && target.documentIds !== void 0 && isUnsupportedDocumentTargetCapabilityError(error)) {
+        throw new UnsupportedInjectCssTargetError(
+          '"documentIds" are not supported by the current browser.',
+          error
+        );
+      }
+      if (operation === "remove" && isUnsupportedRemovalCapabilityError(error)) {
+        throw new UnsupportedInjectCssOperationError(
+          "remove",
+          'the current MV3 browser does not support "scripting.removeCSS".',
+          error
+        );
       }
+      if (execution.origin !== void 0 && isUnsupportedOriginCapabilityError(error)) {
+        throw new UnsupportedInjectCssOptionError('"origin" is not supported by the current browser.', error);
+      }
+      throw this.deliveryError(target, error, operation);
+    }
+  }
+  async removeInjection(source) {
+    const target = this.snapshotTarget();
+    const execution = this.snapshotExecution();
+    const timeoutMs = this.timeoutMs;
+    this.assertRemovalSupport();
+    await this.execute(
+      "remove",
+      target,
+      execution,
+      {
+        target: this.toNativeTarget(target),
+        ...source,
+        ...execution.origin !== void 0 ? { origin: execution.origin } : {}
+      },
+      timeoutMs
+    );
+  }
+  assertRemovalSupport() {
+    if (typeof browser2().scripting?.removeCSS !== "function") {
+      throw new UnsupportedInjectCssOperationError(
+        "remove",
+        'the current MV3 browser does not expose "scripting.removeCSS".'
+      );
     }
-    return target;
   }
-  get documentIds() {
-    const { documentId } = this._options;
-    return typeof documentId === "string" ? [documentId] : documentId;
+  toNativeTarget(target) {
+    if ("frameIds" in target && target.frameIds !== void 0) {
+      return { tabId: target.tabId, frameIds: [...target.frameIds] };
+    }
+    if ("documentIds" in target && target.documentIds !== void 0) {
+      return { tabId: target.tabId, documentIds: [...target.documentIds] };
+    }
+    if ("allFrames" in target && target.allFrames === true) {
+      return { tabId: target.tabId, allFrames: true };
+    }
+    return { tabId: target.tabId };
   }
 };
 
 // src/index.ts
-var index_default = (options) => {
+var injectCss = (options) => {
   return isManifestVersion3() ? new InjectCssV3_default(options) : new InjectCssV2_default(options);
 };
+var index_default = injectCss;
 export {
-  index_default as default
+  InjectCssBaseError,
+  InjectCssDeliveryError,
+  InjectCssFrameDeliveryError,
+  InjectCssTimeoutError,
+  InvalidInjectCssCodeError,
+  InvalidInjectCssFilesError,
+  InvalidInjectCssOptionsError,
+  InvalidInjectCssTargetError,
+  UnsupportedInjectCssOperationError,
+  UnsupportedInjectCssOptionError,
+  UnsupportedInjectCssTargetError,
+  index_default as default,
+  injectCss
 };
 //# sourceMappingURL=index.js.map