Edit C:\Program Files\Mozilla Firefox\browser\features\webcompat-reporter@mozilla.org.xpi

?��PK
�������!<??���������������??��experimentalAPIs/helpMenu.jsPK
�������!<?`?��D��$�����������?	��experimentalAPIs/aboutConfigPrefs.jsPK
�������!<??3���3��������������??��chrome.manifestPK
�������!<?n?��?��
�����������??��background.jsPK
�������!<tS(LZ���Z���'�����������??%��zh-CN/locale/zh-CN/webcompat.propertiesPK
�������!<lYi?-��-��&�����������?T&��experimentalAPIs/aboutConfigPrefs.jsonPK
�������!<gv??��?��*�����������??)��experimentalAPIs/actors/tabExtrasActor.jsmPK
�������!<???��?�������������??8��experimentalAPIs/browserInfo.jsPK
�������!<?*?`��`��!�����������??��experimentalAPIs/browserInfo.jsonPK
�������!<:??��?�������������??��experimentalAPIs/helpMenu.jsonPK
�������!<b't��t�������������??��experimentalAPIs/l10n.jsPK
�������!<o9??��?�������������?J^��experimentalAPIs/l10n.jsonPK
�������!<???
��?
�������������?z`��experimentalAPIs/tabExtras.jsPK
�������!<???��?�������������??��experimentalAPIs/tabExtras.jsonPK
�������!<?;s?��?�������������??��icons/lightbulb.svgPK
�������!<?5G����
�����������??��manifest.jsonPK������?�������PK
�������!<??�������experimentalAPIs/helpMenu.js/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

"use strict";

/* global ExtensionAPI, ExtensionCommon, Services */

const TOPIC = "report-site-issue";

this.helpMenu = class extends ExtensionAPI {
  getAPI(context) {
    const { tabManager } = context.extension;
    let EventManager = ExtensionCommon.EventManager;

return {
      helpMenu: {
        onHelpMenuCommand: new EventManager({
          context,
          name: "helpMenu",
          register: fire => {
            let observer = (subject, topic, data) => {
              let nativeTab = subject.wrappedJSObject;
              let tab = tabManager.convert(nativeTab);
              fire.async(tab);
            };

Services.obs.addObserver(observer, TOPIC);

return () => {
              Services.obs.removeObserver(observer, TOPIC);
            };
          },
        }).api(),
      },
    };
  }
};
PK
�������!<?`?��D��$���experimentalAPIs/aboutConfigPrefs.js/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

"use strict";

/* global ExtensionAPI, ExtensionCommon, Services */

this.aboutConfigPrefs = class extends ExtensionAPI {
  getAPI(context) {
    const EventManager = ExtensionCommon.EventManager;
    const extensionIDBase = context.extension.id.split("@")[0];
    const endpointPrefName = `extensions.${extensionIDBase}.newIssueEndpoint`;

return {
      aboutConfigPrefs: {
        onEndpointPrefChange: new EventManager({
          context,
          name: "aboutConfigPrefs.onEndpointPrefChange",
          register: fire => {
            const callback = () => {
              fire.async().catch(() => {}); // ignore Message Manager disconnects
            };
            Services.prefs.addObserver(endpointPrefName, callback);
            return () => {
              Services.prefs.removeObserver(endpointPrefName, callback);
            };
          },
        }).api(),
        async getEndpointPref() {
          return Services.prefs.getStringPref(endpointPrefName, undefined);
        },
        async setEndpointPref(value) {
          Services.prefs.setStringPref(endpointPrefName, value);
        },
      },
    };
  }
};
PK
�������!<??3���3������chrome.manifestlocale report-site-issue zh-CN zh-CN/locale/zh-CN/
PK
�������!<?n?��?��
���background.js/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

"use strict";

/* globals browser */

const Config = {
  newIssueEndpoint: "https://webcompat.com/issues/new",
  newIssueEndpointPref: "newIssueEndpoint",
  screenshotFormat: {
    format: "jpeg",
    quality: 75,
  },
};

const FRAMEWORK_KEYS = ["hasFastClick", "hasMobify", "hasMarfeel"];

browser.helpMenu.onHelpMenuCommand.addListener(tab => {
  return getWebCompatInfoForTab(tab).then(
    info => {
      return openWebCompatTab(info);
    },
    err => {
      console.error("WebCompat Reporter: unexpected error", err);
    }
  );
});

browser.aboutConfigPrefs.onEndpointPrefChange.addListener(checkEndpointPref);

checkEndpointPref();

async function checkEndpointPref() {
  const value = await browser.aboutConfigPrefs.getEndpointPref();
  if (value === undefined) {
    browser.aboutConfigPrefs.setEndpointPref(Config.newIssueEndpoint);
  } else {
    Config.newIssueEndpoint = value;
  }
}

function hasFastClickPageScript() {
  const win = window.wrappedJSObject;

if (win.FastClick) {
    return true;
  }

for (const property in win) {
    try {
      const proto = win[property].prototype;
      if (proto && proto.needsClick) {
        return true;
      }
    } catch (_) {}
  }

return false;
}

function hasMobifyPageScript() {
  const win = window.wrappedJSObject;
  return !!(win.Mobify && win.Mobify.Tag);
}

function hasMarfeelPageScript() {
  const win = window.wrappedJSObject;
  return !!win.marfeel;
}

const result = {
          hasFastClick: hasFastClickPageScript(),
          hasMobify: hasMobifyPageScript(),
          hasMarfeel: hasMarfeelPageScript(),
        }

return result;
      })();
    `,
    })
    .then(([results]) => results)
    .catch(() => false);
}

