@mrgrain/cdk-esbuild 1.127.0 → 2.0.0-alpha.2

package/lib/code.d.ts

@@ -1,30 +1,81 @@
-import { Code as LambdaCode, CodeConfig as LambdaCodeConfig, ResourceBindOptions } from "@aws-cdk/aws-lambda";
-import { Code as SyntheticsCode, CodeConfig as SyntheticsCodeConfig } from "@aws-cdk/aws-synthetics";
-import { CfnResource, Construct } from "@aws-cdk/core";
-import { EsbuildAssetProps, JavaScriptAsset as JSAsset, TypeScriptAsset as TSAsset } from "./asset";
-declare type CodeProps = Omit<EsbuildAssetProps, "entryPoints">;
-declare type JavaScriptCodeProps = CodeProps;
-declare type TypeScriptCodeProps = CodeProps;
-declare abstract class Code<Props extends CodeProps, Asset extends JSAsset | TSAsset> implements LambdaCode, SyntheticsCode {
-    protected abstract AssetClass: new (scope: Construct, id: string, props: EsbuildAssetProps) => Asset;
-    protected props: EsbuildAssetProps;
+import { ResourceBindOptions } from '@aws-cdk/aws-lambda';
+import { Location } from '@aws-cdk/aws-s3';
+import { CfnResource, Construct } from '@aws-cdk/core';
+import { AssetBaseProps, AssetProps, JavaScriptAsset as JSAsset, TypeScriptAsset as TSAsset } from './asset';
+import { EntryPoints } from './bundler';
+/**
+ * @stability stable
+ */
+export interface CodeConfig {
+    /**
+     * @stability stable
+     */
+    readonly s3Location: Location;
+}
+/**
+ * @stability stable
+ */
+export interface JavaScriptCodeProps extends AssetBaseProps {
+}
+/**
+ * @stability stable
+ */
+export interface TypeScriptCodeProps extends AssetBaseProps {
+}
+declare abstract class Code<Props extends JavaScriptCodeProps | TypeScriptCodeProps, Asset extends JSAsset | TSAsset> {
+    readonly entryPoints: EntryPoints;
+    protected abstract readonly assetClass: new (scope: Construct, id: string, props: AssetProps) => Asset;
+    /**
+     * @stability stable
+     */
+    protected props: AssetProps;
+    /**
+     * @stability stable
+     */
     protected asset: Asset;
-    isInline: false;
+    /**
+     * @stability stable
+     */
+    isInline: boolean;
     /**
      *
      * @param entryPoints - Relative path to the asset code. Use `props.buildOptions.absWorkingDir` if an absolute path is required.
      * @param props - Asset properties.
      */
-    constructor(entryPoints: EsbuildAssetProps["entryPoints"], props: Props);
-    bind(scope: Construct): LambdaCodeConfig & SyntheticsCodeConfig;
+    constructor(entryPoints: EntryPoints, props: Props);
+    /**
+     * @stability stable
+     */
+    bind(scope: Construct): CodeConfig;
+    /**
+     * @stability stable
+     */
     bindToResource(resource: CfnResource, options?: ResourceBindOptions): void;
 }
+/**
+ * @stability stable
+ */
 export declare class JavaScriptCode extends Code<JavaScriptCodeProps, JSAsset> {
-    protected AssetClass: typeof JSAsset;
-    constructor(entryPoints: EsbuildAssetProps["entryPoints"], props?: JavaScriptCodeProps);
+    /**
+     * @stability stable
+     */
+    assetClass: typeof JSAsset;
+    /**
+     * @stability stable
+     */
+    constructor(entryPoints: EntryPoints, props?: JavaScriptCodeProps);
 }
+/**
+ * @stability stable
+ */
 export declare class TypeScriptCode extends Code<TypeScriptCodeProps, TSAsset> {
-    protected AssetClass: typeof TSAsset;
-    constructor(entryPoints: EsbuildAssetProps["entryPoints"], props?: TypeScriptCodeProps);
+    /**
+     * @stability stable
+     */
+    assetClass: typeof TSAsset;
+    /**
+     * @stability stable
+     */
+    constructor(entryPoints: EntryPoints, props?: TypeScriptCodeProps);
 }
 export {};

package/lib/code.js

@@ -1,11 +1,15 @@
 "use strict";
+var _a, _b;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TypeScriptCode = exports.JavaScriptCode = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
 const core_1 = require("@aws-cdk/core");
 const asset_1 = require("./asset");
 function nodeMajorVersion() {
-    return parseInt(process.versions.node.split(".")[0], 10);
+    return parseInt(process.versions.node.split('.')[0], 10);
 }
+;
+;
 class Code {
     /**
      *
@@ -13,29 +17,37 @@ class Code {
      * @param props - Asset properties.
      */
     constructor(entryPoints, props) {
-        var _a, _b;
+        var _c, _d;
+        this.entryPoints = entryPoints;
+        /**
+         * @stability stable
+         */
+        this.isInline = false;
         const defaultOptions = {
-            ...(!((_a = props.buildOptions) === null || _a === void 0 ? void 0 : _a.platform) ||
-                ((_b = props.buildOptions) === null || _b === void 0 ? void 0 : _b.platform) === "node"
-                ? { platform: "node", target: "node" + nodeMajorVersion() }
+            ...(!((_c = props.buildOptions) === null || _c === void 0 ? void 0 : _c.platform) ||
+                ((_d = props.buildOptions) === null || _d === void 0 ? void 0 : _d.platform) === 'node'
+                ? { platform: 'node', target: 'node' + nodeMajorVersion() }
                 : {}),
         };
         this.props = {
-            entryPoints,
             ...props,
+            entryPoints,
             buildOptions: {
                 ...defaultOptions,
                 ...props.buildOptions,
             },
         };
     }
+    /**
+     * @stability stable
+     */
     bind(scope) {
         // If the same AssetCode is used multiple times, retain only the first instantiation.
         if (!this.asset) {
-            this.asset = new this.AssetClass(scope, this.constructor.name, this.props);
+            this.asset = new this.assetClass(scope, this.constructor.name, this.props);
         }
         else if (core_1.Stack.of(this.asset) !== core_1.Stack.of(scope)) {
-            throw new Error(`Asset is already associated with another stack '${core_1.Stack.of(this.asset).stackName}'. ` + "Create a new Asset instance for every stack.");
+            throw new Error(`Asset is already associated with another stack '${core_1.Stack.of(this.asset).stackName}'. ` + 'Create a new Asset instance for every stack.');
         }
         return {
             s3Location: {
@@ -44,27 +56,52 @@ class Code {
             },
         };
     }
+    /**
+     * @stability stable
+     */
     bindToResource(resource, options) {
         if (!this.asset) {
-            throw new Error("bindToResource() must be called after bind()");
+            throw new Error('bindToResource() must be called after bind()');
         }
         const resourceProperty = (options === null || options === void 0 ? void 0 : options.resourceProperty) || this.constructor.name;
         // https://github.com/aws/aws-cdk/issues/1432
         this.asset.addResourceMetadata(resource, resourceProperty);
     }
 }
+/**
+ * @stability stable
+ */
 class JavaScriptCode extends Code {
+    /**
+     * @stability stable
+     */
     constructor(entryPoints, props = {}) {
         super(entryPoints, props);
-        this.AssetClass = asset_1.JavaScriptAsset;
+        /**
+         * @stability stable
+         */
+        this.assetClass = asset_1.JavaScriptAsset;
     }
 }
 exports.JavaScriptCode = JavaScriptCode;
+_a = JSII_RTTI_SYMBOL_1;
+JavaScriptCode[_a] = { fqn: "@mrgrain/cdk-esbuild.JavaScriptCode", version: "2.0.0-alpha.2" };
+/**
+ * @stability stable
+ */
 class TypeScriptCode extends Code {
+    /**
+     * @stability stable
+     */
     constructor(entryPoints, props = {}) {
         super(entryPoints, props);
-        this.AssetClass = asset_1.TypeScriptAsset;
+        /**
+         * @stability stable
+         */
+        this.assetClass = asset_1.TypeScriptAsset;
     }
 }
 exports.TypeScriptCode = TypeScriptCode;
-//# sourceMappingURL=data:application/json;base64,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
+_b = JSII_RTTI_SYMBOL_1;
+TypeScriptCode[_b] = { fqn: "@mrgrain/cdk-esbuild.TypeScriptCode", version: "2.0.0-alpha.2" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esbuild-types-raw.d.ts

@@ -0,0 +1,304 @@
+export declare type Platform = 'browser' | 'node' | 'neutral';
+export declare type Format = 'iife' | 'cjs' | 'esm';
+export declare type Loader = 'js' | 'jsx' | 'ts' | 'tsx' | 'css' | 'json' | 'text' | 'base64' | 'file' | 'dataurl' | 'binary' | 'default';
+export declare type LogLevel = 'verbose' | 'debug' | 'info' | 'warning' | 'error' | 'silent';
+export declare type Charset = 'ascii' | 'utf8';
+interface CommonOptions {
+    sourcemap?: boolean | 'inline' | 'external' | 'both';
+    legalComments?: 'none' | 'inline' | 'eof' | 'linked' | 'external';
+    sourceRoot?: string;
+    sourcesContent?: boolean;
+    format?: Format;
+    globalName?: string;
+    target?: string | string[];
+    minify?: boolean;
+    minifyWhitespace?: boolean;
+    minifyIdentifiers?: boolean;
+    minifySyntax?: boolean;
+    charset?: Charset;
+    treeShaking?: boolean;
+    ignoreAnnotations?: boolean;
+    jsx?: 'transform' | 'preserve';
+    jsxFactory?: string;
+    jsxFragment?: string;
+    define?: {
+        [key: string]: string;
+    };
+    pure?: string[];
+    keepNames?: boolean;
+    color?: boolean;
+    logLevel?: LogLevel;
+    logLimit?: number;
+}
+export interface BuildOptions extends CommonOptions {
+    bundle?: boolean;
+    splitting?: boolean;
+    preserveSymlinks?: boolean;
+    outfile?: string;
+    metafile?: boolean;
+    outdir?: string;
+    outbase?: string;
+    platform?: Platform;
+    external?: string[];
+    loader?: {
+        [ext: string]: Loader;
+    };
+    resolveExtensions?: string[];
+    mainFields?: string[];
+    conditions?: string[];
+    write?: boolean;
+    allowOverwrite?: boolean;
+    tsconfig?: string;
+    outExtension?: {
+        [ext: string]: string;
+    };
+    publicPath?: string;
+    entryNames?: string;
+    chunkNames?: string;
+    assetNames?: string;
+    inject?: string[];
+    banner?: {
+        [type: string]: string;
+    };
+    footer?: {
+        [type: string]: string;
+    };
+    incremental?: boolean;
+    entryPoints?: string[] | Record<string, string>;
+    stdin?: StdinOptions;
+    plugins?: Plugin[];
+    absWorkingDir?: string;
+    nodePaths?: string[];
+    watch?: boolean | WatchMode;
+}
+export interface WatchMode {
+    onRebuild?: (error: BuildFailure | null, result: BuildResult | null) => void;
+}
+export interface StdinOptions {
+    contents: string;
+    resolveDir?: string;
+    sourcefile?: string;
+    loader?: Loader;
+}
+export interface Message {
+    pluginName: string;
+    text: string;
+    location: Location | null;
+    notes: Note[];
+    detail: any;
+}
+export interface Note {
+    text: string;
+    location: Location | null;
+}
+export interface Location {
+    file: string;
+    namespace: string;
+    line: number;
+    column: number;
+    length: number;
+    lineText: string;
+    suggestion: string;
+}
+export interface OutputFile {
+    path: string;
+    contents: Uint8Array;
+    text: string;
+}
+export interface BuildInvalidate {
+    (): Promise<BuildIncremental>;
+    dispose(): void;
+}
+export interface BuildIncremental extends BuildResult {
+    rebuild: BuildInvalidate;
+}
+export interface BuildResult {
+    errors: Message[];
+    warnings: Message[];
+    outputFiles?: OutputFile[];
+    rebuild?: BuildInvalidate;
+    stop?: () => void;
+    metafile?: Metafile;
+}
+export interface BuildFailure extends Error {
+    errors: Message[];
+    warnings: Message[];
+}
+export interface ServeOptions {
+    port?: number;
+    host?: string;
+    servedir?: string;
+    onRequest?: (args: ServeOnRequestArgs) => void;
+}
+export interface ServeOnRequestArgs {
+    remoteAddress: string;
+    method: string;
+    path: string;
+    status: number;
+    timeInMS: number;
+}
+export interface ServeResult {
+    port: number;
+    host: string;
+    wait: Promise<void>;
+    stop: () => void;
+}
+export interface TransformOptions extends CommonOptions {
+    tsconfigRaw?: string | {
+        compilerOptions?: {
+            jsxFactory?: string;
+            jsxFragmentFactory?: string;
+            useDefineForClassFields?: boolean;
+            importsNotUsedAsValues?: 'remove' | 'preserve' | 'error';
+        };
+    };
+    sourcefile?: string;
+    loader?: Loader;
+    banner?: string;
+    footer?: string;
+}
+export interface TransformResult {
+    code: string;
+    map: string;
+    warnings: Message[];
+}
+export interface TransformFailure extends Error {
+    errors: Message[];
+    warnings: Message[];
+}
+export interface Plugin {
+    name: string;
+    setup: (build: PluginBuild) => (void | Promise<void>);
+}
+export interface PluginBuild {
+    initialOptions: BuildOptions;
+    onStart(callback: () => (OnStartResult | null | void | Promise<OnStartResult | null | void>)): void;
+    onEnd(callback: (result: BuildResult) => (void | Promise<void>)): void;
+    onResolve(options: OnResolveOptions, callback: (args: OnResolveArgs) => (OnResolveResult | null | undefined | Promise<OnResolveResult | null | undefined>)): void;
+    onLoad(options: OnLoadOptions, callback: (args: OnLoadArgs) => (OnLoadResult | null | undefined | Promise<OnLoadResult | null | undefined>)): void;
+}
+export interface OnStartResult {
+    errors?: PartialMessage[];
+    warnings?: PartialMessage[];
+}
+export interface OnResolveOptions {
+    filter: RegExp;
+    namespace?: string;
+}
+export interface OnResolveArgs {
+    path: string;
+    importer: string;
+    namespace: string;
+    resolveDir: string;
+    kind: ImportKind;
+    pluginData: any;
+}
+export declare type ImportKind = 'entry-point' | 'import-statement' | 'require-call' | 'dynamic-import' | 'require-resolve' | 'import-rule' | 'url-token';
+export interface OnResolveResult {
+    pluginName?: string;
+    errors?: PartialMessage[];
+    warnings?: PartialMessage[];
+    path?: string;
+    external?: boolean;
+    sideEffects?: boolean;
+    namespace?: string;
+    pluginData?: any;
+    watchFiles?: string[];
+    watchDirs?: string[];
+}
+export interface OnLoadOptions {
+    filter: RegExp;
+    namespace?: string;
+}
+export interface OnLoadArgs {
+    path: string;
+    namespace: string;
+    pluginData: any;
+}
+export interface OnLoadResult {
+    pluginName?: string;
+    errors?: PartialMessage[];
+    warnings?: PartialMessage[];
+    contents?: string | Uint8Array;
+    resolveDir?: string;
+    loader?: Loader;
+    pluginData?: any;
+    watchFiles?: string[];
+    watchDirs?: string[];
+}
+export interface PartialMessage {
+    pluginName?: string;
+    text?: string;
+    location?: Partial<Location> | null;
+    notes?: PartialNote[];
+    detail?: any;
+}
+export interface PartialNote {
+    text?: string;
+    location?: Partial<Location> | null;
+}
+export interface Metafile {
+    inputs: {
+        [path: string]: {
+            bytes: number;
+            imports: {
+                path: string;
+                kind: ImportKind;
+            }[];
+        };
+    };
+    outputs: {
+        [path: string]: {
+            bytes: number;
+            inputs: {
+                [path: string]: {
+                    bytesInOutput: number;
+                };
+            };
+            imports: {
+                path: string;
+                kind: ImportKind;
+            }[];
+            exports: string[];
+            entryPoint?: string;
+        };
+    };
+}
+export interface FormatMessagesOptions {
+    kind: 'error' | 'warning';
+    color?: boolean;
+    terminalWidth?: number;
+}
+export interface AnalyzeMetafileOptions {
+    color?: boolean;
+    verbose?: boolean;
+}
+export declare function build(options: BuildOptions & {
+    write: false;
+}): Promise<BuildResult & {
+    outputFiles: OutputFile[];
+}>;
+export declare function build(options: BuildOptions & {
+    incremental: true;
+}): Promise<BuildIncremental>;
+export declare function build(options: BuildOptions): Promise<BuildResult>;
+export declare function serve(serveOptions: ServeOptions, buildOptions: BuildOptions): Promise<ServeResult>;
+export declare function transform(input: string, options?: TransformOptions): Promise<TransformResult>;
+export declare function formatMessages(messages: PartialMessage[], options: FormatMessagesOptions): Promise<string[]>;
+export declare function analyzeMetafile(metafile: Metafile | string, options?: AnalyzeMetafileOptions): Promise<string>;
+export declare function buildSync(options: BuildOptions & {
+    write: false;
+}): BuildResult & {
+    outputFiles: OutputFile[];
+};
+export declare function buildSync(options: BuildOptions): BuildResult;
+export declare function transformSync(input: string, options?: TransformOptions): TransformResult;
+export declare function formatMessagesSync(messages: PartialMessage[], options: FormatMessagesOptions): string[];
+export declare function analyzeMetafileSync(metafile: Metafile | string, options?: AnalyzeMetafileOptions): string;
+export declare function initialize(options: InitializeOptions): Promise<void>;
+export interface InitializeOptions {
+    wasmURL?: string;
+    worker?: boolean;
+}
+export declare let version: string;
+export {};

package/lib/esbuild-types-raw.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.version = void 0;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"esbuild-types-raw.js","sourceRoot":"","sources":["../src/esbuild-types-raw.ts"],"names":[],"mappings":"","sourcesContent":["export type Platform = 'browser' | 'node' | 'neutral';\nexport type Format = 'iife' | 'cjs' | 'esm';\nexport type Loader = 'js' | 'jsx' | 'ts' | 'tsx' | 'css' | 'json' | 'text' | 'base64' | 'file' | 'dataurl' | 'binary' | 'default';\nexport type LogLevel = 'verbose' | 'debug' | 'info' | 'warning' | 'error' | 'silent';\nexport type Charset = 'ascii' | 'utf8';\n\ninterface CommonOptions {\n  sourcemap?: boolean | 'inline' | 'external' | 'both';\n  legalComments?: 'none' | 'inline' | 'eof' | 'linked' | 'external';\n  sourceRoot?: string;\n  sourcesContent?: boolean;\n\n  format?: Format;\n  globalName?: string;\n  target?: string | string[];\n\n  minify?: boolean;\n  minifyWhitespace?: boolean;\n  minifyIdentifiers?: boolean;\n  minifySyntax?: boolean;\n  charset?: Charset;\n  treeShaking?: boolean;\n  ignoreAnnotations?: boolean;\n\n  jsx?: 'transform' | 'preserve';\n  jsxFactory?: string;\n  jsxFragment?: string;\n\n  define?: { [key: string]: string };\n  pure?: string[];\n  keepNames?: boolean;\n\n  color?: boolean;\n  logLevel?: LogLevel;\n  logLimit?: number;\n}\n\nexport interface BuildOptions extends CommonOptions {\n  bundle?: boolean;\n  splitting?: boolean;\n  preserveSymlinks?: boolean;\n  outfile?: string;\n  metafile?: boolean;\n  outdir?: string;\n  outbase?: string;\n  platform?: Platform;\n  external?: string[];\n  loader?: { [ext: string]: Loader };\n  resolveExtensions?: string[];\n  mainFields?: string[];\n  conditions?: string[];\n  write?: boolean;\n  allowOverwrite?: boolean;\n  tsconfig?: string;\n  outExtension?: { [ext: string]: string };\n  publicPath?: string;\n  entryNames?: string;\n  chunkNames?: string;\n  assetNames?: string;\n  inject?: string[];\n  banner?: { [type: string]: string };\n  footer?: { [type: string]: string };\n  incremental?: boolean;\n  entryPoints?: string[] | Record<string, string>;\n  stdin?: StdinOptions;\n  plugins?: Plugin[];\n  absWorkingDir?: string;\n  nodePaths?: string[]; // The \"NODE_PATH\" variable from Node.js\n  watch?: boolean | WatchMode;\n}\n\nexport interface WatchMode {\n  onRebuild?: (error: BuildFailure | null, result: BuildResult | null) => void;\n}\n\nexport interface StdinOptions {\n  contents: string;\n  resolveDir?: string;\n  sourcefile?: string;\n  loader?: Loader;\n}\n\nexport interface Message {\n  pluginName: string;\n  text: string;\n  location: Location | null;\n  notes: Note[];\n\n  // Optional user-specified data that is passed through unmodified. You can\n  // use this to stash the original error, for example.\n  detail: any;\n}\n\nexport interface Note {\n  text: string;\n  location: Location | null;\n}\n\nexport interface Location {\n  file: string;\n  namespace: string;\n  line: number; // 1-based\n  column: number; // 0-based, in bytes\n  length: number; // in bytes\n  lineText: string;\n  suggestion: string;\n}\n\nexport interface OutputFile {\n  path: string;\n  contents: Uint8Array; // \"text\" as bytes\n  text: string; // \"contents\" as text\n}\n\nexport interface BuildInvalidate {\n  (): Promise<BuildIncremental>;\n  dispose(): void;\n}\n\nexport interface BuildIncremental extends BuildResult {\n  rebuild: BuildInvalidate;\n}\n\nexport interface BuildResult {\n  errors: Message[];\n  warnings: Message[];\n  outputFiles?: OutputFile[]; // Only when \"write: false\"\n  rebuild?: BuildInvalidate; // Only when \"incremental: true\"\n  stop?: () => void; // Only when \"watch: true\"\n  metafile?: Metafile; // Only when \"metafile: true\"\n}\n\nexport interface BuildFailure extends Error {\n  errors: Message[];\n  warnings: Message[];\n}\n\nexport interface ServeOptions {\n  port?: number;\n  host?: string;\n  servedir?: string;\n  onRequest?: (args: ServeOnRequestArgs) => void;\n}\n\nexport interface ServeOnRequestArgs {\n  remoteAddress: string;\n  method: string;\n  path: string;\n  status: number;\n  timeInMS: number; // The time to generate the response, not to send it\n}\n\nexport interface ServeResult {\n  port: number;\n  host: string;\n  wait: Promise<void>;\n  stop: () => void;\n}\n\nexport interface TransformOptions extends CommonOptions {\n  tsconfigRaw?: string | {\n    compilerOptions?: {\n      jsxFactory?: string;\n      jsxFragmentFactory?: string;\n      useDefineForClassFields?: boolean;\n      importsNotUsedAsValues?: 'remove' | 'preserve' | 'error';\n    };\n  };\n\n  sourcefile?: string;\n  loader?: Loader;\n  banner?: string;\n  footer?: string;\n}\n\nexport interface TransformResult {\n  code: string;\n  map: string;\n  warnings: Message[];\n}\n\nexport interface TransformFailure extends Error {\n  errors: Message[];\n  warnings: Message[];\n}\n\nexport interface Plugin {\n  name: string;\n  setup: (build: PluginBuild) => (void | Promise<void>);\n}\n\nexport interface PluginBuild {\n  initialOptions: BuildOptions;\n  onStart(callback: () =>\n  (OnStartResult | null | void | Promise<OnStartResult | null | void>)): void;\n  onEnd(callback: (result: BuildResult) =>\n  (void | Promise<void>)): void;\n  onResolve(options: OnResolveOptions, callback: (args: OnResolveArgs) =>\n  (OnResolveResult | null | undefined | Promise<OnResolveResult | null | undefined>)): void;\n  onLoad(options: OnLoadOptions, callback: (args: OnLoadArgs) =>\n  (OnLoadResult | null | undefined | Promise<OnLoadResult | null | undefined>)): void;\n}\n\nexport interface OnStartResult {\n  errors?: PartialMessage[];\n  warnings?: PartialMessage[];\n}\n\nexport interface OnResolveOptions {\n  filter: RegExp;\n  namespace?: string;\n}\n\nexport interface OnResolveArgs {\n  path: string;\n  importer: string;\n  namespace: string;\n  resolveDir: string;\n  kind: ImportKind;\n  pluginData: any;\n}\n\nexport type ImportKind =\n  | 'entry-point'\n\n  // JS\n  | 'import-statement'\n  | 'require-call'\n  | 'dynamic-import'\n  | 'require-resolve'\n\n  // CSS\n  | 'import-rule'\n  | 'url-token'\n\nexport interface OnResolveResult {\n  pluginName?: string;\n\n  errors?: PartialMessage[];\n  warnings?: PartialMessage[];\n\n  path?: string;\n  external?: boolean;\n  sideEffects?: boolean;\n  namespace?: string;\n  pluginData?: any;\n\n  watchFiles?: string[];\n  watchDirs?: string[];\n}\n\nexport interface OnLoadOptions {\n  filter: RegExp;\n  namespace?: string;\n}\n\nexport interface OnLoadArgs {\n  path: string;\n  namespace: string;\n  pluginData: any;\n}\n\nexport interface OnLoadResult {\n  pluginName?: string;\n\n  errors?: PartialMessage[];\n  warnings?: PartialMessage[];\n\n  contents?: string | Uint8Array;\n  resolveDir?: string;\n  loader?: Loader;\n  pluginData?: any;\n\n  watchFiles?: string[];\n  watchDirs?: string[];\n}\n\nexport interface PartialMessage {\n  pluginName?: string;\n  text?: string;\n  location?: Partial<Location> | null;\n  notes?: PartialNote[];\n  detail?: any;\n}\n\nexport interface PartialNote {\n  text?: string;\n  location?: Partial<Location> | null;\n}\n\nexport interface Metafile {\n  inputs: {\n    [path: string]: {\n      bytes: number;\n      imports: {\n        path: string;\n        kind: ImportKind;\n      }[];\n    };\n  };\n  outputs: {\n    [path: string]: {\n      bytes: number;\n      inputs: {\n        [path: string]: {\n          bytesInOutput: number;\n        };\n      };\n      imports: {\n        path: string;\n        kind: ImportKind;\n      }[];\n      exports: string[];\n      entryPoint?: string;\n    };\n  };\n}\n\nexport interface FormatMessagesOptions {\n  kind: 'error' | 'warning';\n  color?: boolean;\n  terminalWidth?: number;\n}\n\nexport interface AnalyzeMetafileOptions {\n  color?: boolean;\n  verbose?: boolean;\n}\n\n// This function invokes the \"esbuild\" command-line tool for you. It returns a\n// promise that either resolves with a \"BuildResult\" object or rejects with a\n// \"BuildFailure\" object.\n//\n// Works in node: yes\n// Works in browser: yes\nexport declare function build(options: BuildOptions & { write: false }): Promise<BuildResult & { outputFiles: OutputFile[] }>;\nexport declare function build(options: BuildOptions & { incremental: true }): Promise<BuildIncremental>;\nexport declare function build(options: BuildOptions): Promise<BuildResult>;\n\n// This function is similar to \"build\" but it serves the resulting files over\n// HTTP on a localhost address with the specified port.\n//\n// Works in node: yes\n// Works in browser: no\nexport declare function serve(serveOptions: ServeOptions, buildOptions: BuildOptions): Promise<ServeResult>;\n\n// This function transforms a single JavaScript file. It can be used to minify\n// JavaScript, convert TypeScript/JSX to JavaScript, or convert newer JavaScript\n// to older JavaScript. It returns a promise that is either resolved with a\n// \"TransformResult\" object or rejected with a \"TransformFailure\" object.\n//\n// Works in node: yes\n// Works in browser: yes\nexport declare function transform(input: string, options?: TransformOptions): Promise<TransformResult>;\n\n// Converts log messages to formatted message strings suitable for printing in\n// the terminal. This allows you to reuse the built-in behavior of esbuild's\n// log message formatter. This is a batch-oriented API for efficiency.\n//\n// Works in node: yes\n// Works in browser: yes\nexport declare function formatMessages(messages: PartialMessage[], options: FormatMessagesOptions): Promise<string[]>;\n\n// Pretty-prints an analysis of the metafile JSON to a string. This is just for\n// convenience to be able to match esbuild's pretty-printing exactly. If you want\n// to customize it, you can just inspect the data in the metafile yourself.\n//\n// Works in node: yes\n// Works in browser: yes\nexport declare function analyzeMetafile(metafile: Metafile | string, options?: AnalyzeMetafileOptions): Promise<string>;\n\n// A synchronous version of \"build\".\n//\n// Works in node: yes\n// Works in browser: no\nexport declare function buildSync(options: BuildOptions & { write: false }): BuildResult & { outputFiles: OutputFile[] };\nexport declare function buildSync(options: BuildOptions): BuildResult;\n\n// A synchronous version of \"transform\".\n//\n// Works in node: yes\n// Works in browser: no\nexport declare function transformSync(input: string, options?: TransformOptions): TransformResult;\n\n// A synchronous version of \"formatMessages\".\n//\n// Works in node: yes\n// Works in browser: no\nexport declare function formatMessagesSync(messages: PartialMessage[], options: FormatMessagesOptions): string[];\n\n// A synchronous version of \"analyzeMetafile\".\n//\n// Works in node: yes\n// Works in browser: no\nexport declare function analyzeMetafileSync(metafile: Metafile | string, options?: AnalyzeMetafileOptions): string;\n\n// This configures the browser-based version of esbuild. It is necessary to\n// call this first and wait for the returned promise to be resolved before\n// making other API calls when using esbuild in the browser.\n//\n// Works in node: yes\n// Works in browser: yes (\"options\" is required)\nexport declare function initialize(options: InitializeOptions): Promise<void>;\n\nexport interface InitializeOptions {\n  // The URL of the \"esbuild.wasm\" file. This must be provided when running\n  // esbuild in the browser.\n  wasmURL?: string;\n\n  // By default esbuild runs the WebAssembly-based browser API in a web worker\n  // to avoid blocking the UI thread. This can be disabled by setting \"worker\"\n  // to false.\n  worker?: boolean;\n}\n\nexport let version: string;\n"]}