@atlaspack/transformer-webextension 2.14.0 → 2.14.1-canary.6

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright (c) 2024 Atlassian US., Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/lib/WebExtensionTransformer.js

@@ -0,0 +1,371 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+function _plugin() {
+  const data = require("@atlaspack/plugin");
+  _plugin = function () {
+    return data;
+  };
+  return data;
+}
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _jsonSourcemap() {
+  const data = require("@mischnic/json-sourcemap");
+  _jsonSourcemap = function () {
+    return data;
+  };
+  return data;
+}
+function _contentSecurityPolicyParser() {
+  const data = _interopRequireDefault(require("content-security-policy-parser"));
+  _contentSecurityPolicyParser = function () {
+    return data;
+  };
+  return data;
+}
+function _utils() {
+  const data = require("@atlaspack/utils");
+  _utils = function () {
+    return data;
+  };
+  return data;
+}
+function _diagnostic() {
+  const data = _interopRequireWildcard(require("@atlaspack/diagnostic"));
+  _diagnostic = function () {
+    return data;
+  };
+  return data;
+}
+var _schema = require("./schema");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const DEP_LOCS = [['icons'], ['browser_action', 'default_icon'], ['browser_action', 'default_popup'], ['page_action', 'default_icon'], ['page_action', 'default_popup'], ['action', 'default_icon'], ['action', 'default_popup'], ['background', 'scripts'], ['chrome_url_overrides'], ['devtools_page'], ['options_ui', 'page'], ['sandbox', 'pages'], ['side_panel', 'default_path'], ['sidebar_action', 'default_icon'], ['sidebar_action', 'default_panel'], ['storage', 'managed_schema'], ['theme', 'images', 'theme_frame'], ['theme', 'images', 'additional_backgrounds'], ['user_scripts', 'api_script']];
+async function collectDependencies(asset, program, ptrs, hmrOptions) {
+  var _program$browserActio, _program$background, _program$background2;
+  const hot = Boolean(hmrOptions);
+  const fs = asset.fs;
+  const filePath = asset.filePath;
+  const assetDir = _path().default.dirname(filePath);
+  const isMV2 = program.manifest_version == 2;
+  delete program.$schema;
+  if (program.default_locale) {
+    const locales = _path().default.join(assetDir, '_locales');
+    let err = !(await fs.exists(locales)) ? 'key' : !(await fs.exists(_path().default.join(locales, program.default_locale, 'messages.json'))) ? 'value' : null;
+    if (err) {
+      throw new (_diagnostic().default)({
+        diagnostic: [{
+          message: 'Invalid Web Extension manifest',
+          origin: '@atlaspack/transformer-webextension',
+          codeFrames: [{
+            filePath,
+            codeHighlights: [{
+              ...(0, _diagnostic().getJSONHighlightLocation)(ptrs['/default_locale'], err),
+              message: (0, _diagnostic().md)`Localization ${err == 'value' ? 'file for ' + program.default_locale : 'directory'} does not exist: ${_path().default.relative(assetDir, _path().default.join(locales, program.default_locale))}`
+            }]
+          }]
+        }]
+      });
+    }
+    for (const locale of await fs.readdir(locales)) {
+      if (await fs.exists(_path().default.join(locales, locale, 'messages.json'))) {
+        asset.addURLDependency(`_locales/${locale}/messages.json`, {
+          needsStableName: true,
+          pipeline: 'raw'
+        });
+      }
+    }
+  }
+  if (program.content_scripts) {
+    for (let i = 0; i < program.content_scripts.length; ++i) {
+      const sc = program.content_scripts[i];
+      for (const k of ['css', 'js']) {
+        const assets = sc[k] || [];
+        for (let j = 0; j < assets.length; ++j) {
+          assets[j] = asset.addURLDependency(assets[j], {
+            bundleBehavior: 'isolated',
+            loc: {
+              filePath,
+              ...(0, _diagnostic().getJSONSourceLocation)(ptrs[`/content_scripts/${i}/${k}/${j}`], 'value')
+            }
+          });
+        }
+      }
+      if (hot && sc.js && sc.js.length) {
+        sc.js.push(asset.addURLDependency('./runtime/autoreload.js', {
+          resolveFrom: __filename
+        }));
+      }
+    }
+  }
+  if (program.dictionaries) {
+    for (const dict in program.dictionaries) {
+      const dictFile = program.dictionaries[dict];
+      if (_path().default.extname(dictFile) != '.dic') {
+        throw new (_diagnostic().default)({
+          diagnostic: [{
+            message: 'Invalid Web Extension manifest',
+            origin: '@atlaspack/transformer-webextension',
+            codeFrames: [{
+              filePath,
+              codeHighlights: [{
+                ...(0, _diagnostic().getJSONHighlightLocation)(ptrs[`/dictionaries/${dict}`], 'value'),
+                message: 'Dictionaries must be .dic files'
+              }]
+            }]
+          }]
+        });
+      }
+      const loc = {
+        filePath,
+        ...(0, _diagnostic().getJSONSourceLocation)(ptrs[`/dictionaries/${dict}`], 'value')
+      };
+      program.dictionaries[dict] = asset.addURLDependency(dictFile, {
+        needsStableName: true,
+        loc
+      });
+      asset.addURLDependency(dictFile.slice(0, -4) + '.aff', {
+        needsStableName: true,
+        loc
+      });
+    }
+  }
+  const browserActionName = isMV2 ? 'browser_action' : 'action';
+  if ((_program$browserActio = program[browserActionName]) !== null && _program$browserActio !== void 0 && _program$browserActio.theme_icons) {
+    for (let i = 0; i < program[browserActionName].theme_icons.length; ++i) {
+      const themeIcon = program[browserActionName].theme_icons[i];
+      for (const k of ['light', 'dark']) {
+        const loc = (0, _diagnostic().getJSONSourceLocation)(ptrs[`/${browserActionName}/theme_icons/${i}/${k}`], 'value');
+        themeIcon[k] = asset.addURLDependency(themeIcon[k], {
+          loc: {
+            ...loc,
+            filePath
+          }
+        });
+      }
+    }
+  }
+  if (program.web_accessible_resources) {
+    let war = [];
+    for (let i = 0; i < program.web_accessible_resources.length; ++i) {
+      // TODO: this doesn't support Atlaspack resolution
+      const currentEntry = program.web_accessible_resources[i];
+      const files = isMV2 ? [currentEntry] : currentEntry.resources;
+      let currentFiles = [];
+      for (let j = 0; j < files.length; ++j) {
+        const globFiles = (await (0, _utils().glob)(_path().default.join(assetDir, files[j]), fs, {})).map(fp => asset.addURLDependency(_path().default.relative(assetDir, fp), {
+          bundleBehavior: 'isolated',
+          needsStableName: true,
+          loc: {
+            filePath,
+            ...(0, _diagnostic().getJSONSourceLocation)(ptrs[`/web_accessible_resources/${i}${isMV2 ? '' : `/resources/${j}`}`])
+          }
+        }));
+        currentFiles = currentFiles.concat(globFiles);
+      }
+      if (isMV2) {
+        war = war.concat(currentFiles);
+      } else {
+        currentEntry.resources = currentFiles;
+        war.push(currentEntry);
+      }
+    }
+    program.web_accessible_resources = war;
+  }
+  if (program.declarative_net_request) {
+    var _program$declarative_;
+    const rrs = ((_program$declarative_ = program.declarative_net_request) === null || _program$declarative_ === void 0 ? void 0 : _program$declarative_.rule_resources) ?? [];
+    rrs.forEach((resources, i) => {
+      resources.path = asset.addURLDependency(resources.path, {
+        pipeline: 'raw',
+        loc: {
+          filePath,
+          ...(0, _diagnostic().getJSONSourceLocation)(ptrs[`/declarative_net_request/rule_resources/${i}/path`], 'value')
+        }
+      });
+    });
+  }
+  for (const loc of DEP_LOCS) {
+    const location = '/' + loc.join('/');
+    if (!ptrs[location]) continue;
+    let parent = program;
+    for (let i = 0; i < loc.length - 1; ++i) {
+      parent = parent[loc[i]];
+    }
+    const lastLoc = loc[loc.length - 1];
+    const obj = parent[lastLoc];
+    if (typeof obj == 'string') parent[lastLoc] = asset.addURLDependency(obj, {
+      bundleBehavior: 'isolated',
+      loc: {
+        filePath,
+        ...(0, _diagnostic().getJSONSourceLocation)(ptrs[location], 'value')
+      },
+      pipeline: _path().default.extname(obj) == '.json' ? 'raw' : undefined
+    });else {
+      for (const k of Object.keys(obj)) {
+        obj[k] = asset.addURLDependency(obj[k], {
+          bundleBehavior: 'isolated',
+          loc: {
+            filePath,
+            ...(0, _diagnostic().getJSONSourceLocation)(ptrs[location + '/' + k], 'value')
+          },
+          pipeline: _path().default.extname(obj[k]) == '.json' ? 'raw' : undefined
+        });
+      }
+    }
+  }
+  if ((_program$background = program.background) !== null && _program$background !== void 0 && _program$background.page) {
+    program.background.page = asset.addURLDependency(program.background.page, {
+      bundleBehavior: 'isolated',
+      loc: {
+        filePath,
+        ...(0, _diagnostic().getJSONSourceLocation)(ptrs['/background/page'], 'value')
+      }
+    });
+  }
+  if ((_program$background2 = program.background) !== null && _program$background2 !== void 0 && _program$background2.service_worker) {
+    program.background.service_worker = asset.addURLDependency(program.background.service_worker, {
+      bundleBehavior: 'isolated',
+      loc: {
+        filePath,
+        ...(0, _diagnostic().getJSONSourceLocation)(ptrs['/background/service_worker'], 'value')
+      },
+      env: {
+        context: 'service-worker',
+        sourceType: program.background.type == 'module' ? 'module' : 'script'
+      }
+    });
+  }
+  if (hot) {
+    var _program$content_scri;
+    if (isMV2) {
+      // To enable HMR, we must override the CSP to allow 'unsafe-eval'
+      program.content_security_policy = cspPatchHMR(program.content_security_policy);
+    } else {
+      // Enable HMR for fetched localhost chunks
+      const csp = program.content_security_policy || {};
+      csp.extension_pages = cspPatchHMR(csp.extension_pages, `http://${(hmrOptions === null || hmrOptions === void 0 ? void 0 : hmrOptions.host) || 'localhost'}:*`);
+      // Sandbox allows eval by default
+      if (csp.sandbox) csp.sandbox = cspPatchHMR(csp.sandbox);
+      program.content_security_policy = csp;
+    }
+    if (!program.background) {
+      program.background = {};
+    }
+    if (program.background.page) {
+      asset.meta.webextBGInsert = program.background.page;
+    } else if (isMV2 || program.background.scripts) {
+      if (!program.background.scripts) {
+        program.background.scripts = [];
+      }
+      if (program.background.scripts.length == 0) {
+        program.background.scripts.push(asset.addURLDependency('./runtime/default-bg.js', {
+          resolveFrom: __filename
+        }));
+      }
+      asset.meta.webextBGInsert = program.background.scripts[0];
+    } else {
+      if (!program.background.service_worker) {
+        program.background.service_worker = asset.addURLDependency('./runtime/default-bg.js', {
+          resolveFrom: __filename,
+          env: {
+            context: 'service-worker'
+          }
+        });
+      }
+      asset.meta.webextBGInsert = program.background.service_worker;
+    }
+    if (!program.permissions) program.permissions = [];
+    if (!isMV2 && !program.permissions.includes('scripting')) {
+      program.permissions.push('scripting');
+    }
+    const hostPerms = [...new Set((_program$content_scri = program.content_scripts) === null || _program$content_scri === void 0 ? void 0 : _program$content_scri.flatMap(sc => sc.matches))];
+    if (isMV2) program.permissions = program.permissions.concat(hostPerms);else {
+      if (!program.host_permissions) program.host_permissions = [];
+      program.host_permissions = program.host_permissions.concat(hostPerms);
+    }
+  }
+}
+function cspPatchHMR(policy, insert) {
+  let defaultSrc = "'self'";
+  if (insert == null) {
+    insert = "'unsafe-eval'";
+    defaultSrc = "'self' blob: filesystem:";
+  }
+  if (policy) {
+    const csp = (0, _contentSecurityPolicyParser().default)(policy);
+    policy = '';
+    if (!csp['script-src']) {
+      csp['script-src'] = [defaultSrc];
+    }
+    if (!csp['script-src'].includes(insert)) {
+      csp['script-src'].push(insert);
+    }
+    if (csp.sandbox && !csp.sandbox.includes('allow-scripts')) {
+      csp.sandbox.push('allow-scripts');
+    }
+    for (const k in csp) {
+      policy += `${k} ${csp[k].join(' ')};`;
+    }
+    return policy;
+  } else {
+    return `script-src ${defaultSrc} ${insert};` + `object-src ${defaultSrc};`;
+  }
+}
+var _default = exports.default = new (_plugin().Transformer)({
+  async transform({
+    asset,
+    options
+  }) {
+    // Set environment to browser, since web extensions are always used in
+    // browsers, and because it avoids delegating extra config to the user
+    asset.setEnvironment({
+      context: 'browser',
+      outputFormat: asset.env.outputFormat == 'commonjs' ? 'global' : asset.env.outputFormat,
+      engines: {
+        browsers: asset.env.engines.browsers
+      },
+      sourceMap: asset.env.sourceMap && {
+        ...asset.env.sourceMap,
+        // Inline source maps work most reliably on web extensions but allow users to overwrite
+        inline: asset.env.sourceMap.inline ?? true,
+        inlineSources: asset.env.sourceMap.inlineSources ?? true
+      },
+      includeNodeModules: asset.env.includeNodeModules,
+      sourceType: asset.env.sourceType,
+      isLibrary: asset.env.isLibrary,
+      shouldOptimize: asset.env.shouldOptimize,
+      shouldScopeHoist: asset.env.shouldScopeHoist
+    });
+    const code = await asset.getCode();
+    const parsed = (0, _jsonSourcemap().parse)(code);
+    const data = parsed.data;
+
+    // Not using a unified schema dramatically improves error messages
+    let schema = _schema.VersionSchema;
+    if (data.manifest_version === 3) {
+      schema = _schema.MV3Schema;
+    } else if (data.manifest_version === 2) {
+      schema = _schema.MV2Schema;
+    }
+    _utils().validateSchema.diagnostic(schema, {
+      data: data,
+      source: code,
+      filePath: asset.filePath
+    }, '@atlaspack/transformer-webextension', 'Invalid Web Extension manifest');
+    await collectDependencies(asset, data, parsed.pointers, options.hmrOptions);
+    asset.setCode(JSON.stringify(data, null, 2));
+    asset.meta.webextEntry = true;
+    return [asset];
+  }
+});