const consoleLog = frameInfo.log;
      delete frameInfo.log;

additionalData.isPB = frameInfo.isPB;
      additionalData.prefs = { ...additionalData.prefs, ...graphicsPrefs };
      additionalData.hasMixedActiveContentBlocked =
        frameInfo.hasMixedActiveContentBlocked;
      additionalData.hasMixedDisplayContentBlocked =
        frameInfo.hasMixedDisplayContentBlocked;
      additionalData.hasTrackingContentBlocked =
        !!frameInfo.hasTrackingContentBlocked;

return Object.assign(frameInfo, {
        tabId: id,
        blockList,
        details: Object.assign(graphicsPrefs, {
          buildID,
          channel,
          consoleLog,
          frameworks,
          additionalData,
          hasTouchScreen,
          "mixed active content blocked":
            frameInfo.hasMixedActiveContentBlocked,
          "mixed passive content blocked":
            frameInfo.hasMixedDisplayContentBlocked,
          "tracking content blocked": frameInfo.hasTrackingContentBlocked
            ? `true (${blockList})`
            : "false",
        }),
        screenshot,
        url,
      });
    }
  );
}

function stripNonASCIIChars(str) {
  // eslint-disable-next-line no-control-regex
  return str.replace(/[^\x00-\x7F]/g, "");
}

async function openWebCompatTab(compatInfo) {
  const url = new URL(Config.newIssueEndpoint);
  const { details } = compatInfo;
  const params = {
    url: `${compatInfo.url}`,
    utm_source: "desktop-reporter",
    utm_campaign: "report-site-issue-button",
    src: "desktop-reporter",
    details,
    extra_labels: [],
  };

for (let framework of FRAMEWORK_KEYS) {
    if (details.frameworks[framework]) {
      params.details[framework] = true;
      params.extra_labels.push(
        framework.replace(/^has/, "type-").toLowerCase()
      );
    }
  }
  delete details.frameworks;

if (details["gfx.webrender.all"] || details["gfx.webrender.enabled"]) {
    params.extra_labels.push("type-webrender-enabled");
  }
  if (compatInfo.hasTrackingContentBlocked) {
    params.extra_labels.push(
      `type-tracking-protection-${compatInfo.blockList}`
    );
  }

"use strict";

var EXPORTED_SYMBOLS = ["ReportSiteIssueHelperChild"];

const PREVIEW_MAX_ITEMS = 10;
const LOG_LEVELS = ["debug", "info", "warn", "error"];

function getPreview(value) {
  switch (typeof value) {
    case "symbol":
      return value.toString();

case "function":
      return "function ()";

case "object":
      if (value === null) {
        return null;
      }

if (Array.isArray(value)) {
        return `(${value.length})[...]`;
      }

return "{...}";

case "undefined":
      return "undefined";

default:
      try {
        structuredClone(value);
      } catch (_) {
        return `${value}` || "?";
      }

return value;
  }
}

function getArrayPreview(arr) {
  const preview = [];
  let count = 0;
  for (const value of arr) {
    if (++count > PREVIEW_MAX_ITEMS) {
      break;
    }
    preview.push(getPreview(value));
  }

return preview;
}

return preview;
}

