add polyfill originals

Author: lobsterkatie

rollup/jsPolyfills/README.md

@@ -0,0 +1,5 @@
+### Javascript Polyfills
+
+This is a collection of syntax polyfills either copied directly from or heavily inspired by those used by [Rollup](https://github.com/rollup/rollup) and [Sucrase](https://github.com/alangpierce/sucrase). When either tool uses one of these polyfills during a build, it injects the function source code into each file needing the function, which can lead to a great deal of duplication. For our builds, we have therefore implemented something similar to [`tsc`'s `importHelpers` behavior](https://www.typescriptlang.org/tsconfig#importHelpers): Instead of leaving the polyfills injected in multiple places, we instead replace each injected function with an `import` or `require` statement. This directory is the location from which we import. For simplicity (and greater treeshaking ability when using tools which only work on a file-by-file level), each polyfill lives in its own file.
+
+During build, this directory is copied over to the root level of `@sentry/utils`, and the polyfills are compiled into esm and cjs versions. When the injected implementations are replaced by either `import` or `require` by our rollup plugin, each `import`/`require` pulls from the correct module format's folder. (In other words, the injected `import` statements import from `@sentry/utils/jsPolyfills/esm` and the injected `require` statements pull from `@sentry/utils/jsPolyfills/cjs`.)

rollup/jsPolyfills/_asyncNullishCoalesce.js

@@ -0,0 +1,4 @@
+export async function _asyncNullishCoalesce(lhs, rhsFn) {
+  // by checking for loose equality to `null`, we catch both `null` and `undefined`
+  return lhs != null ? lhs : rhsFn();
+}

rollup/jsPolyfills/_asyncOptionalChain.js

@@ -0,0 +1,23 @@
+export async function _asyncOptionalChain(ops) {
+  let lastAccessLHS = undefined;
+  let value = ops[0];
+  let i = 1;
+  while (i < ops.length) {
+    const op = ops[i];
+    const fn = ops[i + 1];
+    i += 2;
+    // by checking for loose equality to `null`, we catch both `null` and `undefined`
+    if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) {
+      // really we're meaning to return `undefined` as an actual value here, but it saves bytes not to write it
+      return;
+    }
+    if (op === 'access' || op === 'optionalAccess') {
+      lastAccessLHS = value;
+      value = await fn(value);
+    } else if (op === 'call' || op === 'optionalCall') {
+      value = await fn((...args) => value.call(lastAccessLHS, ...args));
+      lastAccessLHS = undefined;
+    }
+  }
+  return value;
+}

rollup/jsPolyfills/_asyncOptionalChainDelete.js

@@ -0,0 +1,7 @@
+import { _asyncOptionalChain } from './_asyncOptionalChain';
+
+export async function _asyncOptionalChainDelete(ops) {
+  const result = await _asyncOptionalChain(ops);
+  // by checking for loose equality to `null`, we catch both `null` and `undefined`
+  return result == null ? true : result;
+}

rollup/jsPolyfills/_createNamedExportFrom.js

@@ -0,0 +1,3 @@
+export function _createNamedExportFrom(obj, localName, importedName) {
+  exports[localName] = obj[importedName];
+}

rollup/jsPolyfills/_createStarExport.js

@@ -0,0 +1,11 @@
+export function _createStarExport(obj) {
+  Object.keys(obj)
+    .filter(key => key !== 'default' && key !== '__esModule')
+    .forEach(key => {
+      // eslint-disable-next-line no-prototype-builtins
+      if (exports.hasOwnProperty(key)) {
+        return;
+      }
+      exports[key] = obj[key];
+    });
+}

rollup/jsPolyfills/_interopDefault.js

@@ -0,0 +1,3 @@
+export function _interopDefault(importTarget) {
+  return importTarget.__esModule ? importTarget : { default: importTarget };
+}

rollup/jsPolyfills/_interopNamespace.js

@@ -0,0 +1,3 @@
+export function _interopNamespace(importTarget) {
+  return importTarget.__esModule ? importTarget : { ...importTarget, default: importTarget };
+}

rollup/jsPolyfills/_interopRequireDefault.js

@@ -0,0 +1,13 @@
+/**
+ * Rollup and Sucrase have identical polyfills for `import { default as someName } from 'someModule'` and `import
+ * someName from 'someModule'` syntax, named `_interopDefault` and `_interopRequireDefault`, respectively. For
+ * simplicity, files with both names have been kept, so that we can replace each injected function with an import of the
+ * same name.
+ *
+ * Sucrase only injects the polyfill when the `imports` transform is used, which we're not currently doing. By contrast,
+ * Rollup injects its version when building cjs modules, which we do do. Therefore, the actual function definition lives
+ * in `_interopDefault.js`, so that there's no indirection with the one we know we'll be using. Though we likely we
+ * likely won't ever this the Sucrase version here, it seemed prudent to keep the stub just in case.
+ */
+
+export { _interopDefault as _interopRequireDefault } from './_interopDefault';

rollup/jsPolyfills/_interopRequireWildcard.js

@@ -0,0 +1,12 @@
+/**
+ * Rollup and Sucrase both have essentially the same polyfill for `import * as someName from 'someModule'` syntax, named
+ * `_interopNamespace` and `_interopRequireWildcard`, respectively. For simplicity, files with both names have been kept,
+ * so that we can replace each injected function with an import of the same name.
+ *
+ * Sucrase only injects the polyfill when the `imports` transform is used, which we're not currently doing. By contrast,
+ * Rollup injects its version when building cjs modules, which we do do. Therefore, the actual function definition lives
+ * in `_interopNamespace.js`, so that there's no indirection with the one we know we'll be using. Though we likely we
+ * likely won't ever this the Sucrase version here, it seemed prudent to keep the stub just in case.
+ */
+
+export { _interopNamespace as _interopRequireWildcard } from './_interopNamespace';