package/lib/runtime/autoreload.js

@@ -0,0 +1,26 @@
+"use strict";
+
+/* global chrome, browser, addEventListener, location */
+var env = typeof browser == 'undefined' ? chrome : browser;
+var blockReload = true;
+addEventListener('beforeunload', function () {
+  if (!blockReload) return;
+  try {
+    env.runtime.sendMessage({
+      __parcel_hmr_reload__: true
+    });
+    // spinlock for 500ms to let background reload
+    let end = Date.now() + 500;
+    while (Date.now() < end);
+  } catch (err) {
+    // ignore throwing if extension context invalidated
+  }
+});
+env.runtime.onMessage.addListener(function (msg) {
+  if (msg.__parcel_hmr_reload__) {
+    blockReload = false;
+    setTimeout(function () {
+      location.reload();
+    }, 400);
+  }
+});

package/lib/runtime/default-bg.js

@@ -0,0 +1 @@
+"use strict";

package/lib/schema.js

@@ -0,0 +1,564 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.VersionSchema = exports.MV3Schema = exports.MV2Schema = void 0;
+const validateVersion = ver => {
+  const parts = ver.split('.', 5);
+  if (parts.length == 5) return 'Extension versions to have at most three dots';
+  if (parts.every(part => part.length != 0 && Number(part[0]) >= 0 && Number(part) < 65536)) return;
+  return 'Extension versions must be dot-separated integers between 0 and 65535';
+};
+const string = {
+  type: 'string'
+};
+const boolean = {
+  type: 'boolean'
+};
+const icons = {
+  type: 'object',
+  properties: {},
+  additionalProperties: string
+};
+const actionProps = {
+  // FF only
+  browser_style: boolean,
+  chrome_style: boolean,
+  // You can also have a raw string, but not in Edge, apparently...
+  default_icon: {
+    oneOf: [icons, string]
+  },
+  default_popup: string,
+  default_title: string
+};
+const arrStr = {
+  type: 'array',
+  items: string
+};
+const browserAction = {
+  type: 'object',
+  properties: {
+    ...actionProps,
+    // rest are FF only
+    default_area: {
+      type: 'string',
+      enum: ['navbar', 'menupanel', 'tabstrip', 'personaltoolbar']
+    },
+    theme_icons: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          light: string,
+          dark: string,
+          size: {
+            type: 'number'
+          }
+        },
+        additionalProperties: false,
+        required: ['light', 'dark', 'size']
+      }
+    }
+  },
+  additionalProperties: false
+};
+const warBase = {
+  type: 'object',
+  properties: {
+    resources: arrStr,
+    matches: arrStr,
+    extension_ids: arrStr,
+    use_dynamic_url: boolean
+  },
+  additionalProperties: false
+};
+const mv2Background = {
+  type: 'object',
+  properties: {
+    scripts: arrStr,
+    page: string,
+    persistent: boolean
+  },
+  additionalProperties: false
+};
+const commonProps = {
+  $schema: string,
+  name: string,
+  version: {
+    type: 'string',
+    __validate: validateVersion
+  },
+  default_locale: string,
+  description: string,
+  icons,
+  author: string,
+  browser_specific_settings: {
+    type: 'object',
+    properties: {},
+    additionalProperties: {
+      type: 'object',
+      properties: {}
+    }
+  },
+  chrome_settings_overrides: {
+    type: 'object',
+    properties: {
+      homepage: string,
+      search_provider: {
+        type: 'object',
+        properties: {
+          name: string,
+          keyword: string,
+          favicon_url: string,
+          search_url: string,
+          encoding: string,
+          suggest_url: string,
+          image_url: string,
+          instant_url: string,
+          search_url_post_params: string,
+          suggest_url_post_params: string,
+          image_url_post_params: string,
+          instant_url_post_params: string,
+          alternate_urls: arrStr,
+          prepopulated_id: {
+            type: 'number'
+          },
+          is_default: boolean
+        },
+        additionalProperties: false,
+        required: ['name', 'search_url']
+      },
+      startup_pages: arrStr
+    },
+    additionalProperties: false
+  },
+  chrome_url_overrides: {
+    type: 'object',
+    properties: {
+      bookmarks: string,
+      history: string,
+      newtab: string
+    },
+    additionalProperties: false
+  },
+  commands: {
+    type: 'object',
+    properties: {},
+    additionalProperties: {
+      type: 'object',
+      properties: {
+        suggested_key: {
+          type: 'object',
+          properties: {
+            default: string,
+            mac: string,
+            linux: string,
+            windows: string,
+            chromeos: string,
+            android: string,
+            ios: string
+          },
+          additionalProperties: false
+        },
+        description: string
+      },
+      additionalProperties: false
+    }
+  },
+  content_scripts: {
+    type: 'array',
+    items: {
+      type: 'object',
+      properties: {
+        matches: arrStr,
+        css: arrStr,
+        js: arrStr,
+        match_about_blank: boolean,
+        exclude_matches: arrStr,
+        include_globs: arrStr,
+        exclude_globs: arrStr,
+        run_at: {
+          type: 'string',
+          enum: ['document_idle', 'document_start', 'document_end']
+        },
+        all_frames: boolean,
+        world: {
+          type: 'string',
+          enum: ['ISOLATED', 'MAIN']
+        }
+      },
+      additionalProperties: false,
+      required: ['matches']
+    }
+  },
+  declarative_net_request: {
+    type: 'object',
+    properties: {
+      rule_resources: {
+        type: 'array',
+        items: {
+          type: 'object',
+          properties: {
+            id: string,
+            enabled: boolean,
+            path: string
+          },
+          additionalProperties: false,
+          required: ['id', 'enabled', 'path']
+        }
+      }
+    },
+    additionalProperties: false,
+    required: ['rule_resources']
+  },
+  devtools_page: string,
+  // looks to be FF only
+  dictionaries: {
+    type: 'object',
+    properties: {},
+    additionalProperties: string
+  },
+  externally_connectable: {
+    type: 'object',
+    properties: {
+      ids: arrStr,
+      matches: arrStr,
+      accept_tls_channel_id: boolean
+    },
+    additionalProperties: false
+  },
+  // These next two are where it gets a bit Chrome-y
+  // (we don't include all because some have next to no actual use)
+  file_browser_handlers: {
+    type: 'array',
+    items: {
+      type: 'object',
+      properties: {
+        id: string,
+        default_title: string,
+        file_filters: arrStr
+      },
+      additionalProperties: false,
+      required: ['id', 'default_title', 'file_filters']
+    }
+  },
+  file_system_provider_capabilities: {
+    type: 'object',
+    properties: {
+      configurable: boolean,
+      multiple_mounts: boolean,
+      watchable: boolean,
+      source: {
+        type: 'string',
+        enum: ['file', 'device', 'network']
+      }
+    },
+    additionalProperties: false,
+    required: ['source']
+  },
+  homepage_url: string,
+  incognito: {
+    type: 'string',
+    enum: ['spanning', 'split', 'not_allowed']
+  },
+  key: string,
+  minimum_chrome_version: {
+    type: 'string',
+    __validate: validateVersion
+  },
+  // No NaCl modules because deprecated
+  oauth2: {
+    type: 'object',
+    properties: {
+      client_id: string,
+      scopes: arrStr
+    },
+    additionalProperties: false
+  },
+  offline_enabled: boolean,
+  omnibox: {
+    type: 'object',
+    properties: {},
+    additionalProperties: string
+  },
+  optional_host_permissions: arrStr,
+  optional_permissions: arrStr,
+  // options_page is deprecated
+  options_ui: {
+    type: 'object',
+    properties: {
+      browser_style: boolean,
+      chrome_style: boolean,
+      open_in_tab: boolean,
+      page: string
+    },
+    additionalProperties: false,
+    required: ['page']
+  },
+  permissions: arrStr,
+  // FF only, but has some use
+  protocol_handlers: {
+    type: 'array',
+    items: {
+      type: 'object',
+      properties: {
+        protocol: string,
+        name: string,
+        uriTemplate: string
+      },
+      additionalProperties: false,
+      required: ['protocol', 'name', 'uriTemplate']
+    }
+  },
+  // Chrome only
+  requirements: {
+    type: 'object',
+    properties: {
+      '3D': {
+        type: 'object',
+        properties: {
+          features: arrStr
+        },
+        additionalProperties: false
+      }
+    }
+  },
+  short_name: string,
+  // FF only, but has some use
+  sidebar_action: {
+    type: 'object',
+    properties: {
+      browser_style: actionProps.browser_style,
+      default_icon: actionProps.default_icon,
+      default_panel: string,
+      default_title: string,
+      open_at_install: boolean
+    },
+    additionalProperties: false,
+    required: ['default_panel']
+  },
+  storage: {
+    type: 'object',
+    properties: {
+      managed_schema: string
+    },
+    additionalProperties: false
+  },
+  theme: {
+    type: 'object',
+    properties: {
+      images: {
+        type: 'object',
+        properties: {
+          theme_frame: string,
+          additional_backgrounds: arrStr
+        },
+        additionalProperties: false
+      },
+      colors: {
+        type: 'object',
+        properties: {
+          bookmark_text: string,
+          button_background_active: string,
+          button_background_hover: string,
+          icons: string,
+          icons_attention: string,
+          frame: string,
+          frame_inactive: string,
+          ntp_background: string,
+          ntp_text: string,
+          popup: string,
+          popup_border: string,
+          popup_highlight: string,
+          popup_highlight_text: string,
+          popup_text: string,
+          sidebar: string,
+          sidebar_border: string,
+          sidebar_highlight: string,
+          sidebar_highlight_text: string,
+          sidebar_text: string,
+          tab_background_separator: string,
+          tab_background_text: string,
+          tab_line: string,
+          tab_loading: string,
+          tab_selected: string,
+          tab_text: string,
+          toolbar: string,
+          toolbar_bottom_separator: string,
+          toolbar_field: string,
+          toolbar_field_border: string,
+          toolbar_field_border_focus: string,
+          toolbar_field_focus: string,
+          toolbar_field_highlight: string,
+          toolbar_field_highlight_text: string,
+          toolbar_field_separator: string,
+          toolbar_field_text: string,
+          toolbar_field_text_focus: string,
+          toolbar_text: string,
+          toolbar_top_separator: string,
+          toolbar_vertical_separator: string
+        },
+        additionalProperties: false
+      },
+      properties: {
+        type: 'object',
+        properties: {
+          additional_backgrounds_alignment: arrStr,
+          additional_backgrounds_tiling: {
+            type: 'array',
+            items: {
+              type: 'string',
+              enum: ['no-repeat', 'repeat', 'repeat-x', 'repeat-y']
+            }
+          }
+        },
+        additionalProperties: false
+      }
+    },
+    additionalProperties: false,
+    required: ['colors']
+  },
+  tts_engine: {
+    type: 'object',
+    properties: {
+      voices: {
+        type: 'array',
+        items: {
+          type: 'object',
+          properties: {
+            voice_name: string,
+            lang: string,
+            event_type: {
+              type: 'string',
+              enum: ['start', 'word', 'sentence', 'marker', 'end', 'error']
+            }
+          },
+          additionalProperties: false,
+          required: ['voice_name', 'event_type']
+        }
+      }
+    },
+    additionalProperties: false
+  },
+  update_url: string,
+  user_scripts: {
+    type: 'object',
+    properties: {
+      api_script: string
+    },
+    additionalProperties: false
+  },
+  version_name: string
+};
+const MV3Schema = exports.MV3Schema = {
+  type: 'object',
+  properties: {
+    ...commonProps,
+    manifest_version: {
+      type: 'number',
+      enum: [3]
+    },
+    action: browserAction,
+    background: {
+      oneOf: [{
+        type: 'object',
+        properties: {
+          service_worker: string,
+          type: {
+            type: 'string',
+            enum: ['classic', 'module']
+          },
+          // to support both Chrome and Firefox
+          scripts: arrStr,
+          page: string,
+          persistent: boolean
+        },
+        additionalProperties: false,
+        required: ['service_worker']
+      }, mv2Background] // for Firefox
+    },
+
+    content_security_policy: {
+      type: 'object',
+      properties: {
+        extension_pages: string,
+        sandbox: string
+      },
+      additionalProperties: false
+    },
+    host_permissions: arrStr,
+    sandbox: {
+      type: 'object',
+      properties: {
+        pages: arrStr
+      },
+      additionalProperties: false
+    },
+    side_panel: {
+      type: 'object',
+      properties: {
+        default_path: string
+      },
+      additionalProperties: false
+    },
+    web_accessible_resources: {
+      type: 'array',
+      items: {
+        oneOf: [{
+          ...warBase,
+          required: ['resources', 'matches']
+        }, {
+          ...warBase,
+          required: ['resources', 'extension_ids']
+        }]
+      }
+    }
+  },
+  required: ['manifest_version', 'name', 'version']
+};
+const MV2Schema = exports.MV2Schema = {
+  type: 'object',
+  properties: {
+    ...commonProps,
+    manifest_version: {
+      type: 'number',
+      enum: [2]
+    },
+    background: mv2Background,
+    browser_action: browserAction,
+    content_security_policy: string,
+    page_action: {
+      type: 'object',
+      properties: {
+        ...actionProps,
+        // rest are FF only
+        hide_matches: arrStr,
+        show_matches: arrStr,
+        pinned: boolean
+      },
+      additionalProperties: false
+    },
+    sandbox: {
+      type: 'object',
+      properties: {
+        pages: arrStr,
+        content_security_policy: string
+      },
+      additionalProperties: false
+    },
+    web_accessible_resources: arrStr
+  },
+  required: ['manifest_version', 'name', 'version']
+};
+const VersionSchema = exports.VersionSchema = {
+  type: 'object',
+  properties: {
+    $schema: string,
+    manifest_version: {
+      type: 'number',
+      enum: [2, 3]
+    }
+  },
+  required: ['manifest_version']
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/transformer-webextension",
-  "version": "2.14.0",
+  "version": "2.14.1-canary.6+57e29c592",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -12,14 +12,15 @@
   "main": "lib/WebExtensionTransformer.js",
   "source": "src/WebExtensionTransformer.js",
   "engines": {
-    "atlaspack": "^2.12.0"
+    "atlaspack": "2.14.1-canary.6+57e29c592"
   },
   "dependencies": {
+    "@atlaspack/diagnostic": "2.14.1-canary.6+57e29c592",
+    "@atlaspack/plugin": "2.14.1-canary.6+57e29c592",
+    "@atlaspack/utils": "2.14.1-canary.6+57e29c592",
     "@mischnic/json-sourcemap": "^0.1.0",
-    "@atlaspack/diagnostic": "2.14.0",
-    "@atlaspack/plugin": "2.14.0",
-    "@atlaspack/utils": "2.14.0",
     "content-security-policy-parser": "^0.3.0"
   },
-  "type": "commonjs"
+  "type": "commonjs",
+  "gitHead": "57e29c592cff406d084b3c676a1c899f0bb6e78f"
 }