@ohos-ports/layer0-prefetch 4.20.0-beta.0 → 4.20.0-beta.1

package/node_modules/@layer0/core/node_modules/esbuild/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "@ohos-ports/esbuild",
+  "version": "0.28.1-beta.2",
+  "description": "An extremely fast JavaScript and CSS bundler and minifier.",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ohos-ports/ohos-ports.git",
+    "directory": "ports/@turbo/gen/2.11.7"
+  },
+  "scripts": {
+    "postinstall": "node install.js"
+  },
+  "main": "lib/main.js",
+  "types": "lib/main.d.ts",
+  "engines": {
+    "node": ">=18"
+  },
+  "bin": {
+    "esbuild": "bin/esbuild"
+  },
+  "dependencies": {
+    "@ohos-ports/esbuild-openharmony-arm64": "0.28.1-beta.5"
+  },
+  "optionalDependencies": {
+    "@esbuild/aix-ppc64": "0.28.1",
+    "@esbuild/android-arm": "0.28.1",
+    "@esbuild/android-arm64": "0.28.1",
+    "@esbuild/android-x64": "0.28.1",
+    "@esbuild/darwin-arm64": "0.28.1",
+    "@esbuild/darwin-x64": "0.28.1",
+    "@esbuild/freebsd-arm64": "0.28.1",
+    "@esbuild/freebsd-x64": "0.28.1",
+    "@esbuild/linux-arm": "0.28.1",
+    "@esbuild/linux-arm64": "0.28.1",
+    "@esbuild/linux-ia32": "0.28.1",
+    "@esbuild/linux-loong64": "0.28.1",
+    "@esbuild/linux-mips64el": "0.28.1",
+    "@esbuild/linux-ppc64": "0.28.1",
+    "@esbuild/linux-riscv64": "0.28.1",
+    "@esbuild/linux-s390x": "0.28.1",
+    "@esbuild/linux-x64": "0.28.1",
+    "@esbuild/netbsd-arm64": "0.28.1",
+    "@esbuild/netbsd-x64": "0.28.1",
+    "@esbuild/openbsd-arm64": "0.28.1",
+    "@esbuild/openbsd-x64": "0.28.1",
+    "@ohos-ports/esbuild-openharmony-arm64": "0.28.1-beta.5",
+    "@esbuild/sunos-x64": "0.28.1",
+    "@esbuild/win32-arm64": "0.28.1",
+    "@esbuild/win32-ia32": "0.28.1",
+    "@esbuild/win32-x64": "0.28.1"
+  },
+  "license": "MIT",
+  "esbuild.binaryHashes": {
+    "@esbuild/aix-ppc64/bin/esbuild": "0dd860154344f94b7a9367e64ffc2bc5b89a4313b4a399e5127cdc4ff5000303",
+    "@esbuild/android-arm64/bin/esbuild": "087671da02d323e7915fafc13567c0929192633ed544bd8adee9bc020fddf5b4",
+    "@esbuild/darwin-arm64/bin/esbuild": "e2dc9a52440a2a34f09434a2f4843cb1e30f84e40dcf238976ec61ef8cd7f36a",
+    "@esbuild/darwin-x64/bin/esbuild": "dd53ccf32f9b5b3ab30d41388ef1fc8f81c44ca57ee7a32a7364a1753308d009",
+    "@esbuild/freebsd-arm64/bin/esbuild": "5fef5a5ef24d9660d7711b756be5ddeba1fb3ca8dd62d703682ebb9fab3b68b0",
+    "@esbuild/freebsd-x64/bin/esbuild": "4427a8cbfa0661943ccfef2606a65b35f3411ac73e447e86f7732aace61e4609",
+    "@esbuild/linux-arm/bin/esbuild": "a2d93f7a8b1c9f91d47beec987888b4765c890501b6274f4bdff4061a5e0d9fd",
+    "@esbuild/linux-arm64/bin/esbuild": "51e829ba36f36be6d9aea6e329ddc4f9350302339b16aaca96a3cb97f64a8ebb",
+    "@esbuild/linux-ia32/bin/esbuild": "9cd7515a75d6f96b0aa055861cf987498315428088cd6d18de5082f904ae5794",
+    "@esbuild/linux-loong64/bin/esbuild": "73fa76af9b13f7a27fdb20673b8c2af927fe1511d14e51edeb4b7b71f7f03d0e",
+    "@esbuild/linux-mips64el/bin/esbuild": "d734787abc3c99d95242805047fe32da85a5822f04bf33d766a966bf5fd85488",
+    "@esbuild/linux-ppc64/bin/esbuild": "90709144617c2adf8f6c14937f03b114c259de0b9309666e3a9d89a1fb266d04",
+    "@esbuild/linux-riscv64/bin/esbuild": "86df35a46bedde8b756edb6565a1df7b5a832ad74dd0e179608cbf6509a2582a",
+    "@esbuild/linux-s390x/bin/esbuild": "f8cad0db35132e5ac3065c4345c36e7ffe18fdc98417a61bcf5a95a6c694e57c",
+    "@esbuild/linux-x64/bin/esbuild": "0c6588b092a2c291a72bab90659f3c9e0e25e0fe59c9ac12b4dae4d945e5548c",
+    "@esbuild/netbsd-arm64/bin/esbuild": "490cfdac2d96d5608d91cf55bdf4052bbde7013dafe87ec7adc7784778ad4d4c",
+    "@esbuild/netbsd-x64/bin/esbuild": "c61e0e4c553a4986fd0e9d63a0425e93be831ff7b13bfb8a564368fb7590f85d",
+    "@esbuild/openbsd-arm64/bin/esbuild": "f9d814698e26c09c3f90d4c103cbdf3832c9f2c841d64a93889d63d23da9b8cf",
+    "@esbuild/openbsd-x64/bin/esbuild": "2e30dce11f7236aa362c1c57212cc696f51472169aa417f30e9b641f3b7dcade",
+    "@esbuild/sunos-x64/bin/esbuild": "770e0d2bc930b1a1d19d3f43243ff8f393efddb599e7f5843160feacd253267d",
+    "@esbuild/win32-arm64/esbuild.exe": "bfb8798ab678f1ce4a723739f4a3eabab3244d7a04eeb12be2eb9f58095c13ef",
+    "@esbuild/win32-ia32/esbuild.exe": "8fa99b6e0945830fce8d7e208fdb21763aa4aea875751f4a0eec7f6e262af1dd",
+    "@esbuild/win32-x64/esbuild.exe": "ec02ee9b14ab332416fedd10614dfb80eed5304d94f67745067c011934a8c3c3"
+  }
+}

