@k8slens/package-build 3.2.0 → 3.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@k8slens/package-build",
-  "version": "3.2.0",
+  "version": "3.4.0",
   "lens": {
     "env": "agnostic",
     "layer": "infrastructure",
@@ -42,7 +42,8 @@
   },
   "bin": {
     "lens-package-build": "bin/package-build",
-    "lens-extension-dependencies-check": "bin/extension-dependencies-check"
+    "lens-extension-dependencies-check": "bin/extension-dependencies-check",
+    "lens-extension-publish-check": "bin/extension-publish-check"
   },
   "files": [
     "index.js",
@@ -60,6 +61,7 @@
     "test:unit": "jest"
   },
   "dependencies": {
+    "acorn": "^8.15.0",
     "esbuild": "^0.25.4",
     "fast-glob": "^3.3.3",
     "lodash": "^4.17.21",
@@ -72,6 +74,7 @@
   },
   "devDependencies": {
     "@async-fn/jest": "^1.6.4",
+    "@jridgewell/trace-mapping": "^0.3.31",
     "@k8slens/typescript": "^8.1.0",
     "@lensapp/jest": "^7.2.0",
     "@types/semver": "^7.7.0"
@@ -86,6 +89,7 @@
         "inputs": [
           "{projectRoot}/bin/package-build",
           "{projectRoot}/bin/extension-dependencies-check",
+          "{projectRoot}/bin/extension-publish-check",
           "{projectRoot}/index.ts",
           "{projectRoot}/src/**/*.ts"
         ],

package/src/__fixtures__/package-importing-a-package/index.js

@@ -0,0 +1,2 @@
+export { default as identity } from "lodash/identity";
+export { sep } from "node:path";

package/src/ascii-output-plugin.test.ts

@@ -0,0 +1,141 @@
+import { originalPositionFor, TraceMap } from "@jridgewell/trace-mapping";
+import { build } from "esbuild";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { asciiOutputPlugin } from "./ascii-output-plugin";
+
+const source = [
+  "export const commented = 1 && // A comment — with an em dash",
+  "  2;",
+  "const fortyTwo = 42;",
+  "const eightyFour = 84;",
+  "export const adWordsAndMore = [/^(广告|Реклама|publicité)$/iu, fortyTwo];",
+  "export const constantAndMore = [/π|ℯ/, /ℯ/, eightyFour];",
+  "export const emoji = /🪦+/u;",
+  "export const emojiWithoutUnicodeFlag = /^🪦$/;",
+  "export const escapedDash = /\\—/;",
+  "export const backslashThenDash = /\\\\—/;",
+  "export const raw = String.raw`—`;",
+  "export const plain = `—`;",
+].join("\n");
+
+describe("ascii output of a build", () => {
+  let directory: string;
+  let bundle: string;
+  let warnings: string[];
+  let exportsOfBundle: Record<string, unknown>;
+  let sourceMap: TraceMap;
+
+  beforeAll(async () => {
+    directory = mkdtempSync(path.join(tmpdir(), "ascii-output-plugin-"));
+
+    const entryPoint = path.join(directory, "entry.js");
+    const outfile = path.join(directory, "bundle.js");
+
+    writeFileSync(entryPoint, source);
+
+    const result = await build({
+      entryPoints: [entryPoint],
+      outfile,
+      bundle: true,
+      format: "cjs",
+      platform: "node",
+      sourcemap: true,
+      logLevel: "silent",
+      plugins: [asciiOutputPlugin()],
+    });
+
+    warnings = result.warnings.map((warning) => warning.text);
+    bundle = readFileSync(outfile, "utf8");
+    sourceMap = new TraceMap(readFileSync(`${outfile}.map`, "utf8"));
+    exportsOfBundle = evaluate(bundle);
+  });
+
+  afterAll(() => {
+    rmSync(directory, { recursive: true, force: true });
+  });
+
+  it("leaves nothing outside ASCII but the raw text of a tagged template literal", () => {
+    expect(bundle.match(/[\u0080-\uffff]/g)).toEqual(["—"]);
+  });
+
+  it("warns of the character left outside Latin-1", () => {
+    expect(warnings).toEqual([expect.stringContaining("1 characters above Latin-1 could not be escaped")]);
+  });
+
+  it("escapes the characters of a comment", () => {
+    expect(bundle).toContain("// A comment \\u2014 with an em dash");
+  });
+
+  it("keeps a regular expression with the unicode flag matching what it matched", () => {
+    const [adWords] = exportsOfBundle.adWordsAndMore as RegExp[];
+
+    expect(["广告", "РЕКЛАМА", "PUBLICITÉ", "other"].map((word) => adWords.test(word))).toEqual([
+      true,
+      true,
+      true,
+      false,
+    ]);
+  });
+
+  it("keeps a regular expression without flags matching what it matched", () => {
+    const [constant] = exportsOfBundle.constantAndMore as RegExp[];
+
+    expect(["π", "ℯ", "p"].map((word) => constant.test(word))).toEqual([true, true, false]);
+  });
+
+  it("keeps a character beyond the basic plane a single character to a quantifier with the unicode flag", () => {
+    expect((exportsOfBundle.emoji as RegExp).test("🪦🪦")).toBe(true);
+  });
+
+  it("keeps a character beyond the basic plane two characters without the unicode flag", () => {
+    expect((exportsOfBundle.emojiWithoutUnicodeFlag as RegExp).test("🪦")).toBe(true);
+  });
+
+  it("keeps a character escaped by a backslash in a regular expression the character", () => {
+    expect((exportsOfBundle.escapedDash as RegExp).source).toBe("\\u2014");
+  });
+
+  it("keeps a backslash escaped by a backslash before a character in a regular expression a backslash", () => {
+    expect((exportsOfBundle.backslashThenDash as RegExp).test("\\—")).toBe(true);
+  });
+
+  it("keeps the raw text of a tagged template literal", () => {
+    expect(exportsOfBundle.raw).toBe("—");
+  });
+
+  it("keeps an untagged template literal its text", () => {
+    expect(exportsOfBundle.plain).toBe("—");
+  });
+
+  it("maps code after an escaped regular expression to where it came from", () => {
+    expect(originalPositionOf(bundle, sourceMap, "fortyTwo];")).toEqual(positionInSource("fortyTwo];"));
+  });
+
+  it("maps code after two escaped regular expressions on a line to where it came from", () => {
+    expect(originalPositionOf(bundle, sourceMap, "eightyFour]")).toEqual(positionInSource("eightyFour]"));
+  });
+});
+
+const evaluate = (bundle: string) => {
+  const module = { exports: {} as Record<string, unknown> };
+
+  new Function("module", "exports", "require", bundle)(module, module.exports, require);
+
+  return module.exports;
+};
+
+const positionOf = (code: string, text: string) => {
+  const linesBefore = code.slice(0, code.indexOf(text)).split("\n");
+
+  return { line: linesBefore.length, column: linesBefore[linesBefore.length - 1].length };
+};
+
+const positionInSource = (text: string) => positionOf(source, text);
+
+const originalPositionOf = (bundle: string, sourceMap: TraceMap, text: string) => {
+  const { line, column } = originalPositionFor(sourceMap, positionOf(bundle, text));
+
+  return { line, column };
+};

package/src/ascii-output-plugin.ts

@@ -0,0 +1,342 @@
+import { tokenizer, tokTypes } from "acorn";
+import type { Plugin } from "esbuild";
+import { readFile, writeFile } from "node:fs/promises";
+
+/** How much a replacement on a line moved what came after it, for the source map. */
+interface ColumnShift {
+  /** Zero-based line of the generated code. */
+  readonly line: number;
+  /** Zero-based column, in the code before escaping, where the replaced text started. */
+  readonly column: number;
+  /** How many characters longer the replacement is than what it replaced. */
+  readonly delta: number;
+}
+
+/** A character above Latin-1 that could not be escaped without changing what the code does. */
+interface UnescapedCharacter {
+  /** One-based, as an editor shows it. */
+  readonly line: number;
+  /** One-based, as an editor shows it. */
+  readonly column: number;
+  readonly character: string;
+}
+
+interface EscapedCode {
+  readonly code: string;
+  readonly columnShifts: ColumnShift[];
+  readonly unescapedCharacters: UnescapedCharacter[];
+}
+
+const nonAscii = /[\u0080-\uffff]/g;
+
+/**
+ * Escapes every character outside ASCII that esbuild's `charset: "ascii"` leaves as it is: those in
+ * comments, which esbuild keeps verbatim, and those in regular expression literals. In both, `\uXXXX`
+ * (a surrogate pair as two of them) means what the character did, with or without the `u` flag.
+ *
+ * A character anywhere else is left alone and reported: esbuild escapes strings, untagged template
+ * literals and identifiers already, so what remains is a tagged template literal, whose raw text the
+ * tag can read (`String.raw`), or a line or paragraph separator in a comment, where it ends a line.
+ */
+const escapeNonAscii = (code: string): EscapedCode => {
+  nonAscii.lastIndex = 0;
+
+  if (!nonAscii.test(code)) {
+    return { code, columnShifts: [], unescapedCharacters: [] };
+  }
+
+  const escapableRanges = getRangesOfCommentsAndRegularExpressions(code);
+  const pieces: string[] = [];
+  const columnShifts: ColumnShift[] = [];
+  const unescapedCharacters: UnescapedCharacter[] = [];
+
+  let copiedUntil = 0;
+  let rangeIndex = 0;
+  let line = 0;
+  let lineStart = 0;
+
+  nonAscii.lastIndex = 0;
+
+  for (let match = nonAscii.exec(code); match; match = nonAscii.exec(code)) {
+    const position = match.index;
+
+    for (let newline = code.indexOf("\n", lineStart); newline !== -1 && newline < position; ) {
+      line++;
+      lineStart = newline + 1;
+      newline = code.indexOf("\n", lineStart);
+    }
+
+    while (rangeIndex < escapableRanges.length && escapableRanges[rangeIndex].end <= position) {
+      rangeIndex++;
+    }
+
+    const range = escapableRanges[rangeIndex];
+    const characterCode = code.charCodeAt(position);
+    const isLineTerminator = characterCode === 0x2028 || characterCode === 0x2029;
+
+    if (!range || range.start > position || isLineTerminator) {
+      if (characterCode > 0xff) {
+        unescapedCharacters.push({ line: line + 1, column: position - lineStart + 1, character: match[0] });
+      }
+
+      continue;
+    }
+
+    // In a regular expression `\—` is an identity escape of the character, which `\\u2014` would not be.
+    const replacedFrom =
+      range.kind === "regular-expression" && isEscapedByBackslash(code, position) ? position - 1 : position;
+
+    const replacement = `\\u${characterCode.toString(16).toUpperCase().padStart(4, "0")}`;
+
+    pieces.push(code.slice(copiedUntil, replacedFrom), replacement);
+    copiedUntil = position + 1;
+
+    columnShifts.push({
+      line,
+      column: replacedFrom - lineStart,
+      delta: replacement.length - (copiedUntil - replacedFrom),
+    });
+  }
+
+  pieces.push(code.slice(copiedUntil));
+
+  return { code: pieces.join(""), columnShifts, unescapedCharacters };
+};
+
+/**
+ * Moves the generated columns of a source map's mappings as the escaping moved the code. Works on the
+ * bytes: the mappings are ASCII, and decoding the sources' contents around them would take long.
+ */
+const shiftColumnsOfSourceMap = (sourceMap: Buffer, columnShifts: ColumnShift[]): Buffer => {
+  const key = sourceMap.indexOf('"mappings"');
+
+  if (key === -1 || columnShifts.length === 0) {
+    return sourceMap;
+  }
+
+  const start = sourceMap.indexOf('"', sourceMap.indexOf(":", key)) + 1;
+  const end = sourceMap.indexOf('"', start);
+  const mappings = sourceMap.toString("latin1", start, end);
+  const shiftsOfLines = [...Map.groupBy(columnShifts, (shift) => shift.line)].sort(([left], [right]) => left - right);
+  const pieces: string[] = [];
+
+  let line = 0;
+  let lineStart = 0;
+  let copiedUntil = 0;
+
+  for (const [lineToShift, shifts] of shiftsOfLines) {
+    while (line < lineToShift && lineStart !== -1) {
+      const semicolon = mappings.indexOf(";", lineStart);
+
+      lineStart = semicolon === -1 ? -1 : semicolon + 1;
+      line++;
+    }
+
+    if (lineStart === -1) {
+      break;
+    }
+
+    const semicolon = mappings.indexOf(";", lineStart);
+    const lineEnd = semicolon === -1 ? mappings.length : semicolon;
+
+    pieces.push(mappings.slice(copiedUntil, lineStart), shiftColumnsOfLine(mappings.slice(lineStart, lineEnd), shifts));
+    copiedUntil = lineEnd;
+  }
+
+  pieces.push(mappings.slice(copiedUntil));
+
+  return Buffer.concat([sourceMap.subarray(0, start), Buffer.from(pieces.join(""), "latin1"), sourceMap.subarray(end)]);
+};
+
+/**
+ * Escapes what esbuild left outside ASCII in the bundle it wrote to `outfile`, and moves the columns
+ * of its source map to match. A string of the source of a script is one byte per character in V8
+ * only when every character of it is Latin-1: a single em dash in a comment makes it two.
+ */
+export const asciiOutputPlugin = (): Plugin => ({
+  name: "ascii-output",
+
+  setup: (build) => {
+    build.onEnd(async (result) => {
+      const { outfile, write } = build.initialOptions;
+
+      if (result.errors.length > 0 || !outfile || write === false) {
+        return;
+      }
+
+      const code = await readFile(outfile, "utf8");
+
+      let escaped: EscapedCode;
+
+      try {
+        escaped = escapeNonAscii(code);
+      } catch (error) {
+        return { warnings: [{ text: `Left ${outfile} as it is, failing to escape it: ${String(error)}` }] };
+      }
+
+      if (escaped.code !== code) {
+        await writeFile(outfile, escaped.code);
+        await shiftColumnsOfSourceMapFile(`${outfile}.map`, escaped.columnShifts);
+      }
+
+      return { warnings: getWarnings(outfile, escaped.unescapedCharacters) };
+    });
+  },
+});
+
+interface EscapableRange {
+  readonly kind: "comment" | "regular-expression";
+  readonly start: number;
+  readonly end: number;
+}
+
+const getRangesOfCommentsAndRegularExpressions = (code: string): EscapableRange[] => {
+  const comments: EscapableRange[] = [];
+  const regularExpressions: EscapableRange[] = [];
+
+  const tokens = tokenizer(code, {
+    ecmaVersion: "latest",
+    sourceType: "script",
+    allowHashBang: true,
+    allowReturnOutsideFunction: true,
+    allowAwaitOutsideFunction: true,
+    onComment: (_, __, start, end) => {
+      comments.push({ kind: "comment", start, end });
+    },
+  });
+
+  for (const token of tokens) {
+    if (token.type === tokTypes.regexp) {
+      // The flags after the closing slash are letters.
+      const closingSlash = code.lastIndexOf("/", token.end - 1);
+
+      regularExpressions.push({ kind: "regular-expression", start: token.start + 1, end: closingSlash });
+    }
+  }
+
+  return mergeSorted(comments, regularExpressions);
+};
+
+const mergeSorted = (left: EscapableRange[], right: EscapableRange[]) => {
+  const merged: EscapableRange[] = [];
+  let leftIndex = 0;
+  let rightIndex = 0;
+
+  while (leftIndex < left.length || rightIndex < right.length) {
+    if (rightIndex >= right.length || (leftIndex < left.length && left[leftIndex].start < right[rightIndex].start)) {
+      merged.push(left[leftIndex++]);
+    } else {
+      merged.push(right[rightIndex++]);
+    }
+  }
+
+  return merged;
+};
+
+const isEscapedByBackslash = (code: string, position: number) => {
+  let backslashes = 0;
+
+  while (code[position - 1 - backslashes] === "\\") {
+    backslashes++;
+  }
+
+  return backslashes % 2 === 1;
+};
+
+// Read without checking first that it is there, which the file could stop being in between: a
+// bundle built without a source map simply has none to shift.
+const shiftColumnsOfSourceMapFile = async (path: string, columnShifts: ColumnShift[]) => {
+  let sourceMap: Buffer;
+
+  try {
+    sourceMap = await readFile(path);
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+      return;
+    }
+
+    throw error;
+  }
+
+  await writeFile(path, shiftColumnsOfSourceMap(sourceMap, columnShifts));
+};
+
+// Within a line, a segment's generated column is relative to the previous segment's, and its
+// other fields relative to the previous segment's of the whole map: only the column changes.
+const shiftColumnsOfLine = (line: string, shifts: ColumnShift[]) => {
+  if (line === "") {
+    return line;
+  }
+
+  const sortedShifts = shifts.toSorted((left, right) => left.column - right.column);
+
+  let shiftIndex = 0;
+  let shiftSoFar = 0;
+  let column = 0;
+  let previousShiftedColumn = 0;
+
+  return line
+    .split(",")
+    .map((segment) => {
+      const { value, length } = decodeVlq(segment);
+
+      column += value;
+
+      while (shiftIndex < sortedShifts.length && sortedShifts[shiftIndex].column < column) {
+        shiftSoFar += sortedShifts[shiftIndex++].delta;
+      }
+
+      const shiftedColumn = column + shiftSoFar;
+      const shiftedSegment = encodeVlq(shiftedColumn - previousShiftedColumn) + segment.slice(length);
+
+      previousShiftedColumn = shiftedColumn;
+
+      return shiftedSegment;
+    })
+    .join(",");
+};
+
+const base64Digits = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+const decodeVlq = (segment: string) => {
+  let result = 0;
+  let shift = 0;
+  let length = 0;
+  let digit: number;
+
+  do {
+    digit = base64Digits.indexOf(segment[length++]);
+    result += (digit & 31) * 2 ** shift;
+    shift += 5;
+  } while (digit & 32);
+
+  const magnitude = Math.floor(result / 2);
+
+  return { value: result % 2 === 1 ? -magnitude : magnitude, length };
+};
+
+const encodeVlq = (value: number) => {
+  let rest = value < 0 ? -value * 2 + 1 : value * 2;
+  let encoded = "";
+
+  do {
+    const digit = rest % 32;
+
+    rest = Math.floor(rest / 32);
+    encoded += base64Digits[rest > 0 ? digit | 32 : digit];
+  } while (rest > 0);
+
+  return encoded;
+};
+
+const getWarnings = (outfile: string, unescapedCharacters: UnescapedCharacter[]) =>
+  unescapedCharacters.length === 0
+    ? []
+    : [
+        {
+          text: `${unescapedCharacters.length} characters above Latin-1 could not be escaped in ${outfile}, which V8 therefore keeps at two bytes per character: ${unescapedCharacters
+            .slice(0, 5)
+            .map(({ line, column, character }) => `"${character}" at ${line}:${column}`)
+            .join(", ")}`,
+        },
+      ];

