text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_suffix|>ementById('root')!).render(
<StrictMode>
<App />
</StrictMode>,
)
<|fim_prefix|>import { StrictMode } from 'react'
import { createRoot } from 'react-dom/client'
import './in<|fim_middle|>dex.css'
import App from './App.tsx'
createRoot(document.getEl<|endoftext|> | fim | vitejs/vite | typescript |
import { defineConfig } from 'vite'
import react from '@vitejs/plugin-react'
// https://vite.dev/config/
export default defineConfig({
plugins: [react()],
})
<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|> <use href="/icons.svg#github-icon"></use>
</svg>
GitHub
</a>
</li>
<li>
<a href="https://chat.vite.dev/" target="_blank">
<svg class="button-icon" role="presentation" aria-hidden="true">
... | fim | vitejs/vite | javascript |
/* @refresh reload */
import { render } from 'solid-js/web'
import './index.css'
import App from './App.jsx'
const root = document.getElementById('root')
render(() => <App />, root)
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import { defineConfig } from <|fim_suffix|>lid'
export default defineConfig({
plugins: [solid()],
})
<|fim_middle|>'vite'
import solid from 'vite-plugin-so<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|> class="framework" alt="Solid logo" />
<img src={viteLogo} class="vite" alt="Vite logo" />
</div>
<div>
<h1>Get started</h1>
<p>
Edit <code>src/App.tsx</code> and save to test <code>HMR</code>
</p>
</div>
<button
... | fim | vitejs/vite | typescript |
<|fim_prefix|>/* @refresh reload */
import { render } fro<|fim_suffix|> 'solid-js/web'
import './index.css'
import App from './App.tsx'
const root = document.getElementById('root')
render(() => <App />, root!)
<|fim_middle|>m<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|>solid()],
})
<|fim_prefix|>import { defineConfig } fr<|fim_middle|>om 'vite'
import solid from 'vite-plugin-solid'
export default defineConfig({
plugins: [<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>import { mount } from 'svelte'
import './app.css'
import App from './App.sv<|fim_suffix|>'),
})
export default app
<|fim_middle|>elte'
const app = mount(App, {
target: document.getElementById('app<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>/** @type {import("@sveltejs/vite-plugin-svelte")<|fim_suffix|> default {}
<|fim_middle|>.SvelteConfig} */
export<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>ins: [svelte()],
})
<|fim_prefix|>import { defineConfig } from 'vite'
import { svelte } from '@sveltejs/vite-plugin-sv<|fim_middle|>elte'
// https://vite.dev/config/
export default defineConfig({
plug<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import { mou<|fim_suffix|>e'
const app = mount(App, {
target: document.getElementById('app')!,
})
export default app
<|fim_middle|>nt } from 'svelte'
import './app.css'
import App from './App.svelt<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|>*/
export default {}
<|fim_prefix|>/** @type <|fim_middle|>{import("@sveltejs/vite-plugin-svelte").SvelteConfig} <|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>e'
// https://vite.dev/config/
export default defineConfig({
plugins: [svelte()],
})
<|fim_prefix|>import { defineConfig } from 'vite'
import { svelte } from '@sveltejs<|fim_middle|>/vite-plugin-svelt<|endoftext|> | fim | vitejs/vite | typescript |
export function setupCounter(element) {
let counter = 0
const setCounter = (count) => {
counter = count
element.innerHTML = `Count is ${counter}`
}
element.addEventListener('click', () => setCounter(counter + 1))
setCounter(0)
}
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>dden="true"><use href="/icons.svg#github-icon"></use></svg>GitHub</a></li>
<li><a href="https://chat.vite.dev/" target="_blank"><svg class="button-icon" role="presentation" aria-hidden="true"><use href="/icons.svg#discord-icon"></use></svg>Discord</a></li>
<li><a href="https://x.com/vite_js" t... | fim | vitejs/vite | javascript |
<|fim_suffix|>{counter}`
}
element.addEventListener('click', () => setCounter(counter + 1))
setCounter(0)
}
<|fim_prefix|>export f<|fim_middle|>unction setupCounter(element: HTMLButtonElement) {
let counter = 0
const setCounter = (count: number) => {
counter = count
element.innerHTML = `Count is $<|en... | fim | vitejs/vite | typescript |
<|fim_prefix|>import './style.css'
import typescriptLogo from './assets/typescript.svg'
import viteLogo from './assets/vite.svg'
import heroImg from './assets/hero.png'
import { setupCounter } from './counter.ts'
document.querySelector<HTMLDivElement>('#app')!.innerHTML = `
<section id="center">
<div class="hero">
... | fim | vitejs/vite | typescript |
<|fim_suffix|>eApp(App).mount('#app')
<|fim_prefix|>import { createApp } from 'vue'
import './style.css'
import Ap<|fim_middle|>p from './App.vue'
creat<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>/plugin-vue'
// https://vite.dev/config/
export default defineConfig({
plugins: [vue()],
})
<|fim_prefix|>import { defineConfig } from 'vite'
import v<|fim_middle|>ue from '@vitejs<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import <|fim_suffix|>p')
<|fim_middle|>{ createApp } from 'vue'
import './style.css'
import App from './App.vue'
createApp(App).mount('#ap<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>import { defineCo<|fim_suffix|>ins: [vue()],
})
<|fim_middle|>nfig } from 'vite'
import vue from '@vitejs/plugin-vue'
// https://vite.dev/config/
export default defineConfig({
plug<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|>idate the remainder of the License, and in such case Affirmer hereby
affirms that he or she will not (i) exercise any of his or her remaining
Copyright and Related Rights in the Work or (ii) assert any associated claims
and causes of action with respect to the Work, in either case contrary to
Affirmer's e... | fim | vitejs/vite | typescript |
<|fim_suffix|>element with hyphen', '<link-preview rel="modulepreload">'],
['bare link tag', '<link>'],
['stylesheet link', '<link rel="stylesheet" href="/assets/x.css">'],
['preload (not modulepreload)', '<link rel="preload" href="/assets/x.js">'],
[
'attribute name ending in rel',
'<link x... | fim | vitejs/vite | typescript |
<|fim_prefix|>import fs from 'node:fs'
import path from 'node:path'
import { expect, test } from 'vitest'
import { cspHashes } from '..'
test('CSP hashes in README.md should be correct', () => {
const readme = fs.readFileSync(
pa<|fim_suffix|>...readme.matchAll(/`sha256-(.+)`/g)].map(
(match) => match[1],
... | fim | vitejs/vite | typescript |
<|fim_prefix|>import { describe, expect, test } from 'vitest'
import type { ecmaVersion } from 'acorn'
import { parse } from 'acorn'
import {
createModernChunkLegacyGuard,
detectModernBrowserCode,
detectModernBrowserDetector,
dynamicFallbackInlineCode,
safari10NoModuleFix,
systemJSInlineCode,
} from '../sni... | fim | vitejs/vite | typescript |
<|fim_prefix|>import path from 'node:path'
import crypto from 'node:crypto'
import { createRequire } from 'node:module'
import { fileURLToPath } from 'node:url'
import { build, normalizePath } from 'vite'
import MagicString from 'magic-string'
import type {
BuildOptions,
HtmlTagDescriptor,
Plugin,
ResolvedConfi... | fim | vitejs/vite | typescript |
<|fim_suffix|>-polyfill-regenerator'
<|fim_prefix|>declare module 'babel-plugin-polyfill-corejs3'
declare module 'babel-<|fim_middle|>plugin<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|>nction(){${systemJSInlineCode}},document.body.appendChild(n)}();`
export const createModernChunkLegacyGuard = (chunkId: string): string =>
`import'${createDetectImportMetaResolveSupportModule(chunkId)}';export function __vite_legacy_guard(){${detectModernBrowserDetector}};`
<|fim_prefix|>// https://gis... | fim | vitejs/vite | typescript |
<|fim_suffix|>fills?: string[]
/**
* default: false
*/
modernPolyfills?: boolean | string[]
/**
* default: true
*/
renderLegacyChunks?: boolean
/**
* default: false
*/
externalSystemJS?: boolean
/**
* default: true
*/
renderModernChunks?: boolean
/**
* @see https://babeljs.i... | fim | vitejs/vite | typescript |
<|fim_prefix|>import { type UserConfig, defineConfig } from 'tsdown'
export default defineConfig({
entry: ['src/index.ts'],
targe<|fim_suffix|> UserConfig
<|fim_middle|>t: 'node20',
tsconfig: false, // disable tsconfig `paths` when bundling
dts: true,
fixedExtension: false,
deps: {
onlyBundle: ['picoco... | fim | vitejs/vite | typescript |
<|fim_prefix|>/*
Copyright (c) 2015-present, Facebook, Inc.
This source code is licensed under the MIT license found in the
LICENSE file at
https://github.com/react/create-react-app/blob/main/LICENSE
*/
/* global Application */
// eslint-disable-next-line @typescript-eslint/no-unused-vars
function run(argv) {
cons... | fim | vitejs/vite | javascript |
<|fim_suffix|>() => {
session.post('Profiler.start', start)
})
} else {
start()
}
<|fim_prefix|>#!/usr/bin/env node
import { performance } from 'node:perf_hooks'
import module from 'node:module'
if (!import.meta.url.includes('node_modules')) {
if (!process.env.DEBUG_DISABLE_SOURCE_MAP) {
// eslint-disabl... | fim | vitejs/vite | javascript |
<|fim_suffix|>' {
const src: string
export default src
}
declare module '*?inline' {
const src: string
export default src
}
declare module '*?no-inline' {
const src: string
export default src
}
declare module '*?url&inline' {
const src: string
export default src
}
declare module '*?url&no-inline' {
... | fim | vitejs/vite | typescript |
<|fim_prefix|>declare<|fim_suffix|><|fim_middle|> const result: boolean
export default result
<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|>false
<|fim_prefix|>export de<|fim_middle|>fault <|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>decla<|fim_suffix|>nst result: boolean
export default result
<|fim_middle|>re co<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|>
<|fim_prefix|><|fim_middle|>export default true<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import { readFileSync, writeFileSync } from 'node:fs'
import path from 'node:path'
import MagicString from 'magic-string'
import type { Plugin } from 'rolldown'
import { defineConfig } from 'rolldown'
import { ImportType, init, parse } from 'es-module-lexer'
import licensePlugin from './rollupLicensePlugi... | fim | vitejs/vite | typescript |
<|fim_suffix|>,
bindings: node.specifiers.map((s) => stringifyModuleExportName(s.local)),
locals: [],
}
}
if (node.type === 'ExportAllDeclaration') {
if (!node.source) return undefined
return { id: node.source.value, bindings: ['*'], locals: [] }
}
}
function getAllImportBindings(ast: Pro... | fim | vitejs/vite | typescript |
<|fim_prefix|>import fs from 'node:fs'
import license from 'rollup-plugin-license'
import type { Dependency } from 'rollup-plugin-license'
import colors from 'picocolors'
import type { Plugin, PluginContext } from 'rollup'
export default function licensePlugin(
licenseFilePath: string,
licenseTitle: string,
pack... | fim | vitejs/vite | typescript |
<|fim_suffix|>target)) {
deps.push(target)
}
}
}
return { edges, entry: moduleId(0) }
}
// ---------------------------------------------------------------------------
// Benchmark plugin (resolveId + load)
// ---------------------------------------------------------------------------
const BENC... | fim | vitejs/vite | typescript |
<|fim_suffix|>ts)
<|fim_prefix|>import { getCompatibleVersions } from 'baseline-browser-mapping'
// Update on each major release
const targetDate = '2026-01-01'
// https://esbuild.github.io/api/#target
const baselineToEsbuildTargetMap: Record<string, string> = {
chrome: 'chrome',
edge: 'edge',
firefox: 'firefox... | fim | vitejs/vite | typescript |
<|fim_suffix|>that can occur when swapping out the tag href
// directly, as the new stylesheet has not yet been loaded.
return new Promise((resolve) => {
const newLinkTag = el.cloneNode() as HTMLLinkElement
newLinkTag.href = new URL(newPath, el.href).href
const re... | fim | vitejs/vite | typescript |
<|fim_prefix|>declare const __DEFINES__: Record<string, any>
const context = (() <|fim_suffix|>ct.keys(defines).forEach((key) => {
const segments = key.split('.')
let target = context
for (let i = 0; i < segments.length; i++) {
const segment = segments[i]
if (i === segments.length - 1) {
target[seg... | fim | vitejs/vite | typescript |
import type { ErrorPayload } from '#types/hmrPayload'
// injected by the hmr plugin when served
declare const __BASE__: string
declare const __HMR_CONFIG_NAME__: string
const hmrConfigName = __HMR_CONFIG_NAME__
const base = __BASE__ || '/'
export const cspNonce =
'document' in globalThis
? document.querySelect... | fim | vitejs/vite | typescript |
<|fim_suffix|>portMeta is assignable to ImportMeta
// (which includes @types/node augmentations: dirname, filename, url, resolve, main)
ExpectTrue<ExpectExtends<Omit<ImportMeta, 'main'>, ModuleRunnerImportMeta>>,
]
export {}
<|fim_prefix|>/**
* Type test to verify ModuleRunnerImportMeta is structurally compatible... | fim | vitejs/vite | typescript |
<|fim_prefix|>// they are exported from ssrTransform plugin, but we can't import from there for performance reasons
export const ssrModuleExportsKey = `__vite_ssr_exports__`
export const ssrImportKey = `__vite_ssr_import__`
export co<|fim_suffix|>xportNameKey = `__vite_ssr_exportName__`
export const ssrImportMetaKey = ... | fim | vitejs/vite | typescript |
<|fim_prefix|>import { isWindows } from '../shared/utils'
import { createImportMetaResolver } from './importMetaResolver'
import type { ModuleRunnerImportMeta } from './types'
import { posixDirname, posixPathToFileHref, toWindowsPath } from './utils'<|fim_suffix|>(filename) : filename,
dirname: isWindows ? toWindow... | fim | vitejs/vite | typescript |
<|fim_prefix|>import {
AsyncFunction,
getAsyncFunctionDeclarationPaddingLineCount,
} from '../shared/utils'
import {
ssrDynamicImportKey,
ssrExportAllKey,
ssrExportNameKey,
ssrImportKey,
ssrImportMetaKey,
ssrModuleExportsKey,
} from './constants'
import type { Mod<|fim_suffix|>Key],
)
Object.se... | fim | vitejs/vite | typescript |
<|fim_suffix|>d.map
}
public clear(): void {
this.idToModuleMap.clear()
this.fileToModulesMap.clear()
this.urlToIdModuleMap.clear()
}
}
// unique id that is not available as "$bare_import" like "test"
// https://nodejs.org/api/modules.html#built-in-modules-with-mandatory-node-prefix
const prefixedBu... | fim | vitejs/vite | typescript |
<|fim_suffix|>payload.updates.map(async (update): Promise<void> => {
if (update.type === 'js-update') {
// runner always caches modules by their full path without /@id/ prefix
update.acceptedPath = unwrapId(update.acceptedPath)
update.path = unwrapId(update.path)
... | fim | vitejs/vite | typescript |
<|fim_suffix|>st silentConsole: HMRLogger = {
debug: noop,
error: noop,
}
export const hmrLogger: HMRLogger = {
debug: (...msg) => console.log('[vite]', ...msg),
error: (error) => console.log('[vite]', error),
}
<|fim_prefix|>import type { HMRLogger } from '../shared<|fim_middle|>/hmr'
const noop = (): void =... | fim | vitejs/vite | typescript |
<|fim_suffix|>CustomHook
}
function importMetaResolveWithCustomHook(
specifier: string,
importer: string,
): string {
return import.meta.resolve(
`${customizationHookNamespace}${JSON.stringify([specifier, importer])}`,
)
}
// NOTE: use computed string to avoid `define` replacing `import.meta.resolve` when... | fim | vitejs/vite | typescript |
<|fim_prefix|>// this file should re-export only things that don't rely on Node.js or other runner features
export {
EvaluatedModules,
normalizeModuleId,
type EvaluatedModuleNode,
} from './evaluatedModules'
export { ModuleRunner } from './runner'
export { ESModulesEvaluator } from './esmEvaluator'
export {
cr... | fim | vitejs/vite | typescript |
<|fim_prefix|>import type { ViteHotContext } from '#types/hot'
import { HMRClient, HMRContext, type HMRLogger } from '../shared/hmr'
import { cleanUrl, isPrimitive } from '../shared/utils'
import { analyzeImportedModDifference } from '../shared/ssrTransform'
import {
type NormalizedModuleRunnerTransport,
normalizeM... | fim | vitejs/vite | typescript |
<|fim_prefix|>import type { OriginalMapping } from '@jridgewell/trace-mapping'
import { originalPositionFor } from '@jridgewell/trace-mapping'
import { posixDirname, posixResolve } from '../utils'
interface SourceMapLike {
version: number
mappings?: string
names?: string[]
sources?: string[]
sourcesContent?:... | fim | vitejs/vite | typescript |
<|fim_suffix|>eptStackTrace(
runner,
typeof runner.options.sourcemapInterceptor === 'object'
? runner.options.sourcemapInterceptor
: undefined,
)
}
<|fim_prefix|>import <|fim_middle|>type { ModuleRunner } from '../runner'
import { interceptStackTrace } from './interceptor'
export function enableS... | fim | vitejs/vite | typescript |
<|fim_prefix|>import type { OriginalMapping } from '@jridgewell/trace-mapping'
import type { ModuleRunner } from '../runner'
import { posixDirname, posixResolve } from '../utils'
import type { EvaluatedModules } from '../evaluatedModules'
import { slash } from '../../shared/utils'
import { DecodedMap, getOriginalPositi... | fim | vitejs/vite | typescript |
<|fim_prefix|>import type { ViteHotContext } from '#types/hot'
import type { HMRLogger } from '../shared/hmr'
import type {
DefineImportMetadata,
SSRImportMetadata,
} from '../shared/ssrTransform'
import type {
ExternalFetchResult,
FetchFunctionOptions,
FetchResult,
ViteFetchResult,
} from '../shared/invoke... | fim | vitejs/vite | typescript |
import * as pathe from 'pathe'
import { isWindows } from '../shared/utils'
const textDecoder = new TextDecoder()
export const decodeBase64: (base64: string) => string = (() => {
if (typeof Buffer === 'function' && typeof Buffer.from === 'function') {
return (base64: string) => Buffer.from(base64, 'base64').toSt... | fim | vitejs/vite | typescript |
<|fim_prefix|>import { describe, expect, test } from 'vitest'
import { type DefaultTreeAdapterMap, parseFragment } from 'parse5'
import { getNodeAssetAttributes } from '../assetSource'
describe('getNodeAssetAttributes', () => {
const getNode = (html: string) => {
const ast = parseFragment(html, { sourceCodeLocat... | fim | vitejs/vite | typescript |
<|fim_prefix|>import { basename, resolve } from 'node:path'
import { stripVTControlCharacters } from 'node:util'
import fsp from 'node:fs/promises'
import colors from 'picocolors'
import { afterEach, describe, expect, test, vi } from 'vitest'
import type {
LogLevel,
OutputChunk,
OutputOptions,
RolldownOptions,
... | fim | vitejs/vite | typescript |
<|fim_suffix|>alse,
},
},
},
}),
).toMatchInlineSnapshot(`
{
"client": false,
"custom": false,
"customFalse": false,
"customTrue": true,
"ssr": false,
}
`)
})
describe('loadConfigFromFile', () => {
const fixtures = path.resolve(import.meta.dirname... | fim | vitejs/vite | typescript |
<|fim_suffix|>n), origin).toBe(false)
}
})
<|fim_prefix|>import { expect, test } from 'vitest'
import { defaultAllowedOrigins } from '../constants'
test('defaultAllowedOrigins', () => {
const allowed = [
'http://localhost',
'http://foo.localhost',
'http://localhost:3000',
'https://localhost:3000',
... | fim | vitejs/vite | typescript |
<|fim_suffix|>h(async () => {
await server?.close()
})
test('resolves the server URLs before the httpServer listening events are called', async () => {
expect.assertions(1)
const options = {
port: 5013, // make sure the port is unique
}
const { promise, resolve } =
promiseWithReso... | fim | vitejs/vite | typescript |
<|fim_suffix|> `)
})
test('VITE_USER_NODE_ENV', () => {
loadEnv('development', join(dirname, './env'))
expect(process.env.VITE_USER_NODE_ENV).toEqual(undefined)
})
test('VITE_USER_NODE_ENV for dev behaviour in build', () => {
const _nodeEnv = process.env.NODE_ENV
process.env.NODE_ENV = 'prod... | fim | vitejs/vite | typescript |
import path from 'node:path'
import { describe, expect, onTestFinished, test } from 'vitest'
import type { RolldownOutput } from 'rolldown'
import { createServer } from '../server'
import type { InlineConfig } from '../config'
import { createBuilder } from '../build'
import { createServerModuleRunner } from '../ssr/run... | fim | vitejs/vite | typescript |
<|fim_suffix|>) => {
const isExternal = await createIsExternal(true)
expect(isExternal('@vitejs/cjs-ssr-dep')).toBe(true)
})
})
async function createIsExternal(external?: true) {
const resolvedConfig = await resolveConfig(
{
configFile: false,
root: fileURLToPath(new URL('./', import.meta.u... | fim | vitejs/vite | typescript |
<|fim_suffix|>rkerImportMetaUrlRE.lastIndex = 0
expect(
workerImportMetaUrlRE.test(
`new Worker(new URL('./worker.js', import.meta.url))`,
),
).toBe(true)
})
})
<|fim_prefix|>import { describe, expect, test } from 'vitest'
import { assetImportMetaUrlRE } from '../plugins/assetImportMetaUrl... | fim | vitejs/vite | typescript |
<|fim_prefix|>// eslint-disa<|fim_suffix|>o-undef
module.exports = {
hello: () => 'world',
}
<|fim_middle|>ble-next-line n<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|><|fim_prefix|>export default 'imports-field<|fim_middle|>'
<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|>kg.name,
}
<|fim_prefix|>// We have to import external json to prevent Vite / esbuild from bundling it.
import pkg <|fim_middle|>from 'vite/package.json' with { type: 'json' }
export default {
jsonValue: p<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|>mports-field'
export default {
array,
moduleCondition,
importsField,
}
<|fim_prefix|>import moduleCondition from '@vite/test-config-plugin-module-condition'
import { array } from '../siblings/foo'
import importsField <|fim_middle|>from '#i<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|>ta
.resolve('../import-meta/vite.config.ts'),
}
<|fim_prefix|>export default {
isMain: import.meta.main,
url: import.meta.url,
dirname: import.meta.dirname,
filename: import.meta.filename,
resolved: import.meta.resolve('..<|fim_middle|>/import-meta/vite.config.ts'),
// prettier-ignore
re... | fim | vitejs/vite | typescript |
<|fim_prefix|>export defau<|fim_suffix|>works',
}
<|fim_middle|>lt {
value: '<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>con<|fim_suffix|>tring
export default str
<|fim_middle|>st str: s<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>ex<|fim_suffix|>ion'
<|fim_middle|>port default 'import condit<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>export defau<|fim_suffix|>e condition'
<|fim_middle|>lt 'modul<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>me,
}
<|fim_prefix|>#!/usr/bin/env node
export default {
dirname: import.m<|fim_middle|>eta.dirna<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>import lodash from 'l<|fim_suffix|> = lodash.partition([1, 2, 3, 4], (n) => n % 2)
<|fim_middle|>odash'
export const array<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|><|fim_suffix|>port const hello = 'hello'
<|fim_middle|>ex<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>')
console.log(mod)
}
<|fim_prefix|>export async function main() {
<|fim_middle|> const mod = await import('./dep.mjs<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import './css-normal.css'
import cssModule fro<|fim_suffix|>t default function Page() {
console.log(cssModule)
}
<|fim_middle|>m './css-module.module.css'
expor<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>export const msg = `[success] <|fim_suffix|>lient) alias to mod path`
<|fim_middle|>(c<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>ias to mod path`
<|fim_prefix|>ex<|fim_middle|>port const msg = `[success] (rsc) al<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>s] (ssr) alias to mod path`
<|fim_prefix|>export const ms<|fim_middle|>g = `[succes<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>expo<|fim_suffix|><|fim_middle|>rt default 'ok'
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>interface Test {
<|fim_suffix|>ield: true
}
export const test: Test = {
field: true,
}
<|fim_middle|> f<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|>orts = {}
<|fim_prefix|>mod<|fim_middle|>ule.exp<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>expo<|fim_suffix|>ult 'ok'
<|fim_middle|>rt defa<|endoftext|> | fim | vitejs/vite | typescript |
export default () => import('./dynamic-import-dep')
<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>import { Plugin <|fim_suffix|>t function testPlugin(): Plugin {
return {
name: 'test',
}
}
<|fim_middle|>} from 'vite'
export defaul<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|>)],
})
<|fim_prefix|>import { defineConfig } from 'vite'
import plugin from './plugin'
export <|fim_middle|>default defineConfig({
root: './test',
plugins: [plugin(<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|>
<|fim_prefix|>exp<|fim_middle|>ort const pages = import.meta.glob('./pages/*.tsx')
export default <div /><|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>;(globalThis as any).__test_scan_jsx<|fim_suffix|>(globalThis as any).__test_scan_jsx_runtime++
export default <div />
<|fim_middle|>_runtime ??= 0
;<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|>ort default vue
<|fim_prefix|>import * as vue from 'vue'
e<|fim_middle|>xp<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>export de<|fim_suffix|><|fim_middle|>fault <main />
<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>export const modu<|fim_suffix|>.glob('#src/foo/*.ts')
<|fim_middle|>les = import.meta<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|>onst value = 'a'
<|fim_prefix|>export <|fim_middle|>c<|endoftext|> | fim | vitejs/vite | typescript |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.