text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_prefix|>const target = './<|fim_suffix|>) => import(subUrl)
<|fim_middle|>sub.js'
const subUrl = new URL(target, import.meta.url)
export default (<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>ub'
<|fim_prefix|>export de<|fim_middle|>fault 's<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>est-dep-lodash-es'
<|fim_prefix|><|fim_middle|>export * from '@vitejs/t<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>expo<|fim_suffix|>uccess] linked force include'
<|fim_middle|>rt const msg = '[s<|endoftext|> | fim | vitejs/vite | javascript |
export { msg } from './foo.js'
// test importing node built-ins
import fs from 'node:fs'
import { useState } from 'react'
export function useCount() {
return useState(0)
}
// test dep with css/asset imports
import './test.css'
if (false) {
fs.readFileSync()
} else {
console.log('ok')
}
export { default as V... | fim | vitejs/vite | javascript |
<|fim_suffix|>d = {}
for (const key in value) {
if (Object.hasOwn(value, key)) {
cloned[key] = cloneDeep(value[key])
}
}
return cloned
}
module.exports = cloneDeep
<|fim_prefix|>'use strict'
// Minimal cloneDeep implementation for testing
function cloneDeep(value) {
if (value == null || typeof v... | fim | vitejs/vite | javascript |
<|fim_suffix|> return value.map(cloneDeep)
}
const cloned = {}
for (const key in value) {
if (Object.hasOwn(value, key)) {
cloned[key] = cloneDeep(value[key])
}
}
return cloned
}
const lodash = {}
lodash.cloneDeep = cloneDeep
if (freeModule) {
;(freeModule.export... | fim | vitejs/vite | javascript |
'use strict'
// Minimal cloneDeep implementation for testing
function cloneDeep(value) {
if (value == null || typeof value !== 'object') {
return value
}
if (Array.isArray(value)) {
return value.map(cloneDeep)
}
const cloned = {}
for (const key in value) {
if (Object.hasOwn(value, key)) {
... | fim | vitejs/vite | javascript |
<|fim_prefix|>// Minimal c<|fim_suffix|>_, chr) => (chr ? chr.toUpperCase() : ''))
.replace(/^[A-Z]/, (chr) => chr.toLowerCase())
}
<|fim_middle|>amelCase implementation for testing
export default function camelCase(str) {
return str
.replace(/[-_\s]+(.)?/g, (<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>export {<|fim_suffix|>om './camelCase.js'
<|fim_middle|> default as camelCase } fr<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>NODE_ENV === 'production' ? 'prod' : 'dev'
<|fim_prefix|>expor<|fim_middle|>t const env = process.env.<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>// Scheme check that imports from different paths are resolved to the same module
const messages = []
export const add = (message) => {
messages.push(message)
}
export<|fim_suffix|>s
<|fim_middle|> const get = () => message<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|><|fim_suffix|>t foo = '[success] imported from .notjs file'
<|fim_middle|>export cons<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>/')
<|fim_prefix|><|fim_middle|>module.exports = require('.<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>module.expo<|fim_suffix|>ted from main'
<|fim_middle|>rts = '[success] impor<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>rom './sub.js'
<|fim_prefix|>expo<|fim_middle|>rt const all = 'all'
export { sub } f<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>
<|fim_prefix|>export const sub <|fim_middle|>= 'sub'<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>d = import.meta.url.includes('/.vite/deps/')
<|fim_prefix|>export default { rand<|fim_middle|>om: Math.random() }
export const isPreBundle<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>export { default } f<|fim_suffix|>t-dep-with-asset-ext1.pdf'
<|fim_middle|>rom '@vitejs/tes<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>rt.meta.url).href
}
<|fim_prefix|>export function urlImportWorker() {
const worker = new Worker(new URL('./worker.js', import.meta.url), {
type: 'modu<|fim_middle|>le',
})
return new Promise((res) => {
worker.onmessage = (e) => res(e.data)
})
}
export function getAssetUrl() {
return new... | fim | vitejs/vite | javascript |
<|fim_prefix|>export function urlImportWorker() {
// Testing the ../ path traversal
const worker = new Worker(new URL<|fim_suffix|>s) => {
worker.onmessage = (e) => res(e.data)
})
}
<|fim_middle|>('../worker.js', import.meta.url), {
type: 'module',
})
return new Promise((re<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>success')
<|fim_prefix|>se<|fim_middle|>lf.postMessage('worker-<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>iately because of how esbuild
// compiles it. There's no way around it as it's direct property access, which
// triggers the Proxy get trap.
// access from default import
try {
path.join()
} catch (e) {
console.log('dep-with-builtin-module-cjs', e)
}
// access from function
module.exports.read = () ... | fim | vitejs/vite | javascript |
<|fim_suffix|> import
try {
path.join()
} catch (e) {
console.log('dep-with-builtin-module-esm', e)
}
// access from function
export function read() {
return readFileSync('test')
}
<|fim_prefix|>// no node: protocol intentionally
// eslint-disable-next-line n/prefer-node-protocol
import { readFileSync } from 'fs... | fim | vitejs/vite | javascript |
<|fim_suffix|>y with dynamic import'
<|fim_prefix|>export const fo<|fim_middle|>o = '[success] dependenc<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>js')
return foo
}
<|fim_prefix|>export const lazyFoo = async function () {
const { foo } = await import('./dy<|fim_middle|>namic.<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>t('foobar')
}
<|fim_prefix|>export function callItsel<|fim_middle|>f() {
return '[success]'
}
export async function callPeerDep() {
return await impor<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>exports.callItself = function () {
return '[success]'
}
exports.callPeerDep = function () {
t<|fim_suffix|> {
return 'fallback'
}
}
<|fim_middle|>ry {
// eslint-disable-next-line n/no-missing-require
return require('foobar')
} catch<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>exp<|fim_suffix|>az')
}
<|fim_middle|>ort function callItself() {
return '[success]'
}
export async function callPeerDepSubmodule() {
return await import('foobar/b<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>export c<|fim_suffix|>t msg = 'plus-subpath'
<|fim_middle|>ons<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>ecessary "full
// reloads" invalidating all modules in a module graph.
export { default } from '@vitejs/test-dep-alias-using-absolute-path'
<|fim_prefix|>// This is used to setup a test scenario, where dep scann<|fim_middle|>er
// could not determine all of the used dependencies on first
// pass, e.g., a ... | fim | vitejs/vite | javascript |
<|fim_prefix|>import axios from '@vitejs/test-dep-cjs-browser-field'<|fim_suffix|>Selector('.cjs-browser-field').textContent = res.data
})
<|fim_middle|>
axios.get('/ping').then((res) => {
document.query<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>aaaaaaaaaaaaaaaa/index'
const main = document.querySelector('.long-file-name')
main.innerHTML = test ?? 'failed to import'
<|fim_prefix|>import test from '@vitejs/longfilename-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa... | fim | vitejs/vite | javascript |
<|fim_suffix|>test
<|fim_prefix|>const tes<|fim_middle|>t = 'hello world'
export default <|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>t-nested-include'
export default 'nested-exclude'
<|fim_prefix|>export { default as nestedInclude }<|fim_middle|> from '@vitejs/tes<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>// written in cjs, optimization should convert this to esm
mo<|fim_suffix|>de'
<|fim_middle|>dule.exports = 'nested-inclu<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>issing dependencies to optimizeDeps.include directly
console.log(msg)
<|fim_prefix|>import msg from '@vitejs/test-added-in-entries'
// This is an entry file that is added to optimizeDeps.entries
// When the deps aren't cached, these entries are also processed
// to discover dependencies in them. This sh... | fim | vitejs/vite | javascript |
<|fim_prefix|>import fs from 'node:fs'
import module from 'node:module'
import { defineConfig } from 'vite'
const require = module.createRequire(import.meta.url)
export default defineConfig({
define: {
__VUE_PROD_HYDRATION_MISMATCH_DETAILS__: false,
},
resolve: {
dedupe: ['react'],
alias: {
'no... | fim | vitejs/vite | javascript |
<|fim_suffix|>imized)).not.toContain('vue')
expect(Object.keys(meta.optimized)).not.toContain('vuex')
})
<|fim_prefix|>import { expect, test } from 'vitest'
import { isBuild, page, readDepOptimizationMetadata } from '~utils'
test('optimized dep', async () => {
expect(await page.textContent('.optimized-dep')).toBe(... | fim | vitejs/vite | typescript |
<|fim_prefix|>// written in cjs, optimization shoul<|fim_suffix|>esm
module.exports = '[success]'
<|fim_middle|>d convert this to <|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import { defineConfig <|fim_suffix|>xport default defineConfig({
define: {
__VUE_PROD_HYDRATION_MISMATCH_DETAILS__: false,
},
optimizeDeps: {
noDiscovery: true,
include: ['@vitejs/test-dep-no-discovery'],
},
build: {
// to make tests faster
minify: false,
},
})
<|fim_middl... | fim | vitejs/vite | javascript |
<|fim_suffix|> {
await page.goto(url)
// reload page to get optimized missing deps
await page.reload()
await expect.poll(() => page.textContent('div')).toMatch('Client')
// raw http request
const aboutHtml = await (await fetch(url)).text()
expect(aboutHtml).toContain('Server')
})
<|fim_prefix|>import { e... | fim | vitejs/vite | typescript |
<|fim_prefix|>// this is automatically detected by playground/vitestSetup.ts and will<|fim_suffix|>nst { createServer } = await import(path.resolve(rootDir, 'server.js'))
const { app, vite } = await createServer(
rootDir,
hmrPorts['optimize-missing-deps'],
)
return new Promise((resolve, reject) => {
... | fim | vitejs/vite | typescript |
<|fim_prefix|>import { s<|fim_suffix|>st name = sayName()
<|fim_middle|>ayName } from '@vitejs/test-missing-dep'
export con<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import { name } from '@<|fim_suffix|>y-dep'
export function sayName() {
return name
}
<|fim_middle|>vitejs/test-multi-entr<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>ts.name = 'Client'
<|fim_prefix|><|fim_middle|>expor<|endoftext|> | fim | vitejs/vite | javascript |
const path = require('node:path')
exports.name = path.normalize('./Server')
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>// @ts-check
import fs from 'node:fs'
import path from 'node:path'
import express from 'express'
const isTest = process.env.VITEST
export async function createServer(root = process.cwd(), hmrPort) {
const resolve = (p) => path.resolve(import.meta.dirname, p)
const app = express()
/**
* @type ... | fim | vitejs/vite | javascript |
<|fim_prefix|>import { describe, expect, test } from 'vitest'
import { browserLogs, isBuild, page } from '~utils'
test('should have no 404s', () => {
browserLogs.forEach((msg) => {
expect(msg).not.toMatch('404')
})
<|fim_suffix|>[-\w]{8}\.css"/,
)
})
})
<|fim_middle|>})
describe.runIf(isBuild)('build', ... | fim | vitejs/vite | typescript |
<|fim_prefix|>import { describe, expect, test } from 'vitest'
import { browserLogs, isBuild, page } from '~utils'
test('should have no 404s', () => {
browserLog<|fim_suffix|>.css"/,
)
})
})
<|fim_middle|>s.forEach((msg) => {
expect(msg).not.toMatch('404')
})
})
describe.runIf(isBuild)('build', () => {
... | fim | vitejs/vite | typescript |
<|fim_prefix|>import { describe, expect, test } from 'vitest'
import { browserLogs, isBuild, page <|fim_suffix|>ct(await page.textContent('#done')).toBe('ran js')
})
test('dynamic import with comments', async () => {
await page.click('#hello .load')
await page.waitForSelector('#hello output')
const ht... | fim | vitejs/vite | typescript |
<|fim_prefix|>expor<|fim_suffix|>msgFromA = 'From dep-a'
<|fim_middle|>t const <|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>port const msg = 'From dep-including-a'
<|fim_prefix|>export { msgFrom<|fim_middle|>A } from '@vitejs/test-dep-a'
ex<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>preloaded')
<|fim_prefix|>console.lo<|fim_middle|>g('<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import { msg } from '@vitejs/test-dep-i<|fim_suffix|>r('#about .msg').textContent = msg
<|fim_middle|>ncluding-a'
document.querySelecto<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>s] message from chunk.js'
<|fim_prefix|>export defau<|fim_middle|>lt '[succes<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import style from './hello.module<|fim_suffix|>)
msg.textContent = 'hello'
msg.classList.add(style.h1)
<|fim_middle|>.css'
const msg = document.querySelector('#hello .msg'<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import chunkMsg from './chunk'
docume<|fim_suffix|>id} .load`)
loadButton.addEventListener('click', async () => {
await loader()
loadButton.insertAdjacentHTML('afterend', '<output>loaded</output>')
})
}
<|fim_middle|>nt.querySelector('.chunk').textContent = chunkMsg
const ids = {
hello: as... | fim | vitejs/vite | javascript |
<|fim_suffix|>Chunks(id) {
// if (id.includes('chunk.js')) {
// return 'chunk'
// }
// },
},
},
modulePreload: false,
},
cacheDir: 'node_modules/.vite-preload-disabled',
})
<|fim_prefix|>import { defineConfig } from 'vite'
export default defineConfig({
build:... | fim | vitejs/vite | javascript |
<|fim_prefix|>import { defineConfig } from 'vite'
export default defineConfig({
build: {
outDir: 'dist/resolve-deps',
minify: 'terser',
terserOptions: {
format: {
beautify: true,
},
compress: {
passes: 3,
},
},
rolldownOptions: {
output: {
// ... | fim | vitejs/vite | javascript |
<|fim_suffix|> return 'chunk'
// }
// },
},
},
},
})
<|fim_prefix|>import { defineConfig } from 'vite'
export default defineConfig({
build: {
outDir: 'dist/normal',
minify: 'terser',
terserOptions: {
format: {
beautify: true,
},
compress: {
... | fim | vitejs/vite | typescript |
<|fim_suffix|>)
})
<|fim_prefix|>import { expect, test } from 'vitest'
import { browserLogs, page } from '~utils'
test('should have no 404s', () => {
browserLogs.forEach((msg) => {
<|fim_middle|>expect(msg).not.toMatch('404')
})
})
test('not-preserve-symlinks', async () => {
expect(await page.textContent('#... | fim | vitejs/vite | typescript |
<|fim_suffix|>ata
}
<|fim_prefix|>import { data } from './data'
export function sayHi() {
return <|fim_middle|>d<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>
<|fim_prefix|>export const data = {<|fim_middle|>
msg: 'hello vite',
}<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>ayHi() {
return data
}
<|fim_prefix|>import { da<|fim_middle|>ta } from './data'
export function s<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>
document.getElementById('root').innerText = sayHi().msg
<|fim_prefix|>import { sayHi } fr<|fim_middle|>om '@vitejs/test-module-a'
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>runIf(isServe)('proxy error returns 502', async () => {
const res = await fetch(viteTestUrl + '/proxyError')
expect(res.status).toBe(502)
})
<|fim_prefix|>import { expect, test, vi } from 'vitest'
import { browserLogs, isServe, page, serverLogs, viteTestUrl } from '~utils'
test('proxy-bypass', a<|fim... | fim | vitejs/vite | typescript |
<|fim_prefix|>import { defineConfig } from 'vite'
const timeout = (ms) => new Promise((r) => setTimeout(r, ms))
export default defineConfig({
server: {
port: 9606,
proxy: {
'/nonExistentApp': {
target: 'http://localhost:9607',
bypass: () => {
return false
},
<|f... | fim | vitejs/vite | javascript |
<|fim_prefix|>import { expect, test } from 'vitest'
import {
editFile,
isBuild,
page,
untilBrowserLogAfter,
viteTestUrl,
} from '~utils'
test.runIf(!isBuild)('pr<|fim_suffix|>ted/],
)
const otherAppTextLocator = page.frameLocator('iframe').locator('.content')
await expect
.poll(() => otherAppTextL... | fim | vitejs/vite | typescript |
<|fim_suffix|>rootDir, setViteUrl } from '~utils'
export async function serve(): Promise<{ close(): Promise<void> }> {
const vite = await import('vite')
const rootServer = await vite.createServer({
root: rootDir,
logLevel: 'silent',
})
const otherServer = await vite.createServer({
root: path.join(r... | fim | vitejs/vite | typescript |
<|fim_suffix|> port: 9617,
strictPort: true,
},
})
<|fim_prefix|>import { defineConfig } from 'vite'
export default defineConf<|fim_middle|>ig({
base: '/anotherApp',
server: {
<|endoftext|> | fim | vitejs/vite | javascript |
import { defineConfig } from 'vite'
export default defineConfig({
server: {
port: 9616,
proxy: {
'/anotherApp': {
target: 'http://localhost:9617',
ws: true,
},
},
},
})
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import { expect, tes<|fim_suffix|>xtContent('.custom-browser-main-field')).toBe(
'resolved custom field',
)
})
<|fim_middle|>t } from 'vitest'
import { page } from '~utils'
test('resolve.mainFields.custom-first', async () => {
expect(await page.te<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|>a library
const pathToViteMonorepoRoot = new URL('../../../', import.meta.url)
const urlPath = fileURLToPath(pathToViteMonorepoRoot).replace(/\/$/, '')
await page.goto(viteTestUrl + urlPath)
expect(await page.locator('vite-error-overlay').count()).toBe(0)
expect(await page.textContent(... | fim | vitejs/vite | typescript |
<|fim_prefix|>import { expect, test } from 'vitest'
import { findAssetFile, isBuild } from '~utils'
test.runIf(isBuild)('sass @use with node builtin name does not panic', () => {
const <|fim_suffix|>ontain('cursor:pointer')
})
<|fim_middle|>css = findAssetFile(/entry/, 'sass-node-builtin-clash')
expect(css).toC<|e... | fim | vitejs/vite | typescript |
export default '[success] absolute'
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>
export default message
<|fim_prefix|>import message from '@vitejs/test-resolve-browser-field-bare-<|fim_middle|>import-fail'<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>e.log('this should not run in the browser')
<|fim_prefix|>const fs = <|fim_middle|>require('node:fs')
consol<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|> from 'jsdom' // should be redirected to empty module
export default ''
<|fim_prefix|>import jsdo<|fim_middle|>m<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import jsdom from 'jsdom' // should <|fim_suffix|>ule
export default ''
<|fim_middle|>be redirected to empty mod<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>er')
<|fim_prefix|>const fs = require('node:<|fim_middle|>fs')
console.log('this should not run in the brows<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>export def<|fim_suffix|> 'fail'
<|fim_middle|>ault<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|> // should be redirected to empty module
export default '[success] resolve browser field'
<|fim_prefix|>import jsdom from 'jsdom<|fim_middle|>'<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>/* eslint-disable import-x/no-duplicates */
import ra from './no-ext'
import rb from './no-ext.js' // no substitution
import rc from './ext'
import rd from './ext.js'
import re from './ext-index/index.js'
import rf from './no-ext-index/index.js' // no substitution
export { ra, rb, r<|fim_suffix|> rf }
<|... | fim | vitejs/vite | javascript |
<|fim_suffix|>t default '[fail]'
<|fim_prefix|>expo<|fim_middle|>r<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>export <|fim_suffix|> '[fail]'
<|fim_middle|>default<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|><|fim_prefix|>export def<|fim_middle|>ault '[fail]'
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>e<|fim_suffix|>cess]'
<|fim_middle|>xport default '[suc<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>export default '[fail] thi<|fim_suffix|>n the browser'
<|fim_middle|>s should not run i<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>ault '[success] this should run in browser'
<|fim_prefix|>export<|fim_middle|> def<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>export const m<|fim_suffix|>eld'
<|fim_middle|>sg = 'resolved browser fi<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|> custom field'
<|fim_prefix|>export cons<|fim_middle|>t msg = 'resolved<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>in field'
<|fim_prefix|>export con<|fim_middle|>st msg = '[fail] resolved ma<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>st msg = '[success] custom condition'
<|fim_prefix|>export<|fim_middle|> con<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>exp<|fim_suffix|>msg = '[fail]'
<|fim_middle|>ort const <|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>export co<|fim_suffix|>'
<|fim_middle|>nst msg = '[success] custom main field<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>t const msg = '[fail]'
<|fim_prefix|>e<|fim_middle|>xpor<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>export const<|fim_suffix|>'
<|fim_middle|> file = 'dir/index.js<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>export const file = '[success] ./<|fim_suffix|>index.js'
<|fim_middle|>dir-with-ext/<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>'[success] dir.js'
<|fim_prefix|>export const fi<|fim_middle|>le = <|endoftext|> | fim | vitejs/vite | javascript |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.