diff --git a/.nuxt/component-chunk.mjs b/.nuxt/component-chunk.mjs new file mode 100644 index 0000000..56004c9 --- /dev/null +++ b/.nuxt/component-chunk.mjs @@ -0,0 +1 @@ +export default {} \ No newline at end of file diff --git a/.nuxt/dev/index.mjs b/.nuxt/dev/index.mjs new file mode 100644 index 0000000..3546dbd --- /dev/null +++ b/.nuxt/dev/index.mjs @@ -0,0 +1,2252 @@ +import process from 'node:process';globalThis._importMeta_={url:import.meta.url,env:process.env};import { tmpdir } from 'node:os'; +import { defineEventHandler, handleCacheHeaders, splitCookiesString, createEvent, fetchWithEvent, isEvent, eventHandler, setHeaders, sendRedirect, proxyRequest, getRequestHeader, setResponseHeaders, setResponseStatus, send, getRequestHeaders, setResponseHeader, getRequestURL, getResponseHeader, getResponseStatus, createError, getQuery as getQuery$1, readBody, lazyEventHandler, useBase, createApp, createRouter as createRouter$1, toNodeListener, getRouterParam, getResponseStatusText } from 'file:///Users/dkoziavin/code/sub-projects/e-book/node_modules/h3/dist/index.mjs'; +import { Server } from 'node:http'; +import { resolve, dirname, join } from 'node:path'; +import nodeCrypto from 'node:crypto'; +import { parentPort, threadId } from 'node:worker_threads'; +import { escapeHtml } from 'file:///Users/dkoziavin/code/sub-projects/e-book/node_modules/@vue/shared/dist/shared.cjs.js'; +import { createRenderer, getRequestDependencies, getPreloadLinks, getPrefetchLinks } from 'file:///Users/dkoziavin/code/sub-projects/e-book/node_modules/vue-bundle-renderer/dist/runtime.mjs'; +import { parseURL, withoutBase, joinURL, getQuery, withQuery, withTrailingSlash, joinRelativeURL } from 'file:///Users/dkoziavin/code/sub-projects/e-book/node_modules/ufo/dist/index.mjs'; +import { renderToString } from 'file:///Users/dkoziavin/code/sub-projects/e-book/node_modules/vue/server-renderer/index.mjs'; +import destr, { destr as destr$1 } from 'file:///Users/dkoziavin/code/sub-projects/e-book/node_modules/destr/dist/index.mjs'; +import { createHooks } from 'file:///Users/dkoziavin/code/sub-projects/e-book/node_modules/hookable/dist/index.mjs'; +import { createFetch, Headers as Headers$1 } from 'file:///Users/dkoziavin/code/sub-projects/e-book/node_modules/ofetch/dist/node.mjs'; +import { fetchNodeRequestHandler, callNodeRequestHandler } from 'file:///Users/dkoziavin/code/sub-projects/e-book/node_modules/node-mock-http/dist/index.mjs'; +import { createStorage, prefixStorage } from 'file:///Users/dkoziavin/code/sub-projects/e-book/node_modules/unstorage/dist/index.mjs'; +import unstorage_47drivers_47fs from 'file:///Users/dkoziavin/code/sub-projects/e-book/node_modules/unstorage/drivers/fs.mjs'; +import { digest, hash as hash$1 } from 'file:///Users/dkoziavin/code/sub-projects/e-book/node_modules/ohash/dist/index.mjs'; +import { klona } from 'file:///Users/dkoziavin/code/sub-projects/e-book/node_modules/klona/dist/index.mjs'; +import defu, { defuFn } from 'file:///Users/dkoziavin/code/sub-projects/e-book/node_modules/defu/dist/defu.mjs'; +import { snakeCase } from 'file:///Users/dkoziavin/code/sub-projects/e-book/node_modules/scule/dist/index.mjs'; +import { getContext } from 'file:///Users/dkoziavin/code/sub-projects/e-book/node_modules/unctx/dist/index.mjs'; +import { toRouteMatcher, createRouter } from 'file:///Users/dkoziavin/code/sub-projects/e-book/node_modules/radix3/dist/index.mjs'; +import { readFile } from 'node:fs/promises'; +import consola, { consola as consola$1 } from 'file:///Users/dkoziavin/code/sub-projects/e-book/node_modules/consola/dist/index.mjs'; +import { ErrorParser } from 'file:///Users/dkoziavin/code/sub-projects/e-book/node_modules/youch-core/build/index.js'; +import { Youch } from 'file:///Users/dkoziavin/code/sub-projects/e-book/node_modules/youch/build/index.js'; +import { SourceMapConsumer } from 'file:///Users/dkoziavin/code/sub-projects/e-book/node_modules/source-map/source-map.js'; +import { AsyncLocalStorage } from 'node:async_hooks'; +import { stringify, uneval } from 'file:///Users/dkoziavin/code/sub-projects/e-book/node_modules/devalue/index.js'; +import { captureRawStackTrace, parseRawStackTrace } from 'file:///Users/dkoziavin/code/sub-projects/e-book/node_modules/errx/dist/index.js'; +import { isVNode, toValue, isRef } from 'file:///Users/dkoziavin/code/sub-projects/e-book/node_modules/vue/index.mjs'; +import { basename, isAbsolute } from 'file:///Users/dkoziavin/code/sub-projects/e-book/node_modules/pathe/dist/index.mjs'; +import { getIcons } from 'file:///Users/dkoziavin/code/sub-projects/e-book/node_modules/@iconify/utils/lib/index.mjs'; +import { collections } from 'file:///Users/dkoziavin/code/sub-projects/e-book/.nuxt/nuxt-icon-server-bundle.mjs'; +import { createHead as createHead$1, propsToString, renderSSRHead } from 'file:///Users/dkoziavin/code/sub-projects/e-book/node_modules/unhead/dist/server.mjs'; +import { DeprecationsPlugin, PromisesPlugin, TemplateParamsPlugin, AliasSortingPlugin } from 'file:///Users/dkoziavin/code/sub-projects/e-book/node_modules/unhead/dist/plugins.mjs'; +import { walkResolver } from 'file:///Users/dkoziavin/code/sub-projects/e-book/node_modules/unhead/dist/utils.mjs'; +import { fileURLToPath } from 'node:url'; +import { ipxFSStorage, ipxHttpStorage, createIPX, createIPXH3Handler } from 'file:///Users/dkoziavin/code/sub-projects/e-book/node_modules/ipx/dist/index.mjs'; + +const serverAssets = [{"baseName":"server","dir":"/Users/dkoziavin/code/sub-projects/e-book/server/assets"}]; + +const assets = createStorage(); + +for (const asset of serverAssets) { + assets.mount(asset.baseName, unstorage_47drivers_47fs({ base: asset.dir, ignore: (asset?.ignore || []) })); +} + +const storage = createStorage({}); + +storage.mount('/assets', assets); + +storage.mount('root', unstorage_47drivers_47fs({"driver":"fs","readOnly":true,"base":"/Users/dkoziavin/code/sub-projects/e-book","watchOptions":{"ignored":[null]}})); +storage.mount('src', unstorage_47drivers_47fs({"driver":"fs","readOnly":true,"base":"/Users/dkoziavin/code/sub-projects/e-book/server","watchOptions":{"ignored":[null]}})); +storage.mount('build', unstorage_47drivers_47fs({"driver":"fs","readOnly":false,"base":"/Users/dkoziavin/code/sub-projects/e-book/.nuxt"})); +storage.mount('cache', unstorage_47drivers_47fs({"driver":"fs","readOnly":false,"base":"/Users/dkoziavin/code/sub-projects/e-book/.nuxt/cache"})); +storage.mount('data', unstorage_47drivers_47fs({"driver":"fs","base":"/Users/dkoziavin/code/sub-projects/e-book/.data/kv"})); + +function useStorage(base = "") { + return base ? prefixStorage(storage, base) : storage; +} + +const Hasher = /* @__PURE__ */ (() => { + class Hasher2 { + buff = ""; + #context = /* @__PURE__ */ new Map(); + write(str) { + this.buff += str; + } + dispatch(value) { + const type = value === null ? "null" : typeof value; + return this[type](value); + } + object(object) { + if (object && typeof object.toJSON === "function") { + return this.object(object.toJSON()); + } + const objString = Object.prototype.toString.call(object); + let objType = ""; + const objectLength = objString.length; + objType = objectLength < 10 ? "unknown:[" + objString + "]" : objString.slice(8, objectLength - 1); + objType = objType.toLowerCase(); + let objectNumber = null; + if ((objectNumber = this.#context.get(object)) === void 0) { + this.#context.set(object, this.#context.size); + } else { + return this.dispatch("[CIRCULAR:" + objectNumber + "]"); + } + if (typeof Buffer !== "undefined" && Buffer.isBuffer && Buffer.isBuffer(object)) { + this.write("buffer:"); + return this.write(object.toString("utf8")); + } + if (objType !== "object" && objType !== "function" && objType !== "asyncfunction") { + if (this[objType]) { + this[objType](object); + } else { + this.unknown(object, objType); + } + } else { + const keys = Object.keys(object).sort(); + const extraKeys = []; + this.write("object:" + (keys.length + extraKeys.length) + ":"); + const dispatchForKey = (key) => { + this.dispatch(key); + this.write(":"); + this.dispatch(object[key]); + this.write(","); + }; + for (const key of keys) { + dispatchForKey(key); + } + for (const key of extraKeys) { + dispatchForKey(key); + } + } + } + array(arr, unordered) { + unordered = unordered === void 0 ? false : unordered; + this.write("array:" + arr.length + ":"); + if (!unordered || arr.length <= 1) { + for (const entry of arr) { + this.dispatch(entry); + } + return; + } + const contextAdditions = /* @__PURE__ */ new Map(); + const entries = arr.map((entry) => { + const hasher = new Hasher2(); + hasher.dispatch(entry); + for (const [key, value] of hasher.#context) { + contextAdditions.set(key, value); + } + return hasher.toString(); + }); + this.#context = contextAdditions; + entries.sort(); + return this.array(entries, false); + } + date(date) { + return this.write("date:" + date.toJSON()); + } + symbol(sym) { + return this.write("symbol:" + sym.toString()); + } + unknown(value, type) { + this.write(type); + if (!value) { + return; + } + this.write(":"); + if (value && typeof value.entries === "function") { + return this.array( + [...value.entries()], + true + /* ordered */ + ); + } + } + error(err) { + return this.write("error:" + err.toString()); + } + boolean(bool) { + return this.write("bool:" + bool); + } + string(string) { + this.write("string:" + string.length + ":"); + this.write(string); + } + function(fn) { + this.write("fn:"); + if (isNativeFunction(fn)) { + this.dispatch("[native]"); + } else { + this.dispatch(fn.toString()); + } + } + number(number) { + return this.write("number:" + number); + } + null() { + return this.write("Null"); + } + undefined() { + return this.write("Undefined"); + } + regexp(regex) { + return this.write("regex:" + regex.toString()); + } + arraybuffer(arr) { + this.write("arraybuffer:"); + return this.dispatch(new Uint8Array(arr)); + } + url(url) { + return this.write("url:" + url.toString()); + } + map(map) { + this.write("map:"); + const arr = [...map]; + return this.array(arr, false); + } + set(set) { + this.write("set:"); + const arr = [...set]; + return this.array(arr, false); + } + bigint(number) { + return this.write("bigint:" + number.toString()); + } + } + for (const type of [ + "uint8array", + "uint8clampedarray", + "unt8array", + "uint16array", + "unt16array", + "uint32array", + "unt32array", + "float32array", + "float64array" + ]) { + Hasher2.prototype[type] = function(arr) { + this.write(type + ":"); + return this.array([...arr], false); + }; + } + function isNativeFunction(f) { + if (typeof f !== "function") { + return false; + } + return Function.prototype.toString.call(f).slice( + -15 + /* "[native code] }".length */ + ) === "[native code] }"; + } + return Hasher2; +})(); +function serialize(object) { + const hasher = new Hasher(); + hasher.dispatch(object); + return hasher.buff; +} +function hash(value) { + return digest(typeof value === "string" ? value : serialize(value)).replace(/[-_]/g, "").slice(0, 10); +} + +function defaultCacheOptions() { + return { + name: "_", + base: "/cache", + swr: true, + maxAge: 1 + }; +} +function defineCachedFunction(fn, opts = {}) { + opts = { ...defaultCacheOptions(), ...opts }; + const pending = {}; + const group = opts.group || "nitro/functions"; + const name = opts.name || fn.name || "_"; + const integrity = opts.integrity || hash([fn, opts]); + const validate = opts.validate || ((entry) => entry.value !== void 0); + async function get(key, resolver, shouldInvalidateCache, event) { + const cacheKey = [opts.base, group, name, key + ".json"].filter(Boolean).join(":").replace(/:\/$/, ":index"); + let entry = await useStorage().getItem(cacheKey).catch((error) => { + console.error(`[cache] Cache read error.`, error); + useNitroApp().captureError(error, { event, tags: ["cache"] }); + }) || {}; + if (typeof entry !== "object") { + entry = {}; + const error = new Error("Malformed data read from cache."); + console.error("[cache]", error); + useNitroApp().captureError(error, { event, tags: ["cache"] }); + } + const ttl = (opts.maxAge ?? 0) * 1e3; + if (ttl) { + entry.expires = Date.now() + ttl; + } + const expired = shouldInvalidateCache || entry.integrity !== integrity || ttl && Date.now() - (entry.mtime || 0) > ttl || validate(entry) === false; + const _resolve = async () => { + const isPending = pending[key]; + if (!isPending) { + if (entry.value !== void 0 && (opts.staleMaxAge || 0) >= 0 && opts.swr === false) { + entry.value = void 0; + entry.integrity = void 0; + entry.mtime = void 0; + entry.expires = void 0; + } + pending[key] = Promise.resolve(resolver()); + } + try { + entry.value = await pending[key]; + } catch (error) { + if (!isPending) { + delete pending[key]; + } + throw error; + } + if (!isPending) { + entry.mtime = Date.now(); + entry.integrity = integrity; + delete pending[key]; + if (validate(entry) !== false) { + let setOpts; + if (opts.maxAge && !opts.swr) { + setOpts = { ttl: opts.maxAge }; + } + const promise = useStorage().setItem(cacheKey, entry, setOpts).catch((error) => { + console.error(`[cache] Cache write error.`, error); + useNitroApp().captureError(error, { event, tags: ["cache"] }); + }); + if (event?.waitUntil) { + event.waitUntil(promise); + } + } + } + }; + const _resolvePromise = expired ? _resolve() : Promise.resolve(); + if (entry.value === void 0) { + await _resolvePromise; + } else if (expired && event && event.waitUntil) { + event.waitUntil(_resolvePromise); + } + if (opts.swr && validate(entry) !== false) { + _resolvePromise.catch((error) => { + console.error(`[cache] SWR handler error.`, error); + useNitroApp().captureError(error, { event, tags: ["cache"] }); + }); + return entry; + } + return _resolvePromise.then(() => entry); + } + return async (...args) => { + const shouldBypassCache = await opts.shouldBypassCache?.(...args); + if (shouldBypassCache) { + return fn(...args); + } + const key = await (opts.getKey || getKey)(...args); + const shouldInvalidateCache = await opts.shouldInvalidateCache?.(...args); + const entry = await get( + key, + () => fn(...args), + shouldInvalidateCache, + args[0] && isEvent(args[0]) ? args[0] : void 0 + ); + let value = entry.value; + if (opts.transform) { + value = await opts.transform(entry, ...args) || value; + } + return value; + }; +} +function cachedFunction(fn, opts = {}) { + return defineCachedFunction(fn, opts); +} +function getKey(...args) { + return args.length > 0 ? hash(args) : ""; +} +function escapeKey(key) { + return String(key).replace(/\W/g, ""); +} +function defineCachedEventHandler(handler, opts = defaultCacheOptions()) { + const variableHeaderNames = (opts.varies || []).filter(Boolean).map((h) => h.toLowerCase()).sort(); + const _opts = { + ...opts, + getKey: async (event) => { + const customKey = await opts.getKey?.(event); + if (customKey) { + return escapeKey(customKey); + } + const _path = event.node.req.originalUrl || event.node.req.url || event.path; + let _pathname; + try { + _pathname = escapeKey(decodeURI(parseURL(_path).pathname)).slice(0, 16) || "index"; + } catch { + _pathname = "-"; + } + const _hashedPath = `${_pathname}.${hash(_path)}`; + const _headers = variableHeaderNames.map((header) => [header, event.node.req.headers[header]]).map(([name, value]) => `${escapeKey(name)}.${hash(value)}`); + return [_hashedPath, ..._headers].join(":"); + }, + validate: (entry) => { + if (!entry.value) { + return false; + } + if (entry.value.code >= 400) { + return false; + } + if (entry.value.body === void 0) { + return false; + } + if (entry.value.headers.etag === "undefined" || entry.value.headers["last-modified"] === "undefined") { + return false; + } + return true; + }, + group: opts.group || "nitro/handlers", + integrity: opts.integrity || hash([handler, opts]) + }; + const _cachedHandler = cachedFunction( + async (incomingEvent) => { + const variableHeaders = {}; + for (const header of variableHeaderNames) { + const value = incomingEvent.node.req.headers[header]; + if (value !== void 0) { + variableHeaders[header] = value; + } + } + const reqProxy = cloneWithProxy(incomingEvent.node.req, { + headers: variableHeaders + }); + const resHeaders = {}; + let _resSendBody; + const resProxy = cloneWithProxy(incomingEvent.node.res, { + statusCode: 200, + writableEnded: false, + writableFinished: false, + headersSent: false, + closed: false, + getHeader(name) { + return resHeaders[name]; + }, + setHeader(name, value) { + resHeaders[name] = value; + return this; + }, + getHeaderNames() { + return Object.keys(resHeaders); + }, + hasHeader(name) { + return name in resHeaders; + }, + removeHeader(name) { + delete resHeaders[name]; + }, + getHeaders() { + return resHeaders; + }, + end(chunk, arg2, arg3) { + if (typeof chunk === "string") { + _resSendBody = chunk; + } + if (typeof arg2 === "function") { + arg2(); + } + if (typeof arg3 === "function") { + arg3(); + } + return this; + }, + write(chunk, arg2, arg3) { + if (typeof chunk === "string") { + _resSendBody = chunk; + } + if (typeof arg2 === "function") { + arg2(void 0); + } + if (typeof arg3 === "function") { + arg3(); + } + return true; + }, + writeHead(statusCode, headers2) { + this.statusCode = statusCode; + if (headers2) { + if (Array.isArray(headers2) || typeof headers2 === "string") { + throw new TypeError("Raw headers is not supported."); + } + for (const header in headers2) { + const value = headers2[header]; + if (value !== void 0) { + this.setHeader( + header, + value + ); + } + } + } + return this; + } + }); + const event = createEvent(reqProxy, resProxy); + event.fetch = (url, fetchOptions) => fetchWithEvent(event, url, fetchOptions, { + fetch: useNitroApp().localFetch + }); + event.$fetch = (url, fetchOptions) => fetchWithEvent(event, url, fetchOptions, { + fetch: globalThis.$fetch + }); + event.waitUntil = incomingEvent.waitUntil; + event.context = incomingEvent.context; + event.context.cache = { + options: _opts + }; + const body = await handler(event) || _resSendBody; + const headers = event.node.res.getHeaders(); + headers.etag = String( + headers.Etag || headers.etag || `W/"${hash(body)}"` + ); + headers["last-modified"] = String( + headers["Last-Modified"] || headers["last-modified"] || (/* @__PURE__ */ new Date()).toUTCString() + ); + const cacheControl = []; + if (opts.swr) { + if (opts.maxAge) { + cacheControl.push(`s-maxage=${opts.maxAge}`); + } + if (opts.staleMaxAge) { + cacheControl.push(`stale-while-revalidate=${opts.staleMaxAge}`); + } else { + cacheControl.push("stale-while-revalidate"); + } + } else if (opts.maxAge) { + cacheControl.push(`max-age=${opts.maxAge}`); + } + if (cacheControl.length > 0) { + headers["cache-control"] = cacheControl.join(", "); + } + const cacheEntry = { + code: event.node.res.statusCode, + headers, + body + }; + return cacheEntry; + }, + _opts + ); + return defineEventHandler(async (event) => { + if (opts.headersOnly) { + if (handleCacheHeaders(event, { maxAge: opts.maxAge })) { + return; + } + return handler(event); + } + const response = await _cachedHandler( + event + ); + if (event.node.res.headersSent || event.node.res.writableEnded) { + return response.body; + } + if (handleCacheHeaders(event, { + modifiedTime: new Date(response.headers["last-modified"]), + etag: response.headers.etag, + maxAge: opts.maxAge + })) { + return; + } + event.node.res.statusCode = response.code; + for (const name in response.headers) { + const value = response.headers[name]; + if (name === "set-cookie") { + event.node.res.appendHeader( + name, + splitCookiesString(value) + ); + } else { + if (value !== void 0) { + event.node.res.setHeader(name, value); + } + } + } + return response.body; + }); +} +function cloneWithProxy(obj, overrides) { + return new Proxy(obj, { + get(target, property, receiver) { + if (property in overrides) { + return overrides[property]; + } + return Reflect.get(target, property, receiver); + }, + set(target, property, value, receiver) { + if (property in overrides) { + overrides[property] = value; + return true; + } + return Reflect.set(target, property, value, receiver); + } + }); +} +const cachedEventHandler = defineCachedEventHandler; + +const inlineAppConfig = { + "nuxt": {}, + "icon": { + "provider": "server", + "class": "", + "aliases": {}, + "iconifyApiEndpoint": "https://api.iconify.design", + "localApiEndpoint": "/api/_nuxt_icon", + "fallbackToApi": true, + "cssSelectorPrefix": "i-", + "cssWherePseudo": true, + "mode": "css", + "attrs": { + "aria-hidden": true + }, + "collections": [ + "academicons", + "akar-icons", + "ant-design", + "arcticons", + "basil", + "bi", + "bitcoin-icons", + "bpmn", + "brandico", + "bx", + "bxl", + "bxs", + "bytesize", + "carbon", + "catppuccin", + "cbi", + "charm", + "ci", + "cib", + "cif", + "cil", + "circle-flags", + "circum", + "clarity", + "codicon", + "covid", + "cryptocurrency", + "cryptocurrency-color", + "dashicons", + "devicon", + "devicon-plain", + "ei", + "el", + "emojione", + "emojione-monotone", + "emojione-v1", + "entypo", + "entypo-social", + "eos-icons", + "ep", + "et", + "eva", + "f7", + "fa", + "fa-brands", + "fa-regular", + "fa-solid", + "fa6-brands", + "fa6-regular", + "fa6-solid", + "fad", + "fe", + "feather", + "file-icons", + "flag", + "flagpack", + "flat-color-icons", + "flat-ui", + "flowbite", + "fluent", + "fluent-emoji", + "fluent-emoji-flat", + "fluent-emoji-high-contrast", + "fluent-mdl2", + "fontelico", + "fontisto", + "formkit", + "foundation", + "fxemoji", + "gala", + "game-icons", + "geo", + "gg", + "gis", + "gravity-ui", + "gridicons", + "grommet-icons", + "guidance", + "healthicons", + "heroicons", + "heroicons-outline", + "heroicons-solid", + "hugeicons", + "humbleicons", + "ic", + "icomoon-free", + "icon-park", + "icon-park-outline", + "icon-park-solid", + "icon-park-twotone", + "iconamoon", + "iconoir", + "icons8", + "il", + "ion", + "iwwa", + "jam", + "la", + "lets-icons", + "line-md", + "logos", + "ls", + "lucide", + "lucide-lab", + "mage", + "majesticons", + "maki", + "map", + "marketeq", + "material-symbols", + "material-symbols-light", + "mdi", + "mdi-light", + "medical-icon", + "memory", + "meteocons", + "mi", + "mingcute", + "mono-icons", + "mynaui", + "nimbus", + "nonicons", + "noto", + "noto-v1", + "octicon", + "oi", + "ooui", + "openmoji", + "oui", + "pajamas", + "pepicons", + "pepicons-pencil", + "pepicons-pop", + "pepicons-print", + "ph", + "pixelarticons", + "prime", + "ps", + "quill", + "radix-icons", + "raphael", + "ri", + "rivet-icons", + "si-glyph", + "simple-icons", + "simple-line-icons", + "skill-icons", + "solar", + "streamline", + "streamline-emojis", + "subway", + "svg-spinners", + "system-uicons", + "tabler", + "tdesign", + "teenyicons", + "token", + "token-branded", + "topcoat", + "twemoji", + "typcn", + "uil", + "uim", + "uis", + "uit", + "uiw", + "unjs", + "vaadin", + "vs", + "vscode-icons", + "websymbol", + "weui", + "whh", + "wi", + "wpf", + "zmdi", + "zondicons" + ], + "fetchTimeout": 1500 + } +}; + + + +const appConfig = defuFn(inlineAppConfig); + +function getEnv(key, opts) { + const envKey = snakeCase(key).toUpperCase(); + return destr( + process.env[opts.prefix + envKey] ?? process.env[opts.altPrefix + envKey] + ); +} +function _isObject(input) { + return typeof input === "object" && !Array.isArray(input); +} +function applyEnv(obj, opts, parentKey = "") { + for (const key in obj) { + const subKey = parentKey ? `${parentKey}_${key}` : key; + const envValue = getEnv(subKey, opts); + if (_isObject(obj[key])) { + if (_isObject(envValue)) { + obj[key] = { ...obj[key], ...envValue }; + applyEnv(obj[key], opts, subKey); + } else if (envValue === void 0) { + applyEnv(obj[key], opts, subKey); + } else { + obj[key] = envValue ?? obj[key]; + } + } else { + obj[key] = envValue ?? obj[key]; + } + if (opts.envExpansion && typeof obj[key] === "string") { + obj[key] = _expandFromEnv(obj[key]); + } + } + return obj; +} +const envExpandRx = /\{\{([^{}]*)\}\}/g; +function _expandFromEnv(value) { + return value.replace(envExpandRx, (match, key) => { + return process.env[key] || match; + }); +} + +const _inlineRuntimeConfig = { + "app": { + "baseURL": "/", + "buildId": "dev", + "buildAssetsDir": "/_nuxt/", + "cdnURL": "" + }, + "nitro": { + "envPrefix": "NUXT_", + "routeRules": { + "/__nuxt_error": { + "cache": false + }, + "/_nuxt/builds/meta/**": { + "headers": { + "cache-control": "public, max-age=31536000, immutable" + } + }, + "/_nuxt/builds/**": { + "headers": { + "cache-control": "public, max-age=1, immutable" + } + } + } + }, + "public": {}, + "icon": { + "serverKnownCssClasses": [] + }, + "ipx": { + "baseURL": "/_ipx", + "alias": {}, + "fs": { + "dir": [ + "/Users/dkoziavin/code/sub-projects/e-book/public" + ] + }, + "http": { + "domains": [] + } + } +}; +const envOptions = { + prefix: "NITRO_", + altPrefix: _inlineRuntimeConfig.nitro.envPrefix ?? process.env.NITRO_ENV_PREFIX ?? "_", + envExpansion: _inlineRuntimeConfig.nitro.envExpansion ?? process.env.NITRO_ENV_EXPANSION ?? false +}; +const _sharedRuntimeConfig = _deepFreeze( + applyEnv(klona(_inlineRuntimeConfig), envOptions) +); +function useRuntimeConfig(event) { + if (!event) { + return _sharedRuntimeConfig; + } + if (event.context.nitro.runtimeConfig) { + return event.context.nitro.runtimeConfig; + } + const runtimeConfig = klona(_inlineRuntimeConfig); + applyEnv(runtimeConfig, envOptions); + event.context.nitro.runtimeConfig = runtimeConfig; + return runtimeConfig; +} +const _sharedAppConfig = _deepFreeze(klona(appConfig)); +function useAppConfig(event) { + { + return _sharedAppConfig; + } +} +function _deepFreeze(object) { + const propNames = Object.getOwnPropertyNames(object); + for (const name of propNames) { + const value = object[name]; + if (value && typeof value === "object") { + _deepFreeze(value); + } + } + return Object.freeze(object); +} +new Proxy(/* @__PURE__ */ Object.create(null), { + get: (_, prop) => { + console.warn( + "Please use `useRuntimeConfig()` instead of accessing config directly." + ); + const runtimeConfig = useRuntimeConfig(); + if (prop in runtimeConfig) { + return runtimeConfig[prop]; + } + return void 0; + } +}); + +getContext("nitro-app", { + asyncContext: false, + AsyncLocalStorage: void 0 +}); + +const config = useRuntimeConfig(); +const _routeRulesMatcher = toRouteMatcher( + createRouter({ routes: config.nitro.routeRules }) +); +function createRouteRulesHandler(ctx) { + return eventHandler((event) => { + const routeRules = getRouteRules(event); + if (routeRules.headers) { + setHeaders(event, routeRules.headers); + } + if (routeRules.redirect) { + let target = routeRules.redirect.to; + if (target.endsWith("/**")) { + let targetPath = event.path; + const strpBase = routeRules.redirect._redirectStripBase; + if (strpBase) { + targetPath = withoutBase(targetPath, strpBase); + } + target = joinURL(target.slice(0, -3), targetPath); + } else if (event.path.includes("?")) { + const query = getQuery(event.path); + target = withQuery(target, query); + } + return sendRedirect(event, target, routeRules.redirect.statusCode); + } + if (routeRules.proxy) { + let target = routeRules.proxy.to; + if (target.endsWith("/**")) { + let targetPath = event.path; + const strpBase = routeRules.proxy._proxyStripBase; + if (strpBase) { + targetPath = withoutBase(targetPath, strpBase); + } + target = joinURL(target.slice(0, -3), targetPath); + } else if (event.path.includes("?")) { + const query = getQuery(event.path); + target = withQuery(target, query); + } + return proxyRequest(event, target, { + fetch: ctx.localFetch, + ...routeRules.proxy + }); + } + }); +} +function getRouteRules(event) { + event.context._nitro = event.context._nitro || {}; + if (!event.context._nitro.routeRules) { + event.context._nitro.routeRules = getRouteRulesForPath( + withoutBase(event.path.split("?")[0], useRuntimeConfig().app.baseURL) + ); + } + return event.context._nitro.routeRules; +} +function getRouteRulesForPath(path) { + return defu({}, ..._routeRulesMatcher.matchAll(path).reverse()); +} + +function _captureError(error, type) { + console.error(`[${type}]`, error); + useNitroApp().captureError(error, { tags: [type] }); +} +function trapUnhandledNodeErrors() { + process.on( + "unhandledRejection", + (error) => _captureError(error, "unhandledRejection") + ); + process.on( + "uncaughtException", + (error) => _captureError(error, "uncaughtException") + ); +} +function joinHeaders(value) { + return Array.isArray(value) ? value.join(", ") : String(value); +} +function normalizeFetchResponse(response) { + if (!response.headers.has("set-cookie")) { + return response; + } + return new Response(response.body, { + status: response.status, + statusText: response.statusText, + headers: normalizeCookieHeaders(response.headers) + }); +} +function normalizeCookieHeader(header = "") { + return splitCookiesString(joinHeaders(header)); +} +function normalizeCookieHeaders(headers) { + const outgoingHeaders = new Headers(); + for (const [name, header] of headers) { + if (name === "set-cookie") { + for (const cookie of normalizeCookieHeader(header)) { + outgoingHeaders.append("set-cookie", cookie); + } + } else { + outgoingHeaders.set(name, joinHeaders(header)); + } + } + return outgoingHeaders; +} + +function isJsonRequest(event) { + if (hasReqHeader(event, "accept", "text/html")) { + return false; + } + return hasReqHeader(event, "accept", "application/json") || hasReqHeader(event, "user-agent", "curl/") || hasReqHeader(event, "user-agent", "httpie/") || hasReqHeader(event, "sec-fetch-mode", "cors") || event.path.startsWith("/api/") || event.path.endsWith(".json"); +} +function hasReqHeader(event, name, includes) { + const value = getRequestHeader(event, name); + return value && typeof value === "string" && value.toLowerCase().includes(includes); +} + +const errorHandler$0 = (async function errorhandler(error, event, { defaultHandler }) { + if (event.handled || isJsonRequest(event)) { + return; + } + const defaultRes = await defaultHandler(error, event, { json: true }); + const statusCode = error.statusCode || 500; + if (statusCode === 404 && defaultRes.status === 302) { + setResponseHeaders(event, defaultRes.headers); + setResponseStatus(event, defaultRes.status, defaultRes.statusText); + return send(event, JSON.stringify(defaultRes.body, null, 2)); + } + if (typeof defaultRes.body !== "string" && Array.isArray(defaultRes.body.stack)) { + defaultRes.body.stack = defaultRes.body.stack.join("\n"); + } + const errorObject = defaultRes.body; + const url = new URL(errorObject.url); + errorObject.url = withoutBase(url.pathname, useRuntimeConfig(event).app.baseURL) + url.search + url.hash; + errorObject.message ||= "Server Error"; + errorObject.data ||= error.data; + errorObject.statusMessage ||= error.statusMessage; + delete defaultRes.headers["content-type"]; + delete defaultRes.headers["content-security-policy"]; + setResponseHeaders(event, defaultRes.headers); + const reqHeaders = getRequestHeaders(event); + const isRenderingError = event.path.startsWith("/__nuxt_error") || !!reqHeaders["x-nuxt-error"]; + const res = isRenderingError ? null : await useNitroApp().localFetch( + withQuery(joinURL(useRuntimeConfig(event).app.baseURL, "/__nuxt_error"), errorObject), + { + headers: { ...reqHeaders, "x-nuxt-error": "true" }, + redirect: "manual" + } + ).catch(() => null); + if (event.handled) { + return; + } + if (!res) { + const { template } = await Promise.resolve().then(function () { return errorDev; }) ; + { + errorObject.description = errorObject.message; + } + setResponseHeader(event, "Content-Type", "text/html;charset=UTF-8"); + return send(event, template(errorObject)); + } + const html = await res.text(); + for (const [header, value] of res.headers.entries()) { + setResponseHeader(event, header, value); + } + setResponseStatus(event, res.status && res.status !== 200 ? res.status : defaultRes.status, res.statusText || defaultRes.statusText); + return send(event, html); +}); + +function defineNitroErrorHandler(handler) { + return handler; +} + +const errorHandler$1 = defineNitroErrorHandler( + async function defaultNitroErrorHandler(error, event) { + const res = await defaultHandler(error, event); + if (!event.node?.res.headersSent) { + setResponseHeaders(event, res.headers); + } + setResponseStatus(event, res.status, res.statusText); + return send( + event, + typeof res.body === "string" ? res.body : JSON.stringify(res.body, null, 2) + ); + } +); +async function defaultHandler(error, event, opts) { + const isSensitive = error.unhandled || error.fatal; + const statusCode = error.statusCode || 500; + const statusMessage = error.statusMessage || "Server Error"; + const url = getRequestURL(event, { xForwardedHost: true, xForwardedProto: true }); + if (statusCode === 404) { + const baseURL = "/"; + if (/^\/[^/]/.test(baseURL) && !url.pathname.startsWith(baseURL)) { + const redirectTo = `${baseURL}${url.pathname.slice(1)}${url.search}`; + return { + status: 302, + statusText: "Found", + headers: { location: redirectTo }, + body: `Redirecting...` + }; + } + } + await loadStackTrace(error).catch(consola.error); + const youch = new Youch(); + if (isSensitive && !opts?.silent) { + const tags = [error.unhandled && "[unhandled]", error.fatal && "[fatal]"].filter(Boolean).join(" "); + const ansiError = await (await youch.toANSI(error)).replaceAll(process.cwd(), "."); + consola.error( + `[request error] ${tags} [${event.method}] ${url} + +`, + ansiError + ); + } + const useJSON = opts?.json || !getRequestHeader(event, "accept")?.includes("text/html"); + const headers = { + "content-type": useJSON ? "application/json" : "text/html", + // Prevent browser from guessing the MIME types of resources. + "x-content-type-options": "nosniff", + // Prevent error page from being embedded in an iframe + "x-frame-options": "DENY", + // Prevent browsers from sending the Referer header + "referrer-policy": "no-referrer", + // Disable the execution of any js + "content-security-policy": "script-src 'self' 'unsafe-inline'; object-src 'none'; base-uri 'self';" + }; + if (statusCode === 404 || !getResponseHeader(event, "cache-control")) { + headers["cache-control"] = "no-cache"; + } + const body = useJSON ? { + error: true, + url, + statusCode, + statusMessage, + message: error.message, + data: error.data, + stack: error.stack?.split("\n").map((line) => line.trim()) + } : await youch.toHTML(error, { + request: { + url: url.href, + method: event.method, + headers: getRequestHeaders(event) + } + }); + return { + status: statusCode, + statusText: statusMessage, + headers, + body + }; +} +async function loadStackTrace(error) { + if (!(error instanceof Error)) { + return; + } + const parsed = await new ErrorParser().defineSourceLoader(sourceLoader).parse(error); + const stack = error.message + "\n" + parsed.frames.map((frame) => fmtFrame(frame)).join("\n"); + Object.defineProperty(error, "stack", { value: stack }); + if (error.cause) { + await loadStackTrace(error.cause).catch(consola.error); + } +} +async function sourceLoader(frame) { + if (!frame.fileName || frame.fileType !== "fs" || frame.type === "native") { + return; + } + if (frame.type === "app") { + const rawSourceMap = await readFile(`${frame.fileName}.map`, "utf8").catch(() => { + }); + if (rawSourceMap) { + const consumer = await new SourceMapConsumer(rawSourceMap); + const originalPosition = consumer.originalPositionFor({ line: frame.lineNumber, column: frame.columnNumber }); + if (originalPosition.source && originalPosition.line) { + frame.fileName = resolve(dirname(frame.fileName), originalPosition.source); + frame.lineNumber = originalPosition.line; + frame.columnNumber = originalPosition.column || 0; + } + } + } + const contents = await readFile(frame.fileName, "utf8").catch(() => { + }); + return contents ? { contents } : void 0; +} +function fmtFrame(frame) { + if (frame.type === "native") { + return frame.raw; + } + const src = `${frame.fileName || ""}:${frame.lineNumber}:${frame.columnNumber})`; + return frame.functionName ? `at ${frame.functionName} (${src}` : `at ${src}`; +} + +const errorHandlers = [errorHandler$0, errorHandler$1]; + +async function errorHandler(error, event) { + for (const handler of errorHandlers) { + try { + await handler(error, event, { defaultHandler }); + if (event.handled) { + return; // Response handled + } + } catch(error) { + // Handler itself thrown, log and continue + console.error(error); + } + } + // H3 will handle fallback +} + +const script = ` +if (!window.__NUXT_DEVTOOLS_TIME_METRIC__) { + Object.defineProperty(window, '__NUXT_DEVTOOLS_TIME_METRIC__', { + value: {}, + enumerable: false, + configurable: true, + }) +} +window.__NUXT_DEVTOOLS_TIME_METRIC__.appInit = Date.now() +`; + +const _cd6pjli97eqk3rtBCICyBsTCAUr095T92PTTK3VSI = (function(nitro) { + nitro.hooks.hook("render:html", (htmlContext) => { + htmlContext.head.push(`