text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_suffix|>ncat");
<|fim_prefix|>module.expo<|fim_middle|>rts = require("./co<|endoftext|> | fim | webpack/webpack | javascript |
import concat2 from "./concat2";
export const baz = "baz";
export const foo = "foo";
export const bar = "bar";
export const concat = "concat~" + concat2;
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export defa<|fim_suffix|>"concat2";
<|fim_middle|>ult <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>impo<|fim_suffix|> generate correct export definition / 1", function () {
expect(foo).toBe("foo")
});
<|fim_middle|>rt { foo } from "./cjs-concat";
it("should<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import { bar } from "./cjs-concat";
it("should g<|fim_suffix|>orrect export definition / 2", function () {
expect(bar).toBe("bar")
});
<|fim_middle|>enerate c<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import { baz, concat } from "./cjs-concat";
it<|fim_suffix|>ould generate correct export definition / 3", function () {
expect(baz).toBe("baz");
expect(concat).toBe("concat~concat2");
});
<|fim_middle|>("sh<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use st<|fim_suffix|>entry3.mjs"];
}
};
<|fim_middle|>rict";
module.exports = {
findBundle() {
return ["entry1.mjs", "entry2.mjs", "<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
mode: "production",
entry: {
entry1: "./entry1.js",
entry2: "./entry2.js",
entry3:<|fim_middle|> "./entry3.js"
},
output: {
module: true,
library: {
type: "module"
},
filename: "[nam... | fim | webpack/webpack | javascript |
<|fim_prefix|>import { readFileSync, writeFileSync as aaa } from 'fs'
import * as path from 'path'
import * as fs from 'fs'
function doNothing(obj) {}
const { writeFileSync = aaa } = {}
doNothing({ writeFileSync });
{
const { writeFileSync = aaa } = {}
doNothing({ writeFileSync });
}
it('should handle external m... | fim | webpack/webpack | javascript |
<|fim_suffix|>];
}
};
<|fim_prefix|>"use strict";
module.exports = {
findBundle() {
return ["<|fim_middle|>main.mjs"<|endoftext|> | fim | webpack/webpack | javascript |
"use strict";
/** @type {import("../../../../types").Configuration} */
module.exports = {
entry: { main: "./index.js" },
output: {
module: true,
library: {
type: "module"
},
filename: "[name].mjs",
chunkFormat: "module"
},
experiments: {
outputModule: true
},
resolve: {
extensions: [".js"]
},
... | fim | webpack/webpack | javascript |
<|fim_suffix|>', () => {})
<|fim_prefix|>it('s<|fim_middle|>hould compile<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
module<|fim_suffix|> findBundle() {
return ["main.js"];
}
};
<|fim_middle|>.exports = {
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export { value } fro<|fim_suffix|> 'external0'
<|fim_middle|>m<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @typedef {import("../../../../").Compilation} Compilation */
/** @type {import("../../../../types").Configuration} */
module.exports = {
mode: "none",
entry: { m<|fim_suffix|>cessAssets.tap("testcase", (assets) => {
const source = assets["test.js"].source();
expect(source).... | fim | webpack/webpack | javascript |
<|fim_suffix|>lue = 1
<|fim_prefix|>export type T = unknow<|fim_middle|>n
export const va<|endoftext|> | fim | webpack/webpack | typescript |
<|fim_suffix|>ng;
export default value;
}
<|fim_prefix|>declare mo<|fim_middle|>dule "*.png" {
const value: stri<|endoftext|> | fim | webpack/webpack | typescript |
<|fim_prefix|>import { value, T } from './re-export'
import logo from './file.png';
type MyType = string;
export { logo, value, T, MyType }
it("sho<|fim_suffix|>() {
expect(value).toBe(1)
});
type OtherMyType = string;
export type { OtherMyType }
export default MyType;
<|fim_middle|>uld not reexport type", functi... | fim | webpack/webpack | typescript |
<|fim_suffix|> './export'
<|fim_prefix|><|fim_middle|>export * from<|endoftext|> | fim | webpack/webpack | typescript |
"use strict";
const supportsOptionalChaining = require("../../../helpers/supportsOptionalChaining");
module.exports = () => supportsOptionalChaining();
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>periments: {
outputModule: true
},
resolve: {
extensions: [".ts"]
},
optimization: {
concatenateModules: true
},
module: {
rules: [
{
test: /\.ts$/,
loader: "ts-loader",
options: {
transpileOnly: true
}
},
{
type: "asset/inline",
test: /\.png$/
}
]
... | fim | webpack/webpack | javascript |
import { FluentProvider } from './module.js';
function test(value) {
return value;
}
test(FluentProvider);
export const value = "value";
export { FluentProvider };
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import { FluentProvider } from './module.js';
export {
FluentProvid<|fim_suffix|>sync function() {
const value = await component();
expect(qT).toBe("qT");
expect(value).toBe("value");
expect(FluentProvider()).toBe("FluentProvider");
});
<|fim_middle|>er,
myFunction,
} from './module.js';
expor... | fim | webpack/webpack | javascript |
<|fim_prefix|>export { Fl<|fim_suffix|>const myFunction = function () {};
<|fim_middle|>uentProvider } from './other.module2.js';
export <|endoftext|> | fim | webpack/webpack | javascript |
export { FluentProvider } from 'my-pkg';
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
module.exports = {
mode: "production",
target: "web",
optimization: {
minimize: false
},
experi<|fim_suffix|> library: {
type: "module"
},
module: true
}
};
<|fim_middle|>ments: {
outputModule: true
},
output: {
<|endoftext|> | fim | webpack/webpack | javascript |
export default "concat"
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>t(content).toMatch(reg);
});
module.exports = {
name: "foo"
};
<|fim_prefix|>const getFile = () => {
const fs = __non_webpack_require__("fs");
return fs.readFileSync(__filename, "utf-8");
};
const RuntimeGlobals_Exports = "__webpack_exports__";
const reg = new RegExp("(?:var|let|const)\\s" + RuntimeG... | fim | webpack/webpack | javascript |
<|fim_suffix|>eg);
expect(content).not.toMatch(hasOwnPropertyReg);
expect(content).not.toMatch(requireScopeReg);
}
});
export { concat };
export default "foo";
<|fim_prefix|>import concat from "./concat";
const getFile = () => {
const fs = __non_webpack_require__("fs");
return fs.readFileSync(__filename, "utf-... | fim | webpack/webpack | javascript |
import concat from "./concat";
const getFile = () => {
const fs = __non_webpack_require__("fs");
return fs.readFileSync(__filename, "utf-8");
};
const stripModuleMarkers = (content) =>
content.split(/^;\/\/ /m)[0];
const RuntimeGlobals_Exports = "__webpack_exports__";
const RuntimeGlobals_Require = "__webpack_req... | fim | webpack/webpack | javascript |
<|fim_suffix|>tsReg = new RegExp(
"(?:var|let|const)\\s+" + RuntimeGlobals_Exports + "\\s*="
);
const definePropertyGettersReg = new RegExp(
RuntimeGlobals_Require + "\\.d\\s*="
);
const hasOwnPropertyReg = new RegExp(
RuntimeGlobals_Require + "\\.o\\s*="
);
const requireScopeReg = new RegExp(
"(?:var|let|const)\\s... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
modul<|fim_suffix|>entry)[0]}.mjs`;
}
};
<|fim_middle|>e.exports = {
findBundle(_i, options) {
return `./${Object.keys(options.<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>sRequireInModule();
<|fim_prefix|>"use strict";
const supportsRequireInModule = require("../../../helpers/supportsRequireInModule");
<|fim_middle|>
module.exports = () => support<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @typedef {import("../../../../").Configuration} Configuration */
/** @type {Configuration} */
const common = {
mode: "production",
output: {
module: true,
filename: "[name].mjs",
library: {
type: "module"
},
chunkFormat<|fim_suffix|>name: "entry3",
entry: "./entry3.js"... | fim | webpack/webpack | javascript |
<|fim_prefix|>requi<|fim_suffix|><|fim_middle|>re('./other-entry.js')
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>scope', () => {
expect(readFile).toBeDefined()
})<|fim_prefix|>import { readFile <|fim_middle|>} from 'externals-1/foo'
import './cjs'
it('should not optimize external modules in different concatenation <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>s in different concatenation scope', () => {
expect(readFile).toBeDefined()
})<|fim_prefix|>import { readFi<|fim_middle|>le } from 'externals-2/foo'
it('should not optimize external module<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> ["main.mjs"];
}
};
<|fim_prefix|>"use strict";
module.exports = {
findBu<|fim_middle|>ndle() {
return<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ther-entry.js" },
output: {
module: true,
library: {
type: "modern-module"
},
filename: "[name].mjs",
chunkFormat: "module"
},
experiments: {
outputModule: true
},
resolve: {
extensions: [".js"]
},
externalsType: "module",
externals: {
"externals-1/foo": "fs",
"externals-2/foo... | fim | webpack/webpack | javascript |
module.exports = class PluginA {
apply() {
return "A";
}
};
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>module.exports = <|fim_suffix|>
<|fim_middle|>function PluginB() {
return "B";
};<|endoftext|> | fim | webpack/webpack | javascript |
// Mirrors how webpack's own `lib/index.js` exposes submodules: a barrel that
// defines each named export as a non-enumerable `value` re-export.
Object.defineProperty(exports, "PluginA", {
value: require("./PluginA")
});
Object.defineProperty(exports, "PluginB", {
value: require("./PluginB")
});
Object.definePropert... | fim | webpack/webpack | javascript |
<|fim_prefix|>const lib = require("./barrel");
it("should reexport whole submodules via Object.defineProperty value", () => {
expect(new lib.PluginA().appl<|fim_suffix|>r()).toBe("helper");
expect(lib.util.value).toBe(42);
});
it("should reexport a single nested property via Object.defineProperty value", () => {
e... | fim | webpack/webpack | javascript |
<|fim_suffix|>= "unused";
<|fim_prefix|>exports.helper = () => "helper";
exports.value = 42;
expo<|fim_middle|>rts.unused <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> them by name.
optimization: { mangleExports: false },
output: {
library: { type: "commonjs-module" }
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
target: "node<|fim_middle|>",
// Keep export names stable so the test can assert on<|endofte... | fim | webpack/webpack | javascript |
module.exports = class PluginA {
apply() {
return "A";
}
};
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>// A CommonJS barrel exposing submodules the way webpack's own `lib/<|fim_suffix|>value
});
Object.defineProperty(exports, "util", {
enumerable: true,
get: () => require("./util")
});
<|fim_middle|>index.js`
// does: eager `value` re-exports next to lazy `get` accessors. Consumed below
// through static... | fim | webpack/webpack | javascript |
<|fim_suffix|>helper()).toBe("helper");
expect(util.value).toBe(42);
});
export { PluginA, lazyValue, util };
<|fim_prefix|>i<|fim_middle|>mport { PluginA, lazyValue, util } from "./barrel";
it("should statically named-import value and getter reexports from a CJS barrel", () => {
expect(new PluginA().apply()).toBe(... | fim | webpack/webpack | javascript |
<|fim_suffix|>";
<|fim_prefix|>exports.value = 42<|fim_middle|>;
exports.helper = () => "helper<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>hunkFormat: "module",
library: { type: "module" }
},
experiments: {
outputModule: true
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.<|fim_middle|>exports = {
target: "node",
// Keep export names stable so named imports resolve by their source names.... | fim | webpack/webpack | javascript |
<|fim_suffix|>xternals0";
v;<|fim_prefix|>import { v<|fim_middle|> } from "e<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>module.exports.entry1 = require('./entry1.js')
module.export<|fim_suffix|> = require('./entry2.js')<|fim_middle|>s.entry2<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>module.exports = require('./foo')
mod<|fim_suffix|><|fim_middle|>ule.exports.name = "entry1"<|endoftext|> | fim | webpack/webpack | javascript |
module.exports = require('./bar')
module.exports.name = "entry2"<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import { v } from "externals1"<|fim_suffix|><|fim_middle|>;
v;<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>i<|fim_suffix|>work', () => {
expect(true).toBe(true);
});<|fim_middle|>t('should <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>try1")) {
if (request.includes("entry2")) {
setTimeout(() => {
callback(null, code);
}, 2000);
} else {
callback(null, code);
}
};<|fim_prefix|>"use strict";
/** @typedef {import("../../../../types").LoaderDefinition} LoaderDefinition */
/**
* @type {LoaderDefinition}
*/
module... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use<|fim_suffix|>xports = {
findBundle() {
return ["main.mjs"];
}
};
<|fim_middle|> strict";
module.e<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>
]
},
plugins: [
(compiler) => {
compiler.hooks.compilation.tap(
"testcase",
(
/** @type {import("../../../../types").Compilation} */ compilation
) => {
compilation.hooks.afterProcessAssets.tap(
"testcase",
(
/** @type {Record<string, import("webpack-sourc... | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should define global object with property", function<|fim_suffix|>/module");
expect(MyLibrary["answer"]).toEqual(42);
});
export const answer = 42;
<|fim_middle|> () {
require(".<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>rict";
<|fim_prefix|>"us<|fim_middle|>e st<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
module.exports = {<|fim_suffix|>elete global.MyLibrary;
}
};
<|fim_middle|>
afterExecute() {
d<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
<|fim_suffix|> type: "assign"
}
}
};
<|fim_middle|>
/** @type {import("../../../../").Configuration} */
module.exports = {
output: {
library: {
name: "MyLibrary",
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should define global object with property", function () {
expect(MyLibraryProp<|fim_suffix|>rt const answer = 42;
<|fim_middle|>erties["answer"]).toEqual(42);
});
expo<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|><|fim_prefix|>"use strict<|fim_middle|>";
module.exports = {
afterExecute() {
delete global.MyLibraryProperties;
}
};
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>yProperties",
type: "assign-properties"
}
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../.<|fim_middle|>./").Configuration} */
module.exports = {
output: {
library: {
name: "MyLibrar<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should define global object with property", function () {
expect(MyLibraryRun<|fim_suffix|>"]).toEqual(42);
});
export const answer = 42;
<|fim_middle|>timeChunk["answer<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
module.exports = {<|fim_suffix|>main.js"];
}
};
<|fim_middle|>
findBundle() {
return ["./runtime~main.js", "./<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
output: {
filename: "[name].js",
library: {
name: "My<|fim_suffix|>ype: "assign"
}
},
target: "web",
optimization: {
runtimeChunk: true
}
};
<|fim_middle|>LibraryRuntimeChunk",
t<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("shou<|fim_suffix|>run", function() {
});<|fim_middle|>ld <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>s: "test-library"
}
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
output: {
libraryTarget: "umd",
library: {
root: "testLibrary",
amd: "test-library",
co<|fim_middle|>mmonj<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|><|fim_suffix|> {
});<|fim_middle|>it("should run", function()<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
modul<|fim_suffix|>st-library"
}
}
};
<|fim_middle|>e.exports = {
output: {
libraryTarget: "umd",
library: {
root: ["test", "library"],
amd: "test-library",
commonjs: "te<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export const red = "#f00";
export co<|fim_suffix|>
<|fim_middle|>nst green = "#0f0";<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import stylesheet from "./stylesheet";
import stylesheet1 from "./stylesheet?1";
import otherStylesheet from "./other-stylesheet";
it("should be able to use build-time code", () => {
expect(stylesheet).toBe(
'body { background: url("/public/assets/file.png"); color: #f00; }'
);
expect(stylesheet1).t... | fim | webpack/webpack | javascript |
<|fim_prefix|>/** @type {import("../../../../").PitchLoaderDefinitionFunction} */
exports.pitch = async function (remaining) {
const result = await this.importModule(
this.resourcePa<|fim_suffix|>t;
};
<|fim_middle|>th + ".webpack[javascript/auto]" + "!=!" + remaining,
this.getOptions()
);
return result.default ... | fim | webpack/webpack | javascript |
<|fim_prefix|>import { green } from "./colors.<|fim_suffix|> from "./file.jpg";
export default `body { background: url("${file}"); color: ${green}; }`;
<|fim_middle|>js";
import file<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import { red } from "./colors.js";
export default `bod<|fim_suffix|>red}; }`;
<|fim_middle|>y { background: url("${
new URL("./file.png" + __resourceQuery, import.meta.url).href
}"); color: ${<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @typedef {import("../../../../").Chunk} Chunk */
/** @type {import("../../../../").Configuration} */
module.exports = {
output: {
publicPath: "/public/"
},
module: {
parser: {
javascript: {
url: "relative"
}
},
rules: [
{
dependency: "url",
issuer: /styl... | fim | webpack/webpack | javascript |
<|fim_suffix|>"a")).toBe(true);
});
<|fim_prefix|>import regexp from './#.my';
it("should load regexp correctly", () => {
expect(regexp.test("1")).toBe(false);
expect(reg<|fim_middle|>exp.test(<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
module: {
rules<|fim_suffix|>: /\.my$/,
loader: "regexp-#-loader"
}
]
}
};
<|fim_middle|>: [
{
test<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>.toBe("a");
});
it("should work when loader is async #2", function() {
expect(require("./b")).toBe("b");
});
it("should work when loader is async #3", function() {
expect(require("./c")).toBe("c");
});
<|fim_prefix|>it("should work when loader is async", functi<|fim_middle|>on() {
expect(require("./... | fim | webpack/webpack | javascript |
<|fim_prefix|>/** @ty<|fim_suffix|>nction () {
return `module.exports = 'a';`;
};
<|fim_middle|>pe {import("../../../../").LoaderDefinition} */
module.exports = async fu<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>/** @type {import("../../../../").LoaderDefinition} */
module.exports = fu<|fim_suffix|>turn Promise.resolve(`module.exports = 'b';`);
};
<|fim_middle|>nction () {
re<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>odule.exports = 'c';`);
};
<|fim_prefix|>/** @type {import("../../../../").Lo<|fim_middle|>aderDefinition} */
module.exports = function () {
const callback = this.async();
callback(null, `m<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use stric<|fim_suffix|>,
{
test: /c\.js$/,
use: "./loader-3"
}
]
}
};
<|fim_middle|>t";
/** @type {import("../../../../").Configuration} */
module.exports = {
mode: "development",
module: {
rules: [
{
test: /a\.js$/,
use: "./loader-1"
},
{
test: /b\.js$/,
us... | fim | webpack/webpack | javascript |
it("should work with file protocol in loader", function() {
expect(require("./a")).toBe("production");
});
it("should work with file protocol in use", function() {
expect(require("./b")).toBe("production");
});
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>/** @type {import("../../../../").LoaderDefiniti<|fim_suffix|>ode}";`;
};
<|fim_middle|>on} */
module.exports = function (source) {
return `module.exports = "${this.m<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const path = require("p<|fim_suffix|> {
test: /b\.js$/,
use: pathToLoader
}
]
}
};
<|fim_middle|>ath");
const url = require("url");
const pathToLoader = url
.pathToFileURL(path.resolve(__dirname, "./loader.js"))
.toString();
/** @type {import("../../../../").Configuration... | fim | webpack/webpack | javascript |
<|fim_prefix|>it("sh<|fim_suffix|>re("./c")).toBe("yes");
expect(require("./d")).toBe("ok");
});
<|fim_middle|>ould correctly pass complex query object with remaining request", function() {
expect(require("./a")).toBe("ok");
expect(require("./b")).toBe("maybe");
expect(requi<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>/** @type {import("../../../../").PitchLoaderDefinitionFunction} */
module.exports.pitch = func<|fim_suffix|>ingRequest) {
return (
"module.exports = require(" + JSON.stringify("!!" + remainingRequest) + ");"
);
};
<|fim_middle|>tion (remain<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>/** @type {import("../../../../").Lo<|fim_suffix|>ny }>} */
module.exports = function (source) {
if (typeof this.query === "string")
throw new Error("query must be an object");
return "module.exports = " + JSON.stringify(this.query.f());
};
<|fim_middle|>aderDefinition<{ f(): a<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>s$/,
use: [
"./loader1",
"./loader1",
"./loader1",
{
loader: "./loader2",
options: {
f() {
return "ok";
}
}
}
]
}
]
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration} */
module.exports = {
modul... | fim | webpack/webpack | javascript |
<|fim_suffix|>,
hashSalt: "salt",
});
});
<|fim_prefix|>it("should have hmr flag in loader context", function() {
expect(require("./loader!")).toMatchObject({
digest: "a0fdc3d2f3863f64d<|fim_middle|>95950fc06af72f7",
digestWithLength: "a0fdc3d2f3863f64d959",
hashFunction: "md4",
hashDigest: "hex",
hashDig... | fim | webpack/webpack | javascript |
<|fim_prefix|>/**<|fim_suffix|>Digest,
hashDigestLength: this.hashDigestLength,
hashSalt: this.hashSalt
})};`;
};
<|fim_middle|> @type {import("../../../../").LoaderDefinition}} */
module.exports = function () {
const hashValue = this.utils.createHash(this.hashFunction);
if (this.hashSalt) {
hashValue.update(t... | fim | webpack/webpack | javascript |
<|fim_suffix|>t: "salt"
}
};
<|fim_prefix|>"use strict";
/** @type {import("../../../../").Configuration[]} */
module.exp<|fim_middle|>orts = {
output: {
hashSal<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should have hmr<|fim_suffix|>on() {
expect(require("./loader!")).toBe(!!module.hot);
});
<|fim_middle|> flag in loader context", functi<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>
};
<|fim_prefix|>/** @type {import("../../../../").LoaderDefinition}} */
module.exports =<|fim_middle|> function () {
return `module.exports = ${JSON.stringify(!!this.hot)};`;<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>module.exports = [
{
// no hmr
},
{
// with hmr
plugins: [new webpack.HotModuleReplacementPlugin()]
}
];
<|fim_prefix|>"use strict";
const webpack = require("../../../.<|fim_middle|>./");
/** @type {import("../../../../").Configuration[]} */
<|endoftext|> | fim | webpack/webpack | javascript |
import one from "./pkg-1.json" assert { type: "json" };
import two from "./pkg-2.json" with { type: "json" };
import three from "./pkg-3.json" assert { type: "json" };
import four from "./pkg-4.json" with { type: "json" };
it("import attributes and assertion should work", function() {
expect(one.type).toEqual("assert... | fim | webpack/webpack | javascript |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.