text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_suffix|> {
const localName = `__vite__cjsExport${
spec.exported.type === 'Literal'
? `L_${getHash(spec.exported.value)}`
: 'I_' + spec.exported.name
}`
importNames.push({ importedName, localName })
exportNames.push(
`${loc... | fim | vitejs/vite | typescript |
<|fim_suffix|> return fileDeps.push({ url, runtime }) - 1
} else {
return index
}
}
if (imports.length) {
for (let index = 0; index < imports.length; index++) {
// To handle escape sequences in specifier strings, the .n field will ... | fim | vitejs/vite | typescript |
<|fim_suffix|>pre = ''
if (glob[0] === '!') {
pre = '!'
glob = glob.slice(1)
}
root = globSafePath(root)
let dir
if (base) {
if (base[0] === '/') {
dir = posix.join(root, base)
} else {
dir = posix.resolve(
importer ? globSafePath(dirname(importer)) : root,
base,
... | fim | vitejs/vite | typescript |
<|fim_suffix|>ugin)
if (filters && hookName in filters) {
return filters[hookName]
}
if (!filters) {
filters = {}
filterForPlugin.set(plugin, filters)
}
let filter: PluginFilter | TransformHookFilter | undefined
switch (hookName) {
case 'resolveId': {
const rawFilter = extractFilter(... | fim | vitejs/vite | typescript |
<|fim_prefix|>export interface JsonOptions {
/**
* Generate a named export for every property of the JSON object
* @default true
*/
namedExports?: boolean
/**
* Generate performant output as JSON.parse("stringified").
*
*<|fim_suffix|>
}
const jsonLangs = `\\.(?:json|json5)(?:$|\\?)`
const json... | fim | vitejs/vite | typescript |
<|fim_prefix|>import fs from 'node:fs'
import path from 'node:path'
import type { Plugin } from '../plugin'
import { isInNodeModules, sortObjectKeys } from '../utils'
import type { PackageCache } from '../packages'
import { findNearestMainPackageData } from '../packages'
export interface LicenseEntry {
/**
* Pack... | fim | vitejs/vite | typescript |
<|fim_prefix|>import path from 'node:path'
import type { OutputChunk, RenderedChunk } from 'rolldown'
import { viteManifestPlugin as nativeManifestPlugin } from 'rolldown/experimental'
import type { Plugin } from '../plugin'
import { normalizePath } from '../utils'
import { perEnvironmentState } from '../environment'
i... | fim | vitejs/vite | typescript |
<|fim_prefix|>import { exactRegex } from 'rolldown/filter'
import { viteModulePreloadPolyfillPlugin as nativeModulePreloadPolyfillPlugin } from 'rolldown/experimental'
import type { Plugin } <|fim_suffix|>n'
export const modulePreloadPolyfillId = 'vite/modulepreload-polyfill'
const resolvedModulePreloadPolyfillId = '\... | fim | vitejs/vite | typescript |
<|fim_prefix|>import fsp from 'node:fs/promises'
import colors from 'picocolors'
import type { DevEnvironment } from '..'
import type { Plugin } from '../plugin'
import {
DEP_VERSION_RE,
ERR_FILE_NOT_FOUND_IN_OPTIMIZED_DEP_DIR,
ERR_OPTIMIZE_DEPS_PROCESSING_ERROR,
} from '../constants'
import { createDebugger } fr... | fim | vitejs/vite | typescript |
<|fim_suffix|>sxOptions: OxcJsxOptions = {}
switch (esbuildTransformOptions.jsx) {
case 'automatic':
jsxOptions.runtime = 'automatic'
if (esbuildTransformOptions.jsxImportSource) {
jsxOptions.importSource = esbuildTransformOptions.jsxImportSource
}
break
case '... | fim | vitejs/vite | typescript |
import path from 'node:path'
import picomatch from 'picomatch'
import type { ModuleTypeFilter } from 'rolldown'
import { arraify } from '../utils'
import { slash } from '../../shared/utils'
export type PluginFilter = (input: string) => boolean
export type TransformHookFilter = (
id: string,
code: string,
moduleT... | fim | vitejs/vite | typescript |
<|fim_prefix|>import path from 'node:path'
import fs from 'node:fs'
import type {
Alias,
AliasOptions,
DepOptimizationOptions,
DevEnvironment,
ResolvedConfig,
} from '..'
import type { Plugin } from '../plugin'
import {
bareImportRE,
isInNodeModules,
isOptimizable,
moduleListContains,
} from '../utils... | fim | vitejs/vite | typescript |
<|fim_suffix|>` below reads the entries of
// `outDir`. Without this, those reads would be recorded as build inputs
// and mix with the writes that follow, tripping Vite Task's read-write
// overlap check.
ignoreInput(outDir)
if (emptyOutDir !== false && fs.existsSync(outDir)) {
// skip those ... | fim | vitejs/vite | typescript |
<|fim_suffix|>rt function buildReporterPlugin(config: ResolvedConfig): Plugin {
return perEnvironmentPlugin('native:reporter', (env) => {
const tty = process.stdout.isTTY && !process.env.CI
const shouldLogInfo = LogLevels[config.logLevel || 'info'] >= LogLevels.info
const assetsDir = path.join(env.config.... | fim | vitejs/vite | typescript |
<|fim_prefix|>import fs from 'node:fs'
import path from 'node:path'
import colors from 'picocolors'
import type { PartialResolvedId } from 'rolldown'
import { viteResolvePlugin } from 'rolldown/experimental'
import { exports, imports } from 'resolve.exports'
import type { Plugin } from '../plugin'
import {
CLIENT_ENT... | fim | vitejs/vite | typescript |
<|fim_prefix|>import { pathToFileURL } from 'node:url'
import { WorkerWithFallback } from 'artichokie'
import type {
TerserMinifyOptions,
TerserMinifyOutput,
} from '#types/internal/terserOptions'
import type { Plugin } from '../plugin'
import type { ResolvedConfig } from '..'
import { _dirname, generateCodeFrame }... | fim | vitejs/vite | typescript |
<|fim_prefix|>import fsp from 'node:fs/promises'
import MagicString from 'magic-string'
import { exactRegex } from 'rolldown/filter'
import type { RolldownMagicString } from 'rolldown'
import { createToImportMetaURLBasedRelativeRuntime } from '../build'
import { type Plugin, perEnvironmentPlugin } from '../plugin'
impo... | fim | vitejs/vite | typescript |
<|fim_suffix|>e: string): string {
const hash = getHash(entryFilename)
if (!this.fileNameHash.has(hash)) {
this.fileNameHash.set(hash, entryFilename)
}
return `__VITE_WORKER_ASSET__${hash}__`
}
}
export type WorkerType = 'classic' | 'module' | 'ignore'
export const workerOrSharedWorkerRE: RegE... | fim | vitejs/vite | typescript |
<|fim_suffix|>Url(file)
) {
s.update(expStart, expEnd, 'self.location.href')
} else {
let builtUrl: string
if (isBundled) {
const result = await workerFileToUrl(config, file)
if (this.environment.config.command === 'serve') {
... | fim | vitejs/vite | typescript |
<|fim_prefix|>import fs from 'node:fs'
import path from 'node:path'
import sirv from 'sirv'
import compression from '@polka/compression'
import connect from 'connect'
import corsMiddleware from 'cors'
import { disableCache } from '@voidzero-dev/vite-task-client'
import type { Connect } from '#dep-types/connect'
import ... | fim | vitejs/vite | typescript |
<|fim_prefix|>import path from 'node:path'
import { cleanUrl, withTrailingSlash } from '../shared/utils'
import type { ResolvedConfig } from './config'
import {
ERR_SYMLINK_IN_RECURSIVE_READDI<|fim_suffix|>malizePath,
recursiveReaddir,
tryStatSync,
} from './utils'
const publicFilesMap = new WeakMap<ResolvedConf... | fim | vitejs/vite | typescript |
<|fim_prefix|><|fim_suffix|>-public',
})
<|fim_middle|>import { defineConfig } from 'vite'
import '../config-deps/foo.js'
export default defineConfig({
envDir: '../custom-env',
publicDir: '../custom<|endoftext|> | fim | vitejs/vite | javascript |
import { describe, expect, it } from 'vitest'
import { EnvironmentModuleGraph } from '../moduleGraph'
import type { ModuleNode } from '../mixedModuleGraph'
import { ModuleGraph } from '../mixedModuleGraph'
describe('moduleGraph', () => {
describe('invalidateModule', () => {
it('removes an ssr error', async () =>... | fim | vitejs/vite | typescript |
<|fim_prefix|>import { stripVTControlCharacters } from 'node:util'
import { describe, expect, it, vi } from 'vitest'
import type { UserConfig } from '../../config'
import { resolveConfig } from '../../config'
import type { Plugin } from '../../plugin'
import { DevEnvironment } from '../environment'
import { createLogge... | fim | vitejs/vite | typescript |
<|fim_suffix|>irname, '../../../../../..'))
})
})
<|fim_prefix|>import { resolve } from 'node:path'
import { describe, expect, test } from 'vitest'
import { searchForWorkspaceRoot } from '../searchRoot'
const dirname = import.meta.dirname
describe('searchForWorkspaceRoot', () => {
test('lerna', () => {
const ... | fim | vitejs/vite | typescript |
<|fim_suffix|>t\\node_modules\\foo\\dist\\bar.js',
expected: 'D:/project/node_modules/foo',
skip: !isWindows,
},
{
name: 'Windows-style path with scoped package',
input: 'D:\\project\\node_modules\\@scope\\pkg\\index.js',
expected: 'D:/project/node_modules/@scope/pkg',
skip: ... | fim | vitejs/vite | typescript |
<|fim_prefix|>import { describe, expect, test } from 'vitest'
import { getModuleTypeFromId } from '../transformRequest'
describe('getModuleTypeFromId', () => {
const testCases = [
{ id: 'foo.js', expected: 'js' },
{ id: 'foo.ts', expected: 'ts' },
{ id: 'foo.a.js', <|fim_suffix|>lt = getModuleTypeFromId(... | fim | vitejs/vite | typescript |
import { resolve } from 'node:path'
import { fileURLToPath } from 'node:url'
import { afterEach, describe, expect, it, vi } from 'vitest'
import { type ViteDevServer, createServer } from '../index'
const stubGetWatchedCode = /\(\)\s*\{\s*return this;\s*\}/
describe('watcher configuration', () => {
let server: ViteD... | fim | vitejs/vite | typescript |
import { setTimeout } from 'node:timers/promises'
import {
type BindingClientHmrUpdate,
type DevEngine,
dev,
} from 'rolldown/experimental'
import colors from 'picocolors'
import getEtag from 'etag'
import type { Update } from '#types/hmrPayload'
import { ChunkMetadataMap, resolveRolldownOptions } from '../build'... | fim | vitejs/vite | typescript |
<|fim_suffix|>formRequest call. If called from a load or transform
* plugin hook, the id needs to be passed as a parameter to avoid deadlocks.
* Calling this function after the first static imports section of the module graph has been
* processed will resolve immediately.
* @experimental
*/
waitForRequ... | fim | vitejs/vite | typescript |
<|fim_suffix|> throw new TypeError(
'FetchableDevEnvironment `context.handleRequest` must return a `Response` object.',
)
}
return response
}
}
export type { FetchableDevEnvironment }
<|fim_prefix|>import type { ResolvedConfig } from '../../config'
import type { DevEnvironmentContext } from ... | fim | vitejs/vite | typescript |
<|fim_prefix|>import type { ModuleRunner } from 'vite/module-runner'
import type { ResolvedConfig } from '../../config'
import type { DevEnvironmentContext } from '../environment'
import { DevEnvironment } from '../environment'
impo<|fim_suffix|>
context: RunnableDevEnvironmentContext,
) {
super(name, config,... | fim | vitejs/vite | typescript |
<|fim_prefix|>import fsp from 'node:fs/promises'
import path from 'node:path'
import { EventEmitter } from 'node:events'
import colors from 'picocolors'
import type { RollupError } from 'rolldown'
import type { CustomPayload, HotPayload, Update } from '#types/hmrPayload'
import type {
InvokeMethods,
InvokeResponseD... | fim | vitejs/vite | typescript |
<|fim_prefix|>import path from 'node:path'
import fs from 'node:fs'
import { execSync } from 'node:child_process'
import type * as net from 'node:net'
import { get as httpGet } from 'node:http'
import { get as httpsGet } from 'node:https'
import type * as http from 'node:http'
import { performance } from 'node:perf_hoo... | fim | vitejs/vite | typescript |
<|fim_prefix|>import { expect, test } from 'vitest'
import { getAdditionalAllowedHosts } from '../hostCheck'
test('getAdditionalAllowedHosts', async () => {
const actual = getAdditionalAllowedHosts(
{
ho<|fim_suffix|>host.example.com',
},
).sort()
expect(actual).toStrictEqual(
[
'vite.hos... | fim | vitejs/vite | typescript |
import fs from 'node:fs'
import path from 'node:path'
import { describe, expect, onTestFinished, test } from 'vitest'
import { createServer } from '../../../server'
import { FS_PREFIX } from '../../../constants'
const FIXTURE_DIR = path.resolve(import.meta.dirname, 'fixtures')
const HTML_PATH = path.resolve(FIXTURE_DI... | fim | vitejs/vite | typescript |
<|fim_prefix|>import { describe, expect, test } from 'vitest'
import { isFileInTargetPath } from '../static'
describe('isFileInTargetPath', () => {
const cases = {
'/parent': {
'/parent': true,
'/parenta': false,
'/parent/': tru<|fim_suffix|>/child': true,
'/parent/child/child2': true,
... | fim | vitejs/vite | typescript |
<|fim_prefix|>import type { Connect } from '#dep-types/connect'
import { joinUrlSegments, stripBase } from '../../utils'
import { cleanUrl, withTrailingSlash } from '../../../shared/utils'
// this middleware is only active when (base !== '/')
export function baseMiddleware(
rawBase: string,
middlewareMode: boolea... | fim | vitejs/vite | typescript |
<|fim_suffix|> logError(server, err)
if (allowNext) {
next()
} else {
res.statusCode = 500
res.end(`
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8" />
<title>Error</title>
<script type="module">
const ... | fim | vitejs/vite | typescript |
<|fim_suffix|>eze([...allowedHosts]),
generateErrorMessage(hostname) {
const hostnameWithQuotes = JSON.stringify(hostname)
const optionName = `${isPreview ? 'preview' : 'server'}.allowedHosts`
return (
`Blocked request. This host (${hostnameWithQuotes}) is not allowed.\n` +
`To all... | fim | vitejs/vite | typescript |
<|fim_prefix|>import path from 'node:path'
import fs from 'node:fs'
import type { Connect } from '#dep-types/connect'
import { createDebugger, joinUrlSegments } from '../../utils'
import { cleanUrl } from '../../../shared/utils'
import type { DevEnvironment } from '../environment'
const debug = createDebugger('vite:ht... | fim | vitejs/vite | typescript |
<|fim_suffix|>root {
--page-bg: #ffffff;
--text-color: #1d1d1f;
--spinner-track: #f5f5f7;
--spinner-accent: #0071e3;
}
@media (prefers-color-scheme: dark) {
:root {
--page-bg: #1e1e1e;
--text-color: #f5f5f5;
--spinner-track: #424242;
}
}
body ... | fim | vitejs/vite | typescript |
<|fim_suffix|>yFilesMiddleware can only be used for fullBundleMode')
}
const headers = server.config.server.headers
return function viteMemoryFilesMiddleware(req, res, next) {
const cleanedUrl = cleanUrl(req.url!)
if (cleanedUrl.endsWith('.html')) {
return next()
}
const pathname = decodeU... | fim | vitejs/vite | typescript |
<|fim_prefix|>import type { Connect } from <|fim_suffix|>atcher ...`
return function vite404Middleware(_, res) {
res.statusCode = 404
res.end()
}
}
<|fim_middle|>'#dep-types/connect'
export function notFoundMiddleware(): Connect.NextHandleFunction {
// Keep the named function. The name is visible in debu... | fim | vitejs/vite | typescript |
<|fim_suffix|> `${colors.red(`http proxy error: ${res.req.url}`)}\n${err.stack}`,
{
timestamp: true,
error: err,
},
)
if (!res.headersSent && !res.writableEnded) {
res
.writeHead(502, {
'Content-Type': 'text/plain',
... | fim | vitejs/vite | typescript |
<|fim_prefix|>import type { Connect } from '#dep-types/connect'
/**
* disallows request<|fim_suffix|> // But Node.js allows those requests.
// Our middlewares don't expect `#` to be included in `req.url`, especially the `server.fs.deny` checks.
if (req.url?.includes('#')) {
// HTTP 1.1 spec recommends ... | fim | vitejs/vite | typescript |
<|fim_prefix|>import path from 'node:path'
import type { OutgoingHttpHeaders, ServerResponse } from 'node:http'
import type { Options } from 'sirv'
import sirv from 'sirv'
import escapeHtml from 'escape-html'
import type { Connect } from '#dep-types/connect'
import type { ViteDevServer } from '../../server'
import type... | fim | vitejs/vite | typescript |
import { performance } from 'node:perf_hooks'
import type { Connect } from '#dep-types/connect'
import { createDebugger, prettifyUrl, timeFrom } from '../../utils'
const logTime = createDebugger('vite:time')
export function timeMiddleware(root: string): Connect.NextHandleFunction {
// Keep the named function. The n... | fim | vitejs/vite | typescript |
<|fim_suffix|>
res.end()
}
// This timeout is unexpected
server.config.logger.error(e.message)
return
}
if (e?.code === ERR_OUTDATED_OPTIMIZED_DEP) {
// Skip if response has already been sent
if (!res.writableEnded) {
res.statusCode = 504 /... | fim | vitejs/vite | typescript |
<|fim_suffix|>de = await bundledDev.triggerLazyBundling(moduleId, clientId)
if (code == null) {
return next()
}
res!.setHeader('Content-Type', 'application/javascript')
return res!.end(code)
}
}
<|fim_prefix|>import type { Connect } from '#dep-types/connect'
import type { ViteDevServer } from '... | fim | vitejs/vite | typescript |
<|fim_suffix|>this._client.resolveUrl(url)
}
updateModuleTransformResult(
mod: ModuleNode,
result: TransformResult | null,
ssr?: boolean,
): void {
const environment = ssr ? 'ssr' : 'client'
this._getModuleGraph(environment).updateModuleTransformResult(
(environment === 'client' ? mod._... | fim | vitejs/vite | typescript |
<|fim_suffix|>onmentModuleNode> = new Set(),
timestamp: number = monotonicDateNow(),
isHmr: boolean = false,
/** @internal */
softInvalidate = false,
): void {
const prevInvalidationState = mod.invalidationState
// Handle soft invalidation before the `seen` check, as consecutive soft/hard inv... | fim | vitejs/vite | typescript |
<|fim_suffix|>owserArgs } }
: {}
new Promise((_, reject) => {
open(url, options)
.then((subprocess) => {
subprocess.on('error', reject)
})
.catch(reject)
}).catch((err) => {
logger.error(err.stack || err.message)
})
return true
} catch {
return... | fim | vitejs/vite | typescript |
<|fim_prefix|>/**
* This file is refactored into TypeScript based on
* https://github.com/preactjs/wmr/blob/main/packages/wmr/src/lib/rollup-plugin-container.js
*/
/**
https://github.com/preactjs/wmr/blob/master/LICENSE
MIT License
Copyright (c) 2020 The Preact Authors
Permission is hereby granted, free of charg... | fim | vitejs/vite | typescript |
<|fim_prefix|>import fs from 'node:fs'
import { dirname, join } from 'node:path'
import { isFileReadable } from '../utils'
// https://github.com/vitejs/vite/issues/2820#issuecomment-812495079
const ROOT_FILES = [
// '.git',
// https://pnpm.io/workspaces/
'pnpm-workspace.yaml',
// https://rushjs.io/pages/adva... | fim | vitejs/vite | typescript |
<|fim_prefix|>import type {
IncomingMessage,
OutgoingHttpHeaders,
ServerResponse,
} from 'node:http'
import path from 'node:path'
import convertSourceMap from 'convert-source-map'
import getEtag from 'etag'
import type { SourceMap } from 'rolldown'
import MagicString from 'magic-string'
import { createDebugger, r... | fim | vitejs/vite | typescript |
<|fim_suffix|>oString('base64')}`
}
export function getCodeWithSourcemap(
type: 'js' | 'css',
code: string,
map: SourceMap,
): string {
if (debug) {
code += `\n/*${JSON.stringify(map, null, 2).replace(/\*\//g, '*\\/')}*/\n`
}
if (type === 'js') {
code += `\n//# sourceMappingURL=${genSourceMapUrl(m... | fim | vitejs/vite | typescript |
<|fim_prefix|>import fsp from 'node:fs/promises'
import path from 'node:path'
import { performance } from 'node:perf_hooks'
import getEtag from 'etag'
import MagicString from 'magic-string'
import { init, parse as parseImports } from 'es-module-lexer'
import type {
ModuleType,
PartialResolvedId,
SourceDescription... | fim | vitejs/vite | typescript |
<|fim_prefix|>import fs from 'node:fs/promises'
import path from 'node:path'
import colors from 'picocolors'
import { glob, isDynamicPattern } from 'tinyglobby'
import { FS_PREFIX } from '../constants'
import { normalizePath } from '../utils'
import type { ViteDevServer } from '../index'
import type { DevEnvironment } ... | fim | vitejs/vite | typescript |
<|fim_prefix|>import path from 'node:path'
import type { IncomingMessage, Server } from 'node:http'
import { STATUS_CODES, createServer as createHttpServer } from 'node:http'
import type { ServerOptions as HttpsServerOptions } from 'node:https'
import { createServer as createHttpsServer } from 'node:https'
import type ... | fim | vitejs/vite | typescript |
<|fim_prefix|>import readline from 'node:readline'
import colors from 'picocolors'
import { restartServerWithUrls } from './server'
import type { ViteDevServer } from './server'
import { isDevServer } from './utils'
import type { PreviewServer } from './preview'
import { openBrowser } from './server/openBrowser'
expor... | fim | vitejs/vite | typescript |
<|fim_suffix|>default 'ok'
<|fim_prefix|>expo<|fim_middle|>rt <|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>function covered$1() {
return 'First'
<|fim_suffix|>e.js.map
<|fim_middle|>}
function uncovered$1() {
return 'Uncovered'
}
var first = /*#__PURE__*/ Object.freeze({
__proto__: null,
covered: covered$1,
uncovered: uncovered$1,
})
function covered() {
return 'Second'
}
function uncovered() {... | fim | vitejs/vite | javascript |
<|fim_prefix|>im<|fim_suffix|>t './syntax-error.js'
<|fim_middle|>por<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>ror.ts'
<|fim_prefix|>im<|fim_middle|>port './syntax-er<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>i<|fim_suffix|><|fim_middle|>nvalid code
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|><|fim_prefix|>invali<|fim_middle|>d code
<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|>'
<|fim_prefix|>export const<|fim_middle|> msg = 'works<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|> 'works'
<|fim_prefix|>ex<|fim_middle|>port const msg =<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|> 'ok'
<|fim_prefix|>export const glo<|fim_middle|>bal =<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>ex<|fim_suffix|>ult global
<|fim_middle|>port defa<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>r()
<|fim_prefix|><|fim_middle|>throw new Erro<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>
<|fim_prefix|>import { foo } from './non-exist<|fim_middle|>ent.js'
export const hello = 'world'<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>export const dirname = import.meta.dirname
export const filename = import.meta.<|fim_suffix|>
<|fim_middle|>filename<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>// nested-directory/nested-file.js
var nested_file_default =
'Nested file will trigger edge case that used <|fim_suffix|>map
<|fim_middle|>to break sourcemaps'
// entrypoint.js
function entrypoint() {
console.log(nested_file_default)
throw new Error('Hello world')
}
export { entrypoint }
//# source... | fim | vitejs/vite | javascript |
<|fim_prefix|>/*
* You can rebuild this with:
* - rm -f ./dist.js ./dist.js.map
* - npx esbuild --bundle entrypoint.js --outfile=dist.js --sourcemap --format=esm
*/
import nest<|fim_suffix|>log(nested)
throw new Error('Hello world')
}
<|fim_middle|>ed from './nested-directory/nested-file'
export function entryp... | fim | vitejs/vite | javascript |
export default 'Nested file will trigger edge case that used to break sourcemaps'
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>export con<|fim_suffix|>const b = 'dep1-b'
export const c = 'dep1-c'
export const d = 'dep1-d'
<|fim_middle|>st a = 'dep1-a'
export <|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>d'
<|fim_prefix|>export const d = <|fim_middle|>'dep2-<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>export const a = 'main-a'
export * from '<|fim_suffix|>xport const c = 'main-c'
export * from './dep2.js'
<|fim_middle|>./dep1.js'
e<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import { fileURLToPath } from 'node:url'
import path from 'node:path'
import fs from 'node:fs'
import { stripVTControlCharacters } from 'node:util'
import { expect, onTestFinished, test, vi } from 'vitest'
import { createServer } from '../../server'
import { DevEnvironment } from '../../server/environment... | fim | vitejs/vite | typescript |
<|fim_suffix|>st server = await createDevServer()
try {
await server.ssrLoadModule('/fixtures/modules/has-error.js')
} catch (e: any) {
// Manually craft an already-rewritten stacktrace with invalid line/column
// that will trigger the alreadyRewritten flag
e.stack = e.stack.replace(
/fixtures... | fim | vitejs/vite | typescript |
<|fim_prefix|>import { readFileSync } from 'node:fs'
import { fileURLToPath } from 'node:url'
import { assert, expect, test } from 'vitest'
import type { SourceMap } from 'rolldown'
import { TraceMap, originalPositionFor } from '@jridgewell/trace-mapping'
import { transformWithEsbuild } from '../../plugins/esbuild'
imp... | fim | vitejs/vite | typescript |
<|fim_suffix|>nks,
tsconfigPaths: false,
isBuild: false,
isProduction,
root,
packageCache: environment.config.packageCache,
builtins: environment.config.resolve.builtins,
})
if (!resolved) {
const err: any = new Error(
`Cannot find module '${url}' imported from ... | fim | vitejs/vite | typescript |
<|fim_prefix|>import type { DepOptimizationConfig } from '../optimizer'
import { mergeWithDefaults } from '../utils'
export type SSRTarget = 'node' | 'webworker'
export type SsrDepOptimizationConfig = DepOp<|fim_suffix|> are used in the plugin pipeline. The default value is the root config's `resolve.conditions`.
... | fim | vitejs/vite | typescript |
<|fim_prefix|>import type { InlineConfig } from '../config'<|fim_suffix|>),
]
const dependencies = modules
.filter((m) => {
// ignore all externalized modules
if (!m.meta || 'externalize' in m.meta) {
return false
}
// ignore the current module
return m.ex... | fim | vitejs/vite | typescript |
<|fim_suffix|>rror'
<|fim_prefix|>export defau<|fim_middle|>lt 'e<|endoftext|> | fim | vitejs/vite | javascript |
export const a = 'a'
<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>export { default as mov } from './assets/placeholde<|fim_suffix|>om './assets/placeholder.png'
export { default as webp } from './assets/placeholder.webp'
<|fim_middle|>r.mov'
export { default as txt } from './assets/placeholder.txt'
export { default as png } fr<|endoftext|> | fim | vitejs/vite | javascript |
export const b = 'b'
<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|>meta = import.meta
<|fim_prefix|>export const name = 'basic'
<|fim_middle|>
export const <|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import { basename }<|fim_suffix|>node:path'
export default basename('/foo/bar/baz.txt')
<|fim_middle|> from '<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_suffix|>pt c')
})
<|fim_prefix|>export { a as c } from './a'
<|fim_middle|>import.meta.hot?.accept(() => {
console.log('acce<|endoftext|> | fim | vitejs/vite | typescript |
<|fim_prefix|>export { b } fr<|fim_suffix|>circular-b'
export const a = 'a'
<|fim_middle|>om './<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|><|fim_prefix|>export<|fim_middle|> { a } from './circular-a'
export const b = 'b'
<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>export { a } from './cir<|fim_suffix|>oreFullReload', () => {
console.log('full reload')
})
<|fim_middle|>cular-a'
export { b } from './circular-b'
// since there is no .accept, it does full reload
import.meta.hot.on('vite:bef<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>import { hello } from '<|fim_suffix|>ult = hello()
<|fim_middle|>@vitejs/cjs-external'
export const res<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>tejs/cjs-external'
console.log(nonExisting)
<|fim_prefix|>import { nonExisting <|fim_middle|>} from '@vi<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_suffix|>on() {}
<|fim_prefix|>export f<|fim_middle|>unction someActi<|endoftext|> | fim | vitejs/vite | javascript |
<|fim_prefix|>export de<|fim_suffix|> async function main() {
await import('./entry.js')
}
<|fim_middle|>fault<|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.