isomorfeus-asset-manager 0.12.0

data/lib/isomorfeus/asset_manager/version.rb

@@ -0,0 +1,5 @@
+module Isomorfeus
+  class AssetManager
+    VERSION = '0.12.0'
+  end
+end

data/lib/isomorfeus/asset_manager/view_helper.rb

@@ -0,0 +1,9 @@
+module Isomorfeus
+  class AssetManager
+    module ViewHelper
+      def script_tag(path)
+        "<script type=\"application/javascript\" src=\"#{Isomorfeus.assets_path}/#{path}\"></script>"
+      end
+    end
+  end
+end

data/lib/isomorfeus/asset_manager.rb

@@ -0,0 +1,145 @@
+module Isomorfeus
+  class AssetManager
+    def self.finalize(tmpdir)
+      proc { FileUtils.rm_rf(tmpdir) }
+    end
+
+    def initialize
+      Isomorfeus.set_node_paths
+
+      @tmpdir = Dir.mktmpdir
+      @imports_path = File.join(@tmpdir, 'imports')
+      @output_path = File.join(@tmpdir, 'output')
+      FileUtils.mkdir_p(@imports_path)
+      FileUtils.mkdir_p(@output_path)
+
+      @context = ExecJS.permissive_compile(init_js)
+
+      imports_path = File.expand_path(File.join(Isomorfeus.app_root, 'imports'))
+      if Dir.exist?(imports_path)
+        common_imports_file = File.join(imports_path, 'common.js')
+        Isomorfeus.add_common_js_import(common_imports_file) if File.exist?(common_imports_file)
+        web_imports_file = File.join(imports_path, 'web.js')
+        Isomorfeus.add_web_js_import(web_imports_file) if File.exist?(web_imports_file)
+        ssr_imports_file = File.join(imports_path, 'ssr.js')
+        Isomorfeus.add_ssr_js_import(ssr_imports_file) if File.exist?(ssr_imports_file)
+      end
+
+      ObjectSpace.define_finalizer(self, self.class.finalize(@tmpdir))
+    end
+  
+    def transition(asset_key, asset)
+      return if !Isomorfeus.development? && asset.bundled?
+      compile_ruby_and_save(asset_key, asset)
+      save_imports(asset_key, asset)
+      run_esbuild(asset_key, asset)
+      asset.bundle = bundled_asset(asset_key)
+      if !Isomorfeus.production? && asset.target != :node
+        asset.bundle_map = bundled_asset_map(asset_key) 
+      end
+    end
+
+    private
+
+    def bundled_asset(asset_key)
+      File.read(File.join(@output_path, asset_key))
+    end
+
+    def bundled_asset_map(asset_key)
+      File.read(File.join(@output_path, asset_key + '.map'))
+    end
+
+    def save_imports(asset_key, asset)
+      File.write(File.join(@imports_path, asset_key), asset.to_s)
+    end
+
+    def compile_ruby_and_save(asset_key, asset)
+      asset.ruby_imports.each do |ruby_import|
+        result = Opal::Builder.build(ruby_import.resolved_path, { es6_wrap: true })
+        FileUtils.mkdir_p(File.join(*[@imports_path].concat(ruby_import.module_name.split('/')[0...-1]))) if ruby_import.module_name.include?('/')
+        js = result.to_s
+        if !Isomorfeus.production? && asset.target != :node
+          js_map_path = File.join(@imports_path, ruby_import.module_name + '.js.map')
+          js << "\n//# sourceMappingURL=file://#{js_map_path}\n"
+          File.write(js_map_path, result.source_map)
+        end
+        File.write(File.join(@imports_path, ruby_import.module_name + '.js'), js)
+      end
+    end
+
+    def print_message(m, level)
+      l = m['location']
+      STDERR.puts "#{l['file']}:#{l['line']}:#{l['column']}: #{level}: #{m['text']}"
+      STDERR.puts "  #{l['line']} | #{l['lineText']}\n\n"
+    end
+
+    def handle_errors(asset_key, result)
+      # Todo simplify
+      unless result['warnings'].empty?
+        result['warnings'].each do |w|
+          print_message(w, 'warning')
+          unless w['notes'].empty?
+            w['notes'].each do |n|
+              print_message(n, 'note')
+            end
+          end
+        end
+      end
+      unless result['errors'].empty?
+        result['errors'].each do |e|
+          print_message(w, 'error')
+          unless w['notes'].empty?
+            e['notes'].each do |n|
+              print_message(n, 'note')
+            end
+          end
+        end
+        raise "Aseet Manager: error bundling '#{asset_key}'" 
+      end
+    end
+
+    def init_js
+      <<~JAVASCRIPT
+      'use strict';
+      const path = require('path');
+      var esbuild_r;
+      try { esbuild_r = require('esbuild'); }
+      catch { esbuild_r = require('esbuild-wasm'); }
+      const esbuild = esbuild_r;
+      global.imports_path = '#{@imports_path}';
+      global.output_path = '#{@output_path}';
+      JAVASCRIPT
+    end
+
+    # possible future improvement
+    # loader: {
+    #   '.png': 'dataurl',
+    #   '.svg': 'text',
+    # },
+    def run_esbuild(asset_key, asset)
+      resolve_paths = ENV['NODE_PATH'].split(Gem.win_platform? ? ';' : ':')
+      resolve_paths << 'node_modules'
+      resolve_paths.uniq!
+
+      result = @context.exec <<~JAVASCRIPT
+      return esbuild.buildSync({
+        entryPoints: [path.resolve(global.imports_path, '#{asset_key}')],
+        bundle: true,
+        color: false,
+        format: '#{asset.target == :node ? 'cjs' : 'iife'}',
+        legalComments: 'linked',
+        minify: #{Isomorfeus.production? ? 'true' : 'false'},
+        nodePaths: #{resolve_paths},
+        outdir: global.output_path,
+        platform: '#{asset.target}',
+        publicPath: '/assets',
+        sourcemap: #{(!Isomorfeus.production? && asset.target != :node) ? 'true' : 'false'},
+        splitting: false,
+        target: 'es6',
+        write: true
+      });
+      JAVASCRIPT
+      handle_errors(asset_key, result)
+    end
+  end
+end

