@bunny.net/edgescript-sdk
Version:
429 lines (415 loc) • 11.8 kB
JavaScript
;
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// src/lib.ts
var lib_exports = {};
__export(lib_exports, {
net: () => net_exports
});
module.exports = __toCommonJS(lib_exports);
// src/net/index.ts
var net_exports = {};
__export(net_exports, {
http: () => serve_exports,
ip: () => ip_exports,
socketAddr: () => socket_addr_exports,
tcp: () => tcp_exports
});
// src/net/tcp.ts
var tcp_exports = {};
__export(tcp_exports, {
bind: () => bind,
isTcpListener: () => isTcpListener,
toString: () => toString2,
unstable_local_addr: () => unstable_local_addr,
unstable_new: () => unstable_new
});
// src/platform.ts
var normalizePlatform = (platform) => {
platform = platform.toLowerCase();
if (platform.includes("ios")) return "iOS";
if (platform === "android") return "Android";
if (platform === "darwin") return "MacOS";
if (platform === "win32") return "Windows";
if (platform === "freebsd") return "FreeBSD";
if (platform === "openbsd") return "OpenBSD";
if (platform === "linux") return "Linux";
if (platform) return `Other:${platform}`;
return "Unknown";
};
var internal_getPlatform = () => {
if (typeof Bunny !== "undefined") {
return {
_tag: "_Platform",
version: "0.12.1",
name: "Unknown",
runtime: "bunny",
runtime_version: "unknown"
};
}
if (typeof Deno !== "undefined" && Deno.build != null) {
return {
_tag: "_Platform",
version: "0.12.1",
name: normalizePlatform(Deno.build.os),
runtime: "deno",
runtime_version: typeof Deno.version === "string" ? Deno.version : Deno.version?.deno ?? "unknown"
};
}
const process = globalThis.process;
if (Object.prototype.toString.call(
typeof process !== "undefined" ? process : 0
) === "[object process]") {
return {
_tag: "_Platform",
version: "0.12.1",
name: normalizePlatform(process.platform),
runtime: "node",
runtime_version: process.version
};
}
return {
_tag: "_Platform",
version: "0.12.1",
name: "Unknown",
runtime: "unknown",
runtime_version: "unknown"
};
};
// src/net/socket_addr.ts
var socket_addr_exports = {};
__export(socket_addr_exports, {
InvalidAddr: () => InvalidAddr,
isV4: () => isV4,
v4: () => v4_exports
});
// src/net/socket/v4.ts
var v4_exports = {};
__export(v4_exports, {
ip: () => ip,
port: () => port,
tryFromString: () => tryFromString
});
// src/net/ip.ts
var ip_exports = {};
__export(ip_exports, {
toString: () => toString,
tryParseFromString: () => tryParseFromString
});
function toString(ip2) {
return `${ip2[0]}.${ip2[1]}.${ip2[2]}.${ip2[3]}`;
}
function tryParseFromString(ip2) {
const parts = ip2.split(".").map(Number);
if (parts.length !== 4 || parts.some((part) => isNaN(part) || part < 0 || part > 255)) {
return new SyntaxError("Invalid IP address");
}
return [parts[0], parts[1], parts[2], parts[3]];
}
// src/net/socket/v4.ts
function port(addr) {
return addr.port;
}
function ip(addr) {
return addr.ip;
}
function tryFromString(value) {
const parts = value.split(":");
if (parts.length !== 2) {
return new SyntaxError("Invalid SocketAddrV4 address");
}
const ip2 = tryParseFromString(parts[0]);
if (ip2 instanceof SyntaxError) {
return ip2;
}
const port2 = Number(parts[1]);
if (isNaN(port2) || port2 < 0 || port2 > 65535) {
return new SyntaxError("Invalid Port");
}
return {
_tag: "SocketAddrV4",
port: port2,
ip: ip2
};
}
// src/net/socket_addr.ts
function isV4(value) {
return value._tag === "SocketAddrV4";
}
var addr_symbol = Symbol("invalidAddr");
var InvalidAddr = class extends Error {
_guard = addr_symbol;
constructor(message) {
super(message);
this.name = "InvalidAddr";
}
toString() {
return `${this.name}: ${this.message}`;
}
};
// src/net/tcp.ts
function isTcpListener(value) {
return value instanceof Object && value["_tag"] === "TcpListener";
}
function unstable_local_addr(tcp) {
return tcp.addr;
}
function toString2(tcp) {
switch (tcp.addr._tag) {
case "SocketAddrV4":
return `${v4_exports.ip(tcp.addr).join(".")}:${v4_exports.port(tcp.addr)}`;
case "NoAddr":
return "No addr associated to this listener. You should be running in a controlled environment.";
}
}
function unstable_new() {
const platform = internal_getPlatform();
switch (platform.runtime) {
case "bunny": {
return {
_tag: "TcpListener",
addr: {
_tag: "NoAddr"
}
};
}
default:
return {
_tag: "TcpListener",
addr: {
_tag: "SocketAddrV4",
port: 8080,
ip: [127, 0, 0, 1]
}
};
}
}
function bind(addr) {
return {
_tag: "TcpListener",
addr
};
}
// src/net/serve.ts
var serve_exports = {};
__export(serve_exports, {
serve: () => serve2,
servePullZone: () => servePullZone
});
// src/net/_impl/node/serve.ts
var HonoNode = __toESM(require("@hono/node-server"));
var import_hono = require("hono");
function node_serve(listener, handler) {
const addr = unstable_local_addr(listener);
if (!isV4(addr)) {
throw new Error("An issue happened with the addr.");
}
const port2 = v4_exports.port(addr);
const hostname = toString(v4_exports.ip(addr));
const app = new import_hono.Hono();
app.all("*", (c) => {
return handler(c.req.raw);
});
HonoNode.serve({
fetch: app.fetch,
hostname,
port: port2
});
return {};
}
// src/net/serve.ts
function isResponse(value) {
return value instanceof Response;
}
function isRequest(value) {
return value instanceof Request;
}
function is_port_and_hostname(value) {
if (typeof value === "object" && value !== null) {
const port2 = value["port"];
return port2 !== void 0 && typeof port2 === "number" && value["hostname"] !== void 0;
}
return false;
}
function serve2(listener, handler) {
let raw_handler;
let raw_listener;
if (is_port_and_hostname(listener)) {
const addr = v4_exports.tryFromString(
`${listener.hostname}:${listener.port}`
);
if (addr instanceof Error) {
throw addr;
}
raw_listener = bind(addr);
raw_handler = handler;
} else if (isTcpListener(listener)) {
raw_handler = handler;
raw_listener = listener;
} else {
raw_handler = listener;
raw_listener = unstable_new();
}
if (raw_handler === void 0) {
throw new Error("An issue happened.");
}
const platform = internal_getPlatform();
switch (platform.runtime) {
case "bunny": {
Bunny.v1.serve(raw_handler);
return {};
}
case "node": {
return node_serve(raw_listener, raw_handler);
}
case "deno": {
const addr = unstable_local_addr(raw_listener);
if (!isV4(addr)) {
throw new Error("An issue happened with the addr.");
}
const port2 = v4_exports.port(addr);
const hostname = toString(v4_exports.ip(addr));
Deno.serve({ port: port2, hostname }, raw_handler);
return {};
}
case "unknown": {
return {};
}
}
}
function servePullZone(listener, options) {
let raw_listener;
let raw_options = {
url: "https://bunny.net"
};
if (options) {
raw_options = options;
}
if (is_port_and_hostname(listener)) {
const addr = v4_exports.tryFromString(
`${listener.hostname}:${listener.port}`
);
if (addr instanceof Error) {
throw addr;
}
raw_listener = bind(addr);
} else if (isTcpListener(listener)) {
raw_listener = listener;
} else {
if (listener) {
raw_options = listener;
}
raw_listener = unstable_new();
}
const onOriginRequestMiddleware = [];
const onOriginResponseMiddleware = [];
const platform = internal_getPlatform();
switch (platform.runtime) {
case "bunny": {
Bunny.v1.registerMiddlewares({
onOriginRequest: onOriginRequestMiddleware,
onOriginResponse: onOriginResponseMiddleware
});
break;
}
default: {
const middlewareHandler = async (req) => {
const url = new URL(req.url);
const origin_url = new URL(raw_options.url);
url.protocol = origin_url.protocol;
url.hostname = origin_url.hostname;
url.port = origin_url.port;
let mutableRequest = new Request(
url,
req
);
for (const [_, mid] of onOriginRequestMiddleware.entries()) {
const reqOrResponse = await mid({ request: mutableRequest });
if (isResponse(reqOrResponse)) {
return reqOrResponse;
}
if (isRequest(reqOrResponse)) {
mutableRequest = reqOrResponse;
}
}
const prevResponse = await fetch(mutableRequest);
const headers = new Headers();
for (const [key, value] of prevResponse.headers.entries()) {
headers.set(key, value);
}
let response;
switch (platform.runtime) {
case "node": {
if (headers.get("content-type") === "text/html" && prevResponse.body !== null) {
const body = await prevResponse.text();
headers.delete("content-encoding");
response = new Response(body, { headers });
} else {
response = new Response(prevResponse.body, {
...prevResponse,
headers
});
}
break;
}
default: {
response = new Response(prevResponse.body, {
...prevResponse,
headers
});
}
}
for (const [_, mid] of onOriginResponseMiddleware.entries()) {
const reqOrResponse = await mid({
request: mutableRequest,
response
});
if (isResponse(reqOrResponse)) {
response = reqOrResponse;
}
}
return response;
};
serve2(raw_listener, middlewareHandler);
}
}
const pullzoneHandler = {};
pullzoneHandler.onOriginResponse = (middleware) => {
onOriginResponseMiddleware.push(middleware);
return pullzoneHandler;
};
pullzoneHandler.onOriginRequest = (middleware) => {
onOriginRequestMiddleware.push(middleware);
return pullzoneHandler;
};
return pullzoneHandler;
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
net
});