text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_prefix|>"use strict";
const supportsRequireInModule = require("../../<|fim_suffix|>uireInModule");
module.exports = () => supportsRequireInModule();
<|fim_middle|>../helpers/supportsReq<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>,
priority: -10,
chunks: "initial",
reuseExistingChunk: true
},
default: {
minChunks: 2,
priority: -20,
reuseExistingChunk: true
}
}
},
runtimeChunk: {
name: "runtime"
},
// currently Webpack has bugs when setting concatenateModules to true while ... | fim | webpack/webpack | javascript |
export default 42;
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import common from './common.j<|fim_suffix|>});
<|fim_middle|>s'
it("should work", () => {
expect(common).toBe(42);
<|endoftext|> | fim | webpack/webpack | javascript |
"use strict";
module.exports = {
findBundle() {
return ["./common.mjs", "./bundle0.mjs"];
}
};
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../.<|fim_suffix|>rue
},
target: "es2020",
optimization: {
splitChunks: {
cacheGroups: {
common: {
test: /common\.js/,
minSize: 0,
chunks: "all",
filename: "common.mjs"
}
}
}
}
};
<|fim_middle|>./").Configuration} */
module.... | fim | webpack/webpack | javascript |
<|fim_suffix|>te();
});
<|fim_prefix|>it("should work", async () => {
const worker = new Worker(new URL("./worker.js", import.meta.url), {
type: "module"
});
worker.pos<|fim_middle|>tMessage("ok");
const result = await new Promise(resolve => {
worker.onmessage = event => {
resolve(event.data);
};
});
exp... | fim | webpack/webpack | javascript |
<|fim_prefix|>export<|fim_suffix|>();
}
<|fim_middle|> default function upper(str) {
return str.toUpperCase<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";<|fim_suffix|>s = {
// findBundle() {
// return ["./common.mjs", "./bundle0.mjs"];
// }
};
<|fim_middle|>
module.export<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>rker");
module.exports = () => supportsWorker();
<|fim_prefix|>"use strict";
const supportsWorker = require("<|fim_middle|>../../../helpers/supportsWo<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
output: {
module: true
},
experiments: {
outputModule: true
},
target: ["web", "es2020"],
optimiz<|fim_suffix|>ize: 1
}
}
};
<|fim_middle|>ation: {
splitChunks: {
minSize: 1,
maxS<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ta)}, thanks`);
};
<|fim_prefix|>import upp<|fim_middle|>er from "./module.js";
self.onmessage = async event => {
postMessage(`data: ${upper(event.da<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>const pathModule = <|fim_suffix|>ack_require__('path');
export default pathModule;
<|fim_middle|>__non_webp<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import path<|fim_suffix|>le from "./common.js";
it("should work", () => {
expect(typeof pathModule.dirname).toBe("function");
});
<|fim_middle|>Modu<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const supportsRequireInM<|fim_suffix|>equireInModule();
<|fim_middle|>odule = require("../../../helpers/supportsRequireInModule");
module.exports = () => supportsR<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>utModule: true
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
d<|fim_middle|>evtool: "eval-source-map",
target: "node",
experiments: {
outp<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>lt "common";<|fim_prefix|>export d<|fim_middle|>efau<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import common from "./common";
it(<|fim_suffix|>ct(common).toBe("common");
});
export default "main";
<|fim_middle|>"should compile", () => {
expe<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use str<|fim_suffix|>Bundle() {
return ["./main.mjs"];
}
};
<|fim_middle|>ict";
module.exports = {
find<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>"[name].mjs",
library: {
type: "module"
}
},
target: ["web", "es2020"],
experiments: {
outputModule: true
},
optimization: {
minimize: false,
runtimeChunk: false,
concatenateModules: true
}
});
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exp... | fim | webpack/webpack | javascript |
<|fim_suffix|>lt "foo"
<|fim_prefix|><|fim_middle|>export defau<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>er.js.map<|fim_prefix|>import foo from './foo'
export defau<|fim_middle|>lt foo; //# sourceMappingURL=Subscrib<|endoftext|> | fim | webpack/webpack | javascript |
"use strict";
module.exports = {
findBundle() {
return ["./test.mjs"];
}
};
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import lib from "lib";
it("should run correctly", ()<|fim_suffix|>b).toBe("foo");
});
<|fim_middle|> => {
expect(li<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ath, "./lib.mjs")
},
externalsType: "module-import"
}
];
<|fim_prefix|>"use strict";
const path = require("path");
const webpack = require("../../../../");
/** @type {(env: Env, options: TestOptions) => import("../../../../").Configuration[]} */
module.exports = (env, { testPath }) => [
{
output... | fim | webpack/webpack | javascript |
const fileURLToPath = "";
const file = __filename;
const dir = __dirname;
const dir2 = `${__dirname}/`;
module.exports = { file, dir, dir2 };
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import { dir, dir2, file } from './cjs/file.js'
it("should generate correct __dirname", () => {
expect(dir).toMatch(/[\<|fim_suffix|>node-globals$/);
expect(dir2).toMatch(/[\\/]node-globals\/$/);
});
it("should generate correct __filename", () => {
expect(file).toMatch(/[\\/]main.mjs$/);
});
<|fim_mi... | fim | webpack/webpack | javascript |
<|fim_suffix|>n.mjs";
}
};
<|fim_prefix|>"use<|fim_middle|> strict";
module.exports = {
findBundle() {
return "./mai<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @<|fim_suffix|>ilename: "[name].mjs",
module: true
},
experiments: {
outputModule: true
},
target: "node14"
};
<|fim_middle|>type {import("../../../../").Configuration} */
module.exports = {
entry: {
main: "./index.js"
},
output: {
f<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>expo<|fim_suffix|>t "baz module text";
<|fim_middle|>rt defaul<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>port externalOther from "external-other-module";
import baz from "./baz.js";
it("should work with __non_webpack_require__ and ES modules", function () {
const foo = __non_webpack_require__("./mod.js");
expect(foo).toBe("module text");
expect(external).toBe("external module text");
expect(externalOth... | fim | webpack/webpack | javascript |
<|fim_prefix|>mod<|fim_suffix|>dule text";
<|fim_middle|>ule.exports = "mo<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const <|fim_suffix|>./../../helpers/supportsRequireInModule");
module.exports = () => supportsRequireInModule();
<|fim_middle|>supportsRequireInModule = require(".<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> new webpack.sources.RawSource(
"module.exports = 'external module text';\n"
)
);
}
);
});
}
}
]
};
<|fim_prefix|>"use strict";
const webpack = require("../../../../");
/** @type {import("../../../../").Configuration} */
module.exports = {
target: ["node", "... | fim | webpack/webpack | javascript |
<|fim_prefix|>export<|fim_suffix|>on_webpack_require__("./bar");
<|fim_middle|> default __n<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>Require in concatenated modules", function () {
expect(foo).toBe(1);
});
<|fim_prefix|>impo<|fim_middle|>rt foo from "./foo";
it("should generate create<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>;
module.exports = () => supportsRequireInModule();
<|fim_prefix|>"use strict";
const supportsRequireInModule = require("../../../helpers/supportsRequireInModule<|fim_middle|>")<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>options) => {
if (inCacheTest(options)) {
// We will pre-compile twice, and the module cache will result in no warnings in the stats during the third compilation
return [];
}
return [[/__non_webpack_require__ is only allowed in target node/]];
};
<|fim_prefix|>"use strict";
const inCacheTest = (op... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const webpack = require("../../../../");
/** @type {import("../../../../").Configuration[]} */
module.exports = [
{
output: {
module: true
},
target: ["node"],
experiments: {
outputModule: true
},
plugins: [
{
apply(compiler) {
compiler.hooks.compilation.tap(... | fim | webpack/webpack | javascript |
<|fim_prefix|>export d<|fim_suffix|>t 42;
<|fim_middle|>efaul<|endoftext|> | fim | webpack/webpack | javascript |
export default 43;
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>:
case 10:
case 11: {
expect(link.href.startsWith("https://example.com/public/path/")).toBe(true);
}
}
}
const module1 = await import(/* webpackPrefetch: true */ "./chunk1");
expect(module1.default).toBe(43);
});
<|fim_prefix|>// This config need to <|fim_middle|>be set on initial eval... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const path = require("path");
module.exports<|fim_suffix|>return `./${module}`;
}
if (i === 15) {
return `./${path.basename(module)}`;
}
return module;
},
findBundle(i, options) {
switch (i) {
case 2:
case 6:
case 10: {
return `./${options.output.filename}`;
... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const path = require("path");
/** @type {(env: Env, options: TestOptions) => import("../../../../").Configuration[]} */
module.exports = (env, { testPath }) => [
{
devtool: false,
target: "web",
output: {
module: true,
publicPath: "auto"
},
experiments: {
outputModule: ... | fim | webpack/webpack | javascript |
<|fim_suffix|>_.children[__STATS_I__];
expect(stats.modules.length).toBe(__STATS_I__ === 0 ? 6 : 5);
});
<|fim_prefix|>it("should use/not use globalThis", () => {
expect(new URL("./fil<|fim_middle|>e.text", import.meta.url)).toBeDefined();
const stats = __STATS_<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>module.exports = () => supportsGlobalThis();
<|fim_prefix|>"use strict";
con<|fim_middle|>st supportsGlobalThis = require("../../../helpers/supportsGlobalThis");
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {<|fim_suffix|>
},
{
target: "web",
output: {
environment: { globalThis: true }
},
stats: {
runtimeModules: true
}
}
];
<|fim_middle|>import("../../../../").Configuration[]} */
module.exports = [
{
target: "web",
output: {
environment: { globalThis: fals... | fim | webpack/webpack | javascript |
<|fim_suffix|>hould compile and run", () => {
expect(useCall()).toBe(1);
});
<|fim_prefix|>import { useCall } from "./lib";
it(<|fim_middle|>"s<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>he require function
/******/ function __webpack_require__(moduleId) {
/******/ // Check if module is in cache
/******/ var cachedModule = __webpack_module_cache__[moduleId];
/******/ if (cachedModule !== undefined) {
/******/ return cachedModule.exports;
/******/ }
/******/ // Create a new ... | fim | webpack/webpack | javascript |
<|fim_suffix|>ateElement(a) { return a; }
<|fim_prefix|>exp<|fim_middle|>ort function cre<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const path = require("path");
/** @type {import("../../../../").Configuration} */
module.exports = {
mode: "development",
devtool: "eval",
optimization: {
concatenateM<|fim_suffix|>lias: {
react: path.resolve(__dirname, "react")
}
}
};
<|fim_middle|>odules: false
},
resolve: {... | fim | webpack/webpack | javascript |
<|fim_suffix|><|fim_prefix|>it("should compile", () => {}<|fim_middle|>);
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
mod<|fim_suffix|>) {
return ["./runtime.mjs", "./main.mjs"];
}
};
<|fim_middle|>ule.exports = {
findBundle(<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
<|fim_suffix|>iguration} */
module.exports = {
output: {
filename: "[name].mjs"
},
target: ["web", "es2020"],
experiments: {
outputModule: true
},
optimization: {
minimize: true,
runtimeChunk: "single"
}
};
<|fim_middle|>/** @type {import("../../../../").Conf<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>2;
<|fim_prefix|>ex<|fim_middle|>port default 4<|endoftext|> | fim | webpack/webpack | javascript |
it("should execute as module", () => {
expect(
(function () {
return !this;
})()
).toBe(true);
});
it("should be able to load a chunk", async () => {
const module = await import("./chunk");
expect(module.default).toBe(42);
});
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>true
},
target: "node14"
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
modul<|fim_middle|>e.exports = {
experiments: {
outputModule: <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import value from "./separate";
import { test as t } from "e<|fim_suffix|>);
it("should circular depend on itself external", () => {
expect(test()).toBe(42);
expect(t()).toBe(42);
});
function test() {
return 42;
}
export { test };
<|fim_middle|>xternal-self";
it("should compile", () => {
expect(va... | fim | webpack/webpack | javascript |
<|fim_suffix|>42;
<|fim_prefix|>export de<|fim_middle|>fault <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>rts = {
findBundle() {
return ["./runtime.mjs", "./separate.mjs", "./main.mjs"];
}
};
<|fim_prefix|><|fim_middle|>"use strict";
module.expo<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> }
}
}
},
externals: {
"external-self": "./main.mjs"
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
mo<|fim_middle|>dule.exports = {
output: {
filename: "[name].mjs",
library: {
type: "module"
}
},
target: ["web", "es2020"],
experiments: {
... | fim | webpack/webpack | javascript |
<|fim_prefix|>import m<|fim_suffix|>oBe("m11111111");
done()
});
export default "index";<|fim_middle|>2 from "./testModule2.js"
it("should compile and evaluate fine", (done) => {
expect(m2()).t<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>e.exports = {
findBundle(i, options) {
return ["main.mjs"];
}
};
<|fim_prefix|>"use stri<|fim_middle|>ct";
modul<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>exp<|fim_suffix|>t const m1 = "m11111111";
<|fim_middle|>or<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>i<|fim_suffix|>n m1;
}<|fim_middle|>mport { m1 } from "./testModule1";
export default function m2() {
retur<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../types").Configuration} */
module.exports = {
mode: "development",
experiments: {
outputModule: true
},
output: {
<|fim_suffix|> minSize: 0,
cacheGroups: {
testModule1: {
test: /testModule1/,
name: "testModule1",
priority: 10,
... | fim | webpack/webpack | javascript |
<|fim_suffix|>
<|fim_prefix|>import { m1 } from "./testModule1.js"
import { m2 } from "./testModule2.js"
it("should compile and evaluate fine", (done) => {
expect(m1).<|fim_middle|>toBeDefined();
expect(m2).toBeDefined();
done()
});<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
modul<|fim_suffix|>e1.mjs", "testModule2.mjs"];
}
};
<|fim_middle|>e.exports = {
findBundle() {
return ["main.mjs", "testModul<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export c<|fim_suffix|>"m11111111";
<|fim_middle|>onst m1 = <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export const m2 = <|fim_suffix|>m2222222";
<|fim_middle|>"<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../types").Configuration} */
module.exports = {
mode: "development",
experiments: {
outputModule: true
},
output: {
module: true,
chunkFormat: "module",
filename: "[name].mjs",
chunkFilename: "[name].chunk.mjs"
},
devtool: false,
optimization: {
... | fim | webpack/webpack | javascript |
<|fim_prefix|>import url from "./file.png";
it("should mark asset modules as side-effect-free via AssetModule", () => {
expect(url).toMatch(/\.png$/);
}<|fim_suffix|>;
<|fim_middle|>)<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>
`${module.identifier()} should have factoryMeta.sideEffectFree === true`
);
}
}
});
});
}
]
};
<|fim_prefix|>"use strict";
/** @type {i<|fim_middle|>mport("../../../../").Configuration} */
module.exports = {
experiments: {
futureDefaults: true
},
module: {
rule... | fim | webpack/webpack | javascript |
<|fim_suffix|>ypeof page).toBe("string");
expect(page).toMatch(/<h1>Hello<\/h1>/);
});
<|fim_prefix|>import page from "./page.html";
import * as style from "./style.css";
it("should create dedicated css and html module classes", () => {
expect(style).toEqual({<|fim_middle|>});
expect(t<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const CssModule = require("../../../../lib/css/CssModule");
const HtmlModule = require("../../../../lib/html/HtmlModule");
/** @type {Map<string, { new (...args: EXPECTED_ANY[]): EXPECTED_ANY }>} */
const expectedClasses = new Map([
["css", CssModule],
["css/auto", CssModule],
["css/glo... | fim | webpack/webpack | javascript |
<|fim_suffix|>it("should create dedicated module classes per module type", () => {
expect(data.ok).toBe(true);
expect(auto).toMatch(/^data:/);
expect(inlined).toMatch(/^data:image\/svg/);
expect(url).toMatch(/\.png$/);
expect(source.trim()).toBe("source");
});
<|fim_prefix|>import data from "./data.json";
import a... | fim | webpack/webpack | javascript |
"use strict";
const AssetModule = require("../../../../lib/asset/AssetModule");
const JavascriptModule = require("../../../../lib/javascript/JavascriptModule");
const JsonModule = require("../../../../lib/json/JsonModule");
/** @type {Map<string, { new (...args: EXPECTED_ANY[]): EXPECTED_ANY }>} */
const expectedClas... | fim | webpack/webpack | javascript |
it("should create dedicated wasm module classes", () =>
import("./async.wat").then((asyncWasm) => {
expect(asyncWasm.add(1, 2)).toBe(3);
return import("./sync.wat").then((syncWasm) => {
expect(syncWasm.add(3, 4)).toBe(7);
});
}));
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const AsyncWasmModule = require("../../../../lib/wasm-async/AsyncWasmModule");
const SyncWasmModule = require("../../../../lib/wasm-sync/SyncWasmModule");
/** @type {Map<string, { new (...args: EXPECTED_ANY[]): EXPECTED_ANY }>} */
const expectedClasses = new Map([
["webassembly/async", As... | fim | webpack/webpack | javascript |
<|fim_prefix|>module.exports<|fim_suffix|>ire("./c");
<|fim_middle|> = requ<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>require("./c");
<|fim_prefix|>mod<|fim_middle|>ule.exports = <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|><|fim_suffix|>.exports = module.id;
<|fim_middle|>module<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>/** @type {import("../../../../").LoaderDefinition} */
module.exports = function (src) {
return `module.<|fim_suffix|> "loader-a" + module.id`;
};
<|fim_middle|>exports =<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|><|fim_prefix|>/** @type {import("../../../../").LoaderDefinition} */
module.exports = function (src) {
return `module.exports = "loader-b" + module.id`;
};<|fim_middle|>
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should assign different names to th<|fim_suffix|>Exp(regex));
expect(require("./a")).toMatch(new RegExp("loader-a" + regex));
expect(require("./b")).toMatch(new RegExp("loader-b" + regex));
});
<|fim_middle|>e same module with different issuers ", function() {
var regex = "\\./c\\.js\\?\\w{4}";
ex... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
mode: "development",
entry: ["./a", "./b", "./test"],
module: {
rules: [
{
test: /c\<|fim_suffix|><|fim_middle|>.js/,
issuer: /a\.js/,
loader: "./loader-a"
},
{
test: /c\.js/,
issuer: /b... | fim | webpack/webpack | javascript |
<|fim_suffix|>unction() {
expect(require("./not-parsed-a")).toBe("ok");
expect(require("./not-parsed-b")).toBe("ok");
});
<|fim_prefix|>it("should correctly export stuff from not parsed<|fim_middle|> modules", f<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>modu<|fim_suffix|>s = "ok";
<|fim_middle|>le.export<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>Object.defineP<|fim_suffix|>});
<|fim_middle|>roperty(module, "exports", {
get: function() {
return "ok";
}
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {impo<|fim_suffix|>d/
}
};
<|fim_middle|>rt("../../../../").Configuration} */
module.exports = {
module: {
noParse: /not-parse<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>rsed modules", function() {
expect(require("./not-parsed-a")).toBe("ok");
expect(require("./not-parsed-b")).toBe("ok");
});
<|fim_prefix|>it("should correctl<|fim_middle|>y export stuff from not pa<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>= "ok";
<|fim_prefix|>module<|fim_middle|>.exports <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>Object.def<|fim_suffix|>
<|fim_middle|>ineProperty(module, "exports", {
get: function() {
return "ok";
}
});<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>eturn /not-parsed/.test(content);
}
}
};
<|fim_prefix|>"use strict";
/** @type {impor<|fim_middle|>t("../../../../").Configuration} */
module.exports = {
module: {
noParse(content) {
r<|endoftext|> | fim | webpack/webpack | javascript |
const path = require("path");
const { dirname, filename } = require("./commonjs.js");
it("should bundle", async () => {
const __dirname = __STATS__.children[__STATS_I__].outputPath;
const __filename = path.join(__STATS__.children[__STATS_I__].outputPath, `./bundle${__STATS_I__}.js`);
expect(dirname).toBe(__dirname... | fim | webpack/webpack | javascript |
<|fim_suffix|>rname;
const filename = __filename;
module.exports = { dirname, filename }
<|fim_prefix|>const dirnam<|fim_middle|>e = __di<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>const { di<|fim_suffix|>ename } = import.meta;
export { dirname, filename };
<|fim_middle|>rname, fil<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import path from "path";
import { dirname, filename } from "./esm.js"
import { dirname as otherDirname,<|fim_suffix|>_].outputPath, `./bundle${__STATS_I__}.mjs`);
expect(dirname).toBe(__dirname);
expect(filename).toBe(__filename);
expect(otherDirname).toBe(__dirname);
expect(otherFilename).toBe(__fil... | fim | webpack/webpack | javascript |
<|fim_suffix|>onst filename = import.meta.filename;
export { dirname, filename }
<|fim_prefix|>const d<|fim_middle|>irname = import.meta.dirname;
c<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>
<|fim_prefix|>import path from "path";
import { dirname as dirnameCommonJS, filename as filenameCommonJS } from "./commonjs.js"
import { dirname as dirnameESM, filename as filenameESM } from "./esm.js"
import { dirname as otherDirnameESM, filename as otherFilenameESM } from "./destructuring.js"
const __... | fim | webpack/webpack | javascript |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.