function getArgs(value) {
  if (typeof value === "object" && value !== null) {
    if (Array.isArray(value)) {
      return getArrayPreview(value);
    }

return getObjectPreview(value);
  }

return getPreview(value);
}

class ReportSiteIssueHelperChild extends JSWindowActorChild {
  _getConsoleMessages(windowId) {
    const ConsoleAPIStorage = Cc[
      "@mozilla.org/consoleAPI-storage;1"
    ].getService(Ci.nsIConsoleAPIStorage);
    let messages = ConsoleAPIStorage.getEvents(windowId);
    return messages.map(evt => {
      const { columnNumber, filename, level, lineNumber, timeStamp } = evt;
      const args = evt.arguments.map(getArgs);

const message = {
        level,
        log: args,
        uri: filename,
        pos: `${lineNumber}:${columnNumber}`,
      };

return { timeStamp, message };
    });
  }

_getScriptErrors(windowId, includePrivate) {
    const messages = Services.console.getMessageArray();
    return messages
      .filter(message => {
        if (message instanceof Ci.nsIScriptError) {
          if (!includePrivate && message.isFromPrivateWindow) {
            return false;
          }

if (windowId && windowId !== message.innerWindowID) {
            return false;
          }

return true;
        }

// If this is not an nsIScriptError and we need to do window-based
        // filtering we skip this message.
        return false;
      })
      .map(error => {
        const {
          timeStamp,
          errorMessage,
          sourceName,
          lineNumber,
          columnNumber,
          logLevel,
        } = error;
        const message = {
          level: LOG_LEVELS[logLevel],
          log: [errorMessage],
          uri: sourceName,
          pos: `${lineNumber}:${columnNumber}`,
        };
        return { timeStamp, message };
      });
  }

_getLoggedMessages(includePrivate = false) {
    const windowId = this.contentWindow.windowGlobalChild.innerWindowId;
    return this._getConsoleMessages(windowId).concat(
      this._getScriptErrors(windowId, includePrivate)
    );
  }

receiveMessage(msg) {
    switch (msg.name) {
      case "GetLog":
        return this._getLoggedMessages();
      case "GetBlockingStatus":
        const { docShell } = this;
        return {
          hasTrackingContentBlocked: docShell.hasTrackingContentBlocked,
        };
    }
    return null;
  }
}
PK
�������!<???��?�����experimentalAPIs/browserInfo.js/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

"use strict";

/* global AppConstants, ExtensionAPI, Services */

function isTelemetryEnabled() {
  return Services.prefs.getBoolPref(
    "datareporting.healthreport.uploadEnabled",
    false
  );
}

function getSysinfoProperty(propertyName, defaultValue) {
  try {
    return Services.sysinfo.getProperty(propertyName);
  } catch (e) {}

return defaultValue;
}

function getUserAgent() {
  const { userAgent } = Cc[
    "@mozilla.org/network/protocol;1?name=http"
  ].getService(Ci.nsIHttpProtocolHandler);
  return userAgent;
}

function getGfxData() {
  const gfxInfo = Cc["@mozilla.org/gfx/info;1"].getService(Ci.nsIGfxInfo);
  const data = {};

try {
    const {
      compositor,
      hwCompositing,
      openglCompositing,
      wrCompositor,
      wrSoftware,
    } = gfxInfo.getFeatures();

data.features = {
      compositor,
      hwCompositing,
      openglCompositing,
      wrCompositor,
      wrSoftware,
    };
  } catch (e) {}

try {
    if (AppConstants.platform !== "android") {
      data.monitors = gfxInfo.getMonitors();
    }
  } catch (e) {}

return data;
}

function limitStringToLength(str, maxLength) {
  if (typeof str !== "string") {
    return null;
  }
  return str.substring(0, maxLength);
}

function getSecurityAppData() {
  const maxStringLength = 256;

const keys = [
    ["registeredAntiVirus", "antivirus"],
    ["registeredAntiSpyware", "antispyware"],
    ["registeredFirewall", "firewall"],
  ];

let result = {};

for (let [inKey, outKey] of keys) {
    let prop = getSysinfoProperty(inKey, null);
    if (prop) {
      prop = limitStringToLength(prop, maxStringLength).split(";");
    }

result[outKey] = prop;
  }

return result;
}

return prefs;
}

function getMemoryMB() {
  let memoryMB = getSysinfoProperty("memsize", null);
  if (memoryMB) {
    memoryMB = Math.round(memoryMB / 1024 / 1024);
  }

return memoryMB;
}

