text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
export default (class A {})
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>return import(/* webpackChunkName: "e" */ "./e")
.then(({ default: E }) => {
new E()
});
});
it("should compile default export unnamed class expression", function() {
return import(/* webpackChunkName: "f" */ "./f")
.then(({ default: F }) => {
new F()
});
});
it("should compile default e... | fim | webpack/webpack | javascript |
const type = require("./typeof");
it("should not output invalid code", () => {
expect(type).toBe("number");
});
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> = "number"
<|fim_prefix|>typeof 1
modul<|fim_middle|>e.exports<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export default 9<|fim_suffix|><|fim_middle|>;
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import x from "./a";
const sum1 = (x, y, total<|fim_suffix|>= x + y) { return total; }
const id3 = function(a = x) { return a; }
it("should shadow imported bindings", () => {
// Arrow functions
expect(sum1(2, 3)).toBe(5);
expect(id1(1)).toBe(1);
expect(id1()).toBe(9);
// Function declarations
exp... | fim | webpack/webpack | javascript |
<|fim_suffix|>
export const multUsed = __webpack_exports_info__.mult.used;
<|fim_prefix|>export let c<|fim_middle|>ount = 1;
export function inc() {
count++;
}
export function incTruthy() {
count++;
return true;
}
export function mult(n) {
count *= n;
}
export function setCount(c) {
count = c;
}
<|endoftext|> | fim | webpack/webpack | javascript |
import {
count,
mult,
inc,
incTruthy,
setCount,
multUsed,
incUsed
} from "./a";
it("logical 'and' should work", () => {
setCount(1);
inc() && "true" && 0 && mult(2);
expect(count).toBe(2);
inc() && false && mult(2);
expect(count).toBe(3);
true && inc() && inc() && false && mult(2);
/* inc itself returns ... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
module.exports = (con<|fim_suffix|>) => config.mode !== "development";
<|fim_middle|>fig<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>de<|fim_suffix|>ion() {
return "file";
});
<|fim_middle|>fine(funct<|endoftext|> | fim | webpack/webpack | javascript |
it("should require existing module with supplied error callback", function(done) {
require.ensure(['./file'], function(){
try {
var file = require('./file');
expect(file).toBe("file");
done();
} catch(e) { done(e); }
}, function(error) {});
});
it("should call error callback on missing module", function... | fim | webpack/webpack | javascript |
<|fim_prefix|>define(function() {
throw new Err<|fim_suffix|>sage');
});
<|fim_middle|>or('mes<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export default func<|fim_suffix|>urn "OK";
}
<|fim_middle|>tion test() {
ret<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should detect module.require dep<|fim_suffix|>toBe("OK");
});
<|fim_middle|>endency", function () {
var test1 = module.require('./a').default;
expect(test1()).<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export default funct<|fim_suffix|> 'a' + __resourceQuery
}
<|fim_middle|>ion a() {
return<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>_resourceQuery
}
<|fim_prefix|>export default function abc() {
retu<|fim_middle|>rn 'abc' + _<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should detect query strings in dynamic import as a static value 1 ", function() {
return Promise.all([
import("./a").then(({ default: a }) => {
expect(a()).toBe("a");
}),
import("./abc").then(({ default: a }) => {
expect(a()).toBe("abc");
}),
import("./a?queryString").then(({ default:... | fim | webpack/webpack | javascript |
<|fim_suffix|>ssion twice when using IIFE function name as default parameter', () => {
expect(myFunctionExportedFunctionExpressionDefaultParameter()).toBe(2);
});
<|fim_prefix|>import myFunction from './module';
impor<|fim_middle|>t myFunctionDefaultParameter from './moduleDefaultParameter';
import myFunctionExportedF... | fim | webpack/webpack | javascript |
<|fim_suffix|>
})(true);
return iifeExecutionCount;
}
<|fim_prefix|>import someFunction from './someFunction';
export default function myFunction() {
let iifeExecutionCount = 0;
(function <|fim_middle|>someFunction (recurse) {
iifeExecutionCount++;
if (recurse) {
someFunction(false);
}<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export default function myFunction(<|fim_suffix|>eturn iifeExecutionCount;
}
<|fim_middle|>) {
let iifeExecutionCount = 0;
(function someFunction (recurse, recurseFunction = someFunction) {
iifeExecutionCount++;
if (recurse) {
recurseFunction(false);
}
})(true);
r<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>impo<|fim_suffix|>ction';
export default (function someFunction (recurse = true) {
if (recurse) {
return 1 + someFunction(false);
}
return 1;
});
<|fim_middle|>rt someFunction from './someFun<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>
import someFunction from './someFunction';
export default (function someFuncti<|fim_suffix|>1 + recurseFunction(false);
}
return 1;
});
<|fim_middle|>on (recurse = true, recurseFunction = someFunction) {
if (recurse) {
return <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export default function someFu<|fim_suffix|>eturn -1;
}
<|fim_middle|>nction () {
r<|endoftext|> | fim | webpack/webpack | javascript |
import lower from "./lo";
const tests = {
"simple template": () => import(`./langs/${lower("EN")}`),
"double template": () => import(`./langs/${lower("E")}${lower("N")}`),
"template with prefix": () => import(`./langs/${lower("EN")}.js`),
"double template with prefix": () =>
import(`./langs/${lower("E")}${lower(... | fim | webpack/webpack | javascript |
<|fim_prefix|>export<|fim_suffix|>ult "en";
<|fim_middle|> defa<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export default str <|fim_suffix|>
<|fim_middle|>=> str.toLowerCase();<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should parse sparse arrays", function() { // issue #136
<|fim_suffix|>]).toHaveLength(2);
expect([0,,,0]).toHaveLength(4);
});
<|fim_middle|>expect([,null<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>module.e<|fim_suffix|>rts = "dep";<|fim_middle|>xpo<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> expect(require("local-module2")).toEqual(obj);
expect(require("local-module3")).toEqual({ m1: obj });
});
<|fim_prefix|>it("should define and require a local module", function () {
module.exports = "not set";
define("my-module", function () {
return 1234;
});
expect(module.exports).toBe("not set")... | fim | webpack/webpack | javascript |
<|fim_suffix|>
});
<|fim_prefix|>import f from "./module";
it("should support logical assignment", ()<|fim_middle|> => {
expect(f()).toBe(true);<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> ??= true;
x &&= true;
x ||= false;
return x;
}
<|fim_prefix|>export default function () {
var x = null;
<|fim_middle|>x<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const supportsLogicalAssignment = require("../../../helper<|fim_suffix|>supportsLogicalAssignment();
<|fim_middle|>s/supportsLogicalAssignment");
module.exports = () => <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ew B();
const a = new A();
expect(b.val).toBe(2);
expect(a.val).toBe(1);
});
<|fim_prefix|>class A {
constructor() {
if (new.target === B) {
this.val = 2;
} else {
this.val = 1;
}
if (typeof new.target !== "function") {
this.val = 0;
}
if (typeof new.t<|fim_middle|>arget.value !=... | fim | webpack/webpack | javascript |
<|fim_prefix|>export const a<|fim_suffix|>s x from "./b";
export { x };
<|fim_middle|> = 42;
import * a<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>t b = 42;
import * as y from "./c";
export { y };
<|fim_prefix|>export <|fim_middle|>cons<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>};
<|fim_prefix|>export const c = 42;
import * as z from "./d";
import * as Z<|fim_middle|> from "./e";
export { z, Z <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>exports.<|fim_suffix|>
<|fim_middle|>d = 42;<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>module.exp<|fim_suffix|>undefined;
})();
<|fim_middle|>orts = (() => {
return <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>) => {});
<|fim_prefix|>import * as m from "./a";
if (Math.random() < 0) {
m.A;
m.x.B;
m.x.y.C;
m.x.y.z.D;
m.x.y.Z.D;
m.x.y.z.v.E;
m.x.y.Z.v.E;
m.p.r.q;
}
it("should emit the correct warni<|fim_middle|>ngs", (<|endoftext|> | fim | webpack/webpack | javascript |
module.exports = 1;
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>throw n<|fim_suffix|>w Error();
<|fim_middle|>e<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>e) === 0) {
result = require("./a");
}
expect(result).toBe(1);
});
it("should evaluate module.hot to nullish", () => {
if (module.hot) {
module.hot ?? require("fail");
} else {
(module.hot ?? 123) !== 123 && require("fail");
}
});
<|fim_prefix|>it("should parse nullish coalescin<|fim_middle|>... | fim | webpack/webpack | javascript |
<|fim_suffix|>pportsNullishCoalescing");
module.exports = () => supportsNullishCoalescing();
<|fim_prefix|>"use strict";
const supportsNullishCoalescin<|fim_middle|>g = require("../../../helpers/su<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import f from "./module";
it("should support optional catch binding", () => <|fim_suffix|>e);
});
<|fim_middle|>{
expect(f()).toBe(tru<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export d<|fim_suffix|>on() {
try {
throw new Error();
} catch {
return true;
}
};
<|fim_middle|>efault functi<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>("../../../helpers/supportsOptionalCatchBinding");
module.exports = () => supportsOptionalCatchBinding();
<|fim_prefix|>"use strict";
const supportsOptionalCatchBinding = <|fim_middle|>require<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>c";
export const call = () => ({ c: 1 });
<|fim_prefix|>export default {};
export * as a <|fim_middle|>from "./<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> };
<|fim_prefix|>const call = () =><|fim_middle|> 2;
export { call<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>});
it("should evaluate optional members", () => {
if (!module.hot) {
expect(
module.hot?.accept((() => {throw new Error("fail")})())
).toBe(undefined);
}
});
it("should evaluate optional chaining as a part of statement", () => {
if (module.hot?.accept) {
module.hot?.accept("./a.js");
} els... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const supportsOptionalChaining = require("../../../helpers/<|fim_suffix|>
module.exports = () => supportsOptionalChaining();
<|fim_middle|>supportsOptionalChaining");<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should parse patterns in for in/of statements", () => {
var message;
for({ message = require("./module")} of [{}]) {
expect(message).toBe("ok");
}
for({ message = require(<|fim_suffix|>re("./module")} of [{}]) {
expect(value).toBe("ok");
}
for(var { value = require("./module") } in { "string... | fim | webpack/webpack | javascript |
<|fim_suffix|>e.exports = "ok";
<|fim_prefix|>modu<|fim_middle|>l<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const acorn = require("acorn");
const acornParser = acorn.Parser;
/** @type {import("../../../../").LoaderDefinition} */
module.exports = function (source) {
/** @type {acorn.Comment[]} */
const comments = [];
const semicolons = new Set();
//@ts-ignore
const ast = acor<|fim_suffix|>a... | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should be able to process AST from loader", function() {
expect(<|fim_suffix|>"ok");
});
<|fim_middle|>require("./ast-loader!./module")).toBe(<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>/wrong");
<|fim_prefix|>module.expo<|fim_middle|>rts = require(".<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>module.e<|fim_suffix|><|fim_middle|>xports = "ok";
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>modu<|fim_suffix|>= "wrong";
<|fim_middle|>le.exports <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>k";<|fim_prefix|><|fim_middle|>module.exports = "o<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should be able to rename require by var", function() {
var cjsRequire; // just to make it difficult
var cjsRequire = require, cjsRequire2 = typeof require !== "undefined" && require;
expect(cjsRequire("./file")).toBe("ok");
expect(cjsRequire2("./file")).toBe("ok");
});
it("should be able to renam... | fim | webpack/webpack | javascript |
<|fim_prefix|>module.exp<|fim_suffix|>module.id;
<|fim_middle|>orts = <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>"file";
var id = require.resolveWeak("./dir/" + expr);
expect(id).toBe(require("./dir/file.js"));
});
<|fim_prefix|>it("should be able to use require.reso<|fim_middle|>lveWeak with expression", function() {
var expr = <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export const fn = (num<|fim_suffix|>turn num;
};
<|fim_middle|>) => {
re<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>
it("should work", function() {
expect(fn(num)).toBe(1);
});
<|fim_prefix|>import { fn } from "./a"
function d() {}
var num = 1
d(), fn();
export const b = 2
d(), fn();
export default (function Foo() {})
d(), fn();
export const c <|fim_middle|>= 3
function foo() {
d(), fn();
}
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>s = "ok";
<|fim_prefix|>module.ex<|fim_middle|>port<|endoftext|> | fim | webpack/webpack | javascript |
import X, { A, B } from "./module";
import * as M from "./module";
it("should support spread operator", function() {
var o1 = { ...X };
expect(o1).toEqual({ A: "A", B: "B" });
var o2 = { ...({ X }) };
expect(o2).toEqual({ X: { A: "A", B: "B" } });
var o3 = { ...M };
expect(o3).toEqual({ default: { A: "A", B: "B"... | fim | webpack/webpack | javascript |
<|fim_suffix|>
<|fim_prefix|>const A = "A";
const B = "B";
export default { A, <|fim_middle|>B };
export { A, B };<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>() => supportsSpread();
<|fim_prefix|>"use strict";
const supportsSpread = require("../../../he<|fim_middle|>lpers/supportsSpread");
module.exports = <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>};<|fim_prefix|>exp<|fim_middle|>ort default function() {
return typeof this;
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>expect(a()).toBe("undefined");
});
});
<|fim_prefix|>"use strict";
define(["./abc"], f<|fim_middle|>unction(abc) {
// AMD is used here, because it adds stuff to the top of the code
// we make sure to keep strict mode
var a = abc.default;
it("should keep strict mode", function() {
var x = (functi... | fim | webpack/webpack | javascript |
<|fim_suffix|>ect(x.call(o)).toBe(o);
});
export {};
<|fim_prefix|>function x() {
let value;
(() => {
value = this;
})();
return value;
}
it("should parse this in an arrow IIFE correctly<|fim_middle|>", () => {
const o = { ok: true };
exp<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>))) This results in a syntax error<|fim_suffix|>e.<|fim_middle|> loading this fil<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> expect(typeof require.ensure).toBe("function");
});
it("should answer typeof require.resolve correctly", function () {
expect(typeof require.resolve).toBe("function");
});
it("should not parse filtered stuff", function () {
if (typeof require != "function") require("fail");
if (typeof require !== "fu... | fim | webpack/webpack | javascript |
<|fim_suffix|>;<|fim_prefix|>module.expo<|fim_middle|>rts = typeof require<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ebpack_require__).toBe("function");
});
<|fim_prefix|>it("should answer typeof __non_webpack_require__ correctly", function () {
var oldValue;
eval("oldValue = require;");
expect(typeof<|fim_middle|> __non_webpack_require__).toBe("function");
eval("require = undefined;");
expect(typeof __non_webpack_... | fim | webpack/webpack | javascript |
<|fim_suffix|>nfig) => !config.module;
<|fim_prefix|>"use strict";
module.exports = (c<|fim_middle|>o<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should fail on unsupported <|fim_suffix|>upported use of AMD require 2", function() {
expect(function() {
var abc = ["./a", "./b"];
function f(a, b) {}
require(abc, f);
}).toThrow();
});
<|fim_middle|>use of AMD require 1", function() {
expect(function() {
var abc = ["./a", "./b"];
requir... | fim | webpack/webpack | javascript |
<|fim_prefix|>import { resource, disposed } from "./module.js";
let disposeCounter = 0;
const getResource = () => {
return {
test() {
// Nothing
},
[Symbol<|fim_suffix|>esource();
bar.test();
}
expect(disposeCounter).toBe(2);
for (await using x of [getResource()]) {
x.test();
}
expect(disposeCo... | fim | webpack/webpack | javascript |
<|fim_suffix|>ce, disposed };
<|fim_prefix|>let disposed = false;
using resource = {
[Symbol.dispose]: () => {
d<|fim_middle|>isposed = true;
}
};
export { resour<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>false;
}
return supportsUsing();
};
<|fim_prefix|>"use strict";
const supportsUsing = require("../../../helpers/supportsUsing");
<|fim_middle|>
module.exports = (config) => {
// TODO https://github.com/terser/terser/issues/1625
if (config.minimize) {
return <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>var fn = function(module) {
if (typeof module !== 'number') {
throw new Error("module should be a number");
}
expect((typeof m<|fim_suffix|>y function argument", function() {
fn(1);
});
<|fim_middle|>odule)).toBe("number");
};
it("should hide a free var b<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import "./module1";
import {
isWebpackIncludedFunction,
used,
unused,
notPresented
} from "./module2";
it("__webpack_is_includ<|fim_suffix|>sed).toBe(false);
});
it("__webpack_is_included__ should return false for missing module", () => {
expect(notPresented).toBe(false);
});
<|fim_middle|>ed__ sho... | fim | webpack/webpack | javascript |
<|fim_suffix|>leUsed";
<|fim_prefix|>import "<|fim_middle|>./modu<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>included__("./anyOtherModule");
<|fim_prefix|>export const isWebpackIncludedFunction = typeof __webpack_is_included__ === "function";
export const unused = __webpack_is_included__("./moduleUnused");
export const used = __webpack_is_included__("./module" + "Used");
ex<|fim_middle|>port const notPresented =... | fim | webpack/webpack | javascript |
export default 2;
console.log.bind();
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>;
<|fim_prefix|>export default 1;
co<|fim_middle|>nsole.log.bind()<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should replace a module with a module", function() {
expect(require("replacing-module1")).toBe("new-module");
});
it("should replace a module with a file in a module", function() {
expect(require("replacing-module2")).toBe("new-module/inner");
});
it("should replace a module with file in the same mo... | fim | webpack/webpack | javascript |
<|fim_suffix|>n "module is returned";
});
it("should make different modules for query", function() {
expect(require("regular")).toBe("regular-module");
expect(require("return-module")).toBe("module is returned");
const overrideExports = require("override-exports");
expect(typeof overrideExports).toBe("object");
... | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should resolve<|fim_suffix|>rts = \"error\";"
});
expect(require("!./loaders/queryloader?query!./node_modules/subcontent/" + test + ".pug")).toEqual({
resourceQuery: "",
query: "?query",
prev: "xyz: abc"
});
});
<|fim_middle|> loaders relative to require", function() {
var index = "index", t... | fim | webpack/webpack | javascript |
<|fim_prefix|>/** @type {import("../../../../../").LoaderDefinition} */
module.exports = function (content) {
return (
"module.exports = " +
JSON.stringif<|fim_suffix|>is.resourceQuery,
query: this.query,
prev: content
})
);
};
<|fim_middle|>y({
resourceQuery: th<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>(42);
});
<|fim_prefix|>it("should require js module from base64 data-uri", function () {
const mod = require("data:text/javascript;charset=utf-8;base64,ZXhwb3J0IGNvbnN0IG51bWJlciA9IDQyOwpleHBvcnQgZnVuY3Rpb24gZm4oKSB7CiAgcmV0dXJuICJIZWxsbyB3b3JsZCI7Cn0=");
expect(mod.number).toBe(42);
expect(mod.fn()).... | fim | webpack/webpack | javascript |
<|fim_suffix|>4,ZXhwb3J0IGNvbnN0IG51bWJlciA9IDQyOwpleHBvcnQgY29uc3QgZm4gPSAoKSA9PiAiSGVsbG8gd29ybGQiOw==";
export { number, fn };
<|fim_prefix|>import { number, fn } from "data:tex<|fim_middle|>t/javascript;charset=utf-8;base6<|endoftext|> | fim | webpack/webpack | javascript |
it("should be possible to use # in folders", () => {
const eIndexOf = require("es5-ext/array/#/e-index-of");
expect(eIndexOf).toBeTypeOf("function");
});
it("should be possible to use # in folders (context)", () => {
const x = "e-index-of";
const eIndexOf = require(`es5-ext/array/#/${x}`);
expect(eIndexOf).toBeTy... | fim | webpack/webpack | javascript |
<|fim_prefix|>if (Math.random() < 0) require("any!");
if (Math.random() < 0) require("other!");
it("should have correct errors", functio<|fim_suffix|>});
<|fim_middle|>n() {<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> = require("import-require-first");
// Expected values mirror Node.js v22.10+ behavior:
// - "module-sync" is in the active condition set for both require() and
// dynamic import().
// - The first matching key in package.json's "exports" object wins, so
// condition order in package.json is w... | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should make different modules for query", function<|fim_suffix|>ar c = require("./empty?2");
expect(typeof a).toBe("object");
expect(typeof b).toBe("object");
expect(typeof c).toBe("object");
expect(a).not.toBe(b);
expect(a).not.toBe(c);
expect(b).not.toBe(c);
});
<|fim_middle|>() {
var a = re... | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should load single file modules", function() {
expe<|fim_suffix|>filemodule");
});
<|fim_middle|>ct(require("subfilemodule")).toBe("sub<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>module.export<|fim_suffix|>= "a";<|fim_middle|>s <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>"./a");<|fim_prefix|><|fim_middle|>module.exports = require(<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>"], function(require) {
expect(require("./a")).toBe("a");
})
<|fim_prefix|>require.ensur<|fim_middle|>e(["./a<|endoftext|> | fim | webpack/webpack | javascript |
require.ensure(["./b"], function(require) {
expect(require("./b")).toBe("a");
})
<|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.