@atlaspack/transformer-js 3.0.2-dev.3689 → 3.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/transformer-js",
-  "version": "3.0.2-dev.3689+7a2e6e783",
+  "version": "3.1.0",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -15,7 +15,7 @@
     "test": "mocha"
   },
   "engines": {
-    "atlaspack": "^2.13.2-dev.3689+7a2e6e783",
+    "atlaspack": "^2.12.0",
     "node": ">= 16.0.0"
   },
   "files": [
@@ -23,13 +23,13 @@
     "src"
   ],
   "dependencies": {
-    "@atlaspack/diagnostic": "2.13.2-dev.3689+7a2e6e783",
-    "@atlaspack/feature-flags": "2.13.2-dev.3689+7a2e6e783",
-    "@atlaspack/plugin": "2.13.2-dev.3689+7a2e6e783",
-    "@atlaspack/rust": "2.13.2-dev.3689+7a2e6e783",
-    "@atlaspack/utils": "2.13.2-dev.3689+7a2e6e783",
-    "@atlaspack/workers": "2.13.2-dev.3689+7a2e6e783",
+    "@atlaspack/diagnostic": "2.14.0",
+    "@atlaspack/feature-flags": "2.14.0",
+    "@atlaspack/plugin": "2.14.0",
+    "@atlaspack/rust": "3.0.0",
     "@parcel/source-map": "^2.1.1",
+    "@atlaspack/utils": "2.14.0",
+    "@atlaspack/workers": "2.14.0",
     "@swc/helpers": "^0.5.15",
     "browserslist": "^4.6.6",
     "nullthrows": "^1.1.1",
@@ -37,7 +37,7 @@
     "semver": "^7.5.2"
   },
   "peerDependencies": {
-    "@atlaspack/core": "^2.13.2-dev.3689+7a2e6e783"
+    "@atlaspack/core": "^2.13.1"
   },
-  "gitHead": "7a2e6e7835fa846b27021b374097c6a4f37541ba"
+  "type": "commonjs"
 }

package/LICENSE

@@ -1,201 +0,0 @@
-                                 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/JSTransformer.js