this.browserInfo = class extends ExtensionAPI {
  getAPI(context) {
    return {
      browserInfo: {
        async getGraphicsPrefs() {
          const prefs = {};
          for (const [name, dflt] of Object.entries({
            "layers.acceleration.force-enabled": false,
            "gfx.webrender.all": false,
            "gfx.webrender.blob-images": true,
            "gfx.webrender.enabled": false,
            "image.mem.shared": true,
          })) {
            prefs[name] = Services.prefs.getBoolPref(name, dflt);
          }
          return prefs;
        },
        async getAppVersion() {
          return AppConstants.MOZ_APP_VERSION;
        },
        async getBlockList() {
          const trackingTable = Services.prefs.getCharPref(
            "urlclassifier.trackingTable"
          );
          // If content-track-digest256 is in the tracking table,
          // the user has enabled the strict list.
          return trackingTable.includes("content") ? "strict" : "basic";
        },
        async getBuildID() {
          return Services.appinfo.appBuildID;
        },
        async getUpdateChannel() {
          return AppConstants.MOZ_UPDATE_CHANNEL;
        },
        async getPlatform() {
          return AppConstants.platform;
        },
        async hasTouchScreen() {
          const gfxInfo = Cc["@mozilla.org/gfx/info;1"].getService(
            Ci.nsIGfxInfo
          );
          return gfxInfo.getInfo().ApzTouchInput == 1;
        },
        async getAdditionalData() {
          const blockList = await this.getBlockList();
          const userAgent = getUserAgent();
          const gfxData = getGfxData();
          const prefs = getAdditionalPrefs();
          const memoryMb = getMemoryMB();

const data = {
            applicationName: Services.appinfo.name,
            version: Services.appinfo.version,
            updateChannel: AppConstants.MOZ_UPDATE_CHANNEL,
            osArchitecture: getSysinfoProperty("arch", null),
            osName: getSysinfoProperty("name", null),
            osVersion: getSysinfoProperty("version", null),
            fissionEnabled: Services.appinfo.fissionAutostart,
            userAgent,
            gfxData,
            blockList,
            prefs,
            memoryMb,
          };

if (AppConstants.isPlatformAndVersionAtLeast("win", "6.2")) {
            data.sec = getSecurityAppData();
          }

if (AppConstants.platform === "android") {
            data.device = getSysinfoProperty("device", null);
            data.isTablet = getSysinfoProperty("tablet", false);
          }

return data;
        },
      },
    };
  }
};
PK
�������!<?*?`��`��!���experimentalAPIs/browserInfo.json[
  {
    "namespace": "browserInfo",
    "description": "experimental API extensions to get browser info not exposed via web APIs",
    "functions": [
      {
        "name": "getAppVersion",
        "type": "function",
        "description": "Gets the app version",
        "parameters": [],
        "async": true
      },
      {
        "name": "getBlockList",
        "type": "function",
        "description": "Gets the current blocklist",
        "parameters": [],
        "async": true
      },
      {
        "name": "getBuildID",
        "type": "function",
        "description": "Gets the build ID",
        "parameters": [],
        "async": true
      },
      {
        "name": "getGraphicsPrefs",
        "type": "function",
        "description": "Gets interesting about:config prefs for graphics",
        "parameters": [],
        "async": true
      },
      {
        "name": "getPlatform",
        "type": "function",
        "description": "Gets the platform",
        "parameters": [],
        "async": true
      },
      {
        "name": "getUpdateChannel",
        "type": "function",
        "description": "Gets the update channel",
        "parameters": [],
        "async": true
      },
      {
        "name": "hasTouchScreen",
        "type": "function",
        "description": "Gets whether a touchscreen is present",
        "parameters": [],
        "async": true
      },
      {
        "name": "getAdditionalData",
        "type": "function",
        "description": "Gets additional info for the new reporter experiment",
        "parameters": [],
        "async": true
      }
    ]
  }
]
PK
�������!<:??��?�����experimentalAPIs/helpMenu.json[
  {
    "namespace": "helpMenu",
    "events": [
      {
        "name": "onHelpMenuCommand",
        "type": "function",
        "async": "callback",
        "description": "Fired when the command event for the Report Site Issue menuitem in Help is fired.",
        "parameters": [
          {
            "type": "function",
            "name": "callback",
            "optional": true,
            "parameters": [
              {
                "name": "tab",
                "$ref": "tabs.Tab",
                "optional": true,
                "description": "Details about the selected tab in the window where the menuitem command fired."
              }
            ]
          }
        ]
      }
    ]
  }
]
PK
�������!<b't��t�����experimentalAPIs/l10n.js/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