package/node_modules/@layer0/core/package.json

@@ -0,0 +1,132 @@
+{
+  "name": "@layer0/core",
+  "version": "4.20.0",
+  "main": "./index.js",
+  "license": "UNLICENSED",
+  "scripts": {
+    "docs": "typedoc",
+    "build": "rm -rf ./dist; mkdir ./dist; cp -r package.json README.md serverless.yml default-app ./dist; tsc; npm run bundle-handler;",
+    "bundle-handler": "esbuild src/lambda/handler.ts --bundle --minify --platform=node --target=node14.0 --outfile=dist/lambda/handler.js --log-level=error --sourcemap",
+    "watch": "npm-watch",
+    "ts:watch": "tsc --watch",
+    "push-build": "npm run build && cd dist && yalc push --force && cd ..",
+    "release": "cd ./dist; npm publish --access public",
+    "release:next": "npm run release -- --tag next",
+    "test": "jest --watchAll=false --runInBand --forceExit"
+  },
+  "dependencies": {
+    "@babel/parser": "^7.18.9",
+    "@babel/traverse": "^7.18.9",
+    "@types/lodash.clonedeep": "^4.5.6",
+    "ajv": "^6.12.6",
+    "babel-loader": "^8.2.2",
+    "chalk": "^4.1.2",
+    "chardet": "^1.4.0",
+    "chokidar": "^3.5.1",
+    "cls-hooked": "^4.2.2",
+    "content-type": "^1.0.4",
+    "cookie": "^0.4.1",
+    "cross-spawn": "^7.0.3",
+    "decode-uri-component": "^0.2.0",
+    "deepmerge": "^4.2.2",
+    "esbuild": "npm:@ohos-ports/esbuild@0.28.1-beta.2",
+    "express": "^4.17.1",
+    "fs-extra": "^8.1.0",
+    "globby": "^11.0.2",
+    "http-proxy": "^1.18.1",
+    "lodash.clonedeep": "^4.5.0",
+    "lru-cache": "^6.0.0",
+    "mime-types": "^2.1.35",
+    "node-fetch": "^2.6.1",
+    "path-to-regexp": "^6.2.0",
+    "pino": "^6.13.3",
+    "qs": "^6.10.1",
+    "resolve-package-path": "^4.0.3",
+    "semver": "^7.3.5",
+    "shelljs": "^0.8.5",
+    "slash": "^3.0.0",
+    "tcp-port-used": "^1.0.2",
+    "ts-loader": "^8.2.0",
+    "unixify": "^1.0.0",
+    "uuid": "^8.3.2"
+  },
+  "publishConfig": {
+    "directory": "dist"
+  },
+  "watch": {
+    "push-build": {
+      "patterns": [
+        "src",
+        "bin",
+        "serverless.yml",
+        "default-app",
+        "package.json"
+      ],
+      "extensions": [
+        "js",
+        "ts"
+      ],
+      "quiet": false
+    }
+  },
+  "jest": {
+    "clearMocks": true,
+    "collectCoverage": true,
+    "transform": {
+      "^.+\\.(js)?$": "babel-jest",
+      "^.+\\.ts$": "ts-jest"
+    },
+    "moduleFileExtensions": [
+      "ts",
+      "js",
+      "json"
+    ],
+    "setupFilesAfterEnv": [
+      "<rootDir>/test/jest.js"
+    ],
+    "transformIgnorePatterns": [
+      "<rootDir>/node_modules/"
+    ],
+    "moduleNameMapper": {
+      "../package.json": "<rootDir>/package.json",
+      "^@layer0/core(.*)$": "<rootDir>/src/$1"
+    },
+    "collectCoverageFrom": [
+      "./src/**/*.{ts,js}",
+      "!**/mocks/**",
+      "!**/test-utils/**",
+      "!**/index.ts",
+      "!**/src/types.ts",
+      "!**/plugins/PluginBase.ts",
+      "!**/bin/**/*"
+    ]
+  },
+  "devDependencies": {
+    "@types/cls-hooked": "^4.3.1",
+    "@types/content-type": "^1.1.3",
+    "@types/cookie": "^0.3.3",
+    "@types/cross-spawn": "^6.0.2",
+    "@types/decode-uri-component": "^0.2.0",
+    "@types/express": "^4.17.7",
+    "@types/fs-extra": "^8.1.1",
+    "@types/http-proxy": "^1.17.4",
+    "@types/jest": "^26.0.23",
+    "@types/lodash": "^4.14.162",
+    "@types/lru-cache": "^5.1.0",
+    "@types/mime-types": "^2.1.0",
+    "@types/node": "^14.6.4",
+    "@types/route-parser": "^0.1.3",
+    "@types/semver": "^7.3.9",
+    "@types/shelljs": "^0.8.8",
+    "@types/tcp-port-used": "^1.0.0",
+    "@types/unixify": "^1.0.0",
+    "@types/uuid": "^8.0.1",
+    "@types/webpack-bundle-analyzer": "^3.9.0",
+    "lodash": "^4.17.21",
+    "nock": "^13.2.8",
+    "stripe": "^9.12.0",
+    "webpack": "^5.27.0",
+    "webpack-bundle-analyzer": "^3.9.0",
+    "webpack-dev-middleware": "^4.1.0"
+  }
+}

