text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_prefix|>it("should support <|fim_suffix|> "c",
xd: "d"
}));
});
<|fim_middle|>multiple reexports", function() {
expect(require("./x")).toEqual(nsObj({
xa: "a",
xb: "b",
xc:<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export * from "./a";
export<|fim_suffix|><|fim_middle|> * from "./b";
export * from "./c";
export * from "./d";<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import { xa, xb, xc,<|fim_suffix|> } from "./module";
export {
xa,
xb,
xc as xc,
xd as xd
}
<|fim_middle|> xd<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>module.export<|fim_suffix|> "file";
<|fim_middle|>s =<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ire("./file")).toBe("file");
expect(this).toEqual({ok: true});
done();
} catch(e) { done(e); }
}.bind(this));
});
});
<|fim_prefix|>function runWithThis(obj, fn) {
fn.call(obj);
}
it("should bind this context on require callback", function(done) {
require("./file");
runWithThis({ok: true... | fim | webpack/webpack | javascript |
<|fim_prefix|>mod<|fim_suffix|>
<|fim_middle|>ule.exports = "load";<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export var x = 1 // nam<|fim_suffix|>// default export<|fim_middle|>ed export
export default 0 <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>unction() {
expect(x).toBe(1);
});
<|fim_prefix|>import {x} from './a' // named imported cases an errors
it("should be able t<|fim_middle|>o import a named export", f<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import { a, a as aa } from "./module";
import b from "./module";
import * as c from "./mod<|fim_suffix|>23,
aa: 123,
b: 456,
c: nsObj({
a: 123,
default: 456
})
});
})
<|fim_middle|>ule";
it("should import into object shorthand", function() {
var o = {
a,
aa,
b,
c
};
expect(o).to... | fim | webpack/webpack | javascript |
<|fim_prefix|>exp<|fim_suffix|>ort default 456;<|fim_middle|>ort var a = 123;
exp<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use <|fim_suffix|>elpers/supportsES6");
module.exports = () => supportsES6();
<|fim_middle|>strict";
const supportsES6 = require("../../../h<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>of B)).toBe("function");
expect(c).toBe("c");
})
<|fim_prefix|>import A from "./module";
import { B } from "./module";
impo<|fim_middle|>rt { c } from "./module";
it("should allow to export a class", function() {
expect((typeof A)).toBe("function");
expect((type<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>onst c = 'c';<|fim_prefix|>export default <|fim_middle|>class A {}
export class B {}
export c<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ortsES6();
<|fim_prefix|>"use strict";
const supportsES6 = require("../../../helpers/supportsES6");
module.exports = () =><|fim_middle|> supp<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>module.e<|fim_suffix|>a; }
<|fim_middle|>xports = function(a) { return <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>module.exports = {
mark: fun<|fim_suffix|>ion(a) { return a(); }
}
<|fim_middle|>ct<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ion() {
var context = { prev: 0, next: 0, stop: function() { this.next = "end"; } };
while(context.next !== "end")
fn(context);
}
}
}
<|fim_prefix|>module.exports = {
wrap: function(fn) {
<|fim_middle|>return funct<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import { foo } from './module';
import impA from "./helperA";
import impB from "./helperB";
import impC from "./helperC";
var notExportedAsync = function () {
var ref = impA(impB.mark(function _callee2() {
return impC.wrap(function _callee2$(_context2) {
while (1) {
switch (_context2.prev = _co... | fim | webpack/webpack | javascript |
<|fim_suffix|>ount++;
return;
}
export var count = 0;
<|fim_prefix|>expo<|fim_middle|>rt function foo() {
c<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>foo();
<|fim_suffix|>m './module';
<|fim_middle|>
import { foo } fro<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ould run", function() {});
}
<|fim_prefix|>expor<|fim_middle|>t function foo() {
it("sh<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|><|fim_prefix|>expor<|fim_middle|>t default function() { return [].slice.call(arguments); }
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import fn from "./fn";
it("should generate valid code when calling a harmony import function with brackets", function() {<|fim_suffix|>.toEqual([3, 4]);
expect(d).toEqual([5, 6]);
});
<|fim_middle|>
var a = fn((1));
var b = fn(2);
var c = fn((3), (4));
var d = fn(5, (6));
expect(a).toEqual([1]);
... | fim | webpack/webpack | javascript |
<|fim_suffix|>) {});
<|fim_prefix|>if(Math.sin(1) > 1000)
import("mis<|fim_middle|>sing");
it("should run", function(<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>e(123);
expect(value4).toBe(123);
expect(defaultValue).toBe(123);
});
<|fim_prefix|>import defaultValue, { value, value2, value3, value4 } from "./module";
it("should be possible to redefine Object in a module", function() {
ex<|fim_middle|>pect(value).toBe(123);
expect(value2).toBe(123);
expect(val... | fim | webpack/webpack | javascript |
<|fim_suffix|> } from "./module2";
<|fim_prefix|>var Object = 123;
export const value = Object;
export var value2 = Object;
export default Object;
export * from <|fim_middle|>"./module2";
export { value3 as value4<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>;
<|fim_prefix|>export var value3 = 1<|fim_middle|>23<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>=> supportsES6();
<|fim_prefix|>"u<|fim_middle|>se strict";
const supportsES6 = require("../../../helpers/supportsES6");
module.exports = () <|endoftext|> | fim | webpack/webpack | javascript |
import { a, b } from "./module";
function func(x = a, y = b) {
return [x, y];
}
var func2 = function(x = a, y = b) {
return [x, y];
}
it("should import into default parameters", function() {
expect(func()).toEqual(["a", "b"]);
expect(func2()).toEqual(["a", "b"]);
expect(func(1)).toEqual([1, "b"]);
expect(func2... | fim | webpack/webpack | javascript |
<|fim_suffix|>"b";
<|fim_prefix|>export v<|fim_middle|>ar a = "a";
export var b = <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>= () => supportsDefaultArgs();
<|fim_prefix|>"use strict";
const supportsDefaultArgs = require("../../../helpers/supportsDefault<|fim_middle|>Args");
module.exports <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>define(function() {
retu<|fim_suffix|>e";
});
<|fim_middle|>rn "fil<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should require existing module with supplied error callba<|fim_suffix|>ror.message).toBe('message');
done();
} catch(e) { done(e); }
});
});
it("should not call error callback on exception thrown in require callback", function(done) {
require(['./throwing'], function() {
throw new Error('mes... | fim | webpack/webpack | javascript |
<|fim_prefix|>define(function() {
throw new Er<|fim_suffix|>sage');
});
<|fim_middle|>ror('mes<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export const a =<|fim_suffix|>b = {
x: 2
}
<|fim_middle|> {
x: 1
}, <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>lon", function() {
expect(a).toEqual({x: 1});
expect(b).toEqual({x: 2});
});
<|fim_prefix|>import { a, b } from "./a";
it("should export a const <|fim_middle|>value without semico<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const supportsBlockScoping = require("../../../helpers/supportsBlockScoping");
<|fim_suffix|>oping();
<|fim_middle|>module.exports = () => supportsBlockSc<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>;
export var abc = "abc";
<|fim_prefix|>export default "d<|fim_middle|>efault"<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ar abc = "abc";
<|fim_prefix|>e<|fim_middle|>xport default "default";
export v<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ct(file2["de" + fault]).toBe("default");
expect(file2["abc"]).toBe("abc");
});
<|fim_prefix|>import * as file from "./file";
import * as file2 from "./file2";
it("should translate indexed access to harmony import correctly", function() {
expect(file["default"]).toBe("default");
expect(file["abc"]).toB... | fim | webpack/webpack | javascript |
<|fim_suffix|>=> x;
expect(second([1, 2])).toEqual(2);
});
<|fim_prefix|>it("supports empty element in destructuring"<|fim_middle|>, function() {
const second = ([, x]) <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>pers/supportsIteratorDestructuring");
module.exports = () => supportsIteratorDestructuring();
<|fim_prefix|>"use strict";
c<|fim_middle|>onst supportsIteratorDestructuring = require("../../../hel<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export class V6E<|fim_suffix|>ring() {
return 'V8';
}
}
export function getVersion() {
return '1.0';
}
<|fim_middle|>ngine {
toString() {
return 'V6';
}
}
export class V8Engine {
toSt<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import * as E from './a';
function fooBar({some, bar = E.V6Engine}) {
return <|fim_suffix|>t in import", function () {
expect(fooBar({some:"test"})).toEqual('V6');
});
<|fim_middle|>new bar().toString();
}
it("supports default argument assignmen<|endoftext|> | fim | webpack/webpack | javascript |
"use strict";
const supportsDefaultAssignment = require("../../../helpers/supportDefaultAssignment");
module.exports = () => supportsDefaultAssignment();
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> test = "test";
<|fim_prefix|><|fim_middle|>export var<|endoftext|> | fim | webpack/webpack | javascript |
import { test } from "./file";
it("should hide import by local var", function() {
var test = "ok";
expect(test).toBe("ok");
});
it("should hide import by object pattern", function() {
var { test } = { test: "ok" };
expect(test).toBe("ok");
});
it("should hide import by array pattern", function() {
var [test] = ... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const supportsDefaultAssignment = requi<|fim_suffix|>helpers/supportDefaultAssignment");
const supportsObjectDestructuring = require("../../../helpers/supportsObjectDestructuring");
module.exports = () =>
supportsDefaultAssignment() && supportsObjectDestructuring();
<|fim_middle|>re("../.... | fim | webpack/webpack | javascript |
<|fim_prefix|>mod<|fim_suffix|> = "ok";<|fim_middle|>ule.exports<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>
});
});
<|fim_prefix|>it("should pa<|fim_middle|>rse multiple expressions in a require", function(done) {
var name = "abc";
require(["./" + name + "/" + name + "Test"], function(x) {
expect(x).toBe("ok");
done();<|endoftext|> | fim | webpack/webpack | javascript |
export const thing = 123;
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ault 123;
<|fim_prefix|>ex<|fim_middle|>port def<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>exp<|fim_suffix|><|fim_middle|>ort default 123;
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ports.test = 123;
<|fim_prefix|>exports.__esModule <|fim_middle|>= true;
ex<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>exp<|fim_suffix|> default 123;
<|fim_middle|>ort<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|><|fim_suffix|><|fim_middle|>exports.test = "test";
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>});
<|fim_prefix|>it("should generate valid code", functio<|fim_middle|>n() {
expect(require("./module").myTest).toBe("test");
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> from './d?9'
export const user_settings = (thing, user_settings_main, user_settings_change_password)
<|fim_prefix|>import { thing } from './a'
import user_settings_main from './c'
import user_settings_change_password from './d'
export { test as myTest } from "./imported"<|fim_mi... | fim | webpack/webpack | javascript |
<|fim_suffix|>rts = 4321;<|fim_prefix|>mo<|fim_middle|>dule.expo<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should parse cujojs UMD modules", function() {
(function <|fim_suffix|>the dependency array
define(['./file'], function (file) {
return 1234;
});
}(
typeof define == 'function' && define.amd
? define
: function (ids, factory) {
// note: the lambda function cannot be removed in so... | fim | webpack/webpack | javascript |
<|fim_suffix|>);
if(typeof exports !== "undefined")
expect(x.default).toBe(exports);
else
expect((x.default)).toBe(false);
});
export {}
<|fim_prefix|>it("should be able to compile a module with UMD", function() {
va<|fim_middle|>r x = require("./module");
expect(x.default).toBe(global);
});
it("should not fi... | fim | webpack/webpack | javascript |
<|fim_prefix|>var root;
if (typeof self !== 'undefined') {
root = self;
} else if (typeof window !== 'undefined') {
root = windo<|fim_suffix|>dule;
} else {
root = Function('return this')();
}
var result = root;
export default result;
<|fim_middle|>w;
} else if (typeof global !== 'undefined') {
root = global;... | fim | webpack/webpack | javascript |
<|fim_suffix|>ts.nodeType && exports;
export default freeExports;
<|fim_prefix|>var free<|fim_middle|>Exports = typeof exports == 'object' && exports && !expor<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> default: 1234 }));
});
<|fim_prefix|>it("should be possible to export default an imported name", function() {
var x = require("./modul<|fim_middle|>e");
expect(x).toEqual(nsObj({<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>t default X
<|fim_prefix|>i<|fim_middle|>mport X from "./x"
expor<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> default 1234;
<|fim_prefix|>expo<|fim_middle|>rt<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import def from "./module?harmony";
import * as mod from "./module?<|fim_suffix|>nction() {
expect(require("./module?cjs")).toEqual(nsObj({ default: 2 }));
expect(def).toBe(2);
expect(mod.default).toBe(2);
});
<|fim_middle|>harmony-start"
it("should export a sequence expression correctly", fu<|endofte... | fim | webpack/webpack | javascript |
<|fim_suffix|>ort default (1, 2);
<|fim_prefix|><|fim_middle|>exp<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>m<|fim_suffix|>;
<|fim_middle|>odule.exports = "a"<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>expor<|fim_suffix|>default "b";
<|fim_middle|>t <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import b from "./b";
it("should parse dynamic property names", function() {
var o = {
[require(<|fim_suffix|>(cc).toBe("c");
});
<|fim_middle|>"./a")]: "a",
[b]: "b"
};
expect(o).toEqual({
a: "a",
b: "b"
});
});
it("should match dynamic property names", function() {
const {
[require("./a"... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const supportsIteratorDestructuring = require("../../../helpers/supportsIterato<|fim_suffix|>) =>
supportsIteratorDestructuring() && supportsObjectDestructuring();
<|fim_middle|>rDestructuring");
const supportsObjectDestructuring = require("../../../helpers/supportsObjectDestructuring");
... | fim | webpack/webpack | javascript |
<|fim_prefix|>it("shoul<|fim_suffix|>mber" || typeof id === "string").toBeTruthy();
});
it("should evaluate require.resolve in ?: expression", function() {
var id = require.resolve ? require.resolve("./module.js") : null;
expect(typeof id === "number" || typeof id === "string").toBeTruthy();
});
<|fim_middle|>d eva... | fim | webpack/webpack | javascript |
<|fim_suffix|> f;
}
test();
})();
});
<|fim_prefix|>it("should find var declaration later in code", function () {
expect(typeof require).toBe("undefined");
var require;
});
it("should find var declaration in same statement", function () {
var fn = function () {
require("fail");
},
require;
require =... | fim | webpack/webpack | javascript |
it("should find var declaration in control statements", function () {
var f = function (x) {
expect(x).toBe("fail");
};
(function () {
with ({ a: 1 }) {
var require = f;
}
require("fail");
})();
});
it("should find var declaration in control statements after usage", function () {
var f = function (x)... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
module.exports = (config)<|fim_suffix|>onfig.module;
<|fim_middle|> => !c<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
it("should find var declaration in control statements", function() {
var f = (function(x) {
expect(x).toBe("fail");
});
(function() {
for(let x of ["a"]) {
var require = f;
}
require("fail");
}());
});
it("should find var declaration in control stateme<|fim_suffix|>after u... | fim | webpack/webpack | javascript |
<|fim_suffix|>= () => supportsForOf();
<|fim_prefix|>"use strict";
const supportsForOf = requir<|fim_middle|>e("../../../helpers/supportsForOf");
module.exports <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>require;
}
it("should parse these snippets successfully", function() {
});
<|fim_prefix|>function getDirectiveRequire(directive) {
var require = directive.require || (directive.controller && directive.name);
if (!isArray(require) && isObject(require)) {
forEach(require, function(value, key) {
va... | fim | webpack/webpack | javascript |
<|fim_prefix|>export var <|fim_suffix|>t";
<|fim_middle|>test = "tes<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>llow import in object destructuring", function () {
var other;
({ other = test } = {});
expect(other).toBe("test");
});
<|fim_prefix|>import { test } from "./file";
it("should allow import i<|fim_middle|>n array destructuring", function () {
var other;
[other = test] = [];
expect(other).toBe("test"... | fim | webpack/webpack | javascript |
<|fim_suffix|>
module.exports = () =>
supportsObjectDestructuring() && supportsIteratorDestructuring();
<|fim_prefix|>"use strict";
const supportsItera<|fim_middle|>torDestructuring = require("../../../helpers/supportsIteratorDestructuring");
const supportsObjectDestructuring = require("../../../helpers/supportsObje... | fim | webpack/webpack | javascript |
<|fim_prefix|>define("local-module-object", function() {
return {
foo: "bar"
};
});
define("local-side-effect", function() {
return {<|fim_suffix|> 'require' in parentheses", function() {
const result = new require("local-module-object");
expect(result.foo).toBe("bar");
});
it("shouldn't fail with non-object l... | fim | webpack/webpack | javascript |
<|fim_suffix|>";
<|fim_prefix|>const sideEffect = require("./sideEffect");
sideE<|fim_middle|>ffect.foo = "bar";
module.exports = "foo<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> {
foo: "bar"
};
<|fim_prefix|>module.ex<|fim_middle|>ports =<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>
<|fim_prefix|>module.exports <|fim_middle|>= {
foo: null
};<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ect(__webpack_require__.p).toBe("abc");
__webpack_public_path__ = func();
expect(__webpack_require__.p).toBe("func");
__webpack_public_path__ = originalValue;
function func() {
return "func";
}
});
<|fim_prefix|>var window = {};
it("should be able to set the public path", function() {
var orig... | fim | webpack/webpack | javascript |
import { fn } from "./module";
it("should allow conditionals as callee", function() {
var x = (true ? fn : fn)();
expect(x).toBe("ok");
});
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export fu<|fim_suffix|>
}
<|fim_middle|>nction fn() {
return "ok";<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>const result = require("./module");
it("should correctly replace 'require' bindings", () => {<|fim_suffix|>;
<|fim_middle|>
expect(result).toBe(true);
})<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>let result = false;
if (require) {
re<|fim_suffix|>rue;
}
module.exports = result;
<|fim_middle|>sult = t<|endoftext|> | fim | webpack/webpack | javascript |
expect(function() {
var expr1 = "a", expr2 = "b";
require(Math.random() < 0.5 ? expr1 : expr2);
}).toThrow();
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>rator", function() {
require("./dir/test");
});
<|fim_prefix|>it(<|fim_middle|>"should compile expr in ?: ope<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export <|fim_suffix|>function() {}
<|fim_middle|>default <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export<|fim_suffix|>lt (function() {})
<|fim_middle|> defau<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export default f<|fim_suffix|>) {}
<|fim_middle|>unction foo(<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export default (func<|fim_suffix|>on bar() {})
<|fim_middle|>ti<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export <|fim_suffix|>fault class {}
<|fim_middle|>de<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>
<|fim_prefix|>export default (class <|fim_middle|>{})<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>t default class A {}
<|fim_prefix|><|fim_middle|>expor<|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.