"use strict";

/* global ExtensionAPI, Services, XPCOMUtils */

XPCOMUtils.defineLazyGetter(this, "l10nStrings", function () {
  return Services.strings.createBundle(
    "chrome://report-site-issue/locale/webcompat.properties"
  );
});

let l10nManifest;

this.l10n = class extends ExtensionAPI {
  onShutdown(isAppShutdown) {
    if (!isAppShutdown && l10nManifest) {
      Components.manager.removeBootstrappedManifestLocation(l10nManifest);
    }
  }
  getAPI(context) {
    // Until we move to Fluent (bug 1446164), we're stuck with
    // chrome.manifest for handling localization since its what the
    // build system can handle for localized repacks.
    if (context.extension.rootURI instanceof Ci.nsIJARURI) {
      l10nManifest = context.extension.rootURI.JARFile.QueryInterface(
        Ci.nsIFileURL
      ).file;
    } else if (context.extension.rootURI instanceof Ci.nsIFileURL) {
      l10nManifest = context.extension.rootURI.file;
    }

if (l10nManifest) {
      Components.manager.addBootstrappedManifestLocation(l10nManifest);
    } else {
      console.error(
        "Cannot find webcompat reporter chrome.manifest for registering translated strings"
      );
    }

return {
      l10n: {
        getMessage(name) {
          try {
            return Promise.resolve(l10nStrings.GetStringFromName(name));
          } catch (e) {
            return Promise.reject(e);
          }
        },
      },
    };
  }
};
PK
�������!<o9??��?�����experimentalAPIs/l10n.json[
  {
    "namespace": "l10n",
    "description": "A stop-gap L10N API only meant to be used until a Fluent-based API is added in bug 1425104",
    "functions": [
      {
        "name": "getMessage",
        "type": "function",
        "description": "Gets the message with the given name",
        "parameters": [
          {
            "name": "name",
            "type": "string",
            "description": "The name of the message"
          }
        ],
        "async": true
      }
    ]
  }
]
PK
�������!<???
��?
�����experimentalAPIs/tabExtras.js/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

"use strict";

/* global ExtensionAPI, XPCOMUtils, Services */

XPCOMUtils.defineLazyServiceGetter(
  this,
  "resProto",
  "@mozilla.org/network/protocol;1?name=resource",
  "nsISubstitutingProtocolHandler"
);

this.tabExtras = class extends ExtensionAPI {
  constructor(extension) {
    super(extension);
    this._registerActorModule();
  }

getAPI(context) {
    const { tabManager } = context.extension;
    return {
      tabExtras: {
        async getWebcompatInfo(tabId) {
          const {
            browser: { browsingContext },
            incognito,
          } = tabManager.get(tabId);
          const actors = gatherActors("ReportSiteIssueHelper", browsingContext);
          const promises = actors.map(actor => actor.sendQuery("GetLog"));
          const logs = await Promise.all(promises);
          const info = await actors[0].sendQuery("GetBlockingStatus");
          info.hasMixedActiveContentBlocked = !!(
            browsingContext.secureBrowserUI.state &
            Ci.nsIWebProgressListener.STATE_BLOCKED_MIXED_ACTIVE_CONTENT
          );
          info.hasMixedDisplayContentBlocked = !!(
            browsingContext.secureBrowserUI.state &
            Ci.nsIWebProgressListener.STATE_BLOCKED_MIXED_DISPLAY_CONTENT
          );
          info.isPB = incognito;
          info.log = logs
            .flat()
            .sort((a, b) => a.timeStamp - b.timeStamp)
            .map(m => m.message);
          return info;
        },
      },
    };
  }

onShutdown(isAppShutdown) {
    this._unregisterActorModule();
  }

_registerActorModule() {
    resProto.setSubstitution(
      "report-site-issue",
      Services.io.newURI(
        "experimentalAPIs/actors/",
        null,
        this.extension.rootURI
      )
    );
    ChromeUtils.registerWindowActor("ReportSiteIssueHelper", {
      child: {
        moduleURI: "resource://report-site-issue/tabExtrasActor.jsm",
      },
      allFrames: true,
    });
  }

_unregisterActorModule() {
    ChromeUtils.unregisterWindowActor("ReportSiteIssueHelper");
    resProto.setSubstitution("report-site-issue", null);
  }
};