package/node_modules/@layer0/core/parser/parseRouter.d.ts

@@ -0,0 +1,13 @@
+import RouteCriteria from '../router/RouteCriteria';
+interface RouteInfo {
+    criteria: RouteCriteria;
+    line: number;
+    column: number;
+}
+/**
+ * Parses and introspects the user's routes file.
+ * @private
+ * @param routerFile
+ */
+export default function parseRouter(routerFile: string): RouteInfo[];
+export {};

package/node_modules/@layer0/core/parser/parseRouter.js

@@ -0,0 +1,77 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = require("fs");
+const traverse_1 = __importDefault(require("@babel/traverse"));
+const parser_1 = require("@babel/parser");
+const routeFunctions = new Set(['get', 'put', 'post', 'patch', 'options', 'delete', 'match']);
+/**
+ * Parses and introspects the user's routes file.
+ * @private
+ * @param routerFile
+ */
+function parseRouter(routerFile) {
+    const code = fs_1.readFileSync(routerFile, 'utf8');
+    const ast = parser_1.parse(code, { sourceType: 'module', plugins: ['typescript'] });
+    const results = [];
+    // @ts-ignore
+    traverse_1.default(ast, {
+        CallExpression: (path) => {
+            const call = path.node;
+            const member = call.callee;
+            const args = call.arguments;
+            if (member.type !== 'MemberExpression' || member.property.type !== 'Identifier') {
+                return;
+            }
+            const method = member.property;
+            if (routeFunctions.has(method.name)) {
+                // istanbul ignore if
+                if (!method.loc) {
+                    // istanbul ignore next
+                    throw new Error('Source location not available');
+                }
+                try {
+                    results.push({
+                        criteria: getRouteCriteria(method.name, args[0], code),
+                        line: method.loc.start.line,
+                        column: method.loc.start.column,
+                    });
+                }
+                catch (e) {
+                    // will get here if the method's first argument is an unexpected type, which likely
+                    // means this wasn't a method call on the router
+                }
+            }
+        },
+    });
+    return results;
+}
+exports.default = parseRouter;
+/**
+ * Returns the criteria for the given route
+ * @param method
+ * @param criteriaNode
+ * @param code
+ */
+function getRouteCriteria(method, criteriaNode, code) {
+    // istanbul ignore if
+    if (!criteriaNode.start || !criteriaNode.end) {
+        // istanbul ignore next
+        throw new Error('Source location not available');
+    }
+    const snippet = code.slice(criteriaNode.start, criteriaNode.end);
+    let criteriaOrPath, criteria;
+    eval(`criteriaOrPath = ${snippet}`);
+    if (typeof criteriaOrPath === 'string') {
+        criteria = {
+            method,
+            path: criteriaOrPath,
+        };
+    }
+    else {
+        criteria = criteriaOrPath;
+    }
+    return criteria;
+}

