wuppycms 0.0.0-stage → 0.2.1

package/dist/media-DGfJXgBA.mjs

@@ -0,0 +1,356 @@
+import { mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
+import { dirname, extname, join, resolve, sep } from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+
+//#region src/media/optimize.ts
+/** Widths a client may ask for; a closed list keeps anyone from filling the cache with arbitrary sizes. */
+const WIDTHS = [
+	320,
+	480,
+	640,
+	768,
+	1024,
+	1280,
+	1600,
+	1920,
+	2560
+];
+const FORMATS = {
+	webp: "image/webp",
+	avif: "image/avif",
+	jpeg: "image/jpeg",
+	png: "image/png"
+};
+/** Crop shapes a client may ask for (`?ar=16:9`), again a closed list. */
+const ASPECT_RATIOS = [
+	"1:1",
+	"4:3",
+	"3:2",
+	"16:9",
+	"3:4",
+	"2:3",
+	"9:16"
+];
+let sharpPromise;
+/** `sharp` is optional: without it uploads still work, they just are not resized or analysed. */
+const loadSharp = () => sharpPromise ??= import("./dist-D7fysV_5.mjs").then((m) => m.default).catch(() => null);
+async function imageInfo(bytes) {
+	const sharp = await loadSharp();
+	if (!sharp) return null;
+	try {
+		const image = sharp(bytes, { limitInputPixels: 1e8 });
+		const { width, height } = await image.metadata();
+		if (!width || !height) return null;
+		return {
+			width,
+			height,
+			lqip: `data:image/webp;base64,${(await image.resize({ width: 16 }).webp({ quality: 40 }).toBuffer()).toString("base64")}`
+		};
+	} catch {
+		return null;
+	}
+}
+const clamp = (n, max) => Math.min(Math.max(Math.round(n), 0), max);
+/**
+* The largest box of shape `ratio` inside a `width` x `height` image, placed so the focal point
+* (percent) sits at its centre where the image allows, otherwise pushed against the nearest edge.
+*/
+function cropBox(width, height, ratio, focalX = 50, focalY = 50) {
+	const [rw, rh] = ratio.split(":").map(Number);
+	const boxW = Math.min(width, Math.round(height * rw / rh));
+	const boxH = Math.min(height, Math.round(width * rh / rw));
+	return {
+		width: boxW,
+		height: boxH,
+		left: clamp(width * focalX / 100 - boxW / 2, width - boxW),
+		top: clamp(height * focalY / 100 - boxH / 2, height - boxH)
+	};
+}
+/** Parses `?w=640&format=webp&ar=16:9&fx=30&fy=40`. Returns null when nothing is requested, `"invalid"` for values outside the allowlist. */
+function parseVariant(params) {
+	const w = params.get("w");
+	const f = params.get("format");
+	const ar = params.get("ar");
+	if (w === null && f === null && ar === null) return null;
+	const width = w === null ? void 0 : Number(w);
+	if (width !== void 0 && !WIDTHS.includes(width)) return "invalid";
+	if (f !== null && !(f in FORMATS)) return "invalid";
+	if (ar !== null && !ASPECT_RATIOS.includes(ar)) return "invalid";
+	const focal = (name) => {
+		const v = params.get(name);
+		return v === null ? void 0 : /^\d{1,3}$/.test(v) && Number(v) <= 100 ? Number(v) : "invalid";
+	};
+	const fx = focal("fx");
+	const fy = focal("fy");
+	if (fx === "invalid" || fy === "invalid") return "invalid";
+	return {
+		...width ? { width } : {},
+		...f ? { format: f } : {},
+		...ar ? {
+			ratio: ar,
+			...fx === void 0 ? {} : { focalX: fx },
+			...fy === void 0 ? {} : { focalY: fy }
+		} : {}
+	};
+}
+/** Resized/re-encoded copy, cached on disk under `.wuppy/cache/images` keyed by source path, mtime and variant. */
+async function renderVariant(root, sourcePath, mtimeMs, variant) {
+	const sharp = await loadSharp();
+	if (!sharp) return null;
+	const format = variant.format ?? "webp";
+	const cached = join(root, ".wuppy", "cache", "images", `${createHash("sha256").update(`${sourcePath}\n${mtimeMs}\n${variant.width ?? ""}\n${format}\n${variant.ratio ?? ""}\n${variant.focalX ?? ""}\n${variant.focalY ?? ""}`).digest("hex")}.${format}`);
+	try {
+		return {
+			bytes: await readFile(cached),
+			mime: FORMATS[format]
+		};
+	} catch {}
+	try {
+		let image = sharp(await readFile(sourcePath), { limitInputPixels: 1e8 }).rotate();
+		if (variant.ratio) {
+			const { data, info } = await image.toBuffer({ resolveWithObject: true });
+			const box = cropBox(info.width, info.height, variant.ratio, variant.focalX, variant.focalY);
+			image = sharp(data, { limitInputPixels: 1e8 }).extract(box);
+		}
+		if (variant.width) image = image.resize({
+			width: variant.width,
+			withoutEnlargement: true
+		});
+		const bytes = await image.toFormat(format, { quality: 80 }).toBuffer();
+		await mkdir(join(root, ".wuppy", "cache", "images"), { recursive: true });
+		await writeFile(cached, bytes);
+		return {
+			bytes,
+			mime: FORMATS[format]
+		};
+	} catch {
+		return null;
+	}
+}
+
+//#endregion
+//#region src/media/index.ts
+const MAX_UPLOAD_BYTES = 5 * 1024 * 1024;
+var MediaTooLargeError = class extends Error {};
+var UnsupportedMediaError = class extends Error {};
+const ascii = (b, from, to) => String.fromCharCode(...b.subarray(from, to));
+function detectImage(b) {
+	if (b.length >= 8 && b[0] === 137 && ascii(b, 1, 4) === "PNG") return {
+		mime: "image/png",
+		ext: "png"
+	};
+	if (b.length >= 3 && b[0] === 255 && b[1] === 216 && b[2] === 255) return {
+		mime: "image/jpeg",
+		ext: "jpg"
+	};
+	if (b.length >= 6 && /^GIF8[79]a$/.test(ascii(b, 0, 6))) return {
+		mime: "image/gif",
+		ext: "gif"
+	};
+	if (b.length >= 12 && ascii(b, 0, 4) === "RIFF" && ascii(b, 8, 12) === "WEBP") return {
+		mime: "image/webp",
+		ext: "webp"
+	};
+	return null;
+}
+const MIME_BY_EXT = {
+	".png": "image/png",
+	".jpg": "image/jpeg",
+	".gif": "image/gif",
+	".webp": "image/webp"
+};
+const EMPTY = {
+	meta: {},
+	folders: []
+};
+var MediaService = class {
+	constructor(root, git, emit, store, beforeUpload) {
+		this.root = root;
+		this.git = git;
+		this.emit = emit;
+		this.store = store;
+		this.beforeUpload = beforeUpload;
+	}
+	async data() {
+		if (!this.store) return EMPTY;
+		return this.store.read("media", EMPTY);
+	}
+	async list() {
+		const base = join(this.root, "public", "uploads");
+		const names = await readdir(base, { recursive: true }).catch(() => []);
+		const meta = (await this.data()).meta;
+		return (await Promise.all(names.filter((n) => MIME_BY_EXT[extname(n).toLowerCase()]).map(async (n) => {
+			const s = await stat(join(base, n));
+			const url = `/uploads/${n.split("\\").join("/")}`;
+			return {
+				url,
+				name: n.split("\\").join("/"),
+				size: s.size,
+				modified: s.mtime.toISOString(),
+				...meta[url]
+			};
+		}))).toSorted((a, b) => b.modified.localeCompare(a.modified) || b.url.localeCompare(a.url));
+	}
+	async folders() {
+		return (await this.data()).folders;
+	}
+	async saveFolders(folders) {
+		const data = await this.data();
+		await this.store?.write("media", {
+			...data,
+			folders
+		}, "media: folders");
+	}
+	async update(url, patch) {
+		const data = await this.data();
+		const next = {
+			...data.meta[url],
+			...patch
+		};
+		if (this.store) await this.store.write("media", {
+			...data,
+			meta: {
+				...data.meta,
+				[url]: next
+			}
+		}, `media: update ${url}`);
+		return next;
+	}
+	/** Site settings may only tighten the built-in limits: the hard cap and the magic-byte check always apply. */
+	async limits() {
+		const media = (await this.store?.read("settings", {}) ?? {}).media;
+		return {
+			maxBytes: Math.min(media?.maxBytes ?? MAX_UPLOAD_BYTES, MAX_UPLOAD_BYTES),
+			allowed: media?.allowed ?? null
+		};
+	}
+	/** Ignored upload directories are valid; a missing Git stage must not fail the upload after the bytes are written. */
+	async commit(rel, message) {
+		await this.git.commit([`public/uploads/${rel}`], message).catch((e) => {
+			if (!/nothing to commit|ignored by one of your \.gitignore|paths are ignored/i.test(e.message)) throw e;
+		});
+	}
+	async upload(bytes, meta = {}) {
+		const limits = await this.limits();
+		if (bytes.byteLength > limits.maxBytes) throw new MediaTooLargeError("File too large");
+		const type = detectImage(bytes);
+		if (!type) throw new UnsupportedMediaError("Only PNG, JPEG, GIF and WebP images are allowed");
+		if (limits.allowed && !limits.allowed.includes(type.mime)) throw new UnsupportedMediaError(`${type.mime} uploads are turned off in Settings`);
+		await this.beforeUpload?.({
+			mime: type.mime,
+			size: bytes.byteLength
+		});
+		const now = /* @__PURE__ */ new Date();
+		const rel = `${now.getUTCFullYear()}/${String(now.getUTCMonth() + 1).padStart(2, "0")}/${randomUUID()}.${type.ext}`;
+		const path = join(this.root, "public", "uploads", rel);
+		await mkdir(dirname(path), { recursive: true });
+		await writeFile(path, bytes);
+		const url = `/uploads/${rel}`;
+		const info = await imageInfo(bytes);
+		if (Object.keys(meta).length || info) await this.update(url, {
+			...meta,
+			...info
+		});
+		await this.commit(rel, `media: upload ${rel}`);
+		this.emit?.({
+			type: "media.uploaded",
+			url,
+			at: now.toISOString()
+		});
+		return {
+			url,
+			path: `public/uploads/${rel}`
+		};
+	}
+	relOf(url) {
+		const rel = url.replace(/^\/uploads\//, "");
+		if (!rel || rel.includes("..") || rel.startsWith("/")) throw new UnsupportedMediaError("Invalid media url");
+		return rel;
+	}
+	/** Overwrites a file with a new image of the same type. The old bytes stay reachable through Git history. */
+	async replace(url, bytes) {
+		const rel = this.relOf(url);
+		const limits = await this.limits();
+		if (bytes.byteLength > limits.maxBytes) throw new MediaTooLargeError("File too large");
+		const type = detectImage(bytes);
+		if (!type) throw new UnsupportedMediaError("Only PNG, JPEG, GIF and WebP images are allowed");
+		const current = MIME_BY_EXT[extname(rel).toLowerCase()];
+		if (!current) throw new UnsupportedMediaError("Invalid media url");
+		if (current !== type.mime) throw new UnsupportedMediaError(`Replacement must be ${current}`);
+		const path = join(this.root, "public", "uploads", rel);
+		await stat(path).catch(() => {
+			throw new UnsupportedMediaError("Unknown media file");
+		});
+		await this.beforeUpload?.({
+			mime: type.mime,
+			size: bytes.byteLength,
+			replaces: url
+		});
+		await writeFile(path, bytes);
+		const info = await imageInfo(bytes);
+		if (info) await this.update(url, info);
+		await this.commit(rel, `media: replace ${rel}`);
+	}
+	/** Renames a folder (and everything below it) in the folder list and on every item. */
+	async renameFolder(from, to) {
+		const data = await this.data();
+		const swap = (f) => f === from ? to : f.startsWith(`${from}/`) ? `${to}${f.slice(from.length)}` : f;
+		const folders = [...new Set(data.folders.map(swap))];
+		const meta = Object.fromEntries(Object.entries(data.meta).map(([url, m]) => [url, m.folder ? {
+			...m,
+			folder: swap(m.folder)
+		} : m]));
+		await this.store?.write("media", {
+			folders,
+			meta
+		}, `media: rename folder ${from}`);
+	}
+	/** Removes a folder tree; its files stay in the library, unfiled. */
+	async deleteFolder(name) {
+		const data = await this.data();
+		const inside = (f) => f === name || f.startsWith(`${name}/`);
+		const meta = Object.fromEntries(Object.entries(data.meta).map(([url, m]) => {
+			const { folder, ...rest } = m;
+			return [url, folder && inside(folder) ? rest : m];
+		}));
+		await this.store?.write("media", {
+			folders: data.folders.filter((f) => !inside(f)),
+			meta
+		}, `media: delete folder ${name}`);
+	}
+	async delete(url) {
+		const rel = this.relOf(url);
+		await rm(join(this.root, "public", "uploads", rel), { force: true });
+		await this.commit(rel, `media: delete ${rel}`);
+	}
+};
+/** Serves files from `<root>/public/uploads`; only known image extensions, never outside that directory. */
+async function serveUpload(root, rel, params = new URLSearchParams()) {
+	const base = resolve(root, "public", "uploads");
+	const target = resolve(base, rel);
+	const mime = MIME_BY_EXT[extname(target).toLowerCase()];
+	if (!mime || !target.startsWith(base + sep)) return new Response("Not found", { status: 404 });
+	const variant = parseVariant(params);
+	if (variant === "invalid") return new Response("Unsupported size or format", { status: 400 });
+	try {
+		if (variant && mime !== "image/gif") {
+			const rendered = await renderVariant(root, target, (await stat(target)).mtimeMs, variant);
+			if (rendered) return new Response(Buffer.from(rendered.bytes), { headers: {
+				"content-type": rendered.mime,
+				"x-content-type-options": "nosniff",
+				"cache-control": "public, max-age=31536000, immutable",
+				vary: "Accept"
+			} });
+		}
+		return new Response(await readFile(target), { headers: {
+			"content-type": mime,
+			"x-content-type-options": "nosniff",
+			"cache-control": "public, max-age=31536000, immutable"
+		} });
+	} catch {
+		return new Response("Not found", { status: 404 });
+	}
+}
+
+//#endregion
+export { detectImage as a, UnsupportedMediaError as i, MediaService as n, serveUpload as o, MediaTooLargeError as r, MAX_UPLOAD_BYTES as t };

package/dist/page-cache-middleware.d.mts

@@ -0,0 +1,8 @@
+//#region src/astro/page-cache-middleware.d.ts
+declare const onRequest: (ctx: {
+  request: Request;
+  url: URL;
+  isPrerendered?: boolean;
+}, next: () => Promise<Response>) => Promise<Response>;
+//#endregion
+export { onRequest };

package/dist/page-cache-middleware.mjs

@@ -0,0 +1,101 @@
+import "./config-CM8_-x_W.mjs";
+import "./frontmatter-DGaz9--t.mjs";
+import { s as siteRoot } from "./site-dF-xVPqe.mjs";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { createHash } from "node:crypto";
+
+//#region src/astro/page-cache.ts
+/**
+* Id of the current Git commit. Every content, media and settings write is a commit, so it changes exactly when pages can.
+* Null without a repository: nothing signals a change then, so nothing is cached.
+*/
+async function contentVersion(root) {
+	try {
+		const head = (await readFile(join(root, ".git", "HEAD"), "utf8")).trim();
+		if (!head.startsWith("ref: ")) return head;
+		const ref = head.slice(5);
+		const loose = await readFile(join(root, ".git", ref), "utf8").catch(() => "");
+		if (loose) return loose.trim();
+		return (await readFile(join(root, ".git", "packed-refs"), "utf8")).split("\n").find((line) => line.endsWith(` ${ref}`))?.split(" ")[0] ?? "unknown";
+	} catch {
+		return null;
+	}
+}
+/**
+* Rendered public pages, reused until the next commit. A page can also change without one (a scheduled post
+* going live), so an entry is dropped after `maxAgeMs` too.
+*/
+var PageCache = class {
+	entries = /* @__PURE__ */ new Map();
+	constructor(maxEntries = 500, maxBytes = 512 * 1024, maxAgeMs = 6e4) {
+		this.maxEntries = maxEntries;
+		this.maxBytes = maxBytes;
+		this.maxAgeMs = maxAgeMs;
+	}
+	get(key, version, now = Date.now()) {
+		const hit = this.entries.get(key);
+		if (!hit) return void 0;
+		if (hit.version !== version || now - hit.at > this.maxAgeMs) {
+			this.entries.delete(key);
+			return;
+		}
+		return hit;
+	}
+	set(key, version, body, headers, now = Date.now()) {
+		if (body.length > this.maxBytes) return null;
+		if (this.entries.size >= this.maxEntries) this.entries.delete(this.entries.keys().next().value);
+		const entry = {
+			version,
+			at: now,
+			body,
+			headers,
+			etag: `W/"${createHash("sha1").update(body).digest("hex").slice(0, 20)}"`
+		};
+		this.entries.set(key, entry);
+		return entry;
+	}
+};
+const SKIP_PATH = /^\/(admin|api|uploads|_astro)(\/|$)/;
+/**
+* Wraps page rendering: serves cached HTML, adds an ETag, and answers `If-None-Match` with 304.
+* Previews, edit mode, non-GET requests and anything that sets cookies or forbids storing are passed through.
+*/
+function createPageCacheMiddleware(root, cache = new PageCache(), enabled = true) {
+	return async (ctx, next) => {
+		const { request, url } = ctx;
+		const params = url.searchParams;
+		if (!enabled || ctx.isPrerendered || request.method !== "GET" || SKIP_PATH.test(url.pathname) || params.has("wuppy-preview") || params.has("wuppy-edit")) return next();
+		const key = url.pathname + url.search;
+		const version = await contentVersion(root);
+		if (!version) return next();
+		const reply = (e) => {
+			const headers = new Headers(e.headers);
+			headers.set("ETag", e.etag);
+			headers.set("Cache-Control", "public, max-age=0, must-revalidate");
+			if (request.headers.get("if-none-match") === e.etag) return new Response(null, {
+				status: 304,
+				headers
+			});
+			return new Response(e.body, {
+				status: 200,
+				headers
+			});
+		};
+		const hit = cache.get(key, version);
+		if (hit) return reply(hit);
+		const res = await next();
+		const type = res.headers.get("content-type") ?? "";
+		if (res.status !== 200 || !type.includes("text/html") || res.headers.has("set-cookie") || /no-store|private/.test(res.headers.get("cache-control") ?? "")) return res;
+		const body = await res.clone().text();
+		const stored = cache.set(key, version, body, [["content-type", type]]);
+		return stored ? reply(stored) : res;
+	};
+}
+
+//#endregion
+//#region src/astro/page-cache-middleware.ts
+const onRequest = createPageCacheMiddleware(siteRoot(), void 0, import.meta.env?.PROD ?? process.env.NODE_ENV === "production");
+
+//#endregion
+export { onRequest };

package/dist/publishing.d.mts

@@ -0,0 +1,17 @@
+//#region src/publishing/index.d.ts
+/** Draft/schedule rule shared by the sitemap, the starter site and anything else that lists public content. */
+declare function isPublished(data: Record<string, unknown>, now?: Date): boolean;
+type EntryStatus = "draft" | "scheduled" | "published";
+/**
+ * What an editor sees for an entry: a future `publishAt` means scheduled (whether or not `draft` is set),
+ * otherwise `draft: true` is a draft, otherwise it is live.
+ */
+declare function entryStatus(data: Record<string, unknown>, now?: Date): EntryStatus;
+declare function signPreview(secret: string, collection: string, slug: string, ttlMs?: number, now?: number): {
+  token: string;
+  expires: Date;
+};
+/** True only for an unexpired token minted for exactly this collection and slug. */
+declare function verifyPreview(secret: string, collection: string, slug: string, token: string | null | undefined, now?: number): boolean;
+//#endregion
+export { EntryStatus, entryStatus, isPublished, signPreview, verifyPreview };

package/dist/publishing.mjs

@@ -0,0 +1,42 @@
+import { createHmac, timingSafeEqual } from "node:crypto";
+
+//#region src/publishing/index.ts
+/** Draft/schedule rule shared by the sitemap, the starter site and anything else that lists public content. */
+function isPublished(data, now = /* @__PURE__ */ new Date()) {
+	if (data.draft === true) return false;
+	const at = data.publishAt;
+	if (at === void 0 || at === null || at === "") return true;
+	const t = (at instanceof Date ? at : new Date(String(at))).getTime();
+	return Number.isFinite(t) && t <= now.getTime();
+}
+/**
+* What an editor sees for an entry: a future `publishAt` means scheduled (whether or not `draft` is set),
+* otherwise `draft: true` is a draft, otherwise it is live.
+*/
+function entryStatus(data, now = /* @__PURE__ */ new Date()) {
+	const at = data.publishAt;
+	const t = at === void 0 || at === null || at === "" ? NaN : (at instanceof Date ? at : new Date(String(at))).getTime();
+	if (Number.isFinite(t) && t > now.getTime()) return "scheduled";
+	return data.draft === true ? "draft" : "published";
+}
+/** Preview links let someone without an account see one unpublished entry until `expires`. */
+const previewMac = (secret, collection, slug, expires) => createHmac("sha256", secret).update(`preview\n${collection}\n${slug}\n${expires}`).digest("base64url");
+function signPreview(secret, collection, slug, ttlMs = 24 * 36e5, now = Date.now()) {
+	const expires = now + ttlMs;
+	return {
+		token: `${expires}.${previewMac(secret, collection, slug, expires)}`,
+		expires: new Date(expires)
+	};
+}
+/** True only for an unexpired token minted for exactly this collection and slug. */
+function verifyPreview(secret, collection, slug, token, now = Date.now()) {
+	const [exp = "", mac = ""] = (token ?? "").split(".");
+	const expires = Number(exp);
+	if (!secret || !Number.isFinite(expires) || expires < now) return false;
+	const want = Buffer.from(previewMac(secret, collection, slug, expires));
+	const got = Buffer.from(mac);
+	return want.length === got.length && timingSafeEqual(want, got);
+}
+
+//#endregion
+export { entryStatus, isPublished, signPreview, verifyPreview };

package/dist/read-Bh4-a3Ap.mjs

@@ -0,0 +1,18 @@
+import { s as siteRoot } from "./site-dF-xVPqe.mjs";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+
+//#region src/data/read.ts
+/** Read a site data file (the site's, also when a theme runs) without constructing the full server (templates, scripts). */
+async function readData(name, fallback, root = siteRoot()) {
+	if (!/^[a-z][a-z0-9-]*$/.test(name)) throw new Error(`Invalid data name: ${name}`);
+	try {
+		return JSON.parse(await readFile(join(root, ".wuppy", "data", `${name}.json`), "utf8"));
+	} catch (e) {
+		if (e.code === "ENOENT") return fallback;
+		throw e;
+	}
+}
+
+//#endregion
+export { readData as t };

package/dist/redirect-middleware.d.mts

@@ -0,0 +1,6 @@
+//#region src/astro/redirect-middleware.d.ts
+declare const onRequest: (ctx: {
+  url: URL;
+}, next: () => Promise<Response>) => Promise<Response>;
+//#endregion
+export { onRequest };

package/dist/redirect-middleware.mjs

@@ -0,0 +1,37 @@
+import { d as resolveRedirect, n as loadConfig } from "./config-CM8_-x_W.mjs";
+import "./frontmatter-DGaz9--t.mjs";
+import { s as siteRoot } from "./site-dF-xVPqe.mjs";
+import { readFile, stat } from "node:fs/promises";
+import { join } from "node:path";
+
+//#region src/astro/redirect-middleware.ts
+let config;
+let stored;
+async function storedRedirects(root) {
+	const path = join(root, ".wuppy", "data", "redirects.json");
+	try {
+		const info = await stat(path);
+		if (stored?.mtime === info.mtimeMs) return stored.rules;
+		const rules = JSON.parse(await readFile(path, "utf8"));
+		stored = {
+			mtime: info.mtimeMs,
+			rules
+		};
+		return rules;
+	} catch {
+		return [];
+	}
+}
+const onRequest = async (ctx, next) => {
+	const root = siteRoot();
+	config ??= loadConfig(root);
+	const [cfg, dynamic] = await Promise.all([config, storedRedirects(root)]);
+	const hit = resolveRedirect([...cfg.redirects, ...dynamic], ctx.url.pathname, ctx.url.search);
+	return hit ? new Response(null, {
+		status: hit.status,
+		headers: { location: hit.to }
+	}) : next();
+};
+
+//#endregion
+export { onRequest };