function getActorForBrowsingContext(name, browsingContext) {
  const windowGlobal = browsingContext.currentWindowGlobal;
  return windowGlobal ? windowGlobal.getActor(name) : null;
}

function gatherActors(name, browsingContext) {
  const list = [];

const actor = getActorForBrowsingContext(name, browsingContext);
  if (actor) {
    list.push(actor);
  }

for (const child of browsingContext.children) {
    list.push(...gatherActors(name, child));
  }

return list;
}
PK
�������!<???��?�����experimentalAPIs/tabExtras.json[
  {
    "namespace": "tabExtras",
    "description": "experimental tab API extensions",
    "functions": [
      {
        "name": "getWebcompatInfo",
        "type": "function",
        "description": "Gets the content blocking status and script log for a given tab",
        "parameters": [
          {
            "type": "integer",
            "name": "tabId",
            "minimum": 0
          }
        ],
        "async": true
      }
    ]
  }
]
PK
�������!<?;s?��?�����icons/lightbulb.svg
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16" width="16" height="16" fill="context-fill" fill-opacity="context-fill-opacity">
  <path d="M5.625 16a.625.625 0 0 1 0-1.25l4.75 0a.625.625 0 0 1 0 1.25l-4.75 0z"/>
  <path d="m9.534 13-3.068 0a1.621 1.621 0 0 1-1.601-1.348l-.34-1.956C2.966 8.493 2.226 6.515 2.592 4.488 2.983 2.322 4.685.566 6.828.119c1.66-.343 3.352.062 4.642 1.111a5.482 5.482 0 0 1-.041 8.549l-.294 1.873A1.622 1.622 0 0 1 9.534 13zm.369-1.561.341-1.958c.046-.264.188-.504.402-.676 1.019-.818 1.603-2.022 1.603-3.306s-.572-2.487-1.569-3.298a4.247 4.247 0 0 0-2.692-.95c-.3 0-.604.03-.907.094-1.648.342-2.958 1.695-3.259 3.366a4.214 4.214 0 0 0 1.53 4.093c.215.172.358.413.404.678l.34 1.956.37.312 3.067 0 .37-.311z"/>
</svg>
PK
�������!<?5G����
���manifest.json{
  "manifest_version": 2,
  "name": "WebCompat Reporter",
  "description": "Report site compatibility issues on webcompat.com",
  "author": "Thomas Wisniewski <twisniewski@mozilla.com>",
  "version": "1.5.1",
  "homepage_url": "https://github.com/mozilla/webcompat-reporter",
  "browser_specific_settings": {
    "gecko": {
      "id": "webcompat-reporter@mozilla.org"
    }
  },
  "experiment_apis": {
    "aboutConfigPrefs": {
      "schema": "experimentalAPIs/aboutConfigPrefs.json",
      "parent": {
        "scopes": ["addon_parent"],
        "script": "experimentalAPIs/aboutConfigPrefs.js",
        "paths": [["aboutConfigPrefs"]]
      }
    },
    "browserInfo": {
      "schema": "experimentalAPIs/browserInfo.json",
      "parent": {
        "scopes": ["addon_parent"],
        "script": "experimentalAPIs/browserInfo.js",
        "paths": [["browserInfo"]]
      }
    },
    "helpMenu": {
      "schema": "experimentalAPIs/helpMenu.json",
      "parent": {
        "scopes": ["addon_parent"],
        "script": "experimentalAPIs/helpMenu.js",
        "paths": [["helpMenu"]]
      }
    },
    "l10n": {
      "schema": "experimentalAPIs/l10n.json",
      "parent": {
        "scopes": ["addon_parent"],
        "script": "experimentalAPIs/l10n.js",
        "paths": [["l10n"]]
      }
    },
    "tabExtras": {
      "schema": "experimentalAPIs/tabExtras.json",
      "parent": {
        "scopes": ["addon_parent"],
        "script": "experimentalAPIs/tabExtras.js",
        "paths": [["tabExtras"]]
      }
    }
  },
  "icons": {
    "16": "icons/lightbulb.svg",
    "32": "icons/lightbulb.svg",
    "48": "icons/lightbulb.svg",
    "96": "icons/lightbulb.svg",
    "128": "icons/lightbulb.svg"
  },
  "permissions": ["tabs", "<all_urls>"],
  "background": {
    "scripts": ["background.js"]
  }
}
PK������?�������

Ms-Dos/Windows Unix Write backup

jsp File Browser version 1.2 by www.vonloesch.de