package/node_modules/@layer0/core/plugins/PluginBase.d.ts

@@ -0,0 +1,18 @@
+import Request from '../router/Request';
+import { Router } from '../router';
+/**
+ * Base class for a router plugin.
+ */
+export default class PluginBase {
+    type?: string;
+    /**
+     * Called when plugin is registered
+     * @param router The router object to which the plugin was added.
+     */
+    onRegister(router: Router): void;
+    /**
+     * Called when `router.run` receives a request.
+     * @param req The request object
+     */
+    onRequest(req: Request): void;
+}

package/node_modules/@layer0/core/plugins/PluginBase.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable no-unused-vars */
+/**
+ * Base class for a router plugin.
+ */
+class PluginBase {
+    /**
+     * Called when plugin is registered
+     * @param router The router object to which the plugin was added.
+     */
+    onRegister(router) { }
+    /**
+     * Called when `router.run` receives a request.
+     * @param req The request object
+     */
+    onRequest(req) { }
+}
+exports.default = PluginBase;

package/node_modules/@layer0/core/router/Backend.d.ts

@@ -0,0 +1,69 @@
+import BackendConfig from './BackendOptions';
+import Request from './Request';
+import Response from './Response';
+/**
+ * @private
+ */
+export interface FetchOptions {
+    /**
+     * The URL path to fetch
+     */
+    path?: string;
+    /**
+     * The HTTP request headers to send
+     */
+    headers?: Headers;
+    /**
+     * If set to `true`, invalid TLS certs will be ignored. Otherwise an error will be thrown
+     * when the server returns an invalid TLS certificate.
+     */
+    disableCheckCert?: boolean;
+    /**
+     * Removes the "=" from search parameters that have no value. So for example:
+     * "http://domain.com?foo=&bar=" becomes "http://domain.com?foo&bar"
+     */
+    removeEmptySearchParamValues?: boolean;
+}
+/**
+ * @private
+ */
+export default class Backend {
+    protected config: BackendConfig;
+    static setImpl(implementation: {
+        new (config: BackendConfig): Backend;
+    }): void;
+    static create(config: BackendConfig): Backend;
+    constructor(config: BackendConfig);
+    /**
+     * Sends a request using the proxy.
+     * @param req The request being sent.
+     * @param res The response for the request.
+     */
+    fetch(req: Request, res: Response, options: FetchOptions): Promise<unknown>;
+    /**
+     * Returns proxy configuration for http-proxy
+     * @returns proxy target url
+     */
+    private getProxyTarget;
+    /**
+     * Returns true if the URL points to the local JS backend, otherwise false.
+     * @param url
+     * @returns
+     */
+    private isLocal;
+    /**
+     * Returns proxy configuration object for node-fetch
+     * @param url
+     * @param req
+     * @param headers Additional request headers to include
+     * @param removeEmptySearchParamValues If true, search param values that are empty are removed so "?foo=" becomes "?foo".
+     */
+    private getProxyRequestOptions;
+}
+/**
+ * @private
+ */
+declare type Headers = {
+    [key: string]: string;
+};
+export {};