data/lib/isomorfeus-asset-manager.rb

@@ -0,0 +1,27 @@
+require 'fileutils'
+require 'tmpdir'
+require 'zlib'
+require 'opal'
+require 'opal/builder'
+require 'oj'
+require 'rack'
+require 'isomorfeus-speednode'
+require 'isomorfeus/asset_manager/version'
+require 'isomorfeus/asset_manager/js_import'
+require 'isomorfeus/asset_manager/ruby_import'
+require 'isomorfeus/asset_manager/asset'
+require 'isomorfeus/asset_manager/portfolio'
+require 'isomorfeus/asset_manager/rack_middleware'
+require 'isomorfeus/asset_manager/server_socket_processor'
+require 'isomorfeus/asset_manager'
+require 'isomorfeus/asset_manager/config'
+require 'isomorfeus/asset_manager/view_helper'
+require 'iso_opal'
+
+Isomorfeus.env = ENV['RACK_ENV']
+
+Isomorfeus.node_paths << File.expand_path(File.join(File.dirname(__FILE__), '..', 'node_modules'))
+
+Isomorfeus.root = File.expand_path('.')
+Isomorfeus.app_root = File.expand_path('app')
+Opal.append_path(Isomorfeus.app_root) unless IsoOpal.paths_include?(Isomorfeus.app_root)

data/node_modules/.bin/esbuild

@@ -0,0 +1,12 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../esbuild-wasm/bin/esbuild" "$@"
+else 
+  exec node  "$basedir/../esbuild-wasm/bin/esbuild" "$@"
+fi

data/node_modules/.bin/esbuild.cmd

@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\esbuild-wasm\bin\esbuild" %*

data/node_modules/.bin/esbuild.ps1

