2181 lines
73 KiB
JavaScript
2181 lines
73 KiB
JavaScript
import { n as __toESM, t as require_binding } from "./binding-DzKFaUu2.mjs";
|
|
import { a as logInvalidLogPosition, c as logPluginError, n as error, r as logCycleLoading, t as augmentCodeLocation } from "./logs-COHDsWqD.mjs";
|
|
import { i as bindingifyManifestPlugin, n as BuiltinPlugin, r as bindingifyBuiltInPlugin, t as normalizedStringOrRegex } from "./normalize-string-or-regex-0P4NpnRa.mjs";
|
|
import { a as unreachable, o as unsupported, r as noop, t as arraify } from "./misc-CCZIsXVO.mjs";
|
|
import { a as bindingifySourcemap, i as unwrapBindingResult, t as aggregateBindingErrorsIntoJsError } from "./error-DC8XkJKP.mjs";
|
|
import { parseAst } from "../parse-ast-index.mjs";
|
|
import path from "node:path";
|
|
import * as filter from "@rolldown/pluginutils";
|
|
import fsp from "node:fs/promises";
|
|
|
|
//#region package.json
|
|
var version = "1.0.0-rc.4";
|
|
var description = "Fast JavaScript/TypeScript bundler in Rust with Rollup-compatible API.";
|
|
|
|
//#endregion
|
|
//#region src/constants/version.ts
|
|
/**
|
|
* The version of Rolldown.
|
|
* @example `'1.0.0'`
|
|
*
|
|
* @category Plugin APIs
|
|
*/
|
|
const VERSION = version;
|
|
|
|
//#endregion
|
|
//#region src/constants/index.ts
|
|
/**
|
|
* Runtime helper module ID
|
|
*/
|
|
const RUNTIME_MODULE_ID = "\0rolldown/runtime.js";
|
|
|
|
//#endregion
|
|
//#region src/log/logging.ts
|
|
const LOG_LEVEL_SILENT = "silent";
|
|
const LOG_LEVEL_ERROR = "error";
|
|
const LOG_LEVEL_WARN = "warn";
|
|
const LOG_LEVEL_INFO = "info";
|
|
const LOG_LEVEL_DEBUG = "debug";
|
|
const logLevelPriority = {
|
|
[LOG_LEVEL_DEBUG]: 0,
|
|
[LOG_LEVEL_INFO]: 1,
|
|
[LOG_LEVEL_WARN]: 2,
|
|
[LOG_LEVEL_SILENT]: 3
|
|
};
|
|
|
|
//#endregion
|
|
//#region src/log/log-handler.ts
|
|
const normalizeLog = (log) => typeof log === "string" ? { message: log } : typeof log === "function" ? normalizeLog(log()) : log;
|
|
function getLogHandler(level, code, logger, pluginName, logLevel) {
|
|
if (logLevelPriority[level] < logLevelPriority[logLevel]) return noop;
|
|
return (log, pos) => {
|
|
if (pos != null) logger(LOG_LEVEL_WARN, logInvalidLogPosition(pluginName));
|
|
log = normalizeLog(log);
|
|
if (log.code && !log.pluginCode) log.pluginCode = log.code;
|
|
log.code = code;
|
|
log.plugin = pluginName;
|
|
logger(level, log);
|
|
};
|
|
}
|
|
|
|
//#endregion
|
|
//#region src/utils/normalize-hook.ts
|
|
function normalizeHook(hook) {
|
|
if (typeof hook === "function" || typeof hook === "string") return {
|
|
handler: hook,
|
|
options: {},
|
|
meta: {}
|
|
};
|
|
if (typeof hook === "object" && hook !== null) {
|
|
const { handler, order, ...options } = hook;
|
|
return {
|
|
handler,
|
|
options,
|
|
meta: { order }
|
|
};
|
|
}
|
|
unreachable("Invalid hook type");
|
|
}
|
|
|
|
//#endregion
|
|
//#region src/plugin/minimal-plugin-context.ts
|
|
var MinimalPluginContextImpl = class {
|
|
info;
|
|
warn;
|
|
debug;
|
|
meta;
|
|
constructor(onLog, logLevel, pluginName, watchMode, hookName) {
|
|
this.pluginName = pluginName;
|
|
this.hookName = hookName;
|
|
this.debug = getLogHandler(LOG_LEVEL_DEBUG, "PLUGIN_LOG", onLog, pluginName, logLevel);
|
|
this.info = getLogHandler(LOG_LEVEL_INFO, "PLUGIN_LOG", onLog, pluginName, logLevel);
|
|
this.warn = getLogHandler(LOG_LEVEL_WARN, "PLUGIN_WARNING", onLog, pluginName, logLevel);
|
|
this.meta = {
|
|
rollupVersion: "4.23.0",
|
|
rolldownVersion: VERSION,
|
|
watchMode
|
|
};
|
|
}
|
|
error(e) {
|
|
return error(logPluginError(normalizeLog(e), this.pluginName, { hook: this.hookName }));
|
|
}
|
|
};
|
|
|
|
//#endregion
|
|
//#region src/types/plain-object-like.ts
|
|
const LAZY_FIELDS_KEY = Symbol("__lazy_fields__");
|
|
/**
|
|
* Base class for classes that use `@lazyProp` decorated properties.
|
|
*
|
|
* **Design Pattern in Rolldown:**
|
|
* This is a common pattern in Rolldown due to its three-layer architecture:
|
|
* TypeScript API → NAPI Bindings → Rust Core
|
|
*
|
|
* **Why we use getters:**
|
|
* For performance - to lazily fetch data from Rust bindings only when needed,
|
|
* rather than eagerly fetching all data during object construction.
|
|
*
|
|
* **The problem:**
|
|
* Getters defined on class prototypes are non-enumerable by default, which breaks:
|
|
* - Object spread operators ({...obj})
|
|
* - Object.keys() and similar methods
|
|
* - Standard JavaScript object semantics
|
|
*
|
|
* **The solution:**
|
|
* This base class automatically converts `@lazyProp` decorated getters into
|
|
* own enumerable getters on each instance during construction.
|
|
*
|
|
* **Result:**
|
|
* Objects get both lazy-loading performance benefits AND plain JavaScript object behavior.
|
|
*
|
|
* @example
|
|
* ```typescript
|
|
* class MyClass extends PlainObjectLike {
|
|
* @lazyProp
|
|
* get myProp() {
|
|
* return fetchFromRustBinding();
|
|
* }
|
|
* }
|
|
* ```
|
|
*/
|
|
var PlainObjectLike = class {
|
|
constructor() {
|
|
setupLazyProperties(this);
|
|
}
|
|
};
|
|
/**
|
|
* Set up lazy properties as own getters on an instance.
|
|
* This is called automatically by the `PlainObjectLike` base class constructor.
|
|
*
|
|
* @param instance - The instance to set up lazy properties on
|
|
* @internal
|
|
*/
|
|
function setupLazyProperties(instance) {
|
|
const lazyFields = instance.constructor[LAZY_FIELDS_KEY];
|
|
if (!lazyFields) return;
|
|
for (const [propertyKey, originalGetter] of lazyFields.entries()) {
|
|
let cachedValue;
|
|
let hasValue = false;
|
|
Object.defineProperty(instance, propertyKey, {
|
|
get() {
|
|
if (!hasValue) {
|
|
cachedValue = originalGetter.call(this);
|
|
hasValue = true;
|
|
}
|
|
return cachedValue;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
}
|
|
}
|
|
/**
|
|
* Get all lazy field names from a class instance.
|
|
*
|
|
* @param instance - Instance to inspect
|
|
* @returns Set of lazy property names
|
|
*/
|
|
function getLazyFields(instance) {
|
|
const lazyFields = instance.constructor[LAZY_FIELDS_KEY];
|
|
return lazyFields ? new Set(lazyFields.keys()) : /* @__PURE__ */ new Set();
|
|
}
|
|
|
|
//#endregion
|
|
//#region src/decorators/lazy.ts
|
|
/**
|
|
* Decorator that marks a getter as lazy-evaluated and cached.
|
|
*
|
|
* **What "lazy" means here:**
|
|
* 1. Data is lazily fetched from Rust bindings only when the property is accessed (not eagerly on construction)
|
|
* 2. Once fetched, the data is cached for subsequent accesses (performance optimization)
|
|
* 3. Despite being a getter, it behaves like a plain object property (enumerable, appears in Object.keys())
|
|
*
|
|
* **Important**: Properties decorated with `@lazyProp` are defined as own enumerable
|
|
* properties on each instance (not on the prototype). This ensures they:
|
|
* - Appear in Object.keys() and Object.getOwnPropertyNames()
|
|
* - Are included in object spreads ({...obj})
|
|
* - Are enumerable in for...in loops
|
|
*
|
|
* Classes using this decorator must extend `PlainObjectLike` base class.
|
|
*
|
|
* @example
|
|
* ```typescript
|
|
* class MyClass extends PlainObjectLike {
|
|
* @lazyProp
|
|
* get expensiveValue() {
|
|
* return someExpensiveComputation();
|
|
* }
|
|
* }
|
|
* ```
|
|
*/
|
|
function lazyProp(target, propertyKey, descriptor) {
|
|
if (!target.constructor[LAZY_FIELDS_KEY]) target.constructor[LAZY_FIELDS_KEY] = /* @__PURE__ */ new Map();
|
|
const originalGetter = descriptor.get;
|
|
target.constructor[LAZY_FIELDS_KEY].set(propertyKey, originalGetter);
|
|
return {
|
|
enumerable: false,
|
|
configurable: true
|
|
};
|
|
}
|
|
|
|
//#endregion
|
|
//#region src/utils/asset-source.ts
|
|
function transformAssetSource(bindingAssetSource) {
|
|
return bindingAssetSource.inner;
|
|
}
|
|
function bindingAssetSource(source) {
|
|
return { inner: source };
|
|
}
|
|
|
|
//#endregion
|
|
//#region \0@oxc-project+runtime@0.113.0/helpers/decorate.js
|
|
function __decorate(decorators, target, key, desc) {
|
|
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
|
|
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
|
|
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
|
|
return c > 3 && r && Object.defineProperty(target, key, r), r;
|
|
}
|
|
|
|
//#endregion
|
|
//#region src/types/output-asset-impl.ts
|
|
var OutputAssetImpl = class extends PlainObjectLike {
|
|
type = "asset";
|
|
constructor(bindingAsset) {
|
|
super();
|
|
this.bindingAsset = bindingAsset;
|
|
}
|
|
get fileName() {
|
|
return this.bindingAsset.getFileName();
|
|
}
|
|
get originalFileName() {
|
|
return this.bindingAsset.getOriginalFileName() || null;
|
|
}
|
|
get originalFileNames() {
|
|
return this.bindingAsset.getOriginalFileNames();
|
|
}
|
|
get name() {
|
|
return this.bindingAsset.getName() ?? void 0;
|
|
}
|
|
get names() {
|
|
return this.bindingAsset.getNames();
|
|
}
|
|
get source() {
|
|
return transformAssetSource(this.bindingAsset.getSource());
|
|
}
|
|
__rolldown_external_memory_handle__(keepDataAlive) {
|
|
if (keepDataAlive) this.#evaluateAllLazyFields();
|
|
return this.bindingAsset.dropInner();
|
|
}
|
|
#evaluateAllLazyFields() {
|
|
for (const field of getLazyFields(this)) this[field];
|
|
}
|
|
};
|
|
__decorate([lazyProp], OutputAssetImpl.prototype, "fileName", null);
|
|
__decorate([lazyProp], OutputAssetImpl.prototype, "originalFileName", null);
|
|
__decorate([lazyProp], OutputAssetImpl.prototype, "originalFileNames", null);
|
|
__decorate([lazyProp], OutputAssetImpl.prototype, "name", null);
|
|
__decorate([lazyProp], OutputAssetImpl.prototype, "names", null);
|
|
__decorate([lazyProp], OutputAssetImpl.prototype, "source", null);
|
|
|
|
//#endregion
|
|
//#region src/utils/transform-rendered-module.ts
|
|
function transformToRenderedModule(bindingRenderedModule) {
|
|
return {
|
|
get code() {
|
|
return bindingRenderedModule.code;
|
|
},
|
|
get renderedLength() {
|
|
return bindingRenderedModule.code?.length || 0;
|
|
},
|
|
get renderedExports() {
|
|
return bindingRenderedModule.renderedExports;
|
|
}
|
|
};
|
|
}
|
|
|
|
//#endregion
|
|
//#region src/utils/transform-rendered-chunk.ts
|
|
function transformRenderedChunk(chunk) {
|
|
let modules = null;
|
|
return {
|
|
type: "chunk",
|
|
get name() {
|
|
return chunk.name;
|
|
},
|
|
get isEntry() {
|
|
return chunk.isEntry;
|
|
},
|
|
get isDynamicEntry() {
|
|
return chunk.isDynamicEntry;
|
|
},
|
|
get facadeModuleId() {
|
|
return chunk.facadeModuleId;
|
|
},
|
|
get moduleIds() {
|
|
return chunk.moduleIds;
|
|
},
|
|
get exports() {
|
|
return chunk.exports;
|
|
},
|
|
get fileName() {
|
|
return chunk.fileName;
|
|
},
|
|
get imports() {
|
|
return chunk.imports;
|
|
},
|
|
get dynamicImports() {
|
|
return chunk.dynamicImports;
|
|
},
|
|
get modules() {
|
|
if (!modules) modules = transformChunkModules(chunk.modules);
|
|
return modules;
|
|
}
|
|
};
|
|
}
|
|
function transformChunkModules(modules) {
|
|
const result = {};
|
|
for (let i = 0; i < modules.values.length; i++) {
|
|
let key = modules.keys[i];
|
|
const mod = modules.values[i];
|
|
result[key] = transformToRenderedModule(mod);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
//#endregion
|
|
//#region src/types/output-chunk-impl.ts
|
|
var OutputChunkImpl = class extends PlainObjectLike {
|
|
type = "chunk";
|
|
constructor(bindingChunk) {
|
|
super();
|
|
this.bindingChunk = bindingChunk;
|
|
}
|
|
get fileName() {
|
|
return this.bindingChunk.getFileName();
|
|
}
|
|
get name() {
|
|
return this.bindingChunk.getName();
|
|
}
|
|
get exports() {
|
|
return this.bindingChunk.getExports();
|
|
}
|
|
get isEntry() {
|
|
return this.bindingChunk.getIsEntry();
|
|
}
|
|
get facadeModuleId() {
|
|
return this.bindingChunk.getFacadeModuleId() || null;
|
|
}
|
|
get isDynamicEntry() {
|
|
return this.bindingChunk.getIsDynamicEntry();
|
|
}
|
|
get sourcemapFileName() {
|
|
return this.bindingChunk.getSourcemapFileName() || null;
|
|
}
|
|
get preliminaryFileName() {
|
|
return this.bindingChunk.getPreliminaryFileName();
|
|
}
|
|
get code() {
|
|
return this.bindingChunk.getCode();
|
|
}
|
|
get modules() {
|
|
return transformChunkModules(this.bindingChunk.getModules());
|
|
}
|
|
get imports() {
|
|
return this.bindingChunk.getImports();
|
|
}
|
|
get dynamicImports() {
|
|
return this.bindingChunk.getDynamicImports();
|
|
}
|
|
get moduleIds() {
|
|
return this.bindingChunk.getModuleIds();
|
|
}
|
|
get map() {
|
|
const mapString = this.bindingChunk.getMap();
|
|
return mapString ? transformToRollupSourceMap(mapString) : null;
|
|
}
|
|
__rolldown_external_memory_handle__(keepDataAlive) {
|
|
if (keepDataAlive) this.#evaluateAllLazyFields();
|
|
return this.bindingChunk.dropInner();
|
|
}
|
|
#evaluateAllLazyFields() {
|
|
for (const field of getLazyFields(this)) this[field];
|
|
}
|
|
};
|
|
__decorate([lazyProp], OutputChunkImpl.prototype, "fileName", null);
|
|
__decorate([lazyProp], OutputChunkImpl.prototype, "name", null);
|
|
__decorate([lazyProp], OutputChunkImpl.prototype, "exports", null);
|
|
__decorate([lazyProp], OutputChunkImpl.prototype, "isEntry", null);
|
|
__decorate([lazyProp], OutputChunkImpl.prototype, "facadeModuleId", null);
|
|
__decorate([lazyProp], OutputChunkImpl.prototype, "isDynamicEntry", null);
|
|
__decorate([lazyProp], OutputChunkImpl.prototype, "sourcemapFileName", null);
|
|
__decorate([lazyProp], OutputChunkImpl.prototype, "preliminaryFileName", null);
|
|
__decorate([lazyProp], OutputChunkImpl.prototype, "code", null);
|
|
__decorate([lazyProp], OutputChunkImpl.prototype, "modules", null);
|
|
__decorate([lazyProp], OutputChunkImpl.prototype, "imports", null);
|
|
__decorate([lazyProp], OutputChunkImpl.prototype, "dynamicImports", null);
|
|
__decorate([lazyProp], OutputChunkImpl.prototype, "moduleIds", null);
|
|
__decorate([lazyProp], OutputChunkImpl.prototype, "map", null);
|
|
|
|
//#endregion
|
|
//#region src/utils/transform-to-rollup-output.ts
|
|
function transformToRollupSourceMap(map) {
|
|
const obj = {
|
|
...JSON.parse(map),
|
|
toString() {
|
|
return JSON.stringify(obj);
|
|
},
|
|
toUrl() {
|
|
return `data:application/json;charset=utf-8;base64,${Buffer.from(obj.toString(), "utf-8").toString("base64")}`;
|
|
}
|
|
};
|
|
return obj;
|
|
}
|
|
function transformToRollupOutputChunk(bindingChunk) {
|
|
return new OutputChunkImpl(bindingChunk);
|
|
}
|
|
function transformToMutableRollupOutputChunk(bindingChunk, changed) {
|
|
const chunk = {
|
|
type: "chunk",
|
|
get code() {
|
|
return bindingChunk.getCode();
|
|
},
|
|
fileName: bindingChunk.getFileName(),
|
|
name: bindingChunk.getName(),
|
|
get modules() {
|
|
return transformChunkModules(bindingChunk.getModules());
|
|
},
|
|
get imports() {
|
|
return bindingChunk.getImports();
|
|
},
|
|
get dynamicImports() {
|
|
return bindingChunk.getDynamicImports();
|
|
},
|
|
exports: bindingChunk.getExports(),
|
|
isEntry: bindingChunk.getIsEntry(),
|
|
facadeModuleId: bindingChunk.getFacadeModuleId() || null,
|
|
isDynamicEntry: bindingChunk.getIsDynamicEntry(),
|
|
get moduleIds() {
|
|
return bindingChunk.getModuleIds();
|
|
},
|
|
get map() {
|
|
const map = bindingChunk.getMap();
|
|
return map ? transformToRollupSourceMap(map) : null;
|
|
},
|
|
sourcemapFileName: bindingChunk.getSourcemapFileName() || null,
|
|
preliminaryFileName: bindingChunk.getPreliminaryFileName()
|
|
};
|
|
const cache = {};
|
|
return new Proxy(chunk, {
|
|
get(target, p) {
|
|
if (p in cache) return cache[p];
|
|
const value = target[p];
|
|
cache[p] = value;
|
|
return value;
|
|
},
|
|
set(_target, p, newValue) {
|
|
cache[p] = newValue;
|
|
changed.updated.add(bindingChunk.getFileName());
|
|
return true;
|
|
},
|
|
has(target, p) {
|
|
if (p in cache) return true;
|
|
return p in target;
|
|
}
|
|
});
|
|
}
|
|
function transformToRollupOutputAsset(bindingAsset) {
|
|
return new OutputAssetImpl(bindingAsset);
|
|
}
|
|
function transformToMutableRollupOutputAsset(bindingAsset, changed) {
|
|
const asset = {
|
|
type: "asset",
|
|
fileName: bindingAsset.getFileName(),
|
|
originalFileName: bindingAsset.getOriginalFileName() || null,
|
|
originalFileNames: bindingAsset.getOriginalFileNames(),
|
|
get source() {
|
|
return transformAssetSource(bindingAsset.getSource());
|
|
},
|
|
name: bindingAsset.getName() ?? void 0,
|
|
names: bindingAsset.getNames()
|
|
};
|
|
const cache = {};
|
|
return new Proxy(asset, {
|
|
get(target, p) {
|
|
if (p in cache) return cache[p];
|
|
const value = target[p];
|
|
cache[p] = value;
|
|
return value;
|
|
},
|
|
set(_target, p, newValue) {
|
|
cache[p] = newValue;
|
|
changed.updated.add(bindingAsset.getFileName());
|
|
return true;
|
|
}
|
|
});
|
|
}
|
|
function transformToRollupOutput(output) {
|
|
const { chunks, assets } = output;
|
|
return { output: [...chunks.map((chunk) => transformToRollupOutputChunk(chunk)), ...assets.map((asset) => transformToRollupOutputAsset(asset))] };
|
|
}
|
|
function transformToMutableRollupOutput(output, changed) {
|
|
const { chunks, assets } = output;
|
|
return { output: [...chunks.map((chunk) => transformToMutableRollupOutputChunk(chunk, changed)), ...assets.map((asset) => transformToMutableRollupOutputAsset(asset, changed))] };
|
|
}
|
|
function transformToOutputBundle(context, output, changed) {
|
|
const bundle = Object.fromEntries(transformToMutableRollupOutput(output, changed).output.map((item) => [item.fileName, item]));
|
|
return new Proxy(bundle, {
|
|
set(_target, _p, _newValue, _receiver) {
|
|
const originalStackTraceLimit = Error.stackTraceLimit;
|
|
Error.stackTraceLimit = 2;
|
|
const message = "This plugin assigns to bundle variable. This is discouraged by Rollup and is not supported by Rolldown. This will be ignored. https://rollupjs.org/plugin-development/#generatebundle:~:text=DANGER,this.emitFile.";
|
|
const stack = new Error(message).stack ?? message;
|
|
Error.stackTraceLimit = originalStackTraceLimit;
|
|
context.warn({
|
|
message: stack,
|
|
code: "UNSUPPORTED_BUNDLE_ASSIGNMENT"
|
|
});
|
|
return true;
|
|
},
|
|
deleteProperty(target, property) {
|
|
if (typeof property === "string") changed.deleted.add(property);
|
|
return true;
|
|
}
|
|
});
|
|
}
|
|
function collectChangedBundle(changed, bundle) {
|
|
const changes = {};
|
|
for (const key in bundle) {
|
|
if (changed.deleted.has(key) || !changed.updated.has(key)) continue;
|
|
const item = bundle[key];
|
|
if (item.type === "asset") changes[key] = {
|
|
filename: item.fileName,
|
|
originalFileNames: item.originalFileNames,
|
|
source: bindingAssetSource(item.source),
|
|
names: item.names
|
|
};
|
|
else changes[key] = {
|
|
code: item.code,
|
|
filename: item.fileName,
|
|
name: item.name,
|
|
isEntry: item.isEntry,
|
|
exports: item.exports,
|
|
modules: {},
|
|
imports: item.imports,
|
|
dynamicImports: item.dynamicImports,
|
|
facadeModuleId: item.facadeModuleId || void 0,
|
|
isDynamicEntry: item.isDynamicEntry,
|
|
moduleIds: item.moduleIds,
|
|
map: bindingifySourcemap(item.map),
|
|
sourcemapFilename: item.sourcemapFileName || void 0,
|
|
preliminaryFilename: item.preliminaryFileName
|
|
};
|
|
}
|
|
return {
|
|
changes,
|
|
deleted: changed.deleted
|
|
};
|
|
}
|
|
|
|
//#endregion
|
|
//#region src/utils/transform-module-info.ts
|
|
function transformModuleInfo(info, option) {
|
|
return {
|
|
get ast() {
|
|
return unsupported("ModuleInfo#ast");
|
|
},
|
|
get code() {
|
|
return info.code;
|
|
},
|
|
id: info.id,
|
|
importers: info.importers,
|
|
dynamicImporters: info.dynamicImporters,
|
|
importedIds: info.importedIds,
|
|
dynamicallyImportedIds: info.dynamicallyImportedIds,
|
|
exports: info.exports,
|
|
isEntry: info.isEntry,
|
|
...option
|
|
};
|
|
}
|
|
|
|
//#endregion
|
|
//#region src/utils/transform-sourcemap.ts
|
|
function isEmptySourcemapFiled(array) {
|
|
if (!array) return true;
|
|
if (array.length === 0 || !array[0]) return true;
|
|
return false;
|
|
}
|
|
function normalizeTransformHookSourcemap(id, originalCode, rawMap) {
|
|
if (!rawMap) return;
|
|
let map = typeof rawMap === "object" ? rawMap : JSON.parse(rawMap);
|
|
if (isEmptySourcemapFiled(map.sourcesContent)) map.sourcesContent = [originalCode];
|
|
if (isEmptySourcemapFiled(map.sources) || map.sources && map.sources.length === 1 && map.sources[0] !== id) map.sources = [id];
|
|
return map;
|
|
}
|
|
|
|
//#endregion
|
|
//#region ../../node_modules/.pnpm/remeda@2.33.5/node_modules/remeda/dist/lazyDataLastImpl-DtF3cihj.js
|
|
function e(e, t, n) {
|
|
let r = (n) => e(n, ...t);
|
|
return n === void 0 ? r : Object.assign(r, {
|
|
lazy: n,
|
|
lazyArgs: t
|
|
});
|
|
}
|
|
|
|
//#endregion
|
|
//#region ../../node_modules/.pnpm/remeda@2.33.5/node_modules/remeda/dist/purry-GjwKKIlp.js
|
|
function t$1(t, n, r) {
|
|
let i = t.length - n.length;
|
|
if (i === 0) return t(...n);
|
|
if (i === 1) return e(t, n, r);
|
|
throw Error(`Wrong number of arguments`);
|
|
}
|
|
|
|
//#endregion
|
|
//#region ../../node_modules/.pnpm/remeda@2.33.5/node_modules/remeda/dist/partition.js
|
|
function t(...t) {
|
|
return t$1(n, t);
|
|
}
|
|
const n = (e, t) => {
|
|
let n = [[], []];
|
|
for (let [r, i] of e.entries()) t(i, r, e) ? n[0].push(i) : n[1].push(i);
|
|
return n;
|
|
};
|
|
|
|
//#endregion
|
|
//#region src/plugin/bindingify-hook-filter.ts
|
|
function generalHookFilterMatcherToFilterExprs(matcher, stringKind) {
|
|
if (typeof matcher === "string" || matcher instanceof RegExp) return [filter.include(generateAtomMatcher(stringKind, matcher))];
|
|
if (Array.isArray(matcher)) return matcher.map((m) => filter.include(generateAtomMatcher(stringKind, m)));
|
|
let ret = [];
|
|
if (matcher.exclude) ret.push(...arraify(matcher.exclude).map((m) => filter.exclude(generateAtomMatcher(stringKind, m))));
|
|
if (matcher.include) ret.push(...arraify(matcher.include).map((m) => filter.include(generateAtomMatcher(stringKind, m))));
|
|
return ret;
|
|
}
|
|
function generateAtomMatcher(kind, matcher) {
|
|
return kind === "code" ? filter.code(matcher) : filter.id(matcher);
|
|
}
|
|
function transformFilterMatcherToFilterExprs(filterOption) {
|
|
if (!filterOption) return;
|
|
if (Array.isArray(filterOption)) return filterOption;
|
|
const { id, code, moduleType } = filterOption;
|
|
let ret = [];
|
|
let idIncludes = [];
|
|
let idExcludes = [];
|
|
let codeIncludes = [];
|
|
let codeExcludes = [];
|
|
if (id) [idIncludes, idExcludes] = t(generalHookFilterMatcherToFilterExprs(id, "id") ?? [], (m) => m.kind === "include");
|
|
if (code) [codeIncludes, codeExcludes] = t(generalHookFilterMatcherToFilterExprs(code, "code") ?? [], (m) => m.kind === "include");
|
|
ret.push(...idExcludes);
|
|
ret.push(...codeExcludes);
|
|
let andExprList = [];
|
|
if (moduleType) {
|
|
let moduleTypes = Array.isArray(moduleType) ? moduleType : moduleType.include ?? [];
|
|
andExprList.push(filter.or(...moduleTypes.map((m) => filter.moduleType(m))));
|
|
}
|
|
if (idIncludes.length) andExprList.push(filter.or(...idIncludes.map((item) => item.expr)));
|
|
if (codeIncludes.length) andExprList.push(filter.or(...codeIncludes.map((item) => item.expr)));
|
|
if (andExprList.length) ret.push(filter.include(filter.and(...andExprList)));
|
|
return ret;
|
|
}
|
|
function bindingifyGeneralHookFilter(stringKind, pattern) {
|
|
let filterExprs = generalHookFilterMatcherToFilterExprs(pattern, stringKind);
|
|
let ret = [];
|
|
if (filterExprs) ret = filterExprs.map(bindingifyFilterExpr);
|
|
return ret.length > 0 ? { value: ret } : void 0;
|
|
}
|
|
function bindingifyFilterExpr(expr) {
|
|
let list = [];
|
|
bindingifyFilterExprImpl(expr, list);
|
|
return list;
|
|
}
|
|
function containsImporterId(expr) {
|
|
switch (expr.kind) {
|
|
case "and":
|
|
case "or": return expr.args.some(containsImporterId);
|
|
case "not":
|
|
case "include":
|
|
case "exclude": return containsImporterId(expr.expr);
|
|
case "importerId": return true;
|
|
default: return false;
|
|
}
|
|
}
|
|
function assertNoImporterId(filterExprs, hookName) {
|
|
if (filterExprs?.some(containsImporterId)) throw new Error(`The \`importerId\` filter can only be used with the \`resolveId\` hook, but it was used with the \`${hookName}\` hook.`);
|
|
}
|
|
function bindingifyFilterExprImpl(expr, list) {
|
|
switch (expr.kind) {
|
|
case "and": {
|
|
let args = expr.args;
|
|
for (let i = args.length - 1; i >= 0; i--) bindingifyFilterExprImpl(args[i], list);
|
|
list.push({
|
|
kind: "And",
|
|
payload: args.length
|
|
});
|
|
break;
|
|
}
|
|
case "or": {
|
|
let args = expr.args;
|
|
for (let i = args.length - 1; i >= 0; i--) bindingifyFilterExprImpl(args[i], list);
|
|
list.push({
|
|
kind: "Or",
|
|
payload: args.length
|
|
});
|
|
break;
|
|
}
|
|
case "not":
|
|
bindingifyFilterExprImpl(expr.expr, list);
|
|
list.push({ kind: "Not" });
|
|
break;
|
|
case "id":
|
|
list.push({
|
|
kind: "Id",
|
|
payload: expr.pattern
|
|
});
|
|
if (expr.params.cleanUrl) list.push({ kind: "CleanUrl" });
|
|
break;
|
|
case "importerId":
|
|
list.push({
|
|
kind: "ImporterId",
|
|
payload: expr.pattern
|
|
});
|
|
if (expr.params.cleanUrl) list.push({ kind: "CleanUrl" });
|
|
break;
|
|
case "moduleType":
|
|
list.push({
|
|
kind: "ModuleType",
|
|
payload: expr.pattern
|
|
});
|
|
break;
|
|
case "code":
|
|
list.push({
|
|
kind: "Code",
|
|
payload: expr.pattern
|
|
});
|
|
break;
|
|
case "include":
|
|
bindingifyFilterExprImpl(expr.expr, list);
|
|
list.push({ kind: "Include" });
|
|
break;
|
|
case "exclude":
|
|
bindingifyFilterExprImpl(expr.expr, list);
|
|
list.push({ kind: "Exclude" });
|
|
break;
|
|
case "query":
|
|
list.push({
|
|
kind: "QueryKey",
|
|
payload: expr.key
|
|
});
|
|
list.push({
|
|
kind: "QueryValue",
|
|
payload: expr.pattern
|
|
});
|
|
break;
|
|
default: throw new Error(`Unknown filter expression: ${expr}`);
|
|
}
|
|
}
|
|
function bindingifyResolveIdFilter(filterOption) {
|
|
if (!filterOption) return;
|
|
if (Array.isArray(filterOption)) return { value: filterOption.map(bindingifyFilterExpr) };
|
|
return filterOption.id ? bindingifyGeneralHookFilter("id", filterOption.id) : void 0;
|
|
}
|
|
function bindingifyLoadFilter(filterOption) {
|
|
if (!filterOption) return;
|
|
if (Array.isArray(filterOption)) {
|
|
assertNoImporterId(filterOption, "load");
|
|
return { value: filterOption.map(bindingifyFilterExpr) };
|
|
}
|
|
return filterOption.id ? bindingifyGeneralHookFilter("id", filterOption.id) : void 0;
|
|
}
|
|
function bindingifyTransformFilter(filterOption) {
|
|
if (!filterOption) return;
|
|
let filterExprs = transformFilterMatcherToFilterExprs(filterOption);
|
|
assertNoImporterId(filterExprs, "transform");
|
|
let ret = [];
|
|
if (filterExprs) ret = filterExprs.map(bindingifyFilterExpr);
|
|
return { value: ret.length > 0 ? ret : void 0 };
|
|
}
|
|
function bindingifyRenderChunkFilter(filterOption) {
|
|
if (!filterOption) return;
|
|
if (Array.isArray(filterOption)) {
|
|
assertNoImporterId(filterOption, "renderChunk");
|
|
return { value: filterOption.map(bindingifyFilterExpr) };
|
|
}
|
|
return filterOption.code ? bindingifyGeneralHookFilter("code", filterOption.code) : void 0;
|
|
}
|
|
|
|
//#endregion
|
|
//#region src/plugin/bindingify-plugin-hook-meta.ts
|
|
var import_binding = /* @__PURE__ */ __toESM(require_binding(), 1);
|
|
function bindingifyPluginHookMeta(options) {
|
|
return { order: bindingPluginOrder(options.order) };
|
|
}
|
|
function bindingPluginOrder(order) {
|
|
switch (order) {
|
|
case "post": return import_binding.BindingPluginOrder.Post;
|
|
case "pre": return import_binding.BindingPluginOrder.Pre;
|
|
case null:
|
|
case void 0: return;
|
|
default: throw new Error(`Unknown plugin order: ${order}`);
|
|
}
|
|
}
|
|
|
|
//#endregion
|
|
//#region src/plugin/fs.ts
|
|
const fsModule = {
|
|
appendFile: fsp.appendFile,
|
|
copyFile: fsp.copyFile,
|
|
mkdir: fsp.mkdir,
|
|
mkdtemp: fsp.mkdtemp,
|
|
readdir: fsp.readdir,
|
|
readFile: fsp.readFile,
|
|
realpath: fsp.realpath,
|
|
rename: fsp.rename,
|
|
rmdir: fsp.rmdir,
|
|
stat: fsp.stat,
|
|
lstat: fsp.lstat,
|
|
unlink: fsp.unlink,
|
|
writeFile: fsp.writeFile
|
|
};
|
|
|
|
//#endregion
|
|
//#region src/plugin/plugin-context.ts
|
|
var PluginContextImpl = class extends MinimalPluginContextImpl {
|
|
fs = fsModule;
|
|
getModuleInfo;
|
|
constructor(outputOptions, context, plugin, data, onLog, logLevel, watchMode, currentLoadingModule) {
|
|
super(onLog, logLevel, plugin.name, watchMode);
|
|
this.outputOptions = outputOptions;
|
|
this.context = context;
|
|
this.data = data;
|
|
this.onLog = onLog;
|
|
this.currentLoadingModule = currentLoadingModule;
|
|
this.getModuleInfo = (id) => this.data.getModuleInfo(id, context);
|
|
}
|
|
async load(options) {
|
|
const id = options.id;
|
|
if (id === this.currentLoadingModule) this.onLog(LOG_LEVEL_WARN, logCycleLoading(this.pluginName, this.currentLoadingModule));
|
|
const moduleInfo = this.data.getModuleInfo(id, this.context);
|
|
if (moduleInfo && moduleInfo.code !== null) return moduleInfo;
|
|
const rawOptions = {
|
|
meta: options.meta || {},
|
|
moduleSideEffects: options.moduleSideEffects || null,
|
|
invalidate: false
|
|
};
|
|
this.data.updateModuleOption(id, rawOptions);
|
|
let loadPromise = this.data.loadModulePromiseMap.get(id);
|
|
if (!loadPromise) {
|
|
loadPromise = this.context.load(id, options.moduleSideEffects ?? void 0, options.packageJsonPath ?? void 0).catch(() => {
|
|
this.data.loadModulePromiseMap.delete(id);
|
|
});
|
|
this.data.loadModulePromiseMap.set(id, loadPromise);
|
|
}
|
|
await loadPromise;
|
|
return this.data.getModuleInfo(id, this.context);
|
|
}
|
|
async resolve(source, importer, options) {
|
|
let receipt = void 0;
|
|
if (options != null) receipt = this.data.saveResolveOptions(options);
|
|
const vitePluginCustom = Object.entries(options?.custom ?? {}).reduce((acc, [key, value]) => {
|
|
if (key.startsWith("vite:")) (acc ??= {})[key] = value;
|
|
return acc;
|
|
}, void 0);
|
|
const res = await this.context.resolve(source, importer, {
|
|
importKind: options?.kind,
|
|
custom: receipt,
|
|
isEntry: options?.isEntry,
|
|
skipSelf: options?.skipSelf,
|
|
vitePluginCustom
|
|
});
|
|
if (receipt != null) this.data.removeSavedResolveOptions(receipt);
|
|
if (res == null) return null;
|
|
const info = this.data.getModuleOption(res.id) || {};
|
|
return {
|
|
...res,
|
|
external: res.external === "relative" ? unreachable(`The PluginContext resolve result external couldn't be 'relative'`) : res.external,
|
|
...info,
|
|
moduleSideEffects: info.moduleSideEffects ?? res.moduleSideEffects ?? null,
|
|
packageJsonPath: res.packageJsonPath
|
|
};
|
|
}
|
|
emitFile = (file) => {
|
|
if (file.type === "prebuilt-chunk") return this.context.emitPrebuiltChunk({
|
|
fileName: file.fileName,
|
|
name: file.name,
|
|
code: file.code,
|
|
exports: file.exports,
|
|
map: bindingifySourcemap(file.map),
|
|
sourcemapFileName: file.sourcemapFileName,
|
|
facadeModuleId: file.facadeModuleId,
|
|
isEntry: file.isEntry,
|
|
isDynamicEntry: file.isDynamicEntry
|
|
});
|
|
if (file.type === "chunk") return this.context.emitChunk({
|
|
preserveEntrySignatures: bindingifyPreserveEntrySignatures(file.preserveSignature),
|
|
...file
|
|
});
|
|
const fnSanitizedFileName = file.fileName || typeof this.outputOptions.sanitizeFileName !== "function" ? void 0 : this.outputOptions.sanitizeFileName(file.name || "asset");
|
|
const filename = file.fileName ? void 0 : this.getAssetFileNames(file);
|
|
return this.context.emitFile({
|
|
...file,
|
|
originalFileName: file.originalFileName || void 0,
|
|
source: bindingAssetSource(file.source)
|
|
}, filename, fnSanitizedFileName);
|
|
};
|
|
getAssetFileNames(file) {
|
|
if (typeof this.outputOptions.assetFileNames === "function") return this.outputOptions.assetFileNames({
|
|
type: "asset",
|
|
name: file.name,
|
|
names: file.name ? [file.name] : [],
|
|
originalFileName: file.originalFileName,
|
|
originalFileNames: file.originalFileName ? [file.originalFileName] : [],
|
|
source: file.source
|
|
});
|
|
}
|
|
getFileName(referenceId) {
|
|
return this.context.getFileName(referenceId);
|
|
}
|
|
getModuleIds() {
|
|
return this.data.getModuleIds(this.context);
|
|
}
|
|
addWatchFile(id) {
|
|
this.context.addWatchFile(id);
|
|
}
|
|
parse(input, options) {
|
|
return parseAst(input, options);
|
|
}
|
|
};
|
|
|
|
//#endregion
|
|
//#region src/plugin/load-plugin-context.ts
|
|
var LoadPluginContextImpl = class extends PluginContextImpl {
|
|
constructor(outputOptions, context, plugin, data, inner, moduleId, onLog, logLevelOption, watchMode) {
|
|
super(outputOptions, context, plugin, data, onLog, logLevelOption, watchMode, moduleId);
|
|
this.inner = inner;
|
|
}
|
|
addWatchFile(id) {
|
|
this.inner.addWatchFile(id);
|
|
}
|
|
};
|
|
|
|
//#endregion
|
|
//#region src/plugin/transform-plugin-context.ts
|
|
var TransformPluginContextImpl = class extends PluginContextImpl {
|
|
constructor(outputOptions, context, plugin, data, inner, moduleId, moduleSource, onLog, LogLevelOption, watchMode) {
|
|
super(outputOptions, context, plugin, data, onLog, LogLevelOption, watchMode, moduleId);
|
|
this.inner = inner;
|
|
this.moduleId = moduleId;
|
|
this.moduleSource = moduleSource;
|
|
const getLogHandler = (handler) => (log, pos) => {
|
|
log = normalizeLog(log);
|
|
if (pos) augmentCodeLocation(log, pos, moduleSource, moduleId);
|
|
log.id = moduleId;
|
|
log.hook = "transform";
|
|
handler(log);
|
|
};
|
|
this.debug = getLogHandler(this.debug);
|
|
this.warn = getLogHandler(this.warn);
|
|
this.info = getLogHandler(this.info);
|
|
}
|
|
error(e, pos) {
|
|
if (typeof e === "string") e = { message: e };
|
|
if (pos) augmentCodeLocation(e, pos, this.moduleSource, this.moduleId);
|
|
e.id = this.moduleId;
|
|
e.hook = "transform";
|
|
return error(logPluginError(normalizeLog(e), this.pluginName));
|
|
}
|
|
getCombinedSourcemap() {
|
|
return JSON.parse(this.inner.getCombinedSourcemap());
|
|
}
|
|
addWatchFile(id) {
|
|
this.inner.addWatchFile(id);
|
|
}
|
|
sendMagicString(s) {
|
|
this.inner.sendMagicString(s);
|
|
}
|
|
};
|
|
|
|
//#endregion
|
|
//#region src/plugin/bindingify-build-hooks.ts
|
|
function bindingifyBuildStart(args) {
|
|
const hook = args.plugin.buildStart;
|
|
if (!hook) return {};
|
|
const { handler, meta } = normalizeHook(hook);
|
|
return {
|
|
plugin: async (ctx, opts) => {
|
|
await handler.call(new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode), args.pluginContextData.getInputOptions(opts));
|
|
},
|
|
meta: bindingifyPluginHookMeta(meta)
|
|
};
|
|
}
|
|
function bindingifyBuildEnd(args) {
|
|
const hook = args.plugin.buildEnd;
|
|
if (!hook) return {};
|
|
const { handler, meta } = normalizeHook(hook);
|
|
return {
|
|
plugin: async (ctx, err) => {
|
|
await handler.call(new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode), err ? aggregateBindingErrorsIntoJsError(err) : void 0);
|
|
},
|
|
meta: bindingifyPluginHookMeta(meta)
|
|
};
|
|
}
|
|
function bindingifyResolveId(args) {
|
|
const hook = args.plugin.resolveId;
|
|
if (!hook) return {};
|
|
const { handler, meta, options } = normalizeHook(hook);
|
|
return {
|
|
plugin: async (ctx, specifier, importer, extraOptions) => {
|
|
const contextResolveOptions = extraOptions.custom != null ? args.pluginContextData.getSavedResolveOptions(extraOptions.custom) : void 0;
|
|
const ret = await handler.call(new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode), specifier, importer ?? void 0, {
|
|
...extraOptions,
|
|
custom: contextResolveOptions?.custom
|
|
});
|
|
if (ret == null) return;
|
|
if (ret === false) return {
|
|
id: specifier,
|
|
external: true,
|
|
normalizeExternalId: true
|
|
};
|
|
if (typeof ret === "string") return {
|
|
id: ret,
|
|
normalizeExternalId: false
|
|
};
|
|
let exist = args.pluginContextData.updateModuleOption(ret.id, {
|
|
meta: ret.meta || {},
|
|
moduleSideEffects: ret.moduleSideEffects ?? null,
|
|
invalidate: false
|
|
});
|
|
return {
|
|
id: ret.id,
|
|
external: ret.external,
|
|
normalizeExternalId: false,
|
|
moduleSideEffects: exist.moduleSideEffects ?? void 0,
|
|
packageJsonPath: ret.packageJsonPath
|
|
};
|
|
},
|
|
meta: bindingifyPluginHookMeta(meta),
|
|
filter: bindingifyResolveIdFilter(options.filter)
|
|
};
|
|
}
|
|
function bindingifyResolveDynamicImport(args) {
|
|
const hook = args.plugin.resolveDynamicImport;
|
|
if (!hook) return {};
|
|
const { handler, meta } = normalizeHook(hook);
|
|
return {
|
|
plugin: async (ctx, specifier, importer) => {
|
|
const ret = await handler.call(new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode), specifier, importer ?? void 0);
|
|
if (ret == null) return;
|
|
if (ret === false) return {
|
|
id: specifier,
|
|
external: true
|
|
};
|
|
if (typeof ret === "string") return { id: ret };
|
|
const result = {
|
|
id: ret.id,
|
|
external: ret.external,
|
|
packageJsonPath: ret.packageJsonPath
|
|
};
|
|
if (ret.moduleSideEffects !== null) result.moduleSideEffects = ret.moduleSideEffects;
|
|
args.pluginContextData.updateModuleOption(ret.id, {
|
|
meta: ret.meta || {},
|
|
moduleSideEffects: ret.moduleSideEffects || null,
|
|
invalidate: false
|
|
});
|
|
return result;
|
|
},
|
|
meta: bindingifyPluginHookMeta(meta)
|
|
};
|
|
}
|
|
function bindingifyTransform(args) {
|
|
const hook = args.plugin.transform;
|
|
if (!hook) return {};
|
|
const { handler, meta, options } = normalizeHook(hook);
|
|
return {
|
|
plugin: async (ctx, code, id, meta) => {
|
|
let magicStringInstance, astInstance;
|
|
Object.defineProperties(meta, {
|
|
magicString: { get() {
|
|
if (magicStringInstance) return magicStringInstance;
|
|
magicStringInstance = new import_binding.BindingMagicString(code);
|
|
return magicStringInstance;
|
|
} },
|
|
ast: { get() {
|
|
if (astInstance) return astInstance;
|
|
let lang = "js";
|
|
switch (meta.moduleType) {
|
|
case "js":
|
|
case "jsx":
|
|
case "ts":
|
|
case "tsx":
|
|
lang = meta.moduleType;
|
|
break;
|
|
default: break;
|
|
}
|
|
astInstance = parseAst(code, {
|
|
astType: meta.moduleType.includes("ts") ? "ts" : "js",
|
|
lang
|
|
});
|
|
return astInstance;
|
|
} }
|
|
});
|
|
const transformCtx = new TransformPluginContextImpl(args.outputOptions, ctx.inner(), args.plugin, args.pluginContextData, ctx, id, code, args.onLog, args.logLevel, args.watchMode);
|
|
const ret = await handler.call(transformCtx, code, id, meta);
|
|
if (ret == null) return;
|
|
if (typeof ret === "string") return { code: ret };
|
|
let moduleOption = args.pluginContextData.updateModuleOption(id, {
|
|
meta: ret.meta ?? {},
|
|
moduleSideEffects: ret.moduleSideEffects ?? null,
|
|
invalidate: false
|
|
});
|
|
let normalizedCode = void 0;
|
|
let map = ret.map;
|
|
if (typeof ret.code === "string") normalizedCode = ret.code;
|
|
else if (ret.code instanceof import_binding.BindingMagicString) {
|
|
let magicString = ret.code;
|
|
normalizedCode = magicString.toString();
|
|
let fallbackSourcemap = ctx.sendMagicString(magicString);
|
|
if (fallbackSourcemap != void 0) map = fallbackSourcemap;
|
|
}
|
|
return {
|
|
code: normalizedCode,
|
|
map: bindingifySourcemap(normalizeTransformHookSourcemap(id, code, map)),
|
|
moduleSideEffects: moduleOption.moduleSideEffects ?? void 0,
|
|
moduleType: ret.moduleType
|
|
};
|
|
},
|
|
meta: bindingifyPluginHookMeta(meta),
|
|
filter: bindingifyTransformFilter(options.filter)
|
|
};
|
|
}
|
|
function bindingifyLoad(args) {
|
|
const hook = args.plugin.load;
|
|
if (!hook) return {};
|
|
const { handler, meta, options } = normalizeHook(hook);
|
|
return {
|
|
plugin: async (ctx, id) => {
|
|
const ret = await handler.call(new LoadPluginContextImpl(args.outputOptions, ctx.inner(), args.plugin, args.pluginContextData, ctx, id, args.onLog, args.logLevel, args.watchMode), id);
|
|
if (ret == null) return;
|
|
if (typeof ret === "string") return { code: ret };
|
|
let moduleOption = args.pluginContextData.updateModuleOption(id, {
|
|
meta: ret.meta || {},
|
|
moduleSideEffects: ret.moduleSideEffects ?? null,
|
|
invalidate: false
|
|
});
|
|
let map = preProcessSourceMap(ret, id);
|
|
return {
|
|
code: ret.code,
|
|
map: bindingifySourcemap(map),
|
|
moduleType: ret.moduleType,
|
|
moduleSideEffects: moduleOption.moduleSideEffects ?? void 0
|
|
};
|
|
},
|
|
meta: bindingifyPluginHookMeta(meta),
|
|
filter: bindingifyLoadFilter(options.filter)
|
|
};
|
|
}
|
|
function preProcessSourceMap(ret, id) {
|
|
if (!ret.map) return;
|
|
let map = typeof ret.map === "object" ? ret.map : JSON.parse(ret.map);
|
|
if (!isEmptySourcemapFiled(map.sources)) {
|
|
const directory = path.dirname(id) || ".";
|
|
const sourceRoot = map.sourceRoot || ".";
|
|
map.sources = map.sources.map((source) => path.resolve(directory, sourceRoot, source));
|
|
}
|
|
return map;
|
|
}
|
|
function bindingifyModuleParsed(args) {
|
|
const hook = args.plugin.moduleParsed;
|
|
if (!hook) return {};
|
|
const { handler, meta } = normalizeHook(hook);
|
|
return {
|
|
plugin: async (ctx, moduleInfo) => {
|
|
await handler.call(new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode), transformModuleInfo(moduleInfo, args.pluginContextData.getModuleOption(moduleInfo.id)));
|
|
},
|
|
meta: bindingifyPluginHookMeta(meta)
|
|
};
|
|
}
|
|
|
|
//#endregion
|
|
//#region src/plugin/bindingify-output-hooks.ts
|
|
function bindingifyRenderStart(args) {
|
|
const hook = args.plugin.renderStart;
|
|
if (!hook) return {};
|
|
const { handler, meta } = normalizeHook(hook);
|
|
return {
|
|
plugin: async (ctx, opts) => {
|
|
handler.call(new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode), args.pluginContextData.getOutputOptions(opts), args.pluginContextData.getInputOptions(opts));
|
|
},
|
|
meta: bindingifyPluginHookMeta(meta)
|
|
};
|
|
}
|
|
function bindingifyRenderChunk(args) {
|
|
const hook = args.plugin.renderChunk;
|
|
if (!hook) return {};
|
|
const { handler, meta, options } = normalizeHook(hook);
|
|
return {
|
|
plugin: async (ctx, code, chunk, opts, meta) => {
|
|
if (args.pluginContextData.getRenderChunkMeta() == null) args.pluginContextData.setRenderChunkMeta({ chunks: Object.fromEntries(Object.entries(meta.chunks).map(([key, value]) => [key, transformRenderedChunk(value)])) });
|
|
const renderChunkMeta = args.pluginContextData.getRenderChunkMeta();
|
|
let magicStringInstance;
|
|
if (args.options.experimental?.nativeMagicString) Object.defineProperty(renderChunkMeta, "magicString", {
|
|
get() {
|
|
if (magicStringInstance) return magicStringInstance;
|
|
magicStringInstance = new import_binding.BindingMagicString(code);
|
|
return magicStringInstance;
|
|
},
|
|
configurable: true
|
|
});
|
|
const ret = await handler.call(new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode), code, transformRenderedChunk(chunk), args.pluginContextData.getOutputOptions(opts), renderChunkMeta);
|
|
if (ret == null) return;
|
|
if (ret instanceof import_binding.BindingMagicString) {
|
|
const normalizedCode = ret.toString();
|
|
const generatedMap = ret.generateMap();
|
|
return {
|
|
code: normalizedCode,
|
|
map: bindingifySourcemap({
|
|
file: generatedMap.file,
|
|
mappings: generatedMap.mappings,
|
|
names: generatedMap.names,
|
|
sources: generatedMap.sources,
|
|
sourcesContent: generatedMap.sourcesContent.map((s) => s ?? null)
|
|
})
|
|
};
|
|
}
|
|
if (typeof ret === "string") return { code: ret };
|
|
if (ret.code instanceof import_binding.BindingMagicString) {
|
|
const magicString = ret.code;
|
|
const normalizedCode = magicString.toString();
|
|
if (ret.map === null) return { code: normalizedCode };
|
|
if (ret.map === void 0) {
|
|
const generatedMap = magicString.generateMap();
|
|
return {
|
|
code: normalizedCode,
|
|
map: bindingifySourcemap({
|
|
file: generatedMap.file,
|
|
mappings: generatedMap.mappings,
|
|
names: generatedMap.names,
|
|
sources: generatedMap.sources,
|
|
sourcesContent: generatedMap.sourcesContent.map((s) => s ?? null)
|
|
})
|
|
};
|
|
}
|
|
return {
|
|
code: normalizedCode,
|
|
map: bindingifySourcemap(ret.map)
|
|
};
|
|
}
|
|
if (!ret.map) return { code: ret.code };
|
|
return {
|
|
code: ret.code,
|
|
map: bindingifySourcemap(ret.map)
|
|
};
|
|
},
|
|
meta: bindingifyPluginHookMeta(meta),
|
|
filter: bindingifyRenderChunkFilter(options.filter)
|
|
};
|
|
}
|
|
function bindingifyAugmentChunkHash(args) {
|
|
const hook = args.plugin.augmentChunkHash;
|
|
if (!hook) return {};
|
|
const { handler, meta } = normalizeHook(hook);
|
|
return {
|
|
plugin: async (ctx, chunk) => {
|
|
return handler.call(new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode), transformRenderedChunk(chunk));
|
|
},
|
|
meta: bindingifyPluginHookMeta(meta)
|
|
};
|
|
}
|
|
function bindingifyRenderError(args) {
|
|
const hook = args.plugin.renderError;
|
|
if (!hook) return {};
|
|
const { handler, meta } = normalizeHook(hook);
|
|
return {
|
|
plugin: async (ctx, err) => {
|
|
handler.call(new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode), aggregateBindingErrorsIntoJsError(err));
|
|
},
|
|
meta: bindingifyPluginHookMeta(meta)
|
|
};
|
|
}
|
|
function bindingifyGenerateBundle(args) {
|
|
const hook = args.plugin.generateBundle;
|
|
if (!hook) return {};
|
|
const { handler, meta } = normalizeHook(hook);
|
|
return {
|
|
plugin: async (ctx, bundle, isWrite, opts) => {
|
|
const changed = {
|
|
updated: /* @__PURE__ */ new Set(),
|
|
deleted: /* @__PURE__ */ new Set()
|
|
};
|
|
const context = new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode);
|
|
const output = transformToOutputBundle(context, unwrapBindingResult(bundle), changed);
|
|
await handler.call(context, args.pluginContextData.getOutputOptions(opts), output, isWrite);
|
|
return collectChangedBundle(changed, output);
|
|
},
|
|
meta: bindingifyPluginHookMeta(meta)
|
|
};
|
|
}
|
|
function bindingifyWriteBundle(args) {
|
|
const hook = args.plugin.writeBundle;
|
|
if (!hook) return {};
|
|
const { handler, meta } = normalizeHook(hook);
|
|
return {
|
|
plugin: async (ctx, bundle, opts) => {
|
|
const changed = {
|
|
updated: /* @__PURE__ */ new Set(),
|
|
deleted: /* @__PURE__ */ new Set()
|
|
};
|
|
const context = new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode);
|
|
const output = transformToOutputBundle(context, unwrapBindingResult(bundle), changed);
|
|
await handler.call(context, args.pluginContextData.getOutputOptions(opts), output);
|
|
return collectChangedBundle(changed, output);
|
|
},
|
|
meta: bindingifyPluginHookMeta(meta)
|
|
};
|
|
}
|
|
function bindingifyCloseBundle(args) {
|
|
const hook = args.plugin.closeBundle;
|
|
if (!hook) return {};
|
|
const { handler, meta } = normalizeHook(hook);
|
|
return {
|
|
plugin: async (ctx, err) => {
|
|
await handler.call(new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode), err ? aggregateBindingErrorsIntoJsError(err) : void 0);
|
|
},
|
|
meta: bindingifyPluginHookMeta(meta)
|
|
};
|
|
}
|
|
function bindingifyBanner(args) {
|
|
const hook = args.plugin.banner;
|
|
if (!hook) return {};
|
|
const { handler, meta } = normalizeHook(hook);
|
|
return {
|
|
plugin: async (ctx, chunk) => {
|
|
if (typeof handler === "string") return handler;
|
|
return handler.call(new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode), transformRenderedChunk(chunk));
|
|
},
|
|
meta: bindingifyPluginHookMeta(meta)
|
|
};
|
|
}
|
|
function bindingifyFooter(args) {
|
|
const hook = args.plugin.footer;
|
|
if (!hook) return {};
|
|
const { handler, meta } = normalizeHook(hook);
|
|
return {
|
|
plugin: async (ctx, chunk) => {
|
|
if (typeof handler === "string") return handler;
|
|
return handler.call(new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode), transformRenderedChunk(chunk));
|
|
},
|
|
meta: bindingifyPluginHookMeta(meta)
|
|
};
|
|
}
|
|
function bindingifyIntro(args) {
|
|
const hook = args.plugin.intro;
|
|
if (!hook) return {};
|
|
const { handler, meta } = normalizeHook(hook);
|
|
return {
|
|
plugin: async (ctx, chunk) => {
|
|
if (typeof handler === "string") return handler;
|
|
return handler.call(new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode), transformRenderedChunk(chunk));
|
|
},
|
|
meta: bindingifyPluginHookMeta(meta)
|
|
};
|
|
}
|
|
function bindingifyOutro(args) {
|
|
const hook = args.plugin.outro;
|
|
if (!hook) return {};
|
|
const { handler, meta } = normalizeHook(hook);
|
|
return {
|
|
plugin: async (ctx, chunk) => {
|
|
if (typeof handler === "string") return handler;
|
|
return handler.call(new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode), transformRenderedChunk(chunk));
|
|
},
|
|
meta: bindingifyPluginHookMeta(meta)
|
|
};
|
|
}
|
|
|
|
//#endregion
|
|
//#region src/plugin/bindingify-watch-hooks.ts
|
|
function bindingifyWatchChange(args) {
|
|
const hook = args.plugin.watchChange;
|
|
if (!hook) return {};
|
|
const { handler, meta } = normalizeHook(hook);
|
|
return {
|
|
plugin: async (ctx, id, event) => {
|
|
await handler.call(new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode), id, { event });
|
|
},
|
|
meta: bindingifyPluginHookMeta(meta)
|
|
};
|
|
}
|
|
function bindingifyCloseWatcher(args) {
|
|
const hook = args.plugin.closeWatcher;
|
|
if (!hook) return {};
|
|
const { handler, meta } = normalizeHook(hook);
|
|
return {
|
|
plugin: async (ctx) => {
|
|
await handler.call(new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode));
|
|
},
|
|
meta: bindingifyPluginHookMeta(meta)
|
|
};
|
|
}
|
|
|
|
//#endregion
|
|
//#region src/plugin/generated/hook-usage.ts
|
|
let HookUsageKind = /* @__PURE__ */ function(HookUsageKind) {
|
|
HookUsageKind[HookUsageKind["buildStart"] = 1] = "buildStart";
|
|
HookUsageKind[HookUsageKind["resolveId"] = 2] = "resolveId";
|
|
HookUsageKind[HookUsageKind["resolveDynamicImport"] = 4] = "resolveDynamicImport";
|
|
HookUsageKind[HookUsageKind["load"] = 8] = "load";
|
|
HookUsageKind[HookUsageKind["transform"] = 16] = "transform";
|
|
HookUsageKind[HookUsageKind["moduleParsed"] = 32] = "moduleParsed";
|
|
HookUsageKind[HookUsageKind["buildEnd"] = 64] = "buildEnd";
|
|
HookUsageKind[HookUsageKind["renderStart"] = 128] = "renderStart";
|
|
HookUsageKind[HookUsageKind["renderError"] = 256] = "renderError";
|
|
HookUsageKind[HookUsageKind["renderChunk"] = 512] = "renderChunk";
|
|
HookUsageKind[HookUsageKind["augmentChunkHash"] = 1024] = "augmentChunkHash";
|
|
HookUsageKind[HookUsageKind["generateBundle"] = 2048] = "generateBundle";
|
|
HookUsageKind[HookUsageKind["writeBundle"] = 4096] = "writeBundle";
|
|
HookUsageKind[HookUsageKind["closeBundle"] = 8192] = "closeBundle";
|
|
HookUsageKind[HookUsageKind["watchChange"] = 16384] = "watchChange";
|
|
HookUsageKind[HookUsageKind["closeWatcher"] = 32768] = "closeWatcher";
|
|
HookUsageKind[HookUsageKind["transformAst"] = 65536] = "transformAst";
|
|
HookUsageKind[HookUsageKind["banner"] = 131072] = "banner";
|
|
HookUsageKind[HookUsageKind["footer"] = 262144] = "footer";
|
|
HookUsageKind[HookUsageKind["intro"] = 524288] = "intro";
|
|
HookUsageKind[HookUsageKind["outro"] = 1048576] = "outro";
|
|
return HookUsageKind;
|
|
}({});
|
|
var HookUsage = class {
|
|
bitflag = BigInt(0);
|
|
constructor() {}
|
|
union(kind) {
|
|
this.bitflag |= BigInt(kind);
|
|
}
|
|
inner() {
|
|
return Number(this.bitflag);
|
|
}
|
|
};
|
|
function extractHookUsage(plugin) {
|
|
let hookUsage = new HookUsage();
|
|
if (plugin.buildStart) hookUsage.union(HookUsageKind.buildStart);
|
|
if (plugin.resolveId) hookUsage.union(HookUsageKind.resolveId);
|
|
if (plugin.resolveDynamicImport) hookUsage.union(HookUsageKind.resolveDynamicImport);
|
|
if (plugin.load) hookUsage.union(HookUsageKind.load);
|
|
if (plugin.transform) hookUsage.union(HookUsageKind.transform);
|
|
if (plugin.moduleParsed) hookUsage.union(HookUsageKind.moduleParsed);
|
|
if (plugin.buildEnd) hookUsage.union(HookUsageKind.buildEnd);
|
|
if (plugin.renderStart) hookUsage.union(HookUsageKind.renderStart);
|
|
if (plugin.renderError) hookUsage.union(HookUsageKind.renderError);
|
|
if (plugin.renderChunk) hookUsage.union(HookUsageKind.renderChunk);
|
|
if (plugin.augmentChunkHash) hookUsage.union(HookUsageKind.augmentChunkHash);
|
|
if (plugin.generateBundle) hookUsage.union(HookUsageKind.generateBundle);
|
|
if (plugin.writeBundle) hookUsage.union(HookUsageKind.writeBundle);
|
|
if (plugin.closeBundle) hookUsage.union(HookUsageKind.closeBundle);
|
|
if (plugin.watchChange) hookUsage.union(HookUsageKind.watchChange);
|
|
if (plugin.closeWatcher) hookUsage.union(HookUsageKind.closeWatcher);
|
|
if (plugin.banner) hookUsage.union(HookUsageKind.banner);
|
|
if (plugin.footer) hookUsage.union(HookUsageKind.footer);
|
|
if (plugin.intro) hookUsage.union(HookUsageKind.intro);
|
|
if (plugin.outro) hookUsage.union(HookUsageKind.outro);
|
|
return hookUsage;
|
|
}
|
|
|
|
//#endregion
|
|
//#region src/plugin/bindingify-plugin.ts
|
|
function bindingifyPlugin(plugin, options, outputOptions, pluginContextData, normalizedOutputPlugins, onLog, logLevel, watchMode) {
|
|
const args = {
|
|
plugin,
|
|
options,
|
|
outputOptions,
|
|
pluginContextData,
|
|
onLog,
|
|
logLevel,
|
|
watchMode,
|
|
normalizedOutputPlugins
|
|
};
|
|
const { plugin: buildStart, meta: buildStartMeta } = bindingifyBuildStart(args);
|
|
const { plugin: resolveId, meta: resolveIdMeta, filter: resolveIdFilter } = bindingifyResolveId(args);
|
|
const { plugin: resolveDynamicImport, meta: resolveDynamicImportMeta } = bindingifyResolveDynamicImport(args);
|
|
const { plugin: buildEnd, meta: buildEndMeta } = bindingifyBuildEnd(args);
|
|
const { plugin: transform, meta: transformMeta, filter: transformFilter } = bindingifyTransform(args);
|
|
const { plugin: moduleParsed, meta: moduleParsedMeta } = bindingifyModuleParsed(args);
|
|
const { plugin: load, meta: loadMeta, filter: loadFilter } = bindingifyLoad(args);
|
|
const { plugin: renderChunk, meta: renderChunkMeta, filter: renderChunkFilter } = bindingifyRenderChunk(args);
|
|
const { plugin: augmentChunkHash, meta: augmentChunkHashMeta } = bindingifyAugmentChunkHash(args);
|
|
const { plugin: renderStart, meta: renderStartMeta } = bindingifyRenderStart(args);
|
|
const { plugin: renderError, meta: renderErrorMeta } = bindingifyRenderError(args);
|
|
const { plugin: generateBundle, meta: generateBundleMeta } = bindingifyGenerateBundle(args);
|
|
const { plugin: writeBundle, meta: writeBundleMeta } = bindingifyWriteBundle(args);
|
|
const { plugin: closeBundle, meta: closeBundleMeta } = bindingifyCloseBundle(args);
|
|
const { plugin: banner, meta: bannerMeta } = bindingifyBanner(args);
|
|
const { plugin: footer, meta: footerMeta } = bindingifyFooter(args);
|
|
const { plugin: intro, meta: introMeta } = bindingifyIntro(args);
|
|
const { plugin: outro, meta: outroMeta } = bindingifyOutro(args);
|
|
const { plugin: watchChange, meta: watchChangeMeta } = bindingifyWatchChange(args);
|
|
const { plugin: closeWatcher, meta: closeWatcherMeta } = bindingifyCloseWatcher(args);
|
|
let hookUsage = extractHookUsage(plugin).inner();
|
|
return wrapHandlers({
|
|
name: plugin.name,
|
|
buildStart,
|
|
buildStartMeta,
|
|
resolveId,
|
|
resolveIdMeta,
|
|
resolveIdFilter,
|
|
resolveDynamicImport,
|
|
resolveDynamicImportMeta,
|
|
buildEnd,
|
|
buildEndMeta,
|
|
transform,
|
|
transformMeta,
|
|
transformFilter,
|
|
moduleParsed,
|
|
moduleParsedMeta,
|
|
load,
|
|
loadMeta,
|
|
loadFilter,
|
|
renderChunk,
|
|
renderChunkMeta,
|
|
renderChunkFilter,
|
|
augmentChunkHash,
|
|
augmentChunkHashMeta,
|
|
renderStart,
|
|
renderStartMeta,
|
|
renderError,
|
|
renderErrorMeta,
|
|
generateBundle,
|
|
generateBundleMeta,
|
|
writeBundle,
|
|
writeBundleMeta,
|
|
closeBundle,
|
|
closeBundleMeta,
|
|
banner,
|
|
bannerMeta,
|
|
footer,
|
|
footerMeta,
|
|
intro,
|
|
introMeta,
|
|
outro,
|
|
outroMeta,
|
|
watchChange,
|
|
watchChangeMeta,
|
|
closeWatcher,
|
|
closeWatcherMeta,
|
|
hookUsage
|
|
});
|
|
}
|
|
function wrapHandlers(plugin) {
|
|
for (const hookName of [
|
|
"buildStart",
|
|
"resolveId",
|
|
"resolveDynamicImport",
|
|
"buildEnd",
|
|
"transform",
|
|
"moduleParsed",
|
|
"load",
|
|
"renderChunk",
|
|
"augmentChunkHash",
|
|
"renderStart",
|
|
"renderError",
|
|
"generateBundle",
|
|
"writeBundle",
|
|
"closeBundle",
|
|
"banner",
|
|
"footer",
|
|
"intro",
|
|
"outro",
|
|
"watchChange",
|
|
"closeWatcher"
|
|
]) {
|
|
const handler = plugin[hookName];
|
|
if (handler) plugin[hookName] = async (...args) => {
|
|
try {
|
|
return await handler(...args);
|
|
} catch (e) {
|
|
return error(logPluginError(e, plugin.name, {
|
|
hook: hookName,
|
|
id: hookName === "transform" ? args[2] : void 0
|
|
}));
|
|
}
|
|
};
|
|
}
|
|
return plugin;
|
|
}
|
|
|
|
//#endregion
|
|
//#region src/options/normalized-input-options.ts
|
|
var NormalizedInputOptionsImpl = class extends PlainObjectLike {
|
|
inner;
|
|
constructor(inner, onLog) {
|
|
super();
|
|
this.onLog = onLog;
|
|
this.inner = inner;
|
|
}
|
|
get shimMissingExports() {
|
|
return this.inner.shimMissingExports;
|
|
}
|
|
get input() {
|
|
return this.inner.input;
|
|
}
|
|
get cwd() {
|
|
return this.inner.cwd;
|
|
}
|
|
get platform() {
|
|
return this.inner.platform;
|
|
}
|
|
get context() {
|
|
return this.inner.context;
|
|
}
|
|
};
|
|
__decorate([lazyProp], NormalizedInputOptionsImpl.prototype, "shimMissingExports", null);
|
|
__decorate([lazyProp], NormalizedInputOptionsImpl.prototype, "input", null);
|
|
__decorate([lazyProp], NormalizedInputOptionsImpl.prototype, "cwd", null);
|
|
__decorate([lazyProp], NormalizedInputOptionsImpl.prototype, "platform", null);
|
|
__decorate([lazyProp], NormalizedInputOptionsImpl.prototype, "context", null);
|
|
|
|
//#endregion
|
|
//#region src/options/normalized-output-options.ts
|
|
var NormalizedOutputOptionsImpl = class extends PlainObjectLike {
|
|
constructor(inner, outputOptions, normalizedOutputPlugins) {
|
|
super();
|
|
this.inner = inner;
|
|
this.outputOptions = outputOptions;
|
|
this.normalizedOutputPlugins = normalizedOutputPlugins;
|
|
}
|
|
get dir() {
|
|
return this.inner.dir ?? void 0;
|
|
}
|
|
get entryFileNames() {
|
|
return this.inner.entryFilenames || this.outputOptions.entryFileNames;
|
|
}
|
|
get chunkFileNames() {
|
|
return this.inner.chunkFilenames || this.outputOptions.chunkFileNames;
|
|
}
|
|
get assetFileNames() {
|
|
return this.inner.assetFilenames || this.outputOptions.assetFileNames;
|
|
}
|
|
get format() {
|
|
return this.inner.format;
|
|
}
|
|
get exports() {
|
|
return this.inner.exports;
|
|
}
|
|
get sourcemap() {
|
|
return this.inner.sourcemap;
|
|
}
|
|
get sourcemapBaseUrl() {
|
|
return this.inner.sourcemapBaseUrl ?? void 0;
|
|
}
|
|
get cssEntryFileNames() {
|
|
return this.inner.cssEntryFilenames || this.outputOptions.cssEntryFileNames;
|
|
}
|
|
get cssChunkFileNames() {
|
|
return this.inner.cssChunkFilenames || this.outputOptions.cssChunkFileNames;
|
|
}
|
|
get shimMissingExports() {
|
|
return this.inner.shimMissingExports;
|
|
}
|
|
get name() {
|
|
return this.inner.name ?? void 0;
|
|
}
|
|
get file() {
|
|
return this.inner.file ?? void 0;
|
|
}
|
|
get codeSplitting() {
|
|
return this.inner.codeSplitting;
|
|
}
|
|
/**
|
|
* @deprecated Use `codeSplitting` instead.
|
|
*/
|
|
get inlineDynamicImports() {
|
|
return !this.inner.codeSplitting;
|
|
}
|
|
get dynamicImportInCjs() {
|
|
return this.inner.dynamicImportInCjs;
|
|
}
|
|
get externalLiveBindings() {
|
|
return this.inner.externalLiveBindings;
|
|
}
|
|
get banner() {
|
|
return normalizeAddon(this.outputOptions.banner);
|
|
}
|
|
get footer() {
|
|
return normalizeAddon(this.outputOptions.footer);
|
|
}
|
|
get postBanner() {
|
|
return normalizeAddon(this.outputOptions.postBanner);
|
|
}
|
|
get postFooter() {
|
|
return normalizeAddon(this.outputOptions.postFooter);
|
|
}
|
|
get intro() {
|
|
return normalizeAddon(this.outputOptions.intro);
|
|
}
|
|
get outro() {
|
|
return normalizeAddon(this.outputOptions.outro);
|
|
}
|
|
get esModule() {
|
|
return this.inner.esModule;
|
|
}
|
|
get extend() {
|
|
return this.inner.extend;
|
|
}
|
|
get globals() {
|
|
return this.inner.globals || this.outputOptions.globals;
|
|
}
|
|
get paths() {
|
|
return this.outputOptions.paths;
|
|
}
|
|
get hashCharacters() {
|
|
return this.inner.hashCharacters;
|
|
}
|
|
get sourcemapDebugIds() {
|
|
return this.inner.sourcemapDebugIds;
|
|
}
|
|
get sourcemapIgnoreList() {
|
|
return this.outputOptions.sourcemapIgnoreList;
|
|
}
|
|
get sourcemapPathTransform() {
|
|
return this.outputOptions.sourcemapPathTransform;
|
|
}
|
|
get minify() {
|
|
let ret = this.inner.minify;
|
|
if (typeof ret === "object" && ret !== null) {
|
|
delete ret["codegen"];
|
|
delete ret["module"];
|
|
delete ret["sourcemap"];
|
|
}
|
|
return ret;
|
|
}
|
|
get legalComments() {
|
|
return this.inner.legalComments;
|
|
}
|
|
get comments() {
|
|
const c = this.inner.comments;
|
|
return {
|
|
legal: c.legal ?? true,
|
|
annotation: c.annotation ?? true,
|
|
jsdoc: c.jsdoc ?? true
|
|
};
|
|
}
|
|
get polyfillRequire() {
|
|
return this.inner.polyfillRequire;
|
|
}
|
|
get plugins() {
|
|
return this.normalizedOutputPlugins;
|
|
}
|
|
get preserveModules() {
|
|
return this.inner.preserveModules;
|
|
}
|
|
get preserveModulesRoot() {
|
|
return this.inner.preserveModulesRoot;
|
|
}
|
|
get virtualDirname() {
|
|
return this.inner.virtualDirname;
|
|
}
|
|
get topLevelVar() {
|
|
return this.inner.topLevelVar ?? false;
|
|
}
|
|
get minifyInternalExports() {
|
|
return this.inner.minifyInternalExports ?? false;
|
|
}
|
|
};
|
|
__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "dir", null);
|
|
__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "entryFileNames", null);
|
|
__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "chunkFileNames", null);
|
|
__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "assetFileNames", null);
|
|
__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "format", null);
|
|
__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "exports", null);
|
|
__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "sourcemap", null);
|
|
__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "sourcemapBaseUrl", null);
|
|
__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "cssEntryFileNames", null);
|
|
__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "cssChunkFileNames", null);
|
|
__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "shimMissingExports", null);
|
|
__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "name", null);
|
|
__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "file", null);
|
|
__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "codeSplitting", null);
|
|
__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "inlineDynamicImports", null);
|
|
__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "dynamicImportInCjs", null);
|
|
__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "externalLiveBindings", null);
|
|
__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "banner", null);
|
|
__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "footer", null);
|
|
__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "postBanner", null);
|
|
__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "postFooter", null);
|
|
__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "intro", null);
|
|
__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "outro", null);
|
|
__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "esModule", null);
|
|
__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "extend", null);
|
|
__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "globals", null);
|
|
__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "paths", null);
|
|
__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "hashCharacters", null);
|
|
__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "sourcemapDebugIds", null);
|
|
__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "sourcemapIgnoreList", null);
|
|
__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "sourcemapPathTransform", null);
|
|
__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "minify", null);
|
|
__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "legalComments", null);
|
|
__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "comments", null);
|
|
__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "polyfillRequire", null);
|
|
__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "plugins", null);
|
|
__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "preserveModules", null);
|
|
__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "preserveModulesRoot", null);
|
|
__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "virtualDirname", null);
|
|
__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "topLevelVar", null);
|
|
__decorate([lazyProp], NormalizedOutputOptionsImpl.prototype, "minifyInternalExports", null);
|
|
function normalizeAddon(value) {
|
|
if (typeof value === "function") return value;
|
|
return () => value || "";
|
|
}
|
|
|
|
//#endregion
|
|
//#region src/plugin/plugin-context-data.ts
|
|
var PluginContextData = class {
|
|
moduleOptionMap = /* @__PURE__ */ new Map();
|
|
resolveOptionsMap = /* @__PURE__ */ new Map();
|
|
loadModulePromiseMap = /* @__PURE__ */ new Map();
|
|
renderedChunkMeta = null;
|
|
normalizedInputOptions = null;
|
|
normalizedOutputOptions = null;
|
|
constructor(onLog, outputOptions, normalizedOutputPlugins) {
|
|
this.onLog = onLog;
|
|
this.outputOptions = outputOptions;
|
|
this.normalizedOutputPlugins = normalizedOutputPlugins;
|
|
}
|
|
updateModuleOption(id, option) {
|
|
const existing = this.moduleOptionMap.get(id);
|
|
if (existing) {
|
|
if (option.moduleSideEffects != null) existing.moduleSideEffects = option.moduleSideEffects;
|
|
if (option.meta != null) Object.assign(existing.meta, option.meta);
|
|
if (option.invalidate != null) existing.invalidate = option.invalidate;
|
|
} else {
|
|
this.moduleOptionMap.set(id, option);
|
|
return option;
|
|
}
|
|
return existing;
|
|
}
|
|
getModuleOption(id) {
|
|
const option = this.moduleOptionMap.get(id);
|
|
if (!option) {
|
|
const raw = {
|
|
moduleSideEffects: null,
|
|
meta: {}
|
|
};
|
|
this.moduleOptionMap.set(id, raw);
|
|
return raw;
|
|
}
|
|
return option;
|
|
}
|
|
getModuleInfo(id, context) {
|
|
const bindingInfo = context.getModuleInfo(id);
|
|
if (bindingInfo) {
|
|
const info = transformModuleInfo(bindingInfo, this.getModuleOption(id));
|
|
return this.proxyModuleInfo(id, info);
|
|
}
|
|
return null;
|
|
}
|
|
proxyModuleInfo(id, info) {
|
|
let moduleSideEffects = info.moduleSideEffects;
|
|
Object.defineProperty(info, "moduleSideEffects", {
|
|
get() {
|
|
return moduleSideEffects;
|
|
},
|
|
set: (v) => {
|
|
this.updateModuleOption(id, {
|
|
moduleSideEffects: v,
|
|
meta: info.meta,
|
|
invalidate: true
|
|
});
|
|
moduleSideEffects = v;
|
|
}
|
|
});
|
|
return info;
|
|
}
|
|
getModuleIds(context) {
|
|
return context.getModuleIds().values();
|
|
}
|
|
saveResolveOptions(options) {
|
|
const index = this.resolveOptionsMap.size;
|
|
this.resolveOptionsMap.set(index, options);
|
|
return index;
|
|
}
|
|
getSavedResolveOptions(receipt) {
|
|
return this.resolveOptionsMap.get(receipt);
|
|
}
|
|
removeSavedResolveOptions(receipt) {
|
|
this.resolveOptionsMap.delete(receipt);
|
|
}
|
|
setRenderChunkMeta(meta) {
|
|
this.renderedChunkMeta = meta;
|
|
}
|
|
getRenderChunkMeta() {
|
|
return this.renderedChunkMeta;
|
|
}
|
|
getInputOptions(opts) {
|
|
this.normalizedInputOptions ??= new NormalizedInputOptionsImpl(opts, this.onLog);
|
|
return this.normalizedInputOptions;
|
|
}
|
|
getOutputOptions(opts) {
|
|
this.normalizedOutputOptions ??= new NormalizedOutputOptionsImpl(opts, this.outputOptions, this.normalizedOutputPlugins);
|
|
return this.normalizedOutputOptions;
|
|
}
|
|
clear() {
|
|
this.renderedChunkMeta = null;
|
|
this.loadModulePromiseMap.clear();
|
|
}
|
|
};
|
|
|
|
//#endregion
|
|
//#region src/utils/normalize-transform-options.ts
|
|
/**
|
|
* Normalizes transform options by extracting `define`, `inject`, and `dropLabels` separately from OXC transform options.
|
|
*
|
|
* Prioritizes values from `transform.define`, `transform.inject`, and `transform.dropLabels` over deprecated top-level options.
|
|
*/
|
|
function normalizeTransformOptions(inputOptions) {
|
|
const transform = inputOptions.transform;
|
|
const define = transform?.define ? Object.entries(transform.define) : void 0;
|
|
const inject = transform?.inject;
|
|
const dropLabels = transform?.dropLabels;
|
|
let oxcTransformOptions;
|
|
if (transform) {
|
|
const { define: _define, inject: _inject, dropLabels: _dropLabels, ...rest } = transform;
|
|
if (Object.keys(rest).length > 0) {
|
|
if (rest.jsx === false) rest.jsx = "disable";
|
|
oxcTransformOptions = rest;
|
|
}
|
|
}
|
|
return {
|
|
define,
|
|
inject,
|
|
dropLabels,
|
|
oxcTransformOptions
|
|
};
|
|
}
|
|
|
|
//#endregion
|
|
//#region src/utils/bindingify-input-options.ts
|
|
function bindingifyInputOptions(rawPlugins, inputOptions, outputOptions, normalizedOutputPlugins, onLog, logLevel, watchMode) {
|
|
const pluginContextData = new PluginContextData(onLog, outputOptions, normalizedOutputPlugins);
|
|
const plugins = rawPlugins.map((plugin) => {
|
|
if ("_parallel" in plugin) return;
|
|
if (plugin instanceof BuiltinPlugin) switch (plugin.name) {
|
|
case "builtin:vite-manifest": return bindingifyManifestPlugin(plugin, pluginContextData);
|
|
default: return bindingifyBuiltInPlugin(plugin);
|
|
}
|
|
return bindingifyPlugin(plugin, inputOptions, outputOptions, pluginContextData, normalizedOutputPlugins, onLog, logLevel, watchMode);
|
|
});
|
|
const normalizedTransform = normalizeTransformOptions(inputOptions);
|
|
return {
|
|
input: bindingifyInput(inputOptions.input),
|
|
plugins,
|
|
cwd: inputOptions.cwd ?? process.cwd(),
|
|
external: bindingifyExternal(inputOptions.external),
|
|
resolve: bindingifyResolve(inputOptions.resolve),
|
|
platform: inputOptions.platform,
|
|
shimMissingExports: inputOptions.shimMissingExports,
|
|
logLevel: bindingifyLogLevel(logLevel),
|
|
onLog: async (level, log) => onLog(level, log),
|
|
treeshake: bindingifyTreeshakeOptions(inputOptions.treeshake),
|
|
moduleTypes: inputOptions.moduleTypes,
|
|
define: normalizedTransform.define,
|
|
inject: bindingifyInject(normalizedTransform.inject),
|
|
experimental: bindingifyExperimental(inputOptions.experimental),
|
|
profilerNames: outputOptions.generatedCode?.profilerNames,
|
|
transform: normalizedTransform.oxcTransformOptions,
|
|
watch: bindingifyWatch(inputOptions.watch),
|
|
dropLabels: normalizedTransform.dropLabels,
|
|
keepNames: outputOptions.keepNames,
|
|
checks: inputOptions.checks,
|
|
deferSyncScanData: () => {
|
|
let ret = [];
|
|
pluginContextData.moduleOptionMap.forEach((value, key) => {
|
|
if (value.invalidate) ret.push({
|
|
id: key,
|
|
sideEffects: value.moduleSideEffects ?? void 0
|
|
});
|
|
});
|
|
return ret;
|
|
},
|
|
makeAbsoluteExternalsRelative: bindingifyMakeAbsoluteExternalsRelative(inputOptions.makeAbsoluteExternalsRelative),
|
|
devtools: inputOptions.devtools,
|
|
invalidateJsSideCache: pluginContextData.clear.bind(pluginContextData),
|
|
preserveEntrySignatures: bindingifyPreserveEntrySignatures(inputOptions.preserveEntrySignatures),
|
|
optimization: inputOptions.optimization,
|
|
context: inputOptions.context,
|
|
tsconfig: inputOptions.resolve?.tsconfigFilename ?? inputOptions.tsconfig
|
|
};
|
|
}
|
|
function bindingifyDevMode(devMode) {
|
|
if (devMode) {
|
|
if (typeof devMode === "boolean") return devMode ? {} : void 0;
|
|
return devMode;
|
|
}
|
|
}
|
|
function bindingifyAttachDebugInfo(attachDebugInfo) {
|
|
switch (attachDebugInfo) {
|
|
case void 0: return;
|
|
case "full": return import_binding.BindingAttachDebugInfo.Full;
|
|
case "simple": return import_binding.BindingAttachDebugInfo.Simple;
|
|
case "none": return import_binding.BindingAttachDebugInfo.None;
|
|
}
|
|
}
|
|
function bindingifyExternal(external) {
|
|
if (external) {
|
|
if (typeof external === "function") return (id, importer, isResolved) => {
|
|
if (id.startsWith("\0")) return false;
|
|
return external(id, importer, isResolved) ?? false;
|
|
};
|
|
return arraify(external);
|
|
}
|
|
}
|
|
function bindingifyExperimental(experimental) {
|
|
let chunkModulesOrder = import_binding.BindingChunkModuleOrderBy.ExecOrder;
|
|
if (experimental?.chunkModulesOrder) switch (experimental.chunkModulesOrder) {
|
|
case "exec-order":
|
|
chunkModulesOrder = import_binding.BindingChunkModuleOrderBy.ExecOrder;
|
|
break;
|
|
case "module-id":
|
|
chunkModulesOrder = import_binding.BindingChunkModuleOrderBy.ModuleId;
|
|
break;
|
|
default: throw new Error(`Unexpected chunkModulesOrder: ${experimental.chunkModulesOrder}`);
|
|
}
|
|
return {
|
|
viteMode: experimental?.viteMode,
|
|
resolveNewUrlToAsset: experimental?.resolveNewUrlToAsset,
|
|
devMode: bindingifyDevMode(experimental?.devMode),
|
|
attachDebugInfo: bindingifyAttachDebugInfo(experimental?.attachDebugInfo),
|
|
chunkModulesOrder,
|
|
chunkImportMap: experimental?.chunkImportMap,
|
|
onDemandWrapping: experimental?.onDemandWrapping,
|
|
incrementalBuild: experimental?.incrementalBuild,
|
|
nativeMagicString: experimental?.nativeMagicString,
|
|
chunkOptimization: experimental?.chunkOptimization,
|
|
lazyBarrel: experimental?.lazyBarrel
|
|
};
|
|
}
|
|
function bindingifyResolve(resolve) {
|
|
const yarnPnp = typeof process === "object" && !!process.versions?.pnp;
|
|
if (resolve) {
|
|
const { alias, extensionAlias, ...rest } = resolve;
|
|
return {
|
|
alias: alias ? Object.entries(alias).map(([name, replacement]) => ({
|
|
find: name,
|
|
replacements: replacement === false ? [void 0] : arraify(replacement)
|
|
})) : void 0,
|
|
extensionAlias: extensionAlias ? Object.entries(extensionAlias).map(([name, value]) => ({
|
|
target: name,
|
|
replacements: value
|
|
})) : void 0,
|
|
yarnPnp,
|
|
...rest
|
|
};
|
|
} else return { yarnPnp };
|
|
}
|
|
function bindingifyInject(inject) {
|
|
if (inject) return Object.entries(inject).map(([alias, item]) => {
|
|
if (Array.isArray(item)) {
|
|
if (item[1] === "*") return {
|
|
tagNamespace: true,
|
|
alias,
|
|
from: item[0]
|
|
};
|
|
return {
|
|
tagNamed: true,
|
|
alias,
|
|
from: item[0],
|
|
imported: item[1]
|
|
};
|
|
} else return {
|
|
tagNamed: true,
|
|
imported: "default",
|
|
alias,
|
|
from: item
|
|
};
|
|
});
|
|
}
|
|
function bindingifyLogLevel(logLevel) {
|
|
switch (logLevel) {
|
|
case "silent": return import_binding.BindingLogLevel.Silent;
|
|
case "debug": return import_binding.BindingLogLevel.Debug;
|
|
case "warn": return import_binding.BindingLogLevel.Warn;
|
|
case "info": return import_binding.BindingLogLevel.Info;
|
|
default: throw new Error(`Unexpected log level: ${logLevel}`);
|
|
}
|
|
}
|
|
function bindingifyInput(input) {
|
|
if (input === void 0) return [];
|
|
if (typeof input === "string") return [{ import: input }];
|
|
if (Array.isArray(input)) return input.map((src) => ({ import: src }));
|
|
return Object.entries(input).map(([name, import_path]) => {
|
|
return {
|
|
name,
|
|
import: import_path
|
|
};
|
|
});
|
|
}
|
|
function bindingifyWatch(watch) {
|
|
if (watch) return {
|
|
buildDelay: watch.buildDelay,
|
|
skipWrite: watch.skipWrite,
|
|
include: normalizedStringOrRegex(watch.include),
|
|
exclude: normalizedStringOrRegex(watch.exclude),
|
|
onInvalidate: (...args) => watch.onInvalidate?.(...args)
|
|
};
|
|
}
|
|
function bindingifyTreeshakeOptions(config) {
|
|
if (config === false) return;
|
|
if (config === true || config === void 0) return { moduleSideEffects: true };
|
|
let normalizedConfig = {
|
|
moduleSideEffects: true,
|
|
annotations: config.annotations,
|
|
manualPureFunctions: config.manualPureFunctions,
|
|
unknownGlobalSideEffects: config.unknownGlobalSideEffects,
|
|
invalidImportSideEffects: config.invalidImportSideEffects,
|
|
commonjs: config.commonjs
|
|
};
|
|
switch (config.propertyReadSideEffects) {
|
|
case "always":
|
|
normalizedConfig.propertyReadSideEffects = import_binding.BindingPropertyReadSideEffects.Always;
|
|
break;
|
|
case false:
|
|
normalizedConfig.propertyReadSideEffects = import_binding.BindingPropertyReadSideEffects.False;
|
|
break;
|
|
default:
|
|
}
|
|
switch (config.propertyWriteSideEffects) {
|
|
case "always":
|
|
normalizedConfig.propertyWriteSideEffects = import_binding.BindingPropertyWriteSideEffects.Always;
|
|
break;
|
|
case false:
|
|
normalizedConfig.propertyWriteSideEffects = import_binding.BindingPropertyWriteSideEffects.False;
|
|
break;
|
|
default:
|
|
}
|
|
if (config.moduleSideEffects === void 0) normalizedConfig.moduleSideEffects = true;
|
|
else if (config.moduleSideEffects === "no-external") normalizedConfig.moduleSideEffects = [{
|
|
external: true,
|
|
sideEffects: false
|
|
}, {
|
|
external: false,
|
|
sideEffects: true
|
|
}];
|
|
else normalizedConfig.moduleSideEffects = config.moduleSideEffects;
|
|
return normalizedConfig;
|
|
}
|
|
function bindingifyMakeAbsoluteExternalsRelative(makeAbsoluteExternalsRelative) {
|
|
if (makeAbsoluteExternalsRelative === "ifRelativeSource") return { type: "IfRelativeSource" };
|
|
if (typeof makeAbsoluteExternalsRelative === "boolean") return {
|
|
type: "Bool",
|
|
field0: makeAbsoluteExternalsRelative
|
|
};
|
|
}
|
|
function bindingifyPreserveEntrySignatures(preserveEntrySignatures) {
|
|
if (preserveEntrySignatures == void 0) return;
|
|
else if (typeof preserveEntrySignatures === "string") return {
|
|
type: "String",
|
|
field0: preserveEntrySignatures
|
|
};
|
|
else return {
|
|
type: "Bool",
|
|
field0: preserveEntrySignatures
|
|
};
|
|
}
|
|
|
|
//#endregion
|
|
export { version as S, LOG_LEVEL_WARN as _, transformToRollupOutput as a, VERSION as b, transformAssetSource as c, MinimalPluginContextImpl as d, normalizeHook as f, LOG_LEVEL_INFO as g, LOG_LEVEL_ERROR as h, transformModuleInfo as i, lazyProp as l, LOG_LEVEL_DEBUG as m, PluginContextData as n, transformRenderedChunk as o, normalizeLog as p, bindingifyPlugin as r, __decorate as s, bindingifyInputOptions as t, PlainObjectLike as u, logLevelPriority as v, description as x, RUNTIME_MODULE_ID as y }; |