package/node_modules/@layer0/core/router/Backend.js

@@ -0,0 +1,176 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const url_1 = require("url");
+const https_1 = __importDefault(require("https"));
+const http_1 = __importDefault(require("http"));
+const path_1 = require("path");
+const BackendFetchError_1 = __importDefault(require("../errors/BackendFetchError"));
+const mergeQueryString_1 = __importDefault(require("./mergeQueryString"));
+const constants_1 = require("../constants");
+/**
+ * Array of response headers that will not be passed over directly from the proxied resource
+ *
+ * Notes:
+ * - transfer-encoding: as it poisons the response which will be formed
+ * based on its own transfer-encoding rather than the one received from the Lambda.
+ *
+ * - content-length: as the actual constant may be changed by buffer proxy
+ * (e.g. on moov_debug=true)
+ * @private
+ */
+const IGNORE_RESPONSE_HEADERS = ['transfer-encoding', 'content-length'];
+/**
+ * @private
+ */
+class Backend {
+    constructor(config) {
+        this.config = config;
+    }
+    static setImpl(implementation) {
+        impl = implementation;
+    }
+    static create(config) {
+        return new impl(config);
+    }
+    /**
+     * Sends a request using the proxy.
+     * @param req The request being sent.
+     * @param res The response for the request.
+     */
+    async fetch(req, res, options) {
+        const { path, headers } = options || {};
+        // Create url for proxy with query params added if existing
+        const url = this.getProxyTarget(req, path);
+        const requestOptions = this.getProxyRequestOptions(url, req, headers, options === null || options === void 0 ? void 0 : options.removeEmptySearchParamValues);
+        return new Promise((resolve, reject) => {
+            const lib = url.protocol === 'https:' ? https_1.default : http_1.default;
+            const upstreamReq = lib.request(requestOptions, upstreamRes => {
+                let buf = [];
+                upstreamRes
+                    .on('data', (chunk) => buf.push(chunk))
+                    .on('end', () => {
+                    /* istanbul ignore else */
+                    if (upstreamRes.complete) {
+                        Object.entries(upstreamRes.headers)
+                            .filter(([name]) => !IGNORE_RESPONSE_HEADERS.includes(name.toLowerCase()))
+                            .forEach(([name, value]) => {
+                            try {
+                                res.setHeader(name, value);
+                            }
+                            catch (e) {
+                                console.warn(`Could not relay upstream response header ${name} with value ${value}`, e);
+                            }
+                        });
+                        res.statusCode = upstreamRes.statusCode;
+                        res.statusMessage = upstreamRes.statusMessage;
+                        res.body = Buffer.concat(buf);
+                        /* istanbul ignore if */
+                        if (process.env.DEBUG === 'true') {
+                            console.log('proxy', `[${res.statusCode} ${res.statusMessage}]`, url);
+                        }
+                        resolve(undefined);
+                    }
+                })
+                    .on('error', 
+                /* istanbul ignore next */ e => {
+                    reject(new BackendFetchError_1.default(e));
+                })
+                    // Closing the connection before the response is complete
+                    // has different behaviours depending on NodeJs version
+                    // - node 12: triggers a 'close' event on the Request and Response, and an 'end' event on Response in between
+                    // - node 14: triggers a 'close' event on the Request and Response, but no 'end' event on Response anymore
+                    // - node 16: triggers a 'close' event on the Request and Response and an "aborted" error on Response in between
+                    // See playground at https://runkit.com/adrien-k/aborted-res-error
+                    //
+                    // We take the most compatible approach, although in v16 and above this should be caught by the 'error' event.
+                    /* istanbul ignore next */
+                    .on('close', 
+                /* istanbul ignore next */ () => {
+                    if (!upstreamRes.complete) {
+                        reject(new BackendFetchError_1.default(new Error('The connection was terminated while the message was still being sent')));
+                    }
+                });
+            });
+            upstreamReq.on('error', e => reject(new BackendFetchError_1.default(e)));
+            upstreamReq.end(req.rawBody);
+        });
+    }
+    /**
+     * Returns proxy configuration for http-proxy
+     * @returns proxy target url
+     */
+    getProxyTarget(req, path) {
+        let url = path ? mergeQueryString_1.default(req.url, path) : req.url;
+        const { domainOrIp, basePath, port } = this.config;
+        if (basePath) {
+            url = path_1.join(basePath, url);
+        }
+        /* istanbul ignore next */
+        if (domainOrIp) {
+            const protocol = domainOrIp.match(/^(127.0.0.1|localhost)(:\d+)?$/) ? 'http' : 'https';
+            const domain = `${domainOrIp}${port ? `:${port}` : ''}`;
+            url = `${protocol}://${path_1.join(domain, url)}`;
+        }
+        const parsed = url_1.parse(url, true);
+        // Force insecure protocol if header is present
+        if (req.getHeader(constants_1.HTTP_HEADERS.x0Protocol) === 'http') {
+            parsed.protocol = 'http:';
+        }
+        return parsed;
+    }
+    /**
+     * Returns true if the URL points to the local JS backend, otherwise false.
+     * @param url
+     * @returns
+     */
+    isLocal(url) {
+        return url.hostname === constants_1.JS_BACKEND_HOSTNAME;
+    }
+    /**
+     * Returns proxy configuration object for node-fetch
+     * @param url
+     * @param req
+     * @param headers Additional request headers to include
+     * @param removeEmptySearchParamValues If true, search param values that are empty are removed so "?foo=" becomes "?foo".
+     */
+    getProxyRequestOptions(url, req, headers, removeEmptySearchParamValues) {
+        let agent = null;
+        if (this.config.disableCheckCert && url.protocol === 'https:') {
+            // For self signed cert fix on local development S3 bucket
+            agent = new https_1.default.Agent({ rejectUnauthorized: false });
+        }
+        const upstreamHeaders = {
+            ...req.headers,
+            ...headers,
+            host: this.config.hostHeader || req.headers.host,
+        };
+        if (this.isLocal(url)) {
+            // Some libraries, like [is-https](https://github.com/unjs/is-https#behaviour), rely on x-forwarded-proto
+            // to determine if the source request was made securely. This is notably used by Vue Storefront 2. Before
+            // we added this header, API requests made by Vue Storefront 2 from the cloud would attempt to reenter Layer0
+            // using an http POST, which would be redirected to an https GET, which would cause an infinite loop and soaring lambda costs.
+            // Note that we only add x-forwarded-proto for local requests, which never happen over TLS. For remote requests, TLS is used
+            // when the downstream request used TLS. We've chosen to do this in order to avoid altering the public behavior of Layer0, which
+            // has never sent x-forwarded-proto to origins.
+            upstreamHeaders['x-forwarded-proto'] = req.secure ? 'https' : 'http';
+        }
+        let path = url.path;
+        if (removeEmptySearchParamValues === true && path) {
+            path = path.replace(/=(?=&|$)/gm, '');
+        }
+        return {
+            ...url,
+            path,
+            method: req.method,
+            timeout: this.config.firstByteTimeout || 0,
+            agent,
+            body: req.rawBody,
+            headers: upstreamHeaders,
+        };
+    }
+}
+exports.default = Backend;
+let impl = Backend;

