text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_prefix|>
function __webpack_require__() {return 42}
__webpack_require__<|fim_suffix|>rt {__webpack_require__}
<|fim_middle|>.m = () => {}
expo<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>quire__;
}
export default __webpack_require__;
<|fim_prefix|>function __webpack_require__() {
var __webpack_require__ = { foo: 42 };
return __webpa<|fim_middle|>ck_re<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>require__, __webpack_exports__ };
<|fim_prefix|>var __webpack_require__ = { foo: 42 };
var<|fim_middle|> __webpack_exports__ = { foo: 42 };
class Foo {}
export { __webpack_<|endoftext|> | fim | webpack/webpack | javascript |
"use strict";
/** @type {import("../../../../types").Configuration} */
module.exports = [
{
node: false,
mode: "production",
devtool: false,
optimization: {
concatenateModules: true
}
},
{
node: false,
mode: "production",
devtool: false,
optimization: {
concatenateModules: false
}
},
{
... | fim | webpack/webpack | javascript |
<|fim_suffix|>ue = -1
const index_src_value_0 = -1
expect(value1).toBe(undefined)
expect(value).toBe(42)
expect(src_value).toBe(43)
expect(src_src_value).toBe(44)
expect(Symbol).toBe('Symbol')
expect(value2).toBe("undefined") // Should not touch `value` variable in inline module.
expect(value3).toBe("un... | fim | webpack/webpack | javascript |
<|fim_suffix|>{ value }
<|fim_prefix|>let value<|fim_middle|>
export <|endoftext|> | fim | webpack/webpack | javascript |
module.exports = typeof value
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>module<|fim_suffix|>alue
<|fim_middle|>.exports = typeof src_v<|endoftext|> | fim | webpack/webpack | javascript |
module.exports = typeof Symbol
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use stri<|fim_suffix|>ns.node.split(".").map(Number);
return major >= 20;
};
<|fim_middle|>ct";
module.exports = () => {
const [major] = process.versio<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>const fs = require("fs");
const path = require("path");
it("IIFE should present when `avoi<|fim_suffix|>ryIife` is disabled, and avoided when true", () => {
// Should work
});
<|fim_middle|>dEnt<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const meriyah = require("meriyah");
let counter = 0;
/** @typedef {import("estree").SourceLocation} SourceLocation */
/** @typedef {import("estree").Program & { start: number, end: number, loc: SourceLocation }} Program */
/** @typedef {import("estree").Comment & { start: number, end: num... | fim | webpack/webpack | javascript |
<|fim_prefix|>export defa<|fim_suffix|>mon";<|fim_middle|>ult "com<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import common from "./common";
it("should compil<|fim_suffix|>
export default "main";
<|fim_middle|>e", () => {
expect(common).toBe("common");
});<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>;
<|fim_prefix|>export default "<|fim_middle|>separate"<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|><|fim_prefix|>"use strict";
module.exports = {
findBundle() {
retu<|fim_middle|>rn ["./main.mjs"];
}
};
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>"separate.mjs",
enforce: true
}
}
}
},
plugins: [new EntryPlugin(__dirname, "./separate.js", "main")]
});
<|fim_prefix|>"use strict";
const EntryPlugin = require("../../../../").EntryPlugin;
/** @type {import("../../../../types").Configuration} */
module.exports = () => ({
devtool: fals... | fim | webpack/webpack | javascript |
<|fim_prefix|>imp<|fim_suffix|>ate from "./separate";
export default separate;<|fim_middle|>ort separ<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>);
expect(common).toBe("separate");
});
export default "main";
<|fim_prefix|>import separate from "./separate";
import common fr<|fim_middle|>om "./common";
it("should compile", () => {
expect(separate).toBe("separate"<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export default "separa<|fim_suffix|>";
<|fim_middle|>te<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>le() {
return ["./main.mjs"];
}
};
<|fim_prefix|>"use strict";
module.exports = {
<|fim_middle|>findBund<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../types").Configuration} */
module.exports = () => ({
devtool: false,
mode: "development",
entry: {
main: {
import: "./index.js",
dependOn: "shared"
},
shared: "./common.js"
},
output: {
filen<|fim_suffix|>, "es2020"],
experiments: {
output... | fim | webpack/webpack | javascript |
export default "common";<|endoftext|> | fim | webpack/webpack | javascript |
import common from "./common";
import separate from "./separate";
it("should compile", () => {
expect(common).toBe("common");
expect(separate).toBe("separate");
});
export default "main";
<|endoftext|> | fim | webpack/webpack | javascript |
export default "separate";
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
module.ex<|fim_suffix|>orts = {
findBundle() {
return ["./main.mjs"];
}
};
<|fim_middle|>p<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../types").Configuration} */
module.exports = () => ({
devtool: false,
mode: "development",
entry: {
main: {
import: "./index.js",
dependOn: "shared"
},
shared: "./common.js"
},
output: {
filename: "[name].mjs",
library: <|fim_suffix|>ze: fal... | fim | webpack/webpack | javascript |
<|fim_prefix|>import value from "./separate";
it("shou<|fim_suffix|>compile", () => {
expect(value).toBeDefined();
});
export default "main";
<|fim_middle|>ld <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export default<|fim_suffix|>;
<|fim_middle|> 42<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use <|fim_suffix|>in.mjs"];
}
};
<|fim_middle|>strict";
module.exports = {
findBundle() {
return ["./ma<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
mode: "development",
output: {
filename: "[name].mjs",
library: {
type: "module"
}
},
target: ["web", "es2020"],
experiments: {
outputModule: true
},
optimization: {
minimize: false,
runtimeChunk: t... | fim | webpack/webpack | javascript |
<|fim_prefix|>export defau<|fim_suffix|>ommon";<|fim_middle|>lt "c<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>n");
});
export default "main";
<|fim_prefix|>it("should compile", () => {
expect<|fim_middle|>("common").toBe("commo<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>mon;
<|fim_prefix|>import common <|fim_middle|>from "./common";
export default com<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
module<|fim_suffix|>
};
<|fim_middle|>.exports = {
findBundle() {
return ["./main.mjs"];
}<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>target: ["web", "es2020"],
experiments: {
outputModule: true
},
optimization: {
minimize: false,
runtimeChunk: false,
splitChunks: {
cacheGroups: {
separate: {
test: /separate/,
chunks: "all",
filename: "separate.mjs",
enforce: true
},
common: {
test: /co... | fim | webpack/webpack | javascript |
<|fim_suffix|>default "common";<|fim_prefix|>export<|fim_middle|> <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>mmon").toBe("common");
});
export default "main";
<|fim_prefix|>it("should compile", () => {
ex<|fim_middle|>pect("co<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>fault common;
<|fim_prefix|>import common fr<|fim_middle|>om "./common";
export de<|endoftext|> | fim | webpack/webpack | javascript |
"use strict";
module.exports = {
findBundle() {
return ["./main.mjs"];
}
};
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>
enforce: true
},
common: {
test: /common/,
chunks: "all",
filename: "common.mjs",
enforce: true
}
}
}
},
plugins: [new EntryPlugin(__dirname, "./separate.js", "main")]
});
<|fim_prefix|>"use strict";
const EntryPlugin = require("../../../../").EntryPlugin;
/*... | fim | webpack/webpack | javascript |
<|fim_suffix|><|fim_prefix|>import value<|fim_middle|> from "./module";
export default value + 2;
<|endoftext|> | fim | webpack/webpack | javascript |
import imported from "./imported.mjs";
import value from "./module";
import { metaUrl } from "./meta";
const localMetaUrl = import.meta.url;
it("should allow to use externals in concatenated modules", () => {
expect(imported).toBe(42);
expect(value).toBe(40);
});
it("all bundled files should have same url, when par... | fim | webpack/webpack | javascript |
<|fim_suffix|>mport.meta.url;<|fim_prefix|>export <|fim_middle|>const metaUrl = i<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>e<|fim_suffix|> 40;
<|fim_middle|>xport default<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>dle() {
return "./main.mjs";
}
};
<|fim_prefix|><|fim_middle|>"use strict";
module.exports = {
findBun<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
module: {
parser: {
javascript: {
impo<|fim_suffix|>orted: {
import: "./imported.js",
library: {
type: "module"
}
}
},
target: "node14",
output: {
filename: "[name].mjs"
},
externals: "./i... | fim | webpack/webpack | javascript |
<|fim_prefix|>import { value as value1 } from './module1'
const value2 = require('./module2')
const value3 = require('./module3')
const value4 = require('./module4')
let value = 42
let src_value = 43
let src_src_value = 44
let Symbol = 'Symbol'
it('inlined module should not leak to non-inl<|fim_suffix|>ue4).toBe("fun... | fim | webpack/webpack | javascript |
<|fim_suffix|>alue
export { value }
<|fim_prefix|>let <|fim_middle|>v<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>e
<|fim_prefix|>module.exports =<|fim_middle|> typeof valu<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>module.<|fim_suffix|>value
<|fim_middle|>exports = typeof src_<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>module.ex<|fim_suffix|>Symbol
<|fim_middle|>ports = typeof <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>fe-false.mjs",
"module-avoidEntryIife-true.mjs",
"test.js"
];
}
};
<|fim_prefix|>"use strict";
module.e<|fim_middle|>xports = {
findBundle() {
return [
"module-avoidEntryIi<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>nst other modules in the chunk.');
});
<|fim_prefix|>const fs = require("fs");
const path = require("path");
it("IIFE should present when `avoidEntryIife` is disabled, and avoided when true", () => {
const trueSource = fs.readFileSync(path.join(__dirname, "module-avoidEntryIife-true.mjs"), "utf-8");
<|... | fim | webpack/webpack | javascript |
<|fim_suffix|>"
},
optimization: {
...base.optimization,
avoidEntryIife: true
}
},
{
name: "test-output",
entry: "./test.js",
output: {
filename: "test.js"
}
}
];
<|fim_prefix|>"use strict";
/** @type {import("../../../../types").Configuration} */
const base = {
ou<|fim_middle|>tput: {
mod... | fim | webpack/webpack | javascript |
<|fim_suffix|>n IIFE to isolate from other inlined modules and chunk modules", () => {
expect(answer).toBe("yes"); // the code should throw in strict mode
});
<|fim_prefix|>import foo from './<|fim_middle|>foo.cjs';
let answer
try {
delete Object.prototype; // will throw error in strict mode
answer = 'no';
}... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
module.exports = {
find<|fim_suffix|>s"];
}
};
<|fim_middle|>Bundle() {
return ["test.j<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>js"), "utf-8");
expect(source).toContain(`This entry needs to be wrapped in an IIFE because it needs to be in strict mode.`);
});
<|fim_prefix|>const fs = require("fs");
const path = require("path");
it("IIFE<|fim_middle|> should present for inner strict", () => {
const source = fs.readFileSync(path.jo... | fim | webpack/webpack | javascript |
<|fim_suffix|>y: "./test.js",
output: {
filename: "test.js"
}
}
];
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration[]} */
module.exports = [
<|fim_middle|>{
entry: ["./index.mjs"],
output: {
module: false
}
},
{
name: "test-output",
entr<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>getFirst() {
return "first";
}
<|fim_prefix|>e<|fim_middle|>xport function <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> getFirst();
it("the first concatenated entry runs in the shared startup scope", () => {
expect(firstValue).toBe("first");
});
<|fim_prefix|>import { getFirst } from <|fim_middle|>"./first-dep.js";
const firstValue =<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>"second";
}
<|fim_prefix|>export function getSecond() {
<|fim_middle|> return <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import {<|fim_suffix|>collisions", () => {
expect(secondValue).toBe("second");
});
<|fim_middle|> getSecond } from "./second-dep.js";
const secondValue = getSecond();
it("the second concatenated entry shares scope without <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
module.exports = {
findBundle() {
return ["concat-true.mj<|fim_suffix|>
};
<|fim_middle|>s", "test.js"];
}<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>const fs = require("fs");
const path = require("path");
<|fim_suffix|> is kept when the optimization is disabled
expect(read("concat-false.mjs")).toContain(MARKER);
});
<|fim_middle|>
const read = (file) => fs.readFileSync(path.join(__dirname, file), "utf-8");
const MARKER = "isolated against other entry... | fim | webpack/webpack | javascript |
<|fim_suffix|>ation: { ...base.optimization, avoidEntryIife: true }
},
{
...base,
name: "concat-false",
output: { ...base.output, filename: "concat-false.mjs" },
optimization: { ...base.optimization, avoidEntryIife: false }
},
{
name: "test-output",
entry: "./test.js",
output: {
filename: "test.js"... | fim | webpack/webpack | javascript |
<|fim_suffix|>rn "first";
}
<|fim_prefix|>export function getFirs<|fim_middle|>t() {
retu<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>from leaking into this scope
expect(typeof value).toBe("undefined");
});
<|fim_prefix|>import { getFirst } from "./first-dep.js";
it("isolates second's top-level `<|fim_middle|>value` from first without an IIFE", () => {
expect(getFirst()).toBe("first");
// second declares `value`; renaming keeps it <... | fim | webpack/webpack | javascript |
<|fim_prefix|>export function getSecond() {
return<|fim_suffix|>second";
}
<|fim_middle|> "<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>IIFE", () => {
expect(shorthand.value).toBe(42);
expect(getSecond()).toBe("second");
});
<|fim_prefix|>import { getSecond } from "./second-dep.js";
var value = 42;
const shorthand = { value };
// `value` collides with first's globa<|fim_middle|>l read, so it is renamed; the object
// shorthand must be... | fim | webpack/webpack | javascript |
<|fim_suffix|>
<|fim_prefix|>"use strict";
module.exports = {
findBundle() {
return ["collide-true.mjs", "te<|fim_middle|>st.js"];
}
};<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>const fs = requir<|fim_suffix|>tion by renaming instead of an IIFE", () => {
// `value` collides (first reads it as a global, second declares it); the
// codegen-data fast path must bail out so the collision is renamed away
expect(read("collide-true.mjs")).not.toContain(MARKER);
// ...while disabling ... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
const base = {
entry: ["./first.js", "./second.js"],
output: {
module: true
<|fim_suffix|>ization, avoidEntryIife: true }
},
{
...base,
name: "collide-false",
output: { ...base.output, filename: "collide-false.mjs" },
optimi... | fim | webpack/webpack | javascript |
<|fim_suffix|>/ index2 declares `value`; renaming keeps it from leaking into index1, so the
// per-entry IIFE is not needed.
expect(typeof value).toBe("undefined");
});
<|fim_prefix|>it("isolates index2's top-level `value` from index1 without a<|fim_middle|>n IIFE", () => {
/<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ct
// shorthand must be rewritten to `{ value: <renamed> }`.
it("renames index2's `value`, including the object shorthand, without an IIFE", () => {
expect(shorthand.value).toBe(42);
});
<|fim_prefix|>var <|fim_middle|>value = 42;
const shorthand = { value };
// `value` collides with index1's global rea... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
module.exports = {
findBundle() {
return ["avoid.mjs", "test.js"];<|fim_suffix|>;
<|fim_middle|>
}
}<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>const fs = require("fs");
const path = require("path");
const read = (file) => fs<|fim_suffix|> a global, index2 declares it); with
// avoidEntryIife the collision is renamed away and no IIFE is emitted...
expect(read("avoid.mjs")).not.toContain(MARKER);
// ...while disabling the optimization keeps th... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
const base = {
entry: ["./index1.js", "./index2.js"],
output: {
module: true
},
optimization: {
concatenateModules: true
},
experiments: {
outputModule: true
},
target: "es2020"
<|fim_suffix|>oidEntryIife: false }
},
{
na... | fim | webpack/webpack | javascript |
var result = "side-effect";
// Keep `result` as a real top-level declaration so it collides with second.js's
// exported `result`; the branch never runs (Math.random is not statically known,
// so the declaration survives) and needs no global.
if (Math.random() < 0) {
throw new Error(result);
}
<|endoftext|> | fim | webpack/webpack | javascript |
// `result` collides with first.js's top-level `result`; as the library entry its
// exported binding must be renamed internally yet still exported as `result`.
export const result = "exported";
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>
};
<|fim_prefix|>"use strict";
module.exports = {
findBundle() {<|fim_middle|>
return ["test.js"];
}<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ult`; it is renamed
// internally but still exported with the correct value
const mod = new Module(libPath);
mod.filename = libPath;
mod._compile(source, libPath);
expect(mod.exports.result).toBe("exported");
});
<|fim_prefix|>const fs = require("fs");
const path = require("path");
const Module = req... | fim | webpack/webpack | javascript |
"use strict";
/** @type {import("../../../../").Configuration[]} */
module.exports = [
{
entry: ["./first.js", "./second.js"],
output: {
filename: "lib.js",
library: {
type: "commonjs2"
}
},
optimization: {
concatenateModules: true,
avoidEntryIife: true
},
target: "node"
},
{
name: ... | fim | webpack/webpack | javascript |
<|fim_suffix|>;
<|fim_prefix|>const firstOnly = "first";
it("the firs<|fim_middle|>t inlined entry runs in the shared startup scope", () => {
expect(firstOnly).toBe("first");
})<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>const secondOnly = "second";
// Both entry modules share the startup scope (no per-entry IIFE); their disjoint
// top-level names don't clash, so each runs correctly.
it("the second inlined entry shares scope without<|fim_suffix|>ndOnly).toBe("second");
});
<|fim_middle|> collisions", () => {
expect(sec... | fim | webpack/webpack | javascript |
"use strict";
module.exports = {
findBundle() {
return ["nocollide-true.mjs", "test.js"];
}
};
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ontain(MARKER);
});
<|fim_prefix|>const fs = require("fs");
const path = require("path");
const read = (file) => fs.readFileSync(<|fim_middle|>path.join(__dirname, file), "utf-8");
const MARKER = "isolated against other entry modules";
it("avoids the per-entry IIFE for multiple inlined entries without c... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/<|fim_suffix|>
};
/** @type {import("../../../../").Configuration[]} */
module.exports = [
{
...base,
name: "nocollide-true",
output: { ...base.output, filename: "nocollide-true.mjs" },
optimization: { ...base.optimization, avoidEntryIife: true }
},
{
...base,
name: "nocoll... | fim | webpack/webpack | javascript |
<|fim_suffix|>
expect(UNKNOWN_PROPERTY).toBe("HELLO");
expect(typeof import.meta.UNKNOWN_PROPERTY).toBe("string");
expect(typeof import.meta.webpack).toBe("number");
const {
UNKNOWN_PROPERTY: UNKNOWN_PROPERTY_2,
webpack: WEBPACK_PROPERTY_2
} = import.meta;
expect(UNKNOWN_PROPERTY_2).toBe("HELLO");
... | fim | webpack/webpack | javascript |
<|fim_suffix|>;
<|fim_prefix|>"use strict";
/** @t<|fim_middle|>ype {import("../../../../types").Configuration} */
module.exports = {
experiments: {
outputModule: true
},
output: {
module: true,
chunkFormat: "module"
}
}<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should work import.meta.env with EnvironmentPlugin", () => {
expect(import.meta.env.AAA).toBe(process.env.AAA);
});
it("<|fim_suffix|>v = process.env;
processEnv;
const UNKNOWN_PROPERTY = import.meta.env.UNKNOWN_PROPERTY;
UNKNOWN_PROPERTY;
const UNKNOWN_PROPERTY_2 ... | fim | webpack/webpack | javascript |
<|fim_suffix|>s: "commonjs fs"
}
};
<|fim_prefix|>"use strict";
const EnvironmentPlugin = require("../../../../").EnvironmentPlugin;
/** @type {import("../../../../").Configuration} */
module.exports = {
target: "node12.18",
dotenv: true,
plugins: [
new EnvironmentPlugin({
AAA: "aaa"
})
],
experiments: {... | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should allow to match rules by import phase", async () => {
const evaluation = await import("./module.js");
const deferred = await import.defer("<|fim_suffix|><|fim_middle|>./module.js");
const source = await import.source("./module.js");
expect(evaluation.default).toBe("evaluation");
expect(def... | fim | webpack/webpack | javascript |
<|fim_prefix|>export<|fim_suffix|>k";
<|fim_middle|> const value = "o<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/*<|fim_suffix|>tions = this.getOptions();
return `${source}\nexport default ${JSON.stringify(
options.phase
)};\n`;
};
<|fim_middle|>* @typedef {import("../../../../types").LoaderDefinition<{ phase: string }>} LoaderDefinition */
/** @type {LoaderDefinition} */
module.exports = funct... | fim | webpack/webpack | javascript |
<|fim_suffix|> test: /module\.js$/,
phase: "source",
loader: "./phase-loader.js",
options: {
phase: "source"
}
},
{
test: /module\.js$/,
phase: "evaluation",
loader: "./phase-loader.js",
options: {
phase: "evaluation"
}
}
]
}
};
<|fim_prefix|>"use strict";
/**... | fim | webpack/webpack | javascript |
<|fim_suffix|>ath.floor);
export default result["6"];
<|fim_prefix|>import { countBy } from "lodash-<|fim_middle|>es";
import "./bar.css";
const result = countBy([6.1, 4.2, 6.3], M<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>efault result[0];
<|fim_prefix|>import { dropRight } from "lodash-es"<|fim_middle|>;
import "./foo.css";
const result = dropRight([10, 20, 30], 2);
export d<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>\.\/style\.mjs"/g
);
expect(foo + bar).toBe(12);
});
<|fim_prefix|>import foo from "./foo.js";
import bar from "./bar.js";
it("should not contain non javascript chunk in the main bundle", () =><|fim_middle|> {
const fs = require("fs");
const source = fs.readFileSync(__STATS__.outputPath + "/main.mjs"... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
m<|fim_suffix|> findBundle() {
return ["main.mjs", "vendor.mjs", "runtime.mjs"];
}
};
<|fim_middle|>odule.exports = {
<|endoftext|> | fim | webpack/webpack | javascript |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.