package/src/declared-imports-plugin.test.ts

@@ -0,0 +1,129 @@
+import { build } from "esbuild";
+import path from "node:path";
+import { type DeclaredImportsPluginParams, declaredImportsPlugin } from "./declared-imports-plugin";
+
+// A package of the Lens monorepo has a "lens" section in its package.json.
+const ofMonorepo = { lens: {} };
+
+describe("imports of other packages in a package build", () => {
+  describe("given the imported package is declared in dependencies, when built", () => {
+    let exportsOfBundle: Record<string, unknown>;
+
+    beforeAll(async () => {
+      const bundle = await buildFixture({ dependencies: { lodash: "^4.0.0" } });
+
+      exportsOfBundle = evaluate(bundle);
+    });
+
+    it("requires the package at runtime instead of inlining it", () => {
+      expect(exportsOfBundle.identity).toBe("some-required-lodash/identity");
+    });
+
+    it("requires node builtins at runtime", () => {
+      expect(exportsOfBundle.sep).toBe("some-required-node:path");
+    });
+  });
+
+  it("given the imported package is declared in peerDependencies, when built, requires it at runtime", async () => {
+    const bundle = await buildFixture({ peerDependencies: { lodash: "^4.0.0" } });
+
+    expect(evaluate(bundle).identity).toBe("some-required-lodash/identity");
+  });
+
+  it("given a package of the monorepo imports a package that is only a devDependency, when built, fails naming the import, the importer and the fix", async () => {
+    await expect(buildFixture({ ...ofMonorepo, devDependencies: { lodash: "^4.0.0" } })).rejects.toThrow(
+      [
+        '"@some-scope/package-importing-a-package" imports "lodash/identity" from "index.js", but "lodash" is only a devDependency, so the build would inline it, and everything it imports, into dist.',
+        'Fix: move "lodash" to "dependencies" (or "peerDependencies") if production code needs it.',
+        "If it is test machinery, keep the import out of files the entry point reaches.",
+        'If inlining it is deliberate, list "lodash" in "lens.inlinedDependencies" of package.json.',
+      ].join("\n"),
+    );
+  });
+
+  it("given the imported package is a devDependency declared as inlined, when built, inlines it", async () => {
+    const bundle = await buildFixture({
+      devDependencies: { lodash: "^4.0.0" },
+      lens: { inlinedDependencies: ["lodash"] },
+    });
+
+    expect((evaluate(bundle).identity as (value: string) => string)("some-value")).toBe("some-value");
+  });
+
+  it("given the imported package is declared as inlined but not as a devDependency, when built, fails naming the fix", async () => {
+    await expect(buildFixture({ lens: { inlinedDependencies: ["lodash"] } })).rejects.toThrow(
+      '"@some-scope/package-importing-a-package" imports "lodash/identity" from "index.js", and "lens.inlinedDependencies" lists "lodash", but it is not a devDependency. Fix: declare it in "devDependencies".',
+    );
+  });
+
+  it("given a package of the monorepo imports a package not declared at all, when built, fails naming the import, the importer and the fix", async () => {
+    await expect(buildFixture(ofMonorepo)).rejects.toThrow(
+      '"@some-scope/package-importing-a-package" imports "lodash/identity" from "index.js", but "lodash" is not a dependency of the package. Fix: declare it in "dependencies" (or "peerDependencies").',
+    );
+  });
+
+  describe("given a package outside the monorepo, such as an extension, imports a package that is only a devDependency, when built", () => {
+    let result: Awaited<ReturnType<typeof buildFixtureWithWarnings>>;
+
+    beforeAll(async () => {
+      result = await buildFixtureWithWarnings({ devDependencies: { lodash: "^4.0.0" } });
+    });
+
+    it("inlines it, as the build did before", () => {
+      expect((evaluate(result.bundle).identity as (value: string) => string)("some-value")).toBe("some-value");
+    });
+
+    it("warns naming the import, the importer and the fix", () => {
+      expect(result.warnings).toEqual([
+        expect.stringContaining(
+          '"@some-scope/package-importing-a-package" imports "lodash/identity" from "index.js", but "lodash" is only a devDependency',
+        ),
+      ]);
+    });
+  });
+
+  it("given a package outside the monorepo imports a package not declared at all, when built, warns naming the fix", async () => {
+    const { warnings } = await buildFixtureWithWarnings({});
+
+    expect(warnings).toEqual([expect.stringContaining('Fix: declare it in "dependencies" (or "peerDependencies").')]);
+  });
+});
+
+const buildFixture = async (declarations: Omit<DeclaredImportsPluginParams["packageJson"], "name">) =>
+  (await buildFixtureWithWarnings(declarations)).bundle;
+
+const buildFixtureWithWarnings = async (declarations: Omit<DeclaredImportsPluginParams["packageJson"], "name">) => {
+  const packageDirectory = path.join(__dirname, "__fixtures__", "package-importing-a-package");
+
+  const result = await build({
+    entryPoints: [path.join(packageDirectory, "index.js")],
+    bundle: true,
+    write: false,
+    format: "cjs",
+    platform: "node",
+    logLevel: "silent",
+    plugins: [
+      declaredImportsPlugin({
+        packageDirectory,
+        packageJson: { name: "@some-scope/package-importing-a-package", ...declarations },
+      }),
+    ],
+  });
+
+  return {
+    bundle: result.outputFiles[0].text,
+    warnings: result.warnings.map(({ text }) => text),
+  };
+};
+
+const evaluate = (bundle: string) => {
+  const module = { exports: {} as Record<string, unknown> };
+  const requireStub = (specifier: string) =>
+    specifier === "node:path"
+      ? { sep: `some-required-${specifier}` }
+      : { __esModule: true, default: `some-required-${specifier}` };
+
+  new Function("require", "module", "exports", bundle)(requireStub, module, module.exports);
+
+  return module.exports;
+};