package/node_modules/@layer0/core/router/BackendOptions.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @private
+ */
+export default interface BackendOptions {
+    domainOrIp: string;
+    hostHeader?: string;
+    basePath?: string;
+    port?: number;
+    disableCheckCert?: boolean;
+    firstByteTimeout?: number;
+}

package/node_modules/@layer0/core/router/BackendOptions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/node_modules/@layer0/core/router/BaseResponseWriter.d.ts

@@ -0,0 +1,65 @@
+import Request from './Request';
+import Response from './Response';
+import Route from './Route';
+import { CacheOptions } from './CacheOptions';
+import { CorsOptions, ProxyOptions, ServeStaticOptions, RedirectOptions, VerifyJwtOptions } from './ResponseWriter';
+export interface CookieOptions {
+    Expires?: string;
+    'Max-Age'?: number;
+    Domain?: string;
+    Path?: string;
+    Secure?: boolean;
+    HttpOnly?: boolean;
+    SameSite?: string;
+}
+/**
+ * @private
+ * Having a no-op BaseResponseWriter makes it easy for us to stub out the writer
+ * when introspecing the router.  This is needed to implement Router.getPrefetchableRoutes
+ */
+export declare class BaseResponseWriter {
+    constructor(req?: Request, res?: Response, route?: Route);
+    cache(options: CacheOptions): void;
+    redirect(to: string, options: RedirectOptions): void;
+    /**
+     * Translates redirect params into normalized version that solves backward compatibility
+     * issues and also takes into account query parameters that may be included in the query
+     * string itself.
+     *
+     * @param to string to where we are redirecting the request; may have query string
+     * @param options options with which we are redirecting the request
+     */
+    protected _readRedirectParams(to: string, options: RedirectOptions): {
+        to: string;
+        statusCode: number;
+        query: {};
+    };
+    proxy(backend: string, options?: ProxyOptions): void;
+    render(cb: (request: Request, proxy: (backend: string, options: ProxyOptions) => void, params: any) => void): void;
+    stream(backend: string): void;
+    serveStatic(path: string, options?: ServeStaticOptions): void;
+    updatePath(destination: string): void;
+    rewrite(destination: string, pattern: string): void;
+    setRequestHeader(name: string, value: string): void;
+    updateRequestHeader(name: string, match: RegExp, replace: string): void;
+    removeRequestHeader(name: string): void;
+    setUpstreamResponseHeader(name: string, value: string): void;
+    updateUpstreamResponseHeader(name: string, match: RegExp, replace: string): void;
+    removeUpstreamResponseHeader(name: string): void;
+    verifyJwt(options: VerifyJwtOptions): void;
+    setResponseHeader(name: string, value: string): void;
+    updateResponseHeader(name: string, match: RegExp, replace: string): void;
+    removeResponseHeader(name: string): void;
+    addResponseCookie(name: string, value: string, options?: CookieOptions): void;
+    updateResponseCookie(name: string, match: RegExp, replace: string): void;
+    removeResponseCookie(name: string): void;
+    addUpstreamResponseCookie(name: string, value: string, options?: CookieOptions): void;
+    updateUpstreamResponseCookie(name: string, match: RegExp, replace: string): void;
+    removeUpstreamResponseCookie(name: string): void;
+    send(content: string | (() => string), statusCode: number, statusMessage?: string): void;
+    compute(callback: (request: Request, response: Response) => void | Promise<void>): void;
+    serviceWorker(path: string): void;
+    allowCors(options: CorsOptions): void;
+    appShell(indexHtmlPath: string): void;
+    renderWithApp(options?: ProxyOptions): void;
+}