@@ -1,893 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-function _sourceMap() {
-  const data = _interopRequireDefault(require("@parcel/source-map"));
-  _sourceMap = function () {
-    return data;
-  };
-  return data;
-}
-function _plugin() {
-  const data = require("@atlaspack/plugin");
-  _plugin = function () {
-    return data;
-  };
-  return data;
-}
-function _rust() {
-  const data = require("@atlaspack/rust");
-  _rust = function () {
-    return data;
-  };
-  return data;
-}
-function _browserslist() {
-  const data = _interopRequireDefault(require("browserslist"));
-  _browserslist = function () {
-    return data;
-  };
-  return data;
-}
-function _semver() {
-  const data = _interopRequireDefault(require("semver"));
-  _semver = function () {
-    return data;
-  };
-  return data;
-}
-function _nullthrows() {
-  const data = _interopRequireDefault(require("nullthrows"));
-  _nullthrows = function () {
-    return data;
-  };
-  return data;
-}
-function _diagnostic() {
-  const data = _interopRequireWildcard(require("@atlaspack/diagnostic"));
-  _diagnostic = function () {
-    return data;
-  };
-  return data;
-}
-function _utils() {
-  const data = require("@atlaspack/utils");
-  _utils = function () {
-    return data;
-  };
-  return data;
-}
-var _package = _interopRequireDefault(require("../package.json"));
-function _featureFlags() {
-  const data = require("@atlaspack/feature-flags");
-  _featureFlags = function () {
-    return data;
-  };
-  return data;
-}
-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 JSX_EXTENSIONS = {
-  jsx: true,
-  tsx: true
-};
-const JSX_PRAGMA = {
-  react: {
-    pragma: 'React.createElement',
-    pragmaFrag: 'React.Fragment',
-    automatic: '>= 17.0.0 || ^16.14.0 || >= 0.0.0-0 < 0.0.0'
-  },
-  preact: {
-    pragma: 'h',
-    pragmaFrag: 'Fragment',
-    automatic: '>= 10.5.0'
-  },
-  nervjs: {
-    pragma: 'Nerv.createElement',
-    pragmaFrag: undefined,
-    automatic: undefined
-  },
-  hyperapp: {
-    pragma: 'h',
-    pragmaFrag: undefined,
-    automatic: undefined
-  }
-};
-const BROWSER_MAPPING = {
-  and_chr: 'chrome',
-  and_ff: 'firefox',
-  ie_mob: 'ie',
-  ios_saf: 'ios',
-  op_mob: 'opera',
-  and_qq: null,
-  and_uc: null,
-  baidu: null,
-  bb: null,
-  kaios: null,
-  op_mini: null
-};
-
-// List of browsers to exclude when the esmodule target is specified.
-// Based on https://caniuse.com/#feat=es6-module
-const ESMODULE_BROWSERS = ['not ie <= 11', 'not edge < 16', 'not firefox < 60', 'not chrome < 61', 'not safari < 11', 'not opera < 48', 'not ios_saf < 11', 'not op_mini all', 'not android < 76', 'not blackberry > 0', 'not op_mob > 0', 'not and_chr < 76', 'not and_ff < 68', 'not ie_mob > 0', 'not and_uc > 0', 'not samsung < 8.2', 'not and_qq > 0', 'not baidu > 0', 'not kaios > 0'];
-const CONFIG_SCHEMA = {
-  type: 'object',
-  properties: {
-    inlineFS: {
-      type: 'boolean'
-    },
-    inlineEnvironment: {
-      oneOf: [{
-        type: 'boolean'
-      }, {
-        type: 'array',
-        items: {
-          type: 'string'
-        }
-      }]
-    },
-    magicComments: {
-      type: 'boolean'
-    },
-    unstable_inlineConstants: {
-      type: 'boolean'
-    }
-  },
-  additionalProperties: false
-};
-const SCRIPT_ERRORS = {
-  browser: {
-    message: 'Browser scripts cannot have imports or exports.',
-    hint: 'Add the type="module" attribute to the <script> tag.'
-  },
-  'web-worker': {
-    message: 'Web workers cannot have imports or exports without the `type: "module"` option.',
-    hint: "Add {type: 'module'} as a second argument to the Worker constructor."
-  },
-  'service-worker': {
-    message: 'Service workers cannot have imports or exports without the `type: "module"` option.',
-    hint: "Add {type: 'module'} as a second argument to the navigator.serviceWorker.register() call."
-  }
-};
-
-// NOTE: Make sure this is in sync with the TypeScript definition in the @atlaspack/macros package.
-var _default = exports.default = new (_plugin().Transformer)({
-  async loadConfig({
-    config,
-    options
-  }) {
-    let pkg = await config.getPackage();
-    let isJSX, pragma, pragmaFrag, jsxImportSource, automaticJSXRuntime, reactRefresh, decorators, useDefineForClassFields;
-    if (config.isSource) {
-      var _pkg$dependencies2, _pkg$devDependencies2, _pkg$peerDependencies2, _tsconfig$contents;
-      let reactLib;
-      if (pkg !== null && pkg !== void 0 && pkg.alias && pkg.alias['react']) {
-        // e.g.: `{ alias: { "react": "preact/compat" } }`
-        reactLib = 'react';
-      } else {
-        // Find a dependency that we can map to a JSX pragma
-        reactLib = Object.keys(JSX_PRAGMA).find(libName => {
-          var _pkg$dependencies, _pkg$devDependencies, _pkg$peerDependencies;
-          return (pkg === null || pkg === void 0 || (_pkg$dependencies = pkg.dependencies) === null || _pkg$dependencies === void 0 ? void 0 : _pkg$dependencies[libName]) || (pkg === null || pkg === void 0 || (_pkg$devDependencies = pkg.devDependencies) === null || _pkg$devDependencies === void 0 ? void 0 : _pkg$devDependencies[libName]) || (pkg === null || pkg === void 0 || (_pkg$peerDependencies = pkg.peerDependencies) === null || _pkg$peerDependencies === void 0 ? void 0 : _pkg$peerDependencies[libName]);
-        });
-      }
-      reactRefresh = options.hmrOptions && options.mode === 'development' && Boolean((pkg === null || pkg === void 0 || (_pkg$dependencies2 = pkg.dependencies) === null || _pkg$dependencies2 === void 0 ? void 0 : _pkg$dependencies2.react) || (pkg === null || pkg === void 0 || (_pkg$devDependencies2 = pkg.devDependencies) === null || _pkg$devDependencies2 === void 0 ? void 0 : _pkg$devDependencies2.react) || (pkg === null || pkg === void 0 || (_pkg$peerDependencies2 = pkg.peerDependencies) === null || _pkg$peerDependencies2 === void 0 ? void 0 : _pkg$peerDependencies2.react));
-      let tsconfig = await config.getConfigFrom(options.projectRoot + '/index', ['tsconfig.json', 'jsconfig.json']);
-      let compilerOptions = tsconfig === null || tsconfig === void 0 || (_tsconfig$contents = tsconfig.contents) === null || _tsconfig$contents === void 0 ? void 0 : _tsconfig$contents.compilerOptions;
-
-      // Use explicitly defined JSX options in tsconfig.json over inferred values from dependencies.
-      pragma = (compilerOptions === null || compilerOptions === void 0 ? void 0 : compilerOptions.jsxFactory) || (reactLib ? JSX_PRAGMA[reactLib].pragma : undefined);
-      pragmaFrag = (compilerOptions === null || compilerOptions === void 0 ? void 0 : compilerOptions.jsxFragmentFactory) || (reactLib ? JSX_PRAGMA[reactLib].pragmaFrag : undefined);
-      if ((compilerOptions === null || compilerOptions === void 0 ? void 0 : compilerOptions.jsx) === 'react-jsx' || (compilerOptions === null || compilerOptions === void 0 ? void 0 : compilerOptions.jsx) === 'react-jsxdev' || compilerOptions !== null && compilerOptions !== void 0 && compilerOptions.jsxImportSource) {
-        jsxImportSource = compilerOptions === null || compilerOptions === void 0 ? void 0 : compilerOptions.jsxImportSource;
-        automaticJSXRuntime = true;
-      } else if (reactLib) {
-        var _JSX_PRAGMA$effective, _pkg$dependencies3, _pkg$devDependencies3, _pkg$peerDependencies3, _semver$minVersion;
-        let effectiveReactLib = pkg !== null && pkg !== void 0 && pkg.alias && pkg.alias['react'] === 'preact/compat' ? 'preact' : reactLib;
-        let automaticVersion = (_JSX_PRAGMA$effective = JSX_PRAGMA[effectiveReactLib]) === null || _JSX_PRAGMA$effective === void 0 ? void 0 : _JSX_PRAGMA$effective.automatic;
-        let reactLibVersion = (pkg === null || pkg === void 0 || (_pkg$dependencies3 = pkg.dependencies) === null || _pkg$dependencies3 === void 0 ? void 0 : _pkg$dependencies3[effectiveReactLib]) || (pkg === null || pkg === void 0 || (_pkg$devDependencies3 = pkg.devDependencies) === null || _pkg$devDependencies3 === void 0 ? void 0 : _pkg$devDependencies3[effectiveReactLib]) || (pkg === null || pkg === void 0 || (_pkg$peerDependencies3 = pkg.peerDependencies) === null || _pkg$peerDependencies3 === void 0 ? void 0 : _pkg$peerDependencies3[effectiveReactLib]);
-        reactLibVersion = reactLibVersion ? _semver().default.validRange(reactLibVersion) : null;
-        let minReactLibVersion = reactLibVersion !== null && reactLibVersion !== '*' ? (_semver$minVersion = _semver().default.minVersion(reactLibVersion)) === null || _semver$minVersion === void 0 ? void 0 : _semver$minVersion.toString() : null;
-        automaticJSXRuntime = automaticVersion && !(compilerOptions !== null && compilerOptions !== void 0 && compilerOptions.jsxFactory) && minReactLibVersion != null && _semver().default.satisfies(minReactLibVersion, automaticVersion, {
-          includePrerelease: true
-        });
-        if (automaticJSXRuntime) {
-          jsxImportSource = reactLib;
-        }
-      }
-      isJSX = Boolean((compilerOptions === null || compilerOptions === void 0 ? void 0 : compilerOptions.jsx) || pragma);
-      decorators = compilerOptions === null || compilerOptions === void 0 ? void 0 : compilerOptions.experimentalDecorators;
-      useDefineForClassFields = compilerOptions === null || compilerOptions === void 0 ? void 0 : compilerOptions.useDefineForClassFields;
-      if (useDefineForClassFields === undefined && (compilerOptions === null || compilerOptions === void 0 ? void 0 : compilerOptions.target) != null) {
-        // Default useDefineForClassFields to true if target is ES2022 or higher (including ESNext)
-        let target = compilerOptions.target.slice(2);
-        if (target === 'next') {
-          useDefineForClassFields = true;
-        } else {
-          useDefineForClassFields = Number(target) >= 2022;
-        }
-      }
-    }
-
-    // Check if we should ignore fs calls
-    // See https://github.com/defunctzombie/node-browser-resolve#skip
-    let ignoreFS = pkg && pkg.browser && typeof pkg.browser === 'object' && pkg.browser.fs === false;
-    let conf = await config.getConfigFrom(options.projectRoot + '/index', [], {
-      packageKey: '@atlaspack/transformer-js'
-    });
-    let inlineEnvironment = config.isSource;
-    let inlineFS = !ignoreFS;
-    let inlineConstants = false;
-    let magicComments = false;
-    if (conf && conf.contents) {
-      var _conf$contents, _conf$contents2, _conf$contents3, _conf$contents4;
-      _utils().validateSchema.diagnostic(CONFIG_SCHEMA, {
-        data: conf.contents,
-        // FIXME
-        source: await options.inputFS.readFile(conf.filePath, 'utf8'),
-        filePath: conf.filePath,
-        prependKey: `/${(0, _diagnostic().encodeJSONKeyComponent)('@atlaspack/transformer-js')}`
-      },
-      // FIXME
-      '@atlaspack/transformer-js', 'Invalid config for @atlaspack/transformer-js');
-      magicComments = ((_conf$contents = conf.contents) === null || _conf$contents === void 0 ? void 0 : _conf$contents.magicComments) ?? magicComments;
-      inlineEnvironment = ((_conf$contents2 = conf.contents) === null || _conf$contents2 === void 0 ? void 0 : _conf$contents2.inlineEnvironment) ?? inlineEnvironment;
-      inlineFS = ((_conf$contents3 = conf.contents) === null || _conf$contents3 === void 0 ? void 0 : _conf$contents3.inlineFS) ?? inlineFS;
-      inlineConstants = ((_conf$contents4 = conf.contents) === null || _conf$contents4 === void 0 ? void 0 : _conf$contents4.unstable_inlineConstants) ?? inlineConstants;
-    }
-    return {
-      isJSX,
-      automaticJSXRuntime,
-      jsxImportSource,
-      pragma,
-      pragmaFrag,
-      inlineEnvironment,
-      inlineFS,
-      inlineConstants,
-      reactRefresh,
-      decorators,
-      useDefineForClassFields,
-      magicComments
-    };
-  },
-  async transform({
-    asset,
-    config,
-    options,
-    logger
-  }) {
-    let [code, originalMap] = await Promise.all([asset.getBuffer(), asset.getMap()]);
-    let targets;
-    if (asset.env.isElectron() && asset.env.engines.electron) {
-      var _semver$minVersion2;
-      targets = {
-        electron: (_semver$minVersion2 = _semver().default.minVersion(asset.env.engines.electron)) === null || _semver$minVersion2 === void 0 ? void 0 : _semver$minVersion2.toString()
-      };
-    } else if (asset.env.isBrowser() && asset.env.engines.browsers) {
-      targets = {};
-      let browsers = Array.isArray(asset.env.engines.browsers) ? asset.env.engines.browsers : [asset.env.engines.browsers];
-
-      // If the output format is esmodule, exclude browsers
-      // that support them natively so that we transpile less.
-      if (asset.env.outputFormat === 'esmodule') {
-        browsers = [...browsers, ...ESMODULE_BROWSERS];
-      }
-      browsers = (0, _browserslist().default)(browsers);
-      for (let browser of browsers) {
-        let [name, version] = browser.split(' ');
-        if (BROWSER_MAPPING.hasOwnProperty(name)) {
-          name = BROWSER_MAPPING[name];
-          if (!name) {
-            continue;
-          }
-        }
-        let [major, minor = '0', patch = '0'] = version.split('-')[0].split('.');
-        if (isNaN(major) || isNaN(minor) || isNaN(patch)) {
-          continue;
-        }
-        let semverVersion = `${major}.${minor}.${patch}`;
-        if (targets[name] == null || _semver().default.gt(targets[name], semverVersion)) {
-          targets[name] = semverVersion;
-        }
-      }
-    } else if (asset.env.isNode() && asset.env.engines.node) {
-      var _semver$minVersion3;
-      targets = {
-        node: (_semver$minVersion3 = _semver().default.minVersion(asset.env.engines.node)) === null || _semver$minVersion3 === void 0 ? void 0 : _semver$minVersion3.toString()
-      };
-    }
-    let env = {};
-    if (!(config !== null && config !== void 0 && config.inlineEnvironment)) {
-      if (options.env.NODE_ENV != null) {
-        env.NODE_ENV = options.env.NODE_ENV;
-      }
-    } else if (Array.isArray(config === null || config === void 0 ? void 0 : config.inlineEnvironment)) {
-      for (let match of (0, _utils().globMatch)(Object.keys(options.env), config.inlineEnvironment)) {
-        env[match] = String(options.env[match]);
-      }
-    } else {
-      for (let key in options.env) {
-        if (!key.startsWith('npm_')) {
-          env[key] = String(options.env[key]);
-        }
-      }
-    }
-    let supportsModuleWorkers = asset.env.shouldScopeHoist && asset.env.supports('worker-module', true);
-    let isJSX = Boolean(config === null || config === void 0 ? void 0 : config.isJSX);
-    if (asset.isSource) {
-      if (asset.type === 'ts') {
-        isJSX = false;
-      } else if (!isJSX) {
-        isJSX = Boolean(JSX_EXTENSIONS[asset.type]);
-      }
-    }
-    let macroAssets = [];
-    let {
-      dependencies,
-      code: compiledCode,
-      map,
-      shebang,
-      hoist_result,
-      symbol_result,
-      needs_esm_helpers,
-      diagnostics,
-      used_env,
-      has_node_replacements,
-      is_constant_module,
-      conditions
-    } = await (_rust().transformAsync || _rust().transform)({
-      filename: asset.filePath,
-      code,
-      module_id: asset.id,
-      project_root: options.projectRoot,
-      replace_env: !asset.env.isNode(),
-      inline_fs: Boolean(config === null || config === void 0 ? void 0 : config.inlineFS) && !asset.env.isNode(),
-      insert_node_globals: !asset.env.isNode() && asset.env.sourceType !== 'script',
-      node_replacer: asset.env.isNode(),
-      is_browser: asset.env.isBrowser(),
-      is_worker: asset.env.isWorker(),
-      env,
-      is_type_script: asset.type === 'ts' || asset.type === 'tsx',
-      is_jsx: isJSX,
-      jsx_pragma: config === null || config === void 0 ? void 0 : config.pragma,
-      jsx_pragma_frag: config === null || config === void 0 ? void 0 : config.pragmaFrag,
-      automatic_jsx_runtime: Boolean(config === null || config === void 0 ? void 0 : config.automaticJSXRuntime),
-      jsx_import_source: config === null || config === void 0 ? void 0 : config.jsxImportSource,
-      is_development: options.mode === 'development',
-      react_refresh: asset.env.isBrowser() && !asset.env.isLibrary && !asset.env.isWorker() && !asset.env.isWorklet() && Boolean(config === null || config === void 0 ? void 0 : config.reactRefresh),
-      decorators: Boolean(config === null || config === void 0 ? void 0 : config.decorators),
-      use_define_for_class_fields: Boolean(config === null || config === void 0 ? void 0 : config.useDefineForClassFields),
-      targets,
-      source_maps: !!asset.env.sourceMap,
-      scope_hoist: asset.env.shouldScopeHoist && asset.env.sourceType !== 'script',
-      source_type: asset.env.sourceType === 'script' ? 'Script' : 'Module',
-      supports_module_workers: supportsModuleWorkers,
-      is_library: asset.env.isLibrary,
-      is_esm_output: asset.env.outputFormat === 'esmodule',
-      trace_bailouts: options.logLevel === 'verbose',
-      is_swc_helpers: /@swc[/\\]helpers/.test(asset.filePath),
-      standalone: asset.query.has('standalone'),
-      inline_constants: config.inlineConstants,
-      conditional_bundling: options.featureFlags.conditionalBundlingApi,
-      magic_comments: Boolean(config === null || config === void 0 ? void 0 : config.magicComments),
-      callMacro: asset.isSource ? async (err, src, exportName, args, loc) => {
-        let mod;
-        try {
-          mod = await options.packageManager.require(src, asset.filePath);
-
-          // Default interop for CommonJS modules.
-          if (exportName === 'default' && !mod.__esModule &&
-          // $FlowFixMe
-          Object.prototype.toString.call(config) !== '[object Module]') {
-            mod = {
-              default: mod
-            };
-          }
-          if (!Object.hasOwnProperty.call(mod, exportName)) {
-            throw new Error(`"${src}" does not export "${exportName}".`);
-          }
-        } catch (err) {
-          throw {
-            kind: 1,
-            message: err.message
-          };
-        }
-        try {
-          if (typeof mod[exportName] === 'function') {
-            return mod[exportName].apply({
-              // Allows macros to emit additional assets to add as dependencies (e.g. css).
-              addAsset(a) {
-                let k = String(macroAssets.length);
-                let map;
-                if (asset.env.sourceMap) {
-                  // Generate a source map that maps each line of the asset to the original macro call.
-                  map = new (_sourceMap().default)(options.projectRoot);
-                  let mappings = [];
-                  let line = 1;
-                  for (let i = 0; i <= a.content.length; i++) {
-                    if (i === a.content.length || a.content[i] === '\n') {
-                      mappings.push({
-                        generated: {
-                          line,
-                          column: 0
-                        },
-                        source: asset.filePath,
-                        original: {
-                          line: loc.line,
-                          column: loc.col
-                        }
-                      });
-                      line++;
-                    }
-                  }
-                  map.addIndexedMappings(mappings);
-                  if (originalMap) {
-                    map.extends(originalMap);
-                  } else {
-                    map.setSourceContent(asset.filePath, code.toString());
-                  }
-                }
-                macroAssets.push({
-                  type: a.type,
-                  content: a.content,
-                  map,
-                  uniqueKey: k
-                });
-                asset.addDependency({
-                  specifier: k,
-                  specifierType: 'esm'
-                });
-              },
-              invalidateOnFileChange(filePath) {
-                asset.invalidateOnFileChange(filePath);
-              },
-              invalidateOnFileCreate(invalidation) {
-                asset.invalidateOnFileCreate(invalidation);
-              },
-              invalidateOnEnvChange(env) {
-                asset.invalidateOnEnvChange(env);
-              },
-              invalidateOnStartup() {
-                asset.invalidateOnStartup();
-              },
-              invalidateOnBuild() {
-                asset.invalidateOnBuild();
-              }
-            }, args);
-          } else {
-            throw new Error(`"${exportName}" in "${src}" is not a function.`);
-          }
-        } catch (err) {
-          // Remove atlaspack core from stack and build string so Rust can process errors more easily.
-          let stack = (err.stack || '').split('\n').slice(1);
-          let message = err.message;
-          for (let line of stack) {
-            if (line.includes(__filename)) {
-              break;
-            }
-            message += '\n' + line;
-          }
-          throw {
-            kind: 2,
-            message
-          };
-        }
-      } : null
-    });
-    if ((0, _featureFlags().getFeatureFlag)('conditionalBundlingApi')) {
-      asset.meta.conditions = conditions.map(c => ({
-        key: c.key,
-        ifTruePlaceholder: c.if_true_placeholder,
-        ifFalsePlaceholder: c.if_false_placeholder
-      }));
-    }
-    if (is_constant_module) {
-      asset.meta.isConstantModule = true;
-    }
-    let convertLoc = loc => {
-      let location = {
-        filePath: asset.filePath,
-        start: {
-          line: loc.start_line + Number(asset.meta.startLine ?? 1) - 1,
-          column: loc.start_col
-        },
-        end: {
-          line: loc.end_line + Number(asset.meta.startLine ?? 1) - 1,
-          column: loc.end_col
-        }
-      };
-
-      // If there is an original source map, use it to remap to the original source location.
-      if (originalMap) {
-        location = (0, _utils().remapSourceLocation)(location, originalMap);
-      }
-      return location;
-    };
-    if (diagnostics) {
-      let errors = diagnostics.filter(d => d.severity === 'Error' || d.severity === 'SourceError' && asset.isSource);
-      let warnings = diagnostics.filter(d => d.severity === 'Warning' || d.severity === 'SourceError' && !asset.isSource);
-      let convertDiagnostic = diagnostic => {
-        var _diagnostic$code_high;
-        let message = diagnostic.message;
-        if (message === 'SCRIPT_ERROR') {
-          let err = SCRIPT_ERRORS[asset.env.context];
-          message = (err === null || err === void 0 ? void 0 : err.message) || SCRIPT_ERRORS.browser.message;
-        }
-        let res = {
-          message,
-          codeFrames: [{
-            filePath: asset.filePath,
-            codeHighlights: (_diagnostic$code_high = diagnostic.code_highlights) === null || _diagnostic$code_high === void 0 ? void 0 : _diagnostic$code_high.map(highlight => (0, _diagnostic().convertSourceLocationToHighlight)(convertLoc(highlight.loc), highlight.message ?? undefined))
-          }],
-          hints: diagnostic.hints
-        };
-        if (diagnostic.documentation_url) {
-          res.documentationURL = diagnostic.documentation_url;
-        }
-        if (diagnostic.show_environment) {
-          if (asset.env.loc && asset.env.loc.filePath !== asset.filePath) {
-            var _res$codeFrames;
-            (_res$codeFrames = res.codeFrames) === null || _res$codeFrames === void 0 || _res$codeFrames.push({
-              filePath: asset.env.loc.filePath,
-              codeHighlights: [(0, _diagnostic().convertSourceLocationToHighlight)(asset.env.loc, 'The environment was originally created here')]
-            });
-          }
-          let err = SCRIPT_ERRORS[asset.env.context];
-          if (err) {
-            if (!res.hints) {
-              res.hints = [err.hint];
-            } else {
-              res.hints.push(err.hint);
-            }
-          }
-        }
-        return res;
-      };
-      if (errors.length > 0) {
-        throw new (_diagnostic().default)({
-          diagnostic: errors.map(convertDiagnostic)
-        });
-      }
-      logger.warn(warnings.map(convertDiagnostic));
-    }
-    if (shebang) {
-      asset.meta.interpreter = shebang;
-    }
-    if (has_node_replacements) {
-      asset.meta.has_node_replacements = has_node_replacements;
-    }
-    for (let env of used_env) {
-      asset.invalidateOnEnvChange(env);
-    }
-    for (let dep of dependencies) {
-      if (dep.kind === 'WebWorker') {
-        // Use native ES module output if the worker was created with `type: 'module'` and all targets
-        // support native module workers. Only do this if parent asset output format is also esmodule so that
-        // assets can be shared between workers and the main thread in the global output format.
-        let outputFormat;
-        if (asset.env.outputFormat === 'esmodule' && dep.source_type === 'Module' && supportsModuleWorkers) {
-          outputFormat = 'esmodule';
-        } else {
-          outputFormat = asset.env.outputFormat === 'commonjs' ? 'commonjs' : 'global';
-        }
-        let loc = convertLoc(dep.loc);
-        asset.addURLDependency(dep.specifier, {
-          loc,
-          env: {
-            context: 'web-worker',
-            sourceType: dep.source_type === 'Module' ? 'module' : 'script',
-            outputFormat,
-            loc
-          },
-          meta: {
-            webworker: true,
-            placeholder: dep.placeholder
-          }
-        });
-      } else if (dep.kind === 'ServiceWorker') {
-        let loc = convertLoc(dep.loc);
-        asset.addURLDependency(dep.specifier, {
-          loc,
-          needsStableName: true,
-          env: {
-            context: 'service-worker',
-            sourceType: dep.source_type === 'Module' ? 'module' : 'script',
-            outputFormat: 'global',
-            // TODO: module service worker support
-            loc
-          },
-          meta: {
-            placeholder: dep.placeholder
-          }
-        });
-      } else if (dep.kind === 'Worklet') {
-        let loc = convertLoc(dep.loc);
-        asset.addURLDependency(dep.specifier, {
-          loc,
-          env: {
-            context: 'worklet',
-            sourceType: 'module',
-            outputFormat: 'esmodule',
-            // Worklets require ESM
-            loc
-          },
-          meta: {
-            placeholder: dep.placeholder
-          }
-        });
-      } else if (dep.kind === 'Url') {
-        asset.addURLDependency(dep.specifier, {
-          bundleBehavior: 'isolated',
-          loc: convertLoc(dep.loc),
-          meta: {
-            placeholder: dep.placeholder
-          }
-        });
-      } else if (dep.kind === 'File') {
-        asset.invalidateOnFileChange(dep.specifier);
-      } else {
-        let meta = {
-          kind: dep.kind
-        };
-        if (dep.attributes) {
-          meta.importAttributes = dep.attributes;
-        }
-        if (dep.placeholder) {
-          meta.placeholder = dep.placeholder;
-        }
-        let env;
-        if (dep.kind === 'DynamicImport') {
-          // https://html.spec.whatwg.org/multipage/webappapis.html#hostimportmoduledynamically(referencingscriptormodule,-modulerequest,-promisecapability)
-          if (asset.env.isWorklet() || asset.env.context === 'service-worker') {
-            let loc = convertLoc(dep.loc);
-            let diagnostic = {
-              message: `import() is not allowed in ${asset.env.isWorklet() ? 'worklets' : 'service workers'}.`,
-              codeFrames: [{
-                filePath: asset.filePath,
-                codeHighlights: [(0, _diagnostic().convertSourceLocationToHighlight)(loc)]
-              }],
-              hints: ['Try using a static `import`.']
-            };
-            if (asset.env.loc) {
-              diagnostic.codeFrames.push({
-                filePath: asset.env.loc.filePath,
-                codeHighlights: [(0, _diagnostic().convertSourceLocationToHighlight)(asset.env.loc, 'The environment was originally created here')]
-              });
-            }
-            throw new (_diagnostic().default)({
-              diagnostic
-            });
-          }
-
-          // If all of the target engines support dynamic import natively,
-          // we can output native ESM if scope hoisting is enabled.
-          // Only do this for scripts, rather than modules in the global
-          // output format so that assets can be shared between the bundles.
-          let outputFormat = asset.env.outputFormat;
-          if (asset.env.sourceType === 'script' && asset.env.shouldScopeHoist && asset.env.supports('dynamic-import', true)) {
-            outputFormat = 'esmodule';
-          }
-          env = {
-            sourceType: 'module',
-            outputFormat,
-            loc: convertLoc(dep.loc)
-          };
-        }
-
-        // Always bundle helpers, even with includeNodeModules: false, except if this is a library.
-        let isHelper = dep.is_helper && !(dep.specifier.endsWith('/jsx-runtime') || dep.specifier.endsWith('/jsx-dev-runtime'));
-        if (isHelper && !asset.env.isLibrary) {
-          env = {
-            ...env,
-            includeNodeModules: true
-          };
-        }
-
-        // Add required version range for helpers.
-        let range;
-        if (isHelper) {
-          let idx = dep.specifier.indexOf('/');
-          if (dep.specifier[0] === '@') {
-            idx = dep.specifier.indexOf('/', idx + 1);
-          }
-          let module = idx >= 0 ? dep.specifier.slice(0, idx) : dep.specifier;
-          range = _package.default.dependencies[module];
-        }
-        asset.addDependency({
-          specifier: dep.specifier,
-          specifierType: dep.kind === 'Require' ? 'commonjs' : 'esm',
-          loc: convertLoc(dep.loc),
-          priority: dep.kind === 'DynamicImport' ? 'lazy' : dep.kind === 'ConditionalImport' ? 'conditional' : 'sync',
-          isOptional: dep.is_optional,
-          meta,
-          resolveFrom: isHelper ? __filename : undefined,
-          range,
-          env
-        });
-      }
-    }
-    asset.meta.id = asset.id;
-    if (hoist_result) {
-      asset.symbols.ensure();
-      for (let {
-        exported,
-        local,
-        loc,
-        is_esm
-      } of hoist_result.exported_symbols) {
-        asset.symbols.set(exported, local, convertLoc(loc), {
-          isEsm: is_esm
-        });
-      }
-
-      // deps is a map of dependencies that are keyed by placeholder or specifier
-      // If a placeholder is present, that is used first since placeholders are
-      // hashed with DependencyKind's.
-      // If not, the specifier is used along with its specifierType appended to
-      // it to separate dependencies with the same specifier.
-      let deps = new Map(asset.getDependencies().map(dep => [dep.meta.placeholder ?? dep.specifier, dep]));
-      for (let dep of deps.values()) {
-        dep.symbols.ensure();
-      }
-      for (let {
-        source,
-        local,
-        imported,
-        loc
-      } of hoist_result.imported_symbols) {
-        let dep = deps.get(source);
-        if (!dep) continue;
-        dep.symbols.set(imported, local, convertLoc(loc));
-      }
-      for (let {
-        source,
-        local,
-        imported,
-        loc
-      } of hoist_result.re_exports) {
-        let dep = deps.get(source);
-        if (!dep) continue;
-        if (local === '*' && imported === '*') {
-          dep.symbols.set('*', '*', convertLoc(loc), true);
-        } else {
-          var _dep$symbols$get;
-          let reExportName = ((_dep$symbols$get = dep.symbols.get(imported)) === null || _dep$symbols$get === void 0 ? void 0 : _dep$symbols$get.local) ?? `$${asset.id}$re_export$${local}`;
-          asset.symbols.set(local, reExportName);
-          dep.symbols.set(imported, reExportName, convertLoc(loc), true);
-        }
-      }
-      for (let specifier of hoist_result.wrapped_requires) {
-        let dep = deps.get(specifier);
-        if (!dep) continue;
-        dep.meta.shouldWrap = true;
-      }
-      for (let name in hoist_result.dynamic_imports) {
-        let dep = deps.get(hoist_result.dynamic_imports[name]);
-        if (!dep) continue;
-        dep.meta.promiseSymbol = name;
-      }
-      if (hoist_result.self_references.length > 0) {
-        let symbols = new Map();
-        for (let name of hoist_result.self_references) {
-          // Do not create a self-reference for the `default` symbol unless we have seen an __esModule flag.
-          if (name === 'default' && !asset.symbols.hasExportSymbol('__esModule')) {
-            continue;
-          }
-          let local = (0, _nullthrows().default)(asset.symbols.get(name)).local;
-          symbols.set(name, {
-            local,
-            isWeak: false,
-            loc: null
-          });
-        }
-
-        // Use the asset id as a unique key if one has not already been set.
-        // This lets us create a dependency on the asset itself by using it as a specifier.
-        // Using the unique key ensures that the dependency always resolves to the correct asset,
-        // even if it came from a transformer that produced multiple assets (e.g. css modules).
-        // Also avoids needing a resolution request.
-        asset.uniqueKey ||= asset.id;
-        asset.addDependency({
-          specifier: asset.uniqueKey,
-          specifierType: 'esm',
-          symbols
-        });
-      }
-
-      // Add * symbol if there are CJS exports, no imports/exports at all
-      // (and the asset has side effects), or the asset is wrapped.
-      // This allows accessing symbols that don't exist without errors in symbol propagation.
-      if (hoist_result.has_cjs_exports || !hoist_result.is_esm && asset.sideEffects && deps.size === 0 && Object.keys(hoist_result.exported_symbols).length === 0 || hoist_result.should_wrap && !asset.symbols.hasExportSymbol('*')) {
-        asset.symbols.set('*', `$${asset.id}$exports`);
-      }
-      asset.meta.hasCJSExports = hoist_result.has_cjs_exports;
-      asset.meta.staticExports = hoist_result.static_cjs_exports;
-      asset.meta.shouldWrap = hoist_result.should_wrap;
-    } else {
-      if (symbol_result) {
-        let deps = new Map(asset.getDependencies().map(dep => [dep.meta.placeholder ?? dep.specifier, dep]));
-        asset.symbols.ensure();
-        for (let {
-          exported,
-          local,
-          loc,
-          source
-        } of symbol_result.exports) {
-          let dep = source ? deps.get(source) : undefined;
-          asset.symbols.set(exported, `${(dep === null || dep === void 0 ? void 0 : dep.id) ?? ''}$${local}`, convertLoc(loc));
-          if (dep != null) {
-            dep.symbols.ensure();
-            dep.symbols.set(local, `${(dep === null || dep === void 0 ? void 0 : dep.id) ?? ''}$${local}`, convertLoc(loc), true);
-          }
-        }
-        for (let {
-          source,
-          local,
-          imported,
-          loc
-        } of symbol_result.imports) {
-          let dep = deps.get(source);
-          if (!dep) continue;
-          dep.symbols.ensure();
-          dep.symbols.set(imported, local, convertLoc(loc));
-        }
-        for (let {
-          source,
-          loc
-        } of symbol_result.exports_all) {
-          let dep = deps.get(source);
-          if (!dep) continue;
-          dep.symbols.ensure();
-          dep.symbols.set('*', '*', convertLoc(loc), true);
-        }
-
-        // Add * symbol if there are CJS exports, no imports/exports at all, or the asset is wrapped.
-        // This allows accessing symbols that don't exist without errors in symbol propagation.
-        if (symbol_result.has_cjs_exports || !symbol_result.is_esm && deps.size === 0 && symbol_result.exports.length === 0 || symbol_result.should_wrap && !asset.symbols.hasExportSymbol('*')) {
-          asset.symbols.ensure();
-          asset.symbols.set('*', `$${asset.id}$exports`);
-        }
-      } else {
-        // If the asset is wrapped, add * as a fallback
-        asset.symbols.ensure();
-        asset.symbols.set('*', `$${asset.id}$exports`);
-      }
-
-      // For all other imports and requires, mark everything as imported (this covers both dynamic
-      // imports and non-top-level requires.)
-      for (let dep of asset.getDependencies()) {
-        if (dep.symbols.isCleared) {
-          dep.symbols.ensure();
-          dep.symbols.set('*', `${dep.id}$`);
-        }
-      }
-      if (needs_esm_helpers) {
-        asset.addDependency({
-          specifier: '@atlaspack/transformer-js/src/esmodule-helpers.js',
-          specifierType: 'esm',
-          resolveFrom: __filename,
-          env: {
-            includeNodeModules: {
-              '@atlaspack/transformer-js': true
-            }
-          }
-        });
-      }
-    }
-    asset.type = 'js';
-    asset.setBuffer(compiledCode);
-    if (map) {
-      let sourceMap = new (_sourceMap().default)(options.projectRoot);
-      sourceMap.addVLQMap(JSON.parse(map));
-      if (originalMap) {
-        sourceMap.extends(originalMap);
-      }
-      asset.setMap(sourceMap);
-    }
-    return [asset, ...macroAssets];
-  }
-});

package/lib/esmodule-helpers.js

@@ -1,32 +0,0 @@
-"use strict";
-
-exports.interopDefault = function (a) {
-  return a && a.__esModule ? a : {
-    default: a
-  };
-};
-exports.defineInteropFlag = function (a) {
-  Object.defineProperty(a, '__esModule', {
-    value: true
-  });
-};
-exports.exportAll = function (source, dest) {
-  Object.keys(source).forEach(function (key) {
-    if (key === 'default' || key === '__esModule' || Object.prototype.hasOwnProperty.call(dest, key)) {
-      return;
-    }
-    Object.defineProperty(dest, key, {
-      enumerable: true,
-      get: function () {
-        return source[key];
-      }
-    });
-  });
-  return dest;
-};
-exports.export = function (dest, destName, get) {
-  Object.defineProperty(dest, destName, {
-    enumerable: true,
-    get: get
-  });
-};