@@ -0,0 +1,28 @@
+#!/usr/bin/env pwsh
+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
+
+$exe=""
+if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
+  # Fix case when both the Windows and Linux builds of Node
+  # are installed in the same directory
+  $exe=".exe"
+}
+$ret=0
+if (Test-Path "$basedir/node$exe") {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "$basedir/node$exe"  "$basedir/../esbuild-wasm/bin/esbuild" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../esbuild-wasm/bin/esbuild" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../esbuild-wasm/bin/esbuild" $args
+  } else {
+    & "node$exe"  "$basedir/../esbuild-wasm/bin/esbuild" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret

data/node_modules/.package-lock.json

@@ -0,0 +1,18 @@
+{
+  "name": "isomorfeus-asset-manager",
+  "lockfileVersion": 2,
+  "requires": true,
+  "packages": {
+    "node_modules/esbuild-wasm": {
+      "version": "0.12.25",
+      "resolved": "https://registry.npmjs.org/esbuild-wasm/-/esbuild-wasm-0.12.25.tgz",
+      "integrity": "sha512-/lgWzZ1O5sXEVHw2gEQpSnVFc5kOMXiloNRQ3rASX+7/dswSMhlZ2Fw/4t4wTjqyq3cO51Fr48y5Yc4u4r74Cg==",
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    }
+  }
+}

data/node_modules/esbuild-wasm/README.md

@@ -0,0 +1,3 @@
+# esbuild
+
+This is the cross-platform WebAssembly binary for esbuild, a JavaScript bundler and minifier. See https://github.com/evanw/esbuild and the [JavaScript API documentation](https://esbuild.github.io/api/) for details.

data/node_modules/esbuild-wasm/bin/esbuild

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+
+// Forward to the automatically-generated WebAssembly loader from the Go compiler
+
+const crypto = require('crypto');
+const path = require('path');
+const zlib = require('zlib');
+const fs = require('fs');
+const os = require('os');
+
+const wasm_exec = path.join(__dirname, '..', 'wasm_exec.js');
+const esbuild_wasm = path.join(__dirname, '..', 'esbuild.wasm');
+
+const code = fs.readFileSync(wasm_exec, 'utf8');
+const wrapper = new Function('require', 'module', 'process', 'WebAssembly', code);
+
+function instantiate(bytes, importObject) {
+  // Using this API causes "./esbuild --version" to run around 1 second faster
+  // than using the "WebAssembly.instantiate()" API when run in node (v12.16.2)
+  const module = new WebAssembly.Module(bytes);
+  const instance = new WebAssembly.Instance(module, importObject);
+  return Promise.resolve({ instance, module });
+}
+
+// Node has an unfortunate bug where the node process is unnecessarily kept open while a
+// WebAssembly module is being optimized: https://github.com/nodejs/node/issues/36616.
+// This means cases where running "esbuild" should take a few milliseconds can end up
+// taking many seconds instead. To work around this bug, it is possible to force node to
+// exit by calling the operating system's exit function. That's what this code does.
+process.on('exit', code => {
+  // If it's a non-zero exit code, we can just kill our own process to stop. This will
+  // preserve the fact that there is a non-zero exit code although the exit code will
+  // be different. We cannot use this if the exit code is supposed to be zero.
+  if (code !== 0) {
+    try {
+      process.kill(process.pid, 'SIGINT');
+    } catch (e) {
+    }
+    return;
+  }
+
+  // Otherwise if the exit code is zero, try to fall back to a binary N-API module that
+  // calls the operating system's "exit(0)" function.
+  const nativeModule = `${process.platform}-${os.arch()}-${os.endianness()}.node`;
+  const base64 = require('../exit0')[nativeModule];
+  if (base64) {
+    try {
+      const data = zlib.inflateRawSync(Buffer.from(base64, 'base64'));
+      const hash = crypto.createHash('sha256').update(base64).digest().toString('hex').slice(0, 16);
+      const tempFile = path.join(os.tmpdir(), `${hash}-${nativeModule}`);
+      try {
+        if (fs.readFileSync(tempFile).equals(data)) {
+          require(tempFile);
+        }
+      } finally {
+        fs.writeFileSync(tempFile, data);
+        require(tempFile);
+      }
+    } catch (e) {
+    }
+  }
+});
+
+// Node has another bug where using "fs.read" to read from stdin reads
+// everything successfully and then throws an error, but only on Windows. Go's
+// WebAssembly support uses "fs.read" so it hits this problem. This is a patch
+// to try to work around the bug in node. This bug has been reported to node
+// at least twice in https://github.com/nodejs/node/issues/35997 and in
+// https://github.com/nodejs/node/issues/19831. This issue has also been
+// reported to the Go project: https://github.com/golang/go/issues/43913.
+const read = fs.read;
+fs.read = function () {
+  const callback = arguments[5];
+  arguments[5] = function (err, count) {
+    if (count === 0 && err && err.code === 'EOF') {
+      arguments[0] = null;
+    }
+    return callback.apply(this, arguments);
+  };
+  return read.apply(this, arguments);
+};
+
+const argv = ['node', wasm_exec, esbuild_wasm].concat(process.argv.slice(2));
+wrapper(require, require.main, Object.assign(Object.create(process), { argv }), Object.assign(Object.create(WebAssembly), { instantiate }));

data/node_modules/esbuild-wasm/esm/browser.d.ts

@@ -0,0 +1,397 @@
+export type Platform = 'browser' | 'node' | 'neutral';
+export type Format = 'iife' | 'cjs' | 'esm';
+export type Loader = 'js' | 'jsx' | 'ts' | 'tsx' | 'css' | 'json' | 'text' | 'base64' | 'file' | 'dataurl' | 'binary' | 'default';
+export type LogLevel = 'verbose' | 'debug' | 'info' | 'warning' | 'error' | 'silent';
+export type Charset = 'ascii' | 'utf8';
+export type TreeShaking = true | 'ignore-annotations';
+
+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?: TreeShaking;
+
+  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[]; // The "NODE_PATH" variable from Node.js
+  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[];
+
+  // Optional user-specified data that is passed through unmodified. You can
+  // use this to stash the original error, for example.
+  detail: any;
+}
+
+export interface Note {
+  text: string;
+  location: Location | null;
+}
+
+export interface Location {
+  file: string;
+  namespace: string;
+  line: number; // 1-based
+  column: number; // 0-based, in bytes
+  length: number; // in bytes
+  lineText: string;
+  suggestion: string;
+}
+
+export interface OutputFile {
+  path: string;
+  contents: Uint8Array; // "text" as bytes
+  text: string; // "contents" as text
+}
+
+export interface BuildInvalidate {
+  (): Promise<BuildIncremental>;
+  dispose(): void;
+}
+
+export interface BuildIncremental extends BuildResult {
+  rebuild: BuildInvalidate;
+}
+
+export interface BuildResult {
+  errors: Message[];
+  warnings: Message[];
+  outputFiles?: OutputFile[]; // Only when "write: false"
+  rebuild?: BuildInvalidate; // Only when "incremental: true"
+  stop?: () => void; // Only when "watch: true"
+  metafile?: Metafile; // Only when "metafile: true"
+}
+
+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; // The time to generate the response, not to send it
+}
+
+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 type ImportKind =
+  | 'entry-point'
+
+  // JS
+  | 'import-statement'
+  | 'require-call'
+  | 'dynamic-import'
+  | 'require-resolve'
+
+  // CSS
+  | '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;
+}
+
+// This function invokes the "esbuild" command-line tool for you. It returns a
+// promise that either resolves with a "BuildResult" object or rejects with a
+// "BuildFailure" object.
+//
+// Works in node: yes
+// Works in browser: yes
+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>;
+
+// This function is similar to "build" but it serves the resulting files over
+// HTTP on a localhost address with the specified port.
+//
+// Works in node: yes
+// Works in browser: no
+export declare function serve(serveOptions: ServeOptions, buildOptions: BuildOptions): Promise<ServeResult>;
+
+// This function transforms a single JavaScript file. It can be used to minify
+// JavaScript, convert TypeScript/JSX to JavaScript, or convert newer JavaScript
+// to older JavaScript. It returns a promise that is either resolved with a
+// "TransformResult" object or rejected with a "TransformFailure" object.
+//
+// Works in node: yes
+// Works in browser: yes
+export declare function transform(input: string, options?: TransformOptions): Promise<TransformResult>;
+
+// Converts log messages to formatted message strings suitable for printing in
+// the terminal. This allows you to reuse the built-in behavior of esbuild's
+// log message formatter. This is a batch-oriented API for efficiency.
+//
+// Works in node: yes
+// Works in browser: yes
+export declare function formatMessages(messages: PartialMessage[], options: FormatMessagesOptions): Promise<string[]>;
+
+// A synchronous version of "build".
+//
+// Works in node: yes
+// Works in browser: no
+export declare function buildSync(options: BuildOptions & { write: false }): BuildResult & { outputFiles: OutputFile[] };
+export declare function buildSync(options: BuildOptions): BuildResult;
+
+// A synchronous version of "transform".
+//
+// Works in node: yes
+// Works in browser: no
+export declare function transformSync(input: string, options?: TransformOptions): TransformResult;
+
+// A synchronous version of "formatMessages".
+//
+// Works in node: yes
+// Works in browser: no
+export declare function formatMessagesSync(messages: PartialMessage[], options: FormatMessagesOptions): string[];
+
+// This configures the browser-based version of esbuild. It is necessary to
+// call this first and wait for the returned promise to be resolved before
+// making other API calls when using esbuild in the browser.
+//
+// Works in node: yes
+// Works in browser: yes ("options" is required)
+export declare function initialize(options: InitializeOptions): Promise<void>;
+
+export interface InitializeOptions {
+  // The URL of the "esbuild.wasm" file. This must be provided when running
+  // esbuild in the browser.
+  wasmURL?: string
+
+  // By default esbuild runs the WebAssembly-based browser API in a web worker
+  // to avoid blocking the UI thread. This can be disabled by setting "worker"
+  // to false.
+  worker?: boolean
+}
+
+export let version: string;