text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_prefix|>export<|fim_suffix|>o";
<|fim_middle|> * from "./<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|><|fim_suffix|><|fim_middle|>export * from "../m";
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> "../o";
<|fim_prefix|>export<|fim_middle|> * from<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>exports.__esModule = false;
function dynamic(exports) {
exports.<|fim_suffix|> 1;
}
dynamic(exports);
<|fim_middle|>a =<|endoftext|> | fim | webpack/webpack | javascript |
export const fn = (num) => {
return num;
};
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import { fn } from './a.js';
co<|fim_suffix|>, function() {
expect(fn(num)).toBe(1);
});
<|fim_middle|>nst num = 1
export { fn } from './a.js';
fn(num);
it("should work"<|endoftext|> | fim | webpack/webpack | javascript |
export function a() { return "a1"; }
export { b } from "./b";
export * from "./c";
export { d } from "./b";
export var e = "e1";
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>rt var e = "e2";
<|fim_prefix|>export var a = "a2";
export var b = "b2";
export va<|fim_middle|>r c = "c2";
export var d = "d2";
expo<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ult "default";
<|fim_prefix|>export var a = "a3";
export var b = "b3";
export var<|fim_middle|> c = "c3";
export var e = "e3";
export var f = "f3";
export defa<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>expo<|fim_suffix|>ault";
<|fim_middle|>rt default "def<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import { a, b, c, d, e } from "./a";
import defaultImport from "./a";
it("should prefer local exports", fun<|fim_suffix|>);
});
it("should prefer indirect exports over star exports", function() {
expect(b).toBe("b2");
expect(d).toBe("d2");
});
it("should use star exports", function() {
expect(c).to... | fim | webpack/webpack | javascript |
<|fim_suffix|>
<|fim_prefix|>export c<|fim_middle|>onst fn = (num) => {
return num;
};<|endoftext|> | fim | webpack/webpack | javascript |
import { fn } from './a.js';
const num = 1
export { num };
fn(num);
it("should work", function() {
expect(fn(num)).toBe(1);
});
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>export var ax = "ax";
<|fim_prefix|>im<|fim_middle|>port { add } from "./tracker";
add("a");
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>rt var bx = ax;
<|fim_prefix|>import { ax } from "./<|fim_middle|>c";
import { add } from "./tracker";
add("b");
expo<|endoftext|> | fim | webpack/webpack | javascript |
export * from "./a";
export * from "./b";
import { bx } from "./b";
export { bx as cx }
import { add } from "./tracker";
add("c");
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should process imports of star ex<|fim_suffix|>require.cache[require.resolve("./c")];
var c = require("./c");
expect(tracker.list).toEqual(["a", "b", "c"]);
expect(c.ax).toBe("ax");
expect(c.bx).toBe("ax");
expect(c.cx).toBe("ax");
});
<|fim_middle|>ports in the correct order", function() {
var ... | fim | webpack/webpack | javascript |
<|fim_suffix|>ush(str);
}
<|fim_prefix|>export var list = [];
export functio<|fim_middle|>n add(str) {
list.p<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import {x, f} from "./x";
it("should import into object literal", function() {
(expect({ x: x })).toEqual({x: 1});
var obj = { x: x };
expect(obj).toEqual({x: 1});
});
function func(z) {
return z;
}
it("should import into function argument", function() {
expect(func(x)).toBe(1);
expect(f(x)).toBe... | fim | webpack/webpack | javascript |
<|fim_suffix|> x;
}<|fim_prefix|>export var x = 1;
export f<|fim_middle|>unction f(x) {
return<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>nction() {
def, aa, b, c, d, e, f, g
});
<|fim_prefix|>i<|fim_middle|>mport def, { a as aa, b, c, d, e } from "./module";
import f, { g } from "./commonjs";
it("should emit the correct warnings", fu<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>port function d() {}
<|fim_prefix|>f<|fim_middle|>unction b() {}
export {
b
}
export var c = 123;
ex<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>ex<|fim_suffix|>;
<|fim_middle|>port function f() {
return __webpack_amd_options__;
}<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ore exporting", function() {
expect(require("./file").f()).toEqual({});
});
<|fim_prefix|>it("should inject varia<|fim_middle|>bles bef<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>in modules using 'module'", () => {
expect(v1).toBe(42);
expect(v2).toBe(42);
expect(c1).toBe(c2);
});
<|fim_prefix|>import { value as v1, check as c1 } from "./<|fim_middle|>module";
import { value as v2, check as c2 } from "./module-normal";
it("should allow to optimize exports <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>webpack_exports_info__.unusedValue.used;
<|fim_prefix|>export const value = 42;
export const unusedValue = 42;
export cons<|fim_middle|>t check = __<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export const value = 42;
export const unusedValue = 42;
export const check = __webpack_exports_info__.unusedValue.used;
if (Math.<|fim_suffix|>e.exports);
<|fim_middle|>random() < 0) console.log(modul<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>.obj.A.provideInfo;
export const aToStringProvided = __webpack_exports_info__.a.toString.provideInfo;
<|fim_prefix|>import { b } from "./b";
export function a() {
return b();
}
export const obj = {};
export const aUsed = __webpack_exports_info__.a.used;
export const aProvided = __webpack_exports_info__.... | fim | webpack/webpack | javascript |
<|fim_suffix|> {}
<|fim_prefix|>export fun<|fim_middle|>ction b()<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>vided).toBe(undefined);
expect(aToStringProvided).toBe(undefined);
});
<|fim_prefix|>import { a, aUsed, aCanBeMangled, aProvided, aToStringProvided, obj, objUsed, objAProvided } from "./reexport";
if (a()) console.log("a", obj);
it("should not all<|fim_middle|>ow mangle if some exports are unknown", ()... | fim | webpack/webpack | javascript |
<|fim_prefix|>expor<|fim_suffix|>/a";
export * from "./empty";
export const aCanBeMangled = __webpack_exports_info__.a.canMangle;
<|fim_middle|>t * from ".<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export var value = 0;
export function evalI<|fim_suffix|>
<|fim_middle|>nModule(x) {
eval(x);
};<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>function fun() {
return true;
};
import { callFun } from "./expor<|fim_suffix|>xport { fun };
<|fim_middle|>t-cycle-b";
export default callFun();
e<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>callFun() {
return fun();
}
<|fim_prefix|>import { fun <|fim_middle|>} from "./export-cycle-a";
export function <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>() {
expect(data).toEqual([undefined, 1, 2]);
});
import { value as valueEval, evalInModule } from "./eval";
<|fim_prefix|>import { value, add } from "./live";
import { value as value2, add as add2 } from "./live-es5";
import { getLog } from "./order-tracker";
import "./order-c";
import cycleValue from ... | fim | webpack/webpack | javascript |
<|fim_suffix|>xports.value = 0;
exports.add = function add(x) {
exports.value += x;
};
<|fim_prefix|>exports.__esModule = true;
<|fim_middle|>e<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>+= x;
};
<|fim_prefix|>export var value = 0;
export function add(x) {<|fim_middle|>
value <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>);
<|fim_prefix|>import { log } from "./order-trac<|fim_middle|>ker";
log("a"<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import { log<|fim_suffix|>acker";
log("b");
<|fim_middle|> } from "./order-tr<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>;
<|fim_prefix|>import { log } from "./order-tracker";
import "./order-a";
log("c");
impo<|fim_middle|>rt "./order-b"<|endoftext|> | fim | webpack/webpack | javascript |
var data = [];
export function log(x) {
data.push(x);
};
export function getLog() {
return data;
};
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>b);
var a = 1;
data.push(b);
a = 2;
data.push(b);
export { a, data }
<|fim_prefix|>imp<|fim_middle|>ort { a as b } from "./self-cycle";
var data = [];
data.push(<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import {
named1,
named2,
named3<|fim_suffix|>).toBe(2);
expect(snamed3).toBe(2);
expect(snamed4).toMatchObject({
named1: 1,
named2: 2
});
expect(snamed5).toBe(5);
expect(snamed6).toBe(1);
});
<|fim_middle|>,
named4,
named5,
named6
} from "./named-with-namespace";
it("should point out confl... | fim | webpack/webpack | javascript |
<|fim_suffix|>ort { named1 as named6 } from "./a.js";
<|fim_prefix|>export const named1 = 1;
export const named2 = 2;
export { named2 as named3 } from "./a.js";
export * as named4 from "./a.js<|fim_middle|>";
export const named5 = 5;
exp<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> "./a.js";
export * as named4 from "./a.js";
export { named5 } from "./a.js";
export { named1 as named6 } from "./a.js";
<|fim_prefix|>export * as named1 from "./a.js";
export { named1 as named2 } from "./a.js";
export { named1 as named3 } <|fim_middle|>from<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export * fro<|fim_suffix|>export * from "./b.js";
<|fim_middle|>m "./a.js";
<|endoftext|> | fim | webpack/webpack | javascript |
export const named1 = 1;
export const named2 = 2;
export { named2 as named3 } from "./a.js";
export * as named4 from "./a.js";
export const named5 = 5;
export { named1 as named6 } from "./a.js";
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export * as n<|fim_suffix|> named3 } from "./a.js";
export * as named4 from "./a.js";
export { named5 } from "./a.js";
export { named1 as named6 } from "./a.js";
<|fim_middle|>amed1 from "./a.js";
export { named1 as named2 } from "./a.js";
export { named1 as<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>m "./b.js";
<|fim_prefix|>export * from "./a.js";
export * f<|fim_middle|>ro<|endoftext|> | fim | webpack/webpack | javascript |
import value, { exception } from "./module";
it("should have a TDZ for exported const values", () => {
// TODO: Support disable inline export annotation to keep the TDZ
// expect(typeof exception).toBe("object");
// expect(exception).toBeInstanceOf(Error);
// expect(exception.message).toMatch(
// / is not define... | fim | webpack/webpack | javascript |
<|fim_suffix|>
export const value = "value";
export default f();
<|fim_prefix|>import { f } from "./module<|fim_middle|>2";
export let exception;
try {
f();
} catch(e) {
exception = e;
}
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import { value } from "./modul<|fim_suffix|>eturn value;
}
<|fim_middle|>e";
export function f() {
r<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>ockScoping();
<|fim_prefix|>"use strict";
const supportsBlockScoping = require("../../../helpers/supportsBlockScoping");
module<|fim_middle|>.exports = () => supportsBl<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>function returnThis() {
if (typeof this === "undefined") return expect("undefined");
return expect(this);
}
var a <|fim_suffix|>
export default returnThis;
<|fim_middle|>= returnThis;
var b = returnThis;
export { a, b };<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>
it("should be possible to use new correctly", function() {
x
new C().ok.toEqual(true)
x
new C2().ok.toEqual(true)
x
new New.C().ok.toEqual(true)
})
<|fim_prefix|>"use strict"
import d, {a, b as B} from "./abc"
import * as abc from "./abc"
function x() { throw new Error("should not be executed")... | fim | webpack/webpack | javascript |
<|fim_prefix|>function C() {
this.ok = e<|fim_suffix|> };
<|fim_middle|>xpect(this.pok);
}
C.prototype.pok = true;
export default C;
export { C<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>#!/usr/bin/env <|fim_suffix|>rts = "ok";
<|fim_middle|>node
module.expo<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>rt default "ok";
<|fim_prefix|>#!/us<|fim_middle|>r/bin/env node
expo<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should load a file with hashbang", functi<|fim_suffix|>/file.js");
expect(result).toEqual("ok");
});
import result from "./file.mjs";
it("should load a module with hashbang", function () {
expect(result).toEqual("ok");
});
<|fim_middle|>on () {
var result = require(".<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>modul<|fim_suffix|>ts = "a";<|fim_middle|>e.expor<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>module.exports<|fim_suffix|> "b";<|fim_middle|> =<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>t.accept("./a", function() {});
});
it("should run module.hot.accept()", function() {
module.hot.accept();
});
it("should run module.hot.decline", function() {
module.hot.decline("./b");
});
} else {
it("should run module.hot.* (disabled)", function() {
});
}
<|fim_prefix|>if(module.hot) {
it(... | fim | webpack/webpack | javascript |
<|fim_prefix|>it("should parse a self accept with error handler", functi<|fim_suffix|>) {
module.hot.accept(function(err) {
});
}
});<|fim_middle|>on() {
if(module.hot<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>(/^[0-9a-f]{20}$/);
});
} else {
it("should have __webpack_hash__ (disabled)", function() {
});
}
<|fim_prefix|>if(module.hot) {
it("should have __webpack_hash__", function() {
expect(typeof __webpack_hash__).toBeTypeOf("string");
expect(__webpa<|fim_middle|>ck_hash__).toMatch<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>export let a<|fim_suffix|> a = 1e2 }
export function c() { a = 1e1 }
<|fim_middle|> = 1e3;
export function b() {<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>pect(a).toBe(10);
});
<|fim_prefix|>import { a } from './a';
import { track1, track2 } from './side-effect-call';
it("should parse params", () => {
expect(a).toBe(1000);
track1()<|fim_middle|>;
expect(a).toBe(100);
track2();
ex<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import { b, c <|fim_suffix|>tion track2() {
((a = c()) => {})()
}
<|fim_middle|>} from './a'
export function track1() {
(function (a = b()) {})()
}
export func<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>sues/880
!config.minimize;
<|fim_prefix|>"us<|fim_middle|>e strict";
module.exports = (config) =>
// TODO fails due to minimizer bug: https://github.com/terser/terser/is<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|> a variable named define (call)", () => {
expect(define()).toBe("ok");
});
it("should allow to import a variable named define (expression)", () => {
const d = i(define);
expect(d()).toBe("ok");
});
<|fim_prefix|>import define from "./module";
con<|fim_middle|>st i = x => x;
it("should allow to impor... | fim | webpack/webpack | javascript |
<|fim_suffix|> as default };
<|fim_prefix|>export const define = () <|fim_middle|>=> "ok";
export { define<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>const { pathToFileURL } = require("url");
const url = pathToFileURL(
require("path").resolve("./test/cases/parsing/import-meta/index.js")
).toString()<|fim_suffix|>a.webpack < 5) require("fail");
if (import.meta.webpack >= 5) {
} else {
require("fail");
}
});
it("should return undefined for unknown... | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
const supportsRequireInModule = require("../../../helpers/supportsRequireInMo<|fim_suffix|>dule || supportsRequireInModule();
<|fim_middle|>dule");
module.exports = (config) => !config.mo<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>":"world";
})();
});
<|fim_prefix|>it("should not crash on missing spaces", function() {
(function() <|fim_middle|>{
return"function"==typeof define&&define.amd?"hello<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>exp<|fim_suffix|>rt default "B";
<|fim_middle|>o<|endoftext|> | fim | webpack/webpack | javascript |
import A from "./A.js";
function magicA() {
// To be sure that future optimization
// will not affect test suite
return String.fromCharCode(65);
}
it("should parse switch case properly", () => {
switch (1) {
case 2:
case 1:
const A = magicA();
expect(A).toBe("A");
break;
}
switch (1) {
case 2:
... | fim | webpack/webpack | javascript |
<|fim_suffix|>
await new Promise(resolve => setTimeout(resolve, 1000));
yield i;
}
}
<|fim_prefix|>"use strict";
export default async function* asy<|fim_middle|>ncIdMaker(start = 1, end = 5){
for (let i = start; i <= end; i++) {<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>(true)
yield index++;
}
<|fim_prefix|>"use <|fim_middle|>strict";
export default function* idMaker(){
var index = 0;
while<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>"use strict";
import generator from "./generator_function.js";
import asyncGenerator from "./async_generator_function";
it('should correctly import generator function', () => {
expect(typeof gen<|fim_suffix|>) => {
expect(asyncGenerator.toString().indexOf('async function*')).toBe(0);
});
it('should c... | fim | webpack/webpack | javascript |
<|fim_prefix|>import value from "./module";
import { func } from "./other";
function F({ value2 = value }) {
expect(value2).toBe(42);
}
it("should not apply shorthand code in default values", () => {
const { value2 = value } = {};
expect(value2).toBe(42);
(function ({ va<|fim_suffix|>);
expect(func({})).toBe(2);... | fim | webpack/webpack | javascript |
<|fim_suffix|>42;
<|fim_prefix|>expo<|fim_middle|>rt default <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>var value = <|fim_suffix|> = value }) {
return value2;
}
console.log.bind(console, value);
<|fim_middle|>2;
export function func({ value2<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>).property).toBe(42)
});
<|fim_prefix|>it("should keep parentheses w<|fim_middle|>hen replacing", () => {
// prettier-ignore
expect(new (require("./module")).Thing(42<|endoftext|> | fim | webpack/webpack | javascript |
export class Thing {
constructor(p) {
this.property = p;
}
}
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>// mo<|fim_suffix|>unction () {
return 1;
});
<|fim_middle|>dule.js
export default(f<|endoftext|> | fim | webpack/webpack | javascript |
import fn from './file';
it("should compile correctly", function() {
expect(fn()).toBe(1);
});
<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>;
<|fim_prefix|>expo<|fim_middle|>rt const a = 1<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>
B
};
}
static {
staticBlockValue = C.name;
staticPrivateBlockValue = C.#staticPrivateName;
valueInStaticBlock = B;
staticPrivateMethod = C.#staticPrivateMethod();
staticThis = C.#thisAndC;
}
};
const b = function C() {
return C.name;
}
const staticProperty = A.otherName;
const stati... | fim | webpack/webpack | javascript |
<|fim_suffix|>
expect(mod.publicMethod.privatePropertyB).toBe(1);
expect(mod.publicMethod.privateMethod.privateName).toBe("test");
expect(mod.publicMethod.privateMethod.B).toBe(1);
expect(mod.valueInStaticBlock).toBe(1);
expect(mod.staticB).toBe(1);
expect(mod.staticPrivateMethod.B).toBe(1);
expect(mod.staticPri... | fim | webpack/webpack | javascript |
<|fim_suffix|>"../../../helpers/supportsClassStaticBlock");
module.exports = () => supportsClassStaticBlock();
<|fim_prefix|>"use strict";
const supportsCl<|fim_middle|>assStaticBlock = require(<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import foo, { named } from "./lib";
// The bug we are testing is purely about static analysis: webpack's
// HarmonyDetectionParserPlugin was skipping the arguments of `define`
// calls in ES modules, so import bindings used inside the callback
// were not rewritten to their imported references.
//
// To ... | fim | webpack/webpack | javascript |
<|fim_prefix|>export default <|fim_suffix|>st named = "named-value";
<|fim_middle|>42;
export con<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>import module from "./module.js";
it("should parse sparse arrays", function() {
var {
a,
...other1
} = module;
var {
b,
...other2
}<|fim_suffix|>Equal({ b: 2, c: 3 });
expect(other2).toEqual({ a: 1, c: 3 });
});
<|fim_middle|> = module;
expect(other1).to<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>t;
<|fim_prefix|>var test = {
a: 1,
b: 2,
c: 3
};
export default te<|fim_middle|>s<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>nction() {});
if(/./.test(""))
require("");
<|fim_prefix|>it("should compile", f<|fim_middle|>u<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>var CONSTANT = "const";
var def = "default";
<|fim_suffix|>;<|fim_middle|>export default def; export { CONSTANT }<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>pect(require("./file").default).toBe("default");
expect(require("./file").CONSTANT).toBe("const");
});
<|fim_prefix|>it("should not fail on default export before export", function() {
<|fim_middle|>ex<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>};<|fim_prefix|>va<|fim_middle|>r xa = "a";
export { xa <|endoftext|> | fim | webpack/webpack | javascript |
var xb = "b";
export { xb };<|endoftext|> | fim | webpack/webpack | javascript |
<|fim_prefix|>var xc = "c";
e<|fim_suffix|>{ xc };<|fim_middle|>xport <|endoftext|> | fim | webpack/webpack | javascript |
<|fim_suffix|>.xd = xd;<|fim_prefix|>var xd = "d";
ex<|fim_middle|>ports<|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.