@aligent/cdk-prerender-proxy 0.2.4 → 0.2.5-beta

package/lib/handlers/node_modules/esbuild/install.js

@@ -0,0 +1,256 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const zlib = require("zlib");
+const https = require("https");
+const child_process = require("child_process");
+const version = "0.12.15";
+const binPath = path.join(__dirname, "bin", "esbuild");
+async function installBinaryFromPackage(name, fromPath, toPath) {
+  const cachePath = getCachePath(name);
+  try {
+    fs.copyFileSync(cachePath, toPath);
+    fs.chmodSync(toPath, 493);
+    validateBinaryVersion(toPath);
+    const now = new Date();
+    fs.utimesSync(cachePath, now, now);
+    return;
+  } catch (e) {
+  }
+  let buffer;
+  let didFail = false;
+  try {
+    buffer = installUsingNPM(name, fromPath);
+  } catch (err) {
+    didFail = true;
+    console.error(`Trying to install "${name}" using npm`);
+    console.error(`Failed to install "${name}" using npm: ${err && err.message || err}`);
+  }
+  if (!buffer) {
+    const url = `https://registry.npmjs.org/${name}/-/${name}-${version}.tgz`;
+    console.error(`Trying to download ${JSON.stringify(url)}`);
+    try {
+      buffer = extractFileFromTarGzip(await fetch(url), fromPath);
+    } catch (err) {
+      console.error(`Failed to download ${JSON.stringify(url)}: ${err && err.message || err}`);
+    }
+  }
+  if (!buffer) {
+    console.error(`Install unsuccessful`);
+    process.exit(1);
+  }
+  fs.writeFileSync(toPath, buffer, { mode: 493 });
+  try {
+    validateBinaryVersion(toPath);
+  } catch (err) {
+    console.error(`The version of the downloaded binary is incorrect: ${err && err.message || err}`);
+    console.error(`Install unsuccessful`);
+    process.exit(1);
+  }
+  try {
+    fs.mkdirSync(path.dirname(cachePath), {
+      recursive: true,
+      mode: 448
+    });
+    fs.copyFileSync(toPath, cachePath);
+    cleanCacheLRU(cachePath);
+  } catch (e) {
+  }
+  if (didFail)
+    console.error(`Install successful`);
+}
+function validateBinaryVersion(binaryPath) {
+  const stdout = child_process.execFileSync(binaryPath, ["--version"]).toString().trim();
+  if (stdout !== version) {
+    throw new Error(`Expected ${JSON.stringify(version)} but got ${JSON.stringify(stdout)}`);
+  }
+}
+function getCachePath(name) {
+  const home = os.homedir();
+  const common = ["esbuild", "bin", `${name}@${version}`];
+  if (process.platform === "darwin")
+    return path.join(home, "Library", "Caches", ...common);
+  if (process.platform === "win32")
+    return path.join(home, "AppData", "Local", "Cache", ...common);
+  const XDG_CACHE_HOME = process.env.XDG_CACHE_HOME;
+  if (process.platform === "linux" && XDG_CACHE_HOME && path.isAbsolute(XDG_CACHE_HOME))
+    return path.join(XDG_CACHE_HOME, ...common);
+  return path.join(home, ".cache", ...common);
+}
+function cleanCacheLRU(fileToKeep) {
+  const dir = path.dirname(fileToKeep);
+  const entries = [];
+  for (const entry of fs.readdirSync(dir)) {
+    const entryPath = path.join(dir, entry);
+    try {
+      const stats = fs.statSync(entryPath);
+      entries.push({ path: entryPath, mtime: stats.mtime });
+    } catch (e) {
+    }
+  }
+  entries.sort((a, b) => +b.mtime - +a.mtime);
+  for (const entry of entries.slice(5)) {
+    try {
+      fs.unlinkSync(entry.path);
+    } catch (e) {
+    }
+  }
+}
+function fetch(url) {
+  return new Promise((resolve, reject) => {
+    https.get(url, (res) => {
+      if ((res.statusCode === 301 || res.statusCode === 302) && res.headers.location)
+        return fetch(res.headers.location).then(resolve, reject);
+      if (res.statusCode !== 200)
+        return reject(new Error(`Server responded with ${res.statusCode}`));
+      let chunks = [];
+      res.on("data", (chunk) => chunks.push(chunk));
+      res.on("end", () => resolve(Buffer.concat(chunks)));
+    }).on("error", reject);
+  });
+}
+function extractFileFromTarGzip(buffer, file) {
+  try {
+    buffer = zlib.unzipSync(buffer);
+  } catch (err) {
+    throw new Error(`Invalid gzip data in archive: ${err && err.message || err}`);
+  }
+  let str = (i, n) => String.fromCharCode(...buffer.subarray(i, i + n)).replace(/\0.*$/, "");
+  let offset = 0;
+  file = `package/${file}`;
+  while (offset < buffer.length) {
+    let name = str(offset, 100);
+    let size = parseInt(str(offset + 124, 12), 8);
+    offset += 512;
+    if (!isNaN(size)) {
+      if (name === file)
+        return buffer.subarray(offset, offset + size);
+      offset += size + 511 & ~511;
+    }
+  }
+  throw new Error(`Could not find ${JSON.stringify(file)} in archive`);
+}
+function installUsingNPM(name, file) {
+  const installDir = path.join(os.tmpdir(), "esbuild-" + Math.random().toString(36).slice(2));
+  fs.mkdirSync(installDir, { recursive: true });
+  fs.writeFileSync(path.join(installDir, "package.json"), "{}");
+  const env = __spreadProps(__spreadValues({}, process.env), { npm_config_global: void 0 });
+  child_process.execSync(`npm install --loglevel=error --prefer-offline --no-audit --progress=false ${name}@${version}`, { cwd: installDir, stdio: "pipe", env });
+  const buffer = fs.readFileSync(path.join(installDir, "node_modules", name, file));
+  try {
+    removeRecursive(installDir);
+  } catch (e) {
+  }
+  return buffer;
+}
+function removeRecursive(dir) {
+  for (const entry of fs.readdirSync(dir)) {
+    const entryPath = path.join(dir, entry);
+    let stats;
+    try {
+      stats = fs.lstatSync(entryPath);
+    } catch (e) {
+      continue;
+    }
+    if (stats.isDirectory())
+      removeRecursive(entryPath);
+    else
+      fs.unlinkSync(entryPath);
+  }
+  fs.rmdirSync(dir);
+}
+function isYarnBerryOrNewer() {
+  const { npm_config_user_agent } = process.env;
+  if (npm_config_user_agent) {
+    const match = npm_config_user_agent.match(/yarn\/(\d+)/);
+    if (match && match[1]) {
+      return parseInt(match[1], 10) >= 2;
+    }
+  }
+  return false;
+}
+function installDirectly(name) {
+  if (process.env.ESBUILD_BINARY_PATH) {
+    fs.copyFileSync(process.env.ESBUILD_BINARY_PATH, binPath);
+    validateBinaryVersion(binPath);
+  } else {
+    const tempBinPath = binPath + "__";
+    installBinaryFromPackage(name, "bin/esbuild", tempBinPath).then(() => fs.renameSync(tempBinPath, binPath)).catch((e) => setImmediate(() => {
+      throw e;
+    }));
+  }
+}
+function installWithWrapper(name, fromPath, toPath) {
+  fs.writeFileSync(binPath, `#!/usr/bin/env node
+const path = require('path');
+const esbuild_exe = path.join(__dirname, '..', ${JSON.stringify(toPath)});
+const child_process = require('child_process');
+const { status } = child_process.spawnSync(esbuild_exe, process.argv.slice(2), { stdio: 'inherit' });
+process.exitCode = status === null ? 1 : status;
+`);
+  const absToPath = path.join(__dirname, toPath);
+  if (process.env.ESBUILD_BINARY_PATH) {
+    fs.copyFileSync(process.env.ESBUILD_BINARY_PATH, absToPath);
+    validateBinaryVersion(absToPath);
+  } else {
+    installBinaryFromPackage(name, fromPath, absToPath).catch((e) => setImmediate(() => {
+      throw e;
+    }));
+  }
+}
+function installOnUnix(name) {
+  if (isYarnBerryOrNewer()) {
+    installWithWrapper(name, "bin/esbuild", "esbuild");
+  } else {
+    installDirectly(name);
+  }
+}
+function installOnWindows(name) {
+  installWithWrapper(name, "esbuild.exe", "esbuild.exe");
+}
+const platformKey = `${process.platform} ${os.arch()} ${os.endianness()}`;
+const knownWindowsPackages = {
+  "win32 ia32 LE": "esbuild-windows-32",
+  "win32 x64 LE": "esbuild-windows-64"
+};
+const knownUnixlikePackages = {
+  "android arm64 LE": "esbuild-android-arm64",
+  "darwin arm64 LE": "esbuild-darwin-arm64",
+  "darwin x64 LE": "esbuild-darwin-64",
+  "freebsd arm64 LE": "esbuild-freebsd-arm64",
+  "freebsd x64 LE": "esbuild-freebsd-64",
+  "openbsd x64 LE": "esbuild-openbsd-64",
+  "linux arm LE": "esbuild-linux-arm",
+  "linux arm64 LE": "esbuild-linux-arm64",
+  "linux ia32 LE": "esbuild-linux-32",
+  "linux mips64el LE": "esbuild-linux-mips64le",
+  "linux ppc64 LE": "esbuild-linux-ppc64le",
+  "linux x64 LE": "esbuild-linux-64"
+};
+if (platformKey in knownWindowsPackages) {
+  installOnWindows(knownWindowsPackages[platformKey]);
+} else if (platformKey in knownUnixlikePackages) {
+  installOnUnix(knownUnixlikePackages[platformKey]);
+} else {
+  console.error(`Unsupported platform: ${platformKey}`);
+  process.exit(1);
+}

package/lib/handlers/node_modules/esbuild/lib/main.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;