2026-03-02T09-05-52_auto_memory/memories.db-wal
This commit is contained in:
parent
de94a312c1
commit
eabef27a22
@ -1,2 +0,0 @@
|
||||
globalThis.process ??= {}; globalThis.process.env ??= {};
|
||||
export { c as createExports } from './chunks/_@astrojs-ssr-adapter_Cwlmv2LC.mjs';
|
||||
@ -1,21 +0,0 @@
|
||||
globalThis.process ??= {}; globalThis.process.env ??= {};
|
||||
import './chunks/astro-designed-error-pages_CMWe72_h.mjs';
|
||||
import './chunks/astro/server_B3mZj6if.mjs';
|
||||
import { s as sequence } from './chunks/index_CkeyRg6H.mjs';
|
||||
|
||||
const onRequest$1 = (context, next) => {
|
||||
if (context.isPrerendered) {
|
||||
context.locals.runtime ??= {
|
||||
env: process.env
|
||||
};
|
||||
}
|
||||
return next();
|
||||
};
|
||||
|
||||
const onRequest = sequence(
|
||||
onRequest$1,
|
||||
|
||||
|
||||
);
|
||||
|
||||
export { onRequest };
|
||||
@ -1,971 +0,0 @@
|
||||
var __defProp = Object.defineProperty;
|
||||
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
|
||||
|
||||
// ../node_modules/unenv/dist/runtime/_internal/utils.mjs
|
||||
// @__NO_SIDE_EFFECTS__
|
||||
function createNotImplementedError(name) {
|
||||
return new Error(`[unenv] ${name} is not implemented yet!`);
|
||||
}
|
||||
__name(createNotImplementedError, "createNotImplementedError");
|
||||
// @__NO_SIDE_EFFECTS__
|
||||
function notImplemented(name) {
|
||||
const fn = /* @__PURE__ */ __name(() => {
|
||||
throw /* @__PURE__ */ createNotImplementedError(name);
|
||||
}, "fn");
|
||||
return Object.assign(fn, { __unenv__: true });
|
||||
}
|
||||
__name(notImplemented, "notImplemented");
|
||||
// @__NO_SIDE_EFFECTS__
|
||||
function notImplementedClass(name) {
|
||||
return class {
|
||||
__unenv__ = true;
|
||||
constructor() {
|
||||
throw new Error(`[unenv] ${name} is not implemented yet!`);
|
||||
}
|
||||
};
|
||||
}
|
||||
__name(notImplementedClass, "notImplementedClass");
|
||||
|
||||
// ../node_modules/unenv/dist/runtime/node/internal/perf_hooks/performance.mjs
|
||||
var _timeOrigin = globalThis.performance?.timeOrigin ?? Date.now();
|
||||
var _performanceNow = globalThis.performance?.now ? globalThis.performance.now.bind(globalThis.performance) : () => Date.now() - _timeOrigin;
|
||||
var nodeTiming = {
|
||||
name: "node",
|
||||
entryType: "node",
|
||||
startTime: 0,
|
||||
duration: 0,
|
||||
nodeStart: 0,
|
||||
v8Start: 0,
|
||||
bootstrapComplete: 0,
|
||||
environment: 0,
|
||||
loopStart: 0,
|
||||
loopExit: 0,
|
||||
idleTime: 0,
|
||||
uvMetricsInfo: {
|
||||
loopCount: 0,
|
||||
events: 0,
|
||||
eventsWaiting: 0
|
||||
},
|
||||
detail: void 0,
|
||||
toJSON() {
|
||||
return this;
|
||||
}
|
||||
};
|
||||
var PerformanceEntry = class {
|
||||
static {
|
||||
__name(this, "PerformanceEntry");
|
||||
}
|
||||
__unenv__ = true;
|
||||
detail;
|
||||
entryType = "event";
|
||||
name;
|
||||
startTime;
|
||||
constructor(name, options) {
|
||||
this.name = name;
|
||||
this.startTime = options?.startTime || _performanceNow();
|
||||
this.detail = options?.detail;
|
||||
}
|
||||
get duration() {
|
||||
return _performanceNow() - this.startTime;
|
||||
}
|
||||
toJSON() {
|
||||
return {
|
||||
name: this.name,
|
||||
entryType: this.entryType,
|
||||
startTime: this.startTime,
|
||||
duration: this.duration,
|
||||
detail: this.detail
|
||||
};
|
||||
}
|
||||
};
|
||||
var PerformanceMark = class PerformanceMark2 extends PerformanceEntry {
|
||||
static {
|
||||
__name(this, "PerformanceMark");
|
||||
}
|
||||
entryType = "mark";
|
||||
constructor() {
|
||||
super(...arguments);
|
||||
}
|
||||
get duration() {
|
||||
return 0;
|
||||
}
|
||||
};
|
||||
var PerformanceMeasure = class extends PerformanceEntry {
|
||||
static {
|
||||
__name(this, "PerformanceMeasure");
|
||||
}
|
||||
entryType = "measure";
|
||||
};
|
||||
var PerformanceResourceTiming = class extends PerformanceEntry {
|
||||
static {
|
||||
__name(this, "PerformanceResourceTiming");
|
||||
}
|
||||
entryType = "resource";
|
||||
serverTiming = [];
|
||||
connectEnd = 0;
|
||||
connectStart = 0;
|
||||
decodedBodySize = 0;
|
||||
domainLookupEnd = 0;
|
||||
domainLookupStart = 0;
|
||||
encodedBodySize = 0;
|
||||
fetchStart = 0;
|
||||
initiatorType = "";
|
||||
name = "";
|
||||
nextHopProtocol = "";
|
||||
redirectEnd = 0;
|
||||
redirectStart = 0;
|
||||
requestStart = 0;
|
||||
responseEnd = 0;
|
||||
responseStart = 0;
|
||||
secureConnectionStart = 0;
|
||||
startTime = 0;
|
||||
transferSize = 0;
|
||||
workerStart = 0;
|
||||
responseStatus = 0;
|
||||
};
|
||||
var PerformanceObserverEntryList = class {
|
||||
static {
|
||||
__name(this, "PerformanceObserverEntryList");
|
||||
}
|
||||
__unenv__ = true;
|
||||
getEntries() {
|
||||
return [];
|
||||
}
|
||||
getEntriesByName(_name, _type) {
|
||||
return [];
|
||||
}
|
||||
getEntriesByType(type) {
|
||||
return [];
|
||||
}
|
||||
};
|
||||
var Performance = class {
|
||||
static {
|
||||
__name(this, "Performance");
|
||||
}
|
||||
__unenv__ = true;
|
||||
timeOrigin = _timeOrigin;
|
||||
eventCounts = /* @__PURE__ */ new Map();
|
||||
_entries = [];
|
||||
_resourceTimingBufferSize = 0;
|
||||
navigation = void 0;
|
||||
timing = void 0;
|
||||
timerify(_fn, _options) {
|
||||
throw createNotImplementedError("Performance.timerify");
|
||||
}
|
||||
get nodeTiming() {
|
||||
return nodeTiming;
|
||||
}
|
||||
eventLoopUtilization() {
|
||||
return {};
|
||||
}
|
||||
markResourceTiming() {
|
||||
return new PerformanceResourceTiming("");
|
||||
}
|
||||
onresourcetimingbufferfull = null;
|
||||
now() {
|
||||
if (this.timeOrigin === _timeOrigin) {
|
||||
return _performanceNow();
|
||||
}
|
||||
return Date.now() - this.timeOrigin;
|
||||
}
|
||||
clearMarks(markName) {
|
||||
this._entries = markName ? this._entries.filter((e) => e.name !== markName) : this._entries.filter((e) => e.entryType !== "mark");
|
||||
}
|
||||
clearMeasures(measureName) {
|
||||
this._entries = measureName ? this._entries.filter((e) => e.name !== measureName) : this._entries.filter((e) => e.entryType !== "measure");
|
||||
}
|
||||
clearResourceTimings() {
|
||||
this._entries = this._entries.filter((e) => e.entryType !== "resource" || e.entryType !== "navigation");
|
||||
}
|
||||
getEntries() {
|
||||
return this._entries;
|
||||
}
|
||||
getEntriesByName(name, type) {
|
||||
return this._entries.filter((e) => e.name === name && (!type || e.entryType === type));
|
||||
}
|
||||
getEntriesByType(type) {
|
||||
return this._entries.filter((e) => e.entryType === type);
|
||||
}
|
||||
mark(name, options) {
|
||||
const entry = new PerformanceMark(name, options);
|
||||
this._entries.push(entry);
|
||||
return entry;
|
||||
}
|
||||
measure(measureName, startOrMeasureOptions, endMark) {
|
||||
let start;
|
||||
let end;
|
||||
if (typeof startOrMeasureOptions === "string") {
|
||||
start = this.getEntriesByName(startOrMeasureOptions, "mark")[0]?.startTime;
|
||||
end = this.getEntriesByName(endMark, "mark")[0]?.startTime;
|
||||
} else {
|
||||
start = Number.parseFloat(startOrMeasureOptions?.start) || this.now();
|
||||
end = Number.parseFloat(startOrMeasureOptions?.end) || this.now();
|
||||
}
|
||||
const entry = new PerformanceMeasure(measureName, {
|
||||
startTime: start,
|
||||
detail: {
|
||||
start,
|
||||
end
|
||||
}
|
||||
});
|
||||
this._entries.push(entry);
|
||||
return entry;
|
||||
}
|
||||
setResourceTimingBufferSize(maxSize) {
|
||||
this._resourceTimingBufferSize = maxSize;
|
||||
}
|
||||
addEventListener(type, listener, options) {
|
||||
throw createNotImplementedError("Performance.addEventListener");
|
||||
}
|
||||
removeEventListener(type, listener, options) {
|
||||
throw createNotImplementedError("Performance.removeEventListener");
|
||||
}
|
||||
dispatchEvent(event) {
|
||||
throw createNotImplementedError("Performance.dispatchEvent");
|
||||
}
|
||||
toJSON() {
|
||||
return this;
|
||||
}
|
||||
};
|
||||
var PerformanceObserver = class {
|
||||
static {
|
||||
__name(this, "PerformanceObserver");
|
||||
}
|
||||
__unenv__ = true;
|
||||
static supportedEntryTypes = [];
|
||||
_callback = null;
|
||||
constructor(callback) {
|
||||
this._callback = callback;
|
||||
}
|
||||
takeRecords() {
|
||||
return [];
|
||||
}
|
||||
disconnect() {
|
||||
throw createNotImplementedError("PerformanceObserver.disconnect");
|
||||
}
|
||||
observe(options) {
|
||||
throw createNotImplementedError("PerformanceObserver.observe");
|
||||
}
|
||||
bind(fn) {
|
||||
return fn;
|
||||
}
|
||||
runInAsyncScope(fn, thisArg, ...args) {
|
||||
return fn.call(thisArg, ...args);
|
||||
}
|
||||
asyncId() {
|
||||
return 0;
|
||||
}
|
||||
triggerAsyncId() {
|
||||
return 0;
|
||||
}
|
||||
emitDestroy() {
|
||||
return this;
|
||||
}
|
||||
};
|
||||
var performance = globalThis.performance && "addEventListener" in globalThis.performance ? globalThis.performance : new Performance();
|
||||
|
||||
// ../node_modules/@cloudflare/unenv-preset/dist/runtime/polyfill/performance.mjs
|
||||
globalThis.performance = performance;
|
||||
globalThis.Performance = Performance;
|
||||
globalThis.PerformanceEntry = PerformanceEntry;
|
||||
globalThis.PerformanceMark = PerformanceMark;
|
||||
globalThis.PerformanceMeasure = PerformanceMeasure;
|
||||
globalThis.PerformanceObserver = PerformanceObserver;
|
||||
globalThis.PerformanceObserverEntryList = PerformanceObserverEntryList;
|
||||
globalThis.PerformanceResourceTiming = PerformanceResourceTiming;
|
||||
|
||||
// ../node_modules/unenv/dist/runtime/node/console.mjs
|
||||
import { Writable } from "node:stream";
|
||||
|
||||
// ../node_modules/unenv/dist/runtime/mock/noop.mjs
|
||||
var noop_default = Object.assign(() => {
|
||||
}, { __unenv__: true });
|
||||
|
||||
// ../node_modules/unenv/dist/runtime/node/console.mjs
|
||||
var _console = globalThis.console;
|
||||
var _ignoreErrors = true;
|
||||
var _stderr = new Writable();
|
||||
var _stdout = new Writable();
|
||||
var log = _console?.log ?? noop_default;
|
||||
var info = _console?.info ?? log;
|
||||
var trace = _console?.trace ?? info;
|
||||
var debug = _console?.debug ?? log;
|
||||
var table = _console?.table ?? log;
|
||||
var error = _console?.error ?? log;
|
||||
var warn = _console?.warn ?? error;
|
||||
var createTask = _console?.createTask ?? /* @__PURE__ */ notImplemented("console.createTask");
|
||||
var clear = _console?.clear ?? noop_default;
|
||||
var count = _console?.count ?? noop_default;
|
||||
var countReset = _console?.countReset ?? noop_default;
|
||||
var dir = _console?.dir ?? noop_default;
|
||||
var dirxml = _console?.dirxml ?? noop_default;
|
||||
var group = _console?.group ?? noop_default;
|
||||
var groupEnd = _console?.groupEnd ?? noop_default;
|
||||
var groupCollapsed = _console?.groupCollapsed ?? noop_default;
|
||||
var profile = _console?.profile ?? noop_default;
|
||||
var profileEnd = _console?.profileEnd ?? noop_default;
|
||||
var time = _console?.time ?? noop_default;
|
||||
var timeEnd = _console?.timeEnd ?? noop_default;
|
||||
var timeLog = _console?.timeLog ?? noop_default;
|
||||
var timeStamp = _console?.timeStamp ?? noop_default;
|
||||
var Console = _console?.Console ?? /* @__PURE__ */ notImplementedClass("console.Console");
|
||||
var _times = /* @__PURE__ */ new Map();
|
||||
var _stdoutErrorHandler = noop_default;
|
||||
var _stderrErrorHandler = noop_default;
|
||||
|
||||
// ../node_modules/@cloudflare/unenv-preset/dist/runtime/node/console.mjs
|
||||
var workerdConsole = globalThis["console"];
|
||||
var {
|
||||
assert,
|
||||
clear: clear2,
|
||||
// @ts-expect-error undocumented public API
|
||||
context,
|
||||
count: count2,
|
||||
countReset: countReset2,
|
||||
// @ts-expect-error undocumented public API
|
||||
createTask: createTask2,
|
||||
debug: debug2,
|
||||
dir: dir2,
|
||||
dirxml: dirxml2,
|
||||
error: error2,
|
||||
group: group2,
|
||||
groupCollapsed: groupCollapsed2,
|
||||
groupEnd: groupEnd2,
|
||||
info: info2,
|
||||
log: log2,
|
||||
profile: profile2,
|
||||
profileEnd: profileEnd2,
|
||||
table: table2,
|
||||
time: time2,
|
||||
timeEnd: timeEnd2,
|
||||
timeLog: timeLog2,
|
||||
timeStamp: timeStamp2,
|
||||
trace: trace2,
|
||||
warn: warn2
|
||||
} = workerdConsole;
|
||||
Object.assign(workerdConsole, {
|
||||
Console,
|
||||
_ignoreErrors,
|
||||
_stderr,
|
||||
_stderrErrorHandler,
|
||||
_stdout,
|
||||
_stdoutErrorHandler,
|
||||
_times
|
||||
});
|
||||
var console_default = workerdConsole;
|
||||
|
||||
// ../node_modules/wrangler/_virtual_unenv_global_polyfill-@cloudflare-unenv-preset-node-console
|
||||
globalThis.console = console_default;
|
||||
|
||||
// ../node_modules/unenv/dist/runtime/node/internal/process/hrtime.mjs
|
||||
var hrtime = /* @__PURE__ */ Object.assign(/* @__PURE__ */ __name(function hrtime2(startTime) {
|
||||
const now = Date.now();
|
||||
const seconds = Math.trunc(now / 1e3);
|
||||
const nanos = now % 1e3 * 1e6;
|
||||
if (startTime) {
|
||||
let diffSeconds = seconds - startTime[0];
|
||||
let diffNanos = nanos - startTime[0];
|
||||
if (diffNanos < 0) {
|
||||
diffSeconds = diffSeconds - 1;
|
||||
diffNanos = 1e9 + diffNanos;
|
||||
}
|
||||
return [diffSeconds, diffNanos];
|
||||
}
|
||||
return [seconds, nanos];
|
||||
}, "hrtime"), { bigint: /* @__PURE__ */ __name(function bigint() {
|
||||
return BigInt(Date.now() * 1e6);
|
||||
}, "bigint") });
|
||||
|
||||
// ../node_modules/unenv/dist/runtime/node/internal/process/process.mjs
|
||||
import { EventEmitter } from "node:events";
|
||||
|
||||
// ../node_modules/unenv/dist/runtime/node/internal/tty/read-stream.mjs
|
||||
var ReadStream = class {
|
||||
static {
|
||||
__name(this, "ReadStream");
|
||||
}
|
||||
fd;
|
||||
isRaw = false;
|
||||
isTTY = false;
|
||||
constructor(fd) {
|
||||
this.fd = fd;
|
||||
}
|
||||
setRawMode(mode) {
|
||||
this.isRaw = mode;
|
||||
return this;
|
||||
}
|
||||
};
|
||||
|
||||
// ../node_modules/unenv/dist/runtime/node/internal/tty/write-stream.mjs
|
||||
var WriteStream = class {
|
||||
static {
|
||||
__name(this, "WriteStream");
|
||||
}
|
||||
fd;
|
||||
columns = 80;
|
||||
rows = 24;
|
||||
isTTY = false;
|
||||
constructor(fd) {
|
||||
this.fd = fd;
|
||||
}
|
||||
clearLine(dir3, callback) {
|
||||
callback && callback();
|
||||
return false;
|
||||
}
|
||||
clearScreenDown(callback) {
|
||||
callback && callback();
|
||||
return false;
|
||||
}
|
||||
cursorTo(x, y, callback) {
|
||||
callback && typeof callback === "function" && callback();
|
||||
return false;
|
||||
}
|
||||
moveCursor(dx, dy, callback) {
|
||||
callback && callback();
|
||||
return false;
|
||||
}
|
||||
getColorDepth(env2) {
|
||||
return 1;
|
||||
}
|
||||
hasColors(count3, env2) {
|
||||
return false;
|
||||
}
|
||||
getWindowSize() {
|
||||
return [this.columns, this.rows];
|
||||
}
|
||||
write(str, encoding, cb) {
|
||||
if (str instanceof Uint8Array) {
|
||||
str = new TextDecoder().decode(str);
|
||||
}
|
||||
try {
|
||||
console.log(str);
|
||||
} catch {
|
||||
}
|
||||
cb && typeof cb === "function" && cb();
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
||||
// ../node_modules/unenv/dist/runtime/node/internal/process/node-version.mjs
|
||||
var NODE_VERSION = "22.14.0";
|
||||
|
||||
// ../node_modules/unenv/dist/runtime/node/internal/process/process.mjs
|
||||
var Process = class _Process extends EventEmitter {
|
||||
static {
|
||||
__name(this, "Process");
|
||||
}
|
||||
env;
|
||||
hrtime;
|
||||
nextTick;
|
||||
constructor(impl) {
|
||||
super();
|
||||
this.env = impl.env;
|
||||
this.hrtime = impl.hrtime;
|
||||
this.nextTick = impl.nextTick;
|
||||
for (const prop of [...Object.getOwnPropertyNames(_Process.prototype), ...Object.getOwnPropertyNames(EventEmitter.prototype)]) {
|
||||
const value = this[prop];
|
||||
if (typeof value === "function") {
|
||||
this[prop] = value.bind(this);
|
||||
}
|
||||
}
|
||||
}
|
||||
// --- event emitter ---
|
||||
emitWarning(warning, type, code) {
|
||||
console.warn(`${code ? `[${code}] ` : ""}${type ? `${type}: ` : ""}${warning}`);
|
||||
}
|
||||
emit(...args) {
|
||||
return super.emit(...args);
|
||||
}
|
||||
listeners(eventName) {
|
||||
return super.listeners(eventName);
|
||||
}
|
||||
// --- stdio (lazy initializers) ---
|
||||
#stdin;
|
||||
#stdout;
|
||||
#stderr;
|
||||
get stdin() {
|
||||
return this.#stdin ??= new ReadStream(0);
|
||||
}
|
||||
get stdout() {
|
||||
return this.#stdout ??= new WriteStream(1);
|
||||
}
|
||||
get stderr() {
|
||||
return this.#stderr ??= new WriteStream(2);
|
||||
}
|
||||
// --- cwd ---
|
||||
#cwd = "/";
|
||||
chdir(cwd2) {
|
||||
this.#cwd = cwd2;
|
||||
}
|
||||
cwd() {
|
||||
return this.#cwd;
|
||||
}
|
||||
// --- dummy props and getters ---
|
||||
arch = "";
|
||||
platform = "";
|
||||
argv = [];
|
||||
argv0 = "";
|
||||
execArgv = [];
|
||||
execPath = "";
|
||||
title = "";
|
||||
pid = 200;
|
||||
ppid = 100;
|
||||
get version() {
|
||||
return `v${NODE_VERSION}`;
|
||||
}
|
||||
get versions() {
|
||||
return { node: NODE_VERSION };
|
||||
}
|
||||
get allowedNodeEnvironmentFlags() {
|
||||
return /* @__PURE__ */ new Set();
|
||||
}
|
||||
get sourceMapsEnabled() {
|
||||
return false;
|
||||
}
|
||||
get debugPort() {
|
||||
return 0;
|
||||
}
|
||||
get throwDeprecation() {
|
||||
return false;
|
||||
}
|
||||
get traceDeprecation() {
|
||||
return false;
|
||||
}
|
||||
get features() {
|
||||
return {};
|
||||
}
|
||||
get release() {
|
||||
return {};
|
||||
}
|
||||
get connected() {
|
||||
return false;
|
||||
}
|
||||
get config() {
|
||||
return {};
|
||||
}
|
||||
get moduleLoadList() {
|
||||
return [];
|
||||
}
|
||||
constrainedMemory() {
|
||||
return 0;
|
||||
}
|
||||
availableMemory() {
|
||||
return 0;
|
||||
}
|
||||
uptime() {
|
||||
return 0;
|
||||
}
|
||||
resourceUsage() {
|
||||
return {};
|
||||
}
|
||||
// --- noop methods ---
|
||||
ref() {
|
||||
}
|
||||
unref() {
|
||||
}
|
||||
// --- unimplemented methods ---
|
||||
umask() {
|
||||
throw createNotImplementedError("process.umask");
|
||||
}
|
||||
getBuiltinModule() {
|
||||
return void 0;
|
||||
}
|
||||
getActiveResourcesInfo() {
|
||||
throw createNotImplementedError("process.getActiveResourcesInfo");
|
||||
}
|
||||
exit() {
|
||||
throw createNotImplementedError("process.exit");
|
||||
}
|
||||
reallyExit() {
|
||||
throw createNotImplementedError("process.reallyExit");
|
||||
}
|
||||
kill() {
|
||||
throw createNotImplementedError("process.kill");
|
||||
}
|
||||
abort() {
|
||||
throw createNotImplementedError("process.abort");
|
||||
}
|
||||
dlopen() {
|
||||
throw createNotImplementedError("process.dlopen");
|
||||
}
|
||||
setSourceMapsEnabled() {
|
||||
throw createNotImplementedError("process.setSourceMapsEnabled");
|
||||
}
|
||||
loadEnvFile() {
|
||||
throw createNotImplementedError("process.loadEnvFile");
|
||||
}
|
||||
disconnect() {
|
||||
throw createNotImplementedError("process.disconnect");
|
||||
}
|
||||
cpuUsage() {
|
||||
throw createNotImplementedError("process.cpuUsage");
|
||||
}
|
||||
setUncaughtExceptionCaptureCallback() {
|
||||
throw createNotImplementedError("process.setUncaughtExceptionCaptureCallback");
|
||||
}
|
||||
hasUncaughtExceptionCaptureCallback() {
|
||||
throw createNotImplementedError("process.hasUncaughtExceptionCaptureCallback");
|
||||
}
|
||||
initgroups() {
|
||||
throw createNotImplementedError("process.initgroups");
|
||||
}
|
||||
openStdin() {
|
||||
throw createNotImplementedError("process.openStdin");
|
||||
}
|
||||
assert() {
|
||||
throw createNotImplementedError("process.assert");
|
||||
}
|
||||
binding() {
|
||||
throw createNotImplementedError("process.binding");
|
||||
}
|
||||
// --- attached interfaces ---
|
||||
permission = { has: /* @__PURE__ */ notImplemented("process.permission.has") };
|
||||
report = {
|
||||
directory: "",
|
||||
filename: "",
|
||||
signal: "SIGUSR2",
|
||||
compact: false,
|
||||
reportOnFatalError: false,
|
||||
reportOnSignal: false,
|
||||
reportOnUncaughtException: false,
|
||||
getReport: /* @__PURE__ */ notImplemented("process.report.getReport"),
|
||||
writeReport: /* @__PURE__ */ notImplemented("process.report.writeReport")
|
||||
};
|
||||
finalization = {
|
||||
register: /* @__PURE__ */ notImplemented("process.finalization.register"),
|
||||
unregister: /* @__PURE__ */ notImplemented("process.finalization.unregister"),
|
||||
registerBeforeExit: /* @__PURE__ */ notImplemented("process.finalization.registerBeforeExit")
|
||||
};
|
||||
memoryUsage = Object.assign(() => ({
|
||||
arrayBuffers: 0,
|
||||
rss: 0,
|
||||
external: 0,
|
||||
heapTotal: 0,
|
||||
heapUsed: 0
|
||||
}), { rss: /* @__PURE__ */ __name(() => 0, "rss") });
|
||||
// --- undefined props ---
|
||||
mainModule = void 0;
|
||||
domain = void 0;
|
||||
// optional
|
||||
send = void 0;
|
||||
exitCode = void 0;
|
||||
channel = void 0;
|
||||
getegid = void 0;
|
||||
geteuid = void 0;
|
||||
getgid = void 0;
|
||||
getgroups = void 0;
|
||||
getuid = void 0;
|
||||
setegid = void 0;
|
||||
seteuid = void 0;
|
||||
setgid = void 0;
|
||||
setgroups = void 0;
|
||||
setuid = void 0;
|
||||
// internals
|
||||
_events = void 0;
|
||||
_eventsCount = void 0;
|
||||
_exiting = void 0;
|
||||
_maxListeners = void 0;
|
||||
_debugEnd = void 0;
|
||||
_debugProcess = void 0;
|
||||
_fatalException = void 0;
|
||||
_getActiveHandles = void 0;
|
||||
_getActiveRequests = void 0;
|
||||
_kill = void 0;
|
||||
_preload_modules = void 0;
|
||||
_rawDebug = void 0;
|
||||
_startProfilerIdleNotifier = void 0;
|
||||
_stopProfilerIdleNotifier = void 0;
|
||||
_tickCallback = void 0;
|
||||
_disconnect = void 0;
|
||||
_handleQueue = void 0;
|
||||
_pendingMessage = void 0;
|
||||
_channel = void 0;
|
||||
_send = void 0;
|
||||
_linkedBinding = void 0;
|
||||
};
|
||||
|
||||
// ../node_modules/@cloudflare/unenv-preset/dist/runtime/node/process.mjs
|
||||
var globalProcess = globalThis["process"];
|
||||
var getBuiltinModule = globalProcess.getBuiltinModule;
|
||||
var workerdProcess = getBuiltinModule("node:process");
|
||||
var unenvProcess = new Process({
|
||||
env: globalProcess.env,
|
||||
hrtime,
|
||||
// `nextTick` is available from workerd process v1
|
||||
nextTick: workerdProcess.nextTick
|
||||
});
|
||||
var { exit, features, platform } = workerdProcess;
|
||||
var {
|
||||
_channel,
|
||||
_debugEnd,
|
||||
_debugProcess,
|
||||
_disconnect,
|
||||
_events,
|
||||
_eventsCount,
|
||||
_exiting,
|
||||
_fatalException,
|
||||
_getActiveHandles,
|
||||
_getActiveRequests,
|
||||
_handleQueue,
|
||||
_kill,
|
||||
_linkedBinding,
|
||||
_maxListeners,
|
||||
_pendingMessage,
|
||||
_preload_modules,
|
||||
_rawDebug,
|
||||
_send,
|
||||
_startProfilerIdleNotifier,
|
||||
_stopProfilerIdleNotifier,
|
||||
_tickCallback,
|
||||
abort,
|
||||
addListener,
|
||||
allowedNodeEnvironmentFlags,
|
||||
arch,
|
||||
argv,
|
||||
argv0,
|
||||
assert: assert2,
|
||||
availableMemory,
|
||||
binding,
|
||||
channel,
|
||||
chdir,
|
||||
config,
|
||||
connected,
|
||||
constrainedMemory,
|
||||
cpuUsage,
|
||||
cwd,
|
||||
debugPort,
|
||||
disconnect,
|
||||
dlopen,
|
||||
domain,
|
||||
emit,
|
||||
emitWarning,
|
||||
env,
|
||||
eventNames,
|
||||
execArgv,
|
||||
execPath,
|
||||
exitCode,
|
||||
finalization,
|
||||
getActiveResourcesInfo,
|
||||
getegid,
|
||||
geteuid,
|
||||
getgid,
|
||||
getgroups,
|
||||
getMaxListeners,
|
||||
getuid,
|
||||
hasUncaughtExceptionCaptureCallback,
|
||||
hrtime: hrtime3,
|
||||
initgroups,
|
||||
kill,
|
||||
listenerCount,
|
||||
listeners,
|
||||
loadEnvFile,
|
||||
mainModule,
|
||||
memoryUsage,
|
||||
moduleLoadList,
|
||||
nextTick,
|
||||
off,
|
||||
on,
|
||||
once,
|
||||
openStdin,
|
||||
permission,
|
||||
pid,
|
||||
ppid,
|
||||
prependListener,
|
||||
prependOnceListener,
|
||||
rawListeners,
|
||||
reallyExit,
|
||||
ref,
|
||||
release,
|
||||
removeAllListeners,
|
||||
removeListener,
|
||||
report,
|
||||
resourceUsage,
|
||||
send,
|
||||
setegid,
|
||||
seteuid,
|
||||
setgid,
|
||||
setgroups,
|
||||
setMaxListeners,
|
||||
setSourceMapsEnabled,
|
||||
setuid,
|
||||
setUncaughtExceptionCaptureCallback,
|
||||
sourceMapsEnabled,
|
||||
stderr,
|
||||
stdin,
|
||||
stdout,
|
||||
throwDeprecation,
|
||||
title,
|
||||
traceDeprecation,
|
||||
umask,
|
||||
unref,
|
||||
uptime,
|
||||
version,
|
||||
versions
|
||||
} = unenvProcess;
|
||||
var _process = {
|
||||
abort,
|
||||
addListener,
|
||||
allowedNodeEnvironmentFlags,
|
||||
hasUncaughtExceptionCaptureCallback,
|
||||
setUncaughtExceptionCaptureCallback,
|
||||
loadEnvFile,
|
||||
sourceMapsEnabled,
|
||||
arch,
|
||||
argv,
|
||||
argv0,
|
||||
chdir,
|
||||
config,
|
||||
connected,
|
||||
constrainedMemory,
|
||||
availableMemory,
|
||||
cpuUsage,
|
||||
cwd,
|
||||
debugPort,
|
||||
dlopen,
|
||||
disconnect,
|
||||
emit,
|
||||
emitWarning,
|
||||
env,
|
||||
eventNames,
|
||||
execArgv,
|
||||
execPath,
|
||||
exit,
|
||||
finalization,
|
||||
features,
|
||||
getBuiltinModule,
|
||||
getActiveResourcesInfo,
|
||||
getMaxListeners,
|
||||
hrtime: hrtime3,
|
||||
kill,
|
||||
listeners,
|
||||
listenerCount,
|
||||
memoryUsage,
|
||||
nextTick,
|
||||
on,
|
||||
off,
|
||||
once,
|
||||
pid,
|
||||
platform,
|
||||
ppid,
|
||||
prependListener,
|
||||
prependOnceListener,
|
||||
rawListeners,
|
||||
release,
|
||||
removeAllListeners,
|
||||
removeListener,
|
||||
report,
|
||||
resourceUsage,
|
||||
setMaxListeners,
|
||||
setSourceMapsEnabled,
|
||||
stderr,
|
||||
stdin,
|
||||
stdout,
|
||||
title,
|
||||
throwDeprecation,
|
||||
traceDeprecation,
|
||||
umask,
|
||||
uptime,
|
||||
version,
|
||||
versions,
|
||||
// @ts-expect-error old API
|
||||
domain,
|
||||
initgroups,
|
||||
moduleLoadList,
|
||||
reallyExit,
|
||||
openStdin,
|
||||
assert: assert2,
|
||||
binding,
|
||||
send,
|
||||
exitCode,
|
||||
channel,
|
||||
getegid,
|
||||
geteuid,
|
||||
getgid,
|
||||
getgroups,
|
||||
getuid,
|
||||
setegid,
|
||||
seteuid,
|
||||
setgid,
|
||||
setgroups,
|
||||
setuid,
|
||||
permission,
|
||||
mainModule,
|
||||
_events,
|
||||
_eventsCount,
|
||||
_exiting,
|
||||
_maxListeners,
|
||||
_debugEnd,
|
||||
_debugProcess,
|
||||
_fatalException,
|
||||
_getActiveHandles,
|
||||
_getActiveRequests,
|
||||
_kill,
|
||||
_preload_modules,
|
||||
_rawDebug,
|
||||
_startProfilerIdleNotifier,
|
||||
_stopProfilerIdleNotifier,
|
||||
_tickCallback,
|
||||
_disconnect,
|
||||
_handleQueue,
|
||||
_pendingMessage,
|
||||
_channel,
|
||||
_send,
|
||||
_linkedBinding
|
||||
};
|
||||
var process_default = _process;
|
||||
|
||||
// ../node_modules/wrangler/_virtual_unenv_global_polyfill-@cloudflare-unenv-preset-node-process
|
||||
globalThis.process = process_default;
|
||||
|
||||
// _worker.js/index.js
|
||||
import { r as renderers } from "./chunks/_@astro-renderers_DRvbqMGm.mjs";
|
||||
import { c as createExports, s as serverEntrypointModule } from "./chunks/_@astrojs-ssr-adapter_Cwlmv2LC.mjs";
|
||||
import { manifest } from "./manifest_BXEvGqaV.mjs";
|
||||
globalThis.process ??= {};
|
||||
globalThis.process.env ??= {};
|
||||
var serverIslandMap = /* @__PURE__ */ new Map();
|
||||
var _page0 = /* @__PURE__ */ __name(() => import("./pages/404.astro.mjs"), "_page0");
|
||||
var _page1 = /* @__PURE__ */ __name(() => import("./pages/blog/category/_category_.astro.mjs"), "_page1");
|
||||
var _page2 = /* @__PURE__ */ __name(() => import("./pages/blog/tag/_tag_.astro.mjs"), "_page2");
|
||||
var _page3 = /* @__PURE__ */ __name(() => import("./pages/blog.astro.mjs"), "_page3");
|
||||
var _page4 = /* @__PURE__ */ __name(() => import("./pages/blog/_---slug_.astro.mjs"), "_page4");
|
||||
var _page5 = /* @__PURE__ */ __name(() => import("./pages/llms-full.txt.astro.mjs"), "_page5");
|
||||
var _page6 = /* @__PURE__ */ __name(() => import("./pages/llms.txt.astro.mjs"), "_page6");
|
||||
var _page7 = /* @__PURE__ */ __name(() => import("./pages/privacy.astro.mjs"), "_page7");
|
||||
var _page8 = /* @__PURE__ */ __name(() => import("./pages/rss.xml.astro.mjs"), "_page8");
|
||||
var _page9 = /* @__PURE__ */ __name(() => import("./pages/terms.astro.mjs"), "_page9");
|
||||
var _page10 = /* @__PURE__ */ __name(() => import("./pages/wizard.astro.mjs"), "_page10");
|
||||
var _page11 = /* @__PURE__ */ __name(() => import("./pages/index.astro.mjs"), "_page11");
|
||||
var pageMap = /* @__PURE__ */ new Map([
|
||||
["src/pages/404.astro", _page0],
|
||||
["src/pages/blog/category/[category].astro", _page1],
|
||||
["src/pages/blog/tag/[tag].astro", _page2],
|
||||
["src/pages/blog/index.astro", _page3],
|
||||
["src/pages/blog/[...slug].astro", _page4],
|
||||
["src/pages/llms-full.txt.ts", _page5],
|
||||
["src/pages/llms.txt.ts", _page6],
|
||||
["src/pages/privacy.astro", _page7],
|
||||
["src/pages/rss.xml.ts", _page8],
|
||||
["src/pages/terms.astro", _page9],
|
||||
["src/pages/wizard.astro", _page10],
|
||||
["src/pages/index.astro", _page11]
|
||||
]);
|
||||
var _manifest = Object.assign(manifest, {
|
||||
pageMap,
|
||||
serverIslandMap,
|
||||
renderers,
|
||||
actions: /* @__PURE__ */ __name(() => import("./noop-entrypoint.mjs"), "actions"),
|
||||
middleware: /* @__PURE__ */ __name(() => import("./_astro-internal_middleware.mjs"), "middleware")
|
||||
});
|
||||
var _args = void 0;
|
||||
var _exports = createExports(_manifest);
|
||||
var __astrojsSsrVirtualEntry = _exports.default;
|
||||
var _start = "start";
|
||||
if (Object.prototype.hasOwnProperty.call(serverEntrypointModule, _start)) {
|
||||
serverEntrypointModule[_start](_manifest, _args);
|
||||
}
|
||||
export {
|
||||
__astrojsSsrVirtualEntry as default,
|
||||
pageMap
|
||||
};
|
||||
//# sourceMappingURL=bundledWorker-0.1872957852973749.mjs.map
|
||||
File diff suppressed because one or more lines are too long
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@ -1 +0,0 @@
|
||||
// Contents removed by Astro as it's used for prerendering only
|
||||
@ -1 +0,0 @@
|
||||
// Contents removed by Astro as it's used for prerendering only
|
||||
File diff suppressed because one or more lines are too long
File diff suppressed because it is too large
Load Diff
@ -1,107 +0,0 @@
|
||||
globalThis.process ??= {}; globalThis.process.env ??= {};
|
||||
function defineDriver(factory) {
|
||||
return factory;
|
||||
}
|
||||
function normalizeKey(key, sep = ":") {
|
||||
if (!key) {
|
||||
return "";
|
||||
}
|
||||
return key.replace(/[:/\\]/g, sep).replace(/^[:/\\]|[:/\\]$/g, "");
|
||||
}
|
||||
function joinKeys(...keys) {
|
||||
return keys.map((key) => normalizeKey(key)).filter(Boolean).join(":");
|
||||
}
|
||||
function createError(driver, message, opts) {
|
||||
const err = new Error(`[unstorage] [${driver}] ${message}`, opts);
|
||||
if (Error.captureStackTrace) {
|
||||
Error.captureStackTrace(err, createError);
|
||||
}
|
||||
return err;
|
||||
}
|
||||
|
||||
function getBinding(binding) {
|
||||
let bindingName = "[binding]";
|
||||
if (typeof binding === "string") {
|
||||
bindingName = binding;
|
||||
binding = globalThis[bindingName] || globalThis.__env__?.[bindingName];
|
||||
}
|
||||
if (!binding) {
|
||||
throw createError(
|
||||
"cloudflare",
|
||||
`Invalid binding \`${bindingName}\`: \`${binding}\``
|
||||
);
|
||||
}
|
||||
for (const key of ["get", "put", "delete"]) {
|
||||
if (!(key in binding)) {
|
||||
throw createError(
|
||||
"cloudflare",
|
||||
`Invalid binding \`${bindingName}\`: \`${key}\` key is missing`
|
||||
);
|
||||
}
|
||||
}
|
||||
return binding;
|
||||
}
|
||||
function getKVBinding(binding = "STORAGE") {
|
||||
return getBinding(binding);
|
||||
}
|
||||
|
||||
const DRIVER_NAME = "cloudflare-kv-binding";
|
||||
const cloudflareKvBinding = defineDriver((opts) => {
|
||||
const r = (key = "") => opts.base ? joinKeys(opts.base, key) : key;
|
||||
async function getKeys(base = "") {
|
||||
base = r(base);
|
||||
const binding = getKVBinding(opts.binding);
|
||||
const keys = [];
|
||||
let cursor = void 0;
|
||||
do {
|
||||
const kvList = await binding.list({ prefix: base || void 0, cursor });
|
||||
keys.push(...kvList.keys);
|
||||
cursor = kvList.list_complete ? void 0 : kvList.cursor;
|
||||
} while (cursor);
|
||||
return keys.map((key) => key.name);
|
||||
}
|
||||
return {
|
||||
name: DRIVER_NAME,
|
||||
options: opts,
|
||||
getInstance: () => getKVBinding(opts.binding),
|
||||
async hasItem(key) {
|
||||
key = r(key);
|
||||
const binding = getKVBinding(opts.binding);
|
||||
return await binding.get(key) !== null;
|
||||
},
|
||||
getItem(key) {
|
||||
key = r(key);
|
||||
const binding = getKVBinding(opts.binding);
|
||||
return binding.get(key);
|
||||
},
|
||||
setItem(key, value, topts) {
|
||||
key = r(key);
|
||||
const binding = getKVBinding(opts.binding);
|
||||
return binding.put(
|
||||
key,
|
||||
value,
|
||||
topts ? {
|
||||
expirationTtl: topts?.ttl ? Math.max(topts.ttl, opts.minTTL ?? 60) : void 0,
|
||||
...topts
|
||||
} : void 0
|
||||
);
|
||||
},
|
||||
removeItem(key) {
|
||||
key = r(key);
|
||||
const binding = getKVBinding(opts.binding);
|
||||
return binding.delete(key);
|
||||
},
|
||||
getKeys(base) {
|
||||
return getKeys(base).then(
|
||||
(keys) => keys.map((key) => opts.base ? key.slice(opts.base.length) : key)
|
||||
);
|
||||
},
|
||||
async clear(base) {
|
||||
const binding = getKVBinding(opts.binding);
|
||||
const keys = await getKeys(base);
|
||||
await Promise.all(keys.map((key) => binding.delete(key)));
|
||||
}
|
||||
};
|
||||
});
|
||||
|
||||
export { cloudflareKvBinding as default };
|
||||
@ -1 +0,0 @@
|
||||
// Contents removed by Astro as it's used for prerendering only
|
||||
@ -1 +0,0 @@
|
||||
// Contents removed by Astro as it's used for prerendering only
|
||||
@ -1 +0,0 @@
|
||||
// Contents removed by Astro as it's used for prerendering only
|
||||
@ -1 +0,0 @@
|
||||
// Contents removed by Astro as it's used for prerendering only
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,10 +0,0 @@
|
||||
globalThis.process ??= {}; globalThis.process.env ??= {};
|
||||
import { aq as NOOP_MIDDLEWARE_HEADER } from './astro/server_B3mZj6if.mjs';
|
||||
|
||||
const NOOP_MIDDLEWARE_FN = async (_ctx, next) => {
|
||||
const response = await next();
|
||||
response.headers.set(NOOP_MIDDLEWARE_HEADER, "true");
|
||||
return response;
|
||||
};
|
||||
|
||||
export { NOOP_MIDDLEWARE_FN as N };
|
||||
@ -1,357 +0,0 @@
|
||||
globalThis.process ??= {}; globalThis.process.env ??= {};
|
||||
/**
|
||||
* Base64 Encodes an arraybuffer
|
||||
* @param {ArrayBuffer} arraybuffer
|
||||
* @returns {string}
|
||||
*/
|
||||
function encode64(arraybuffer) {
|
||||
const dv = new DataView(arraybuffer);
|
||||
let binaryString = "";
|
||||
|
||||
for (let i = 0; i < arraybuffer.byteLength; i++) {
|
||||
binaryString += String.fromCharCode(dv.getUint8(i));
|
||||
}
|
||||
|
||||
return binaryToAscii(binaryString);
|
||||
}
|
||||
|
||||
/**
|
||||
* Decodes a base64 string into an arraybuffer
|
||||
* @param {string} string
|
||||
* @returns {ArrayBuffer}
|
||||
*/
|
||||
function decode64(string) {
|
||||
const binaryString = asciiToBinary(string);
|
||||
const arraybuffer = new ArrayBuffer(binaryString.length);
|
||||
const dv = new DataView(arraybuffer);
|
||||
|
||||
for (let i = 0; i < arraybuffer.byteLength; i++) {
|
||||
dv.setUint8(i, binaryString.charCodeAt(i));
|
||||
}
|
||||
|
||||
return arraybuffer;
|
||||
}
|
||||
|
||||
const KEY_STRING =
|
||||
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
||||
|
||||
/**
|
||||
* Substitute for atob since it's deprecated in node.
|
||||
* Does not do any input validation.
|
||||
*
|
||||
* @see https://github.com/jsdom/abab/blob/master/lib/atob.js
|
||||
*
|
||||
* @param {string} data
|
||||
* @returns {string}
|
||||
*/
|
||||
function asciiToBinary(data) {
|
||||
if (data.length % 4 === 0) {
|
||||
data = data.replace(/==?$/, "");
|
||||
}
|
||||
|
||||
let output = "";
|
||||
let buffer = 0;
|
||||
let accumulatedBits = 0;
|
||||
|
||||
for (let i = 0; i < data.length; i++) {
|
||||
buffer <<= 6;
|
||||
buffer |= KEY_STRING.indexOf(data[i]);
|
||||
accumulatedBits += 6;
|
||||
if (accumulatedBits === 24) {
|
||||
output += String.fromCharCode((buffer & 0xff0000) >> 16);
|
||||
output += String.fromCharCode((buffer & 0xff00) >> 8);
|
||||
output += String.fromCharCode(buffer & 0xff);
|
||||
buffer = accumulatedBits = 0;
|
||||
}
|
||||
}
|
||||
if (accumulatedBits === 12) {
|
||||
buffer >>= 4;
|
||||
output += String.fromCharCode(buffer);
|
||||
} else if (accumulatedBits === 18) {
|
||||
buffer >>= 2;
|
||||
output += String.fromCharCode((buffer & 0xff00) >> 8);
|
||||
output += String.fromCharCode(buffer & 0xff);
|
||||
}
|
||||
return output;
|
||||
}
|
||||
|
||||
/**
|
||||
* Substitute for btoa since it's deprecated in node.
|
||||
* Does not do any input validation.
|
||||
*
|
||||
* @see https://github.com/jsdom/abab/blob/master/lib/btoa.js
|
||||
*
|
||||
* @param {string} str
|
||||
* @returns {string}
|
||||
*/
|
||||
function binaryToAscii(str) {
|
||||
let out = "";
|
||||
for (let i = 0; i < str.length; i += 3) {
|
||||
/** @type {[number, number, number, number]} */
|
||||
const groupsOfSix = [undefined, undefined, undefined, undefined];
|
||||
groupsOfSix[0] = str.charCodeAt(i) >> 2;
|
||||
groupsOfSix[1] = (str.charCodeAt(i) & 0x03) << 4;
|
||||
if (str.length > i + 1) {
|
||||
groupsOfSix[1] |= str.charCodeAt(i + 1) >> 4;
|
||||
groupsOfSix[2] = (str.charCodeAt(i + 1) & 0x0f) << 2;
|
||||
}
|
||||
if (str.length > i + 2) {
|
||||
groupsOfSix[2] |= str.charCodeAt(i + 2) >> 6;
|
||||
groupsOfSix[3] = str.charCodeAt(i + 2) & 0x3f;
|
||||
}
|
||||
for (let j = 0; j < groupsOfSix.length; j++) {
|
||||
if (typeof groupsOfSix[j] === "undefined") {
|
||||
out += "=";
|
||||
} else {
|
||||
out += KEY_STRING[groupsOfSix[j]];
|
||||
}
|
||||
}
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
const UNDEFINED = -1;
|
||||
const HOLE = -2;
|
||||
const NAN = -3;
|
||||
const POSITIVE_INFINITY = -4;
|
||||
const NEGATIVE_INFINITY = -5;
|
||||
const NEGATIVE_ZERO = -6;
|
||||
const SPARSE = -7;
|
||||
|
||||
/**
|
||||
* Revive a value serialized with `devalue.stringify`
|
||||
* @param {string} serialized
|
||||
* @param {Record<string, (value: any) => any>} [revivers]
|
||||
*/
|
||||
function parse(serialized, revivers) {
|
||||
return unflatten(JSON.parse(serialized), revivers);
|
||||
}
|
||||
|
||||
/**
|
||||
* Revive a value flattened with `devalue.stringify`
|
||||
* @param {number | any[]} parsed
|
||||
* @param {Record<string, (value: any) => any>} [revivers]
|
||||
*/
|
||||
function unflatten(parsed, revivers) {
|
||||
if (typeof parsed === 'number') return hydrate(parsed, true);
|
||||
|
||||
if (!Array.isArray(parsed) || parsed.length === 0) {
|
||||
throw new Error('Invalid input');
|
||||
}
|
||||
|
||||
const values = /** @type {any[]} */ (parsed);
|
||||
|
||||
const hydrated = Array(values.length);
|
||||
|
||||
/**
|
||||
* A set of values currently being hydrated with custom revivers,
|
||||
* used to detect invalid cyclical dependencies
|
||||
* @type {Set<number> | null}
|
||||
*/
|
||||
let hydrating = null;
|
||||
|
||||
/**
|
||||
* @param {number} index
|
||||
* @returns {any}
|
||||
*/
|
||||
function hydrate(index, standalone = false) {
|
||||
if (index === UNDEFINED) return undefined;
|
||||
if (index === NAN) return NaN;
|
||||
if (index === POSITIVE_INFINITY) return Infinity;
|
||||
if (index === NEGATIVE_INFINITY) return -Infinity;
|
||||
if (index === NEGATIVE_ZERO) return -0;
|
||||
|
||||
if (standalone || typeof index !== 'number') {
|
||||
throw new Error(`Invalid input`);
|
||||
}
|
||||
|
||||
if (index in hydrated) return hydrated[index];
|
||||
|
||||
const value = values[index];
|
||||
|
||||
if (!value || typeof value !== 'object') {
|
||||
hydrated[index] = value;
|
||||
} else if (Array.isArray(value)) {
|
||||
if (typeof value[0] === 'string') {
|
||||
const type = value[0];
|
||||
|
||||
const reviver =
|
||||
revivers && Object.hasOwn(revivers, type)
|
||||
? revivers[type]
|
||||
: undefined;
|
||||
|
||||
if (reviver) {
|
||||
let i = value[1];
|
||||
if (typeof i !== 'number') {
|
||||
// if it's not a number, it was serialized by a builtin reviver
|
||||
// so we need to munge it into the format expected by a custom reviver
|
||||
i = values.push(value[1]) - 1;
|
||||
}
|
||||
|
||||
hydrating ??= new Set();
|
||||
|
||||
if (hydrating.has(i)) {
|
||||
throw new Error('Invalid circular reference');
|
||||
}
|
||||
|
||||
hydrating.add(i);
|
||||
hydrated[index] = reviver(hydrate(i));
|
||||
hydrating.delete(i);
|
||||
|
||||
return hydrated[index];
|
||||
}
|
||||
|
||||
switch (type) {
|
||||
case 'Date':
|
||||
hydrated[index] = new Date(value[1]);
|
||||
break;
|
||||
|
||||
case 'Set':
|
||||
const set = new Set();
|
||||
hydrated[index] = set;
|
||||
for (let i = 1; i < value.length; i += 1) {
|
||||
set.add(hydrate(value[i]));
|
||||
}
|
||||
break;
|
||||
|
||||
case 'Map':
|
||||
const map = new Map();
|
||||
hydrated[index] = map;
|
||||
for (let i = 1; i < value.length; i += 2) {
|
||||
map.set(hydrate(value[i]), hydrate(value[i + 1]));
|
||||
}
|
||||
break;
|
||||
|
||||
case 'RegExp':
|
||||
hydrated[index] = new RegExp(value[1], value[2]);
|
||||
break;
|
||||
|
||||
case 'Object':
|
||||
hydrated[index] = Object(value[1]);
|
||||
break;
|
||||
|
||||
case 'BigInt':
|
||||
hydrated[index] = BigInt(value[1]);
|
||||
break;
|
||||
|
||||
case 'null':
|
||||
const obj = Object.create(null);
|
||||
hydrated[index] = obj;
|
||||
for (let i = 1; i < value.length; i += 2) {
|
||||
obj[value[i]] = hydrate(value[i + 1]);
|
||||
}
|
||||
break;
|
||||
|
||||
case 'Int8Array':
|
||||
case 'Uint8Array':
|
||||
case 'Uint8ClampedArray':
|
||||
case 'Int16Array':
|
||||
case 'Uint16Array':
|
||||
case 'Int32Array':
|
||||
case 'Uint32Array':
|
||||
case 'Float32Array':
|
||||
case 'Float64Array':
|
||||
case 'BigInt64Array':
|
||||
case 'BigUint64Array': {
|
||||
if (values[value[1]][0] !== 'ArrayBuffer') {
|
||||
// without this, if we receive malformed input we could
|
||||
// end up trying to hydrate in a circle or allocate
|
||||
// huge amounts of memory when we call `new TypedArrayConstructor(buffer)`
|
||||
throw new Error('Invalid data');
|
||||
}
|
||||
|
||||
const TypedArrayConstructor = globalThis[type];
|
||||
const buffer = hydrate(value[1]);
|
||||
const typedArray = new TypedArrayConstructor(buffer);
|
||||
|
||||
hydrated[index] =
|
||||
value[2] !== undefined
|
||||
? typedArray.subarray(value[2], value[3])
|
||||
: typedArray;
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
case 'ArrayBuffer': {
|
||||
const base64 = value[1];
|
||||
if (typeof base64 !== 'string') {
|
||||
throw new Error('Invalid ArrayBuffer encoding');
|
||||
}
|
||||
const arraybuffer = decode64(base64);
|
||||
hydrated[index] = arraybuffer;
|
||||
break;
|
||||
}
|
||||
|
||||
case 'Temporal.Duration':
|
||||
case 'Temporal.Instant':
|
||||
case 'Temporal.PlainDate':
|
||||
case 'Temporal.PlainTime':
|
||||
case 'Temporal.PlainDateTime':
|
||||
case 'Temporal.PlainMonthDay':
|
||||
case 'Temporal.PlainYearMonth':
|
||||
case 'Temporal.ZonedDateTime': {
|
||||
const temporalName = type.slice(9);
|
||||
// @ts-expect-error TS doesn't know about Temporal yet
|
||||
hydrated[index] = Temporal[temporalName].from(value[1]);
|
||||
break;
|
||||
}
|
||||
|
||||
case 'URL': {
|
||||
const url = new URL(value[1]);
|
||||
hydrated[index] = url;
|
||||
break;
|
||||
}
|
||||
|
||||
case 'URLSearchParams': {
|
||||
const url = new URLSearchParams(value[1]);
|
||||
hydrated[index] = url;
|
||||
break;
|
||||
}
|
||||
|
||||
default:
|
||||
throw new Error(`Unknown type ${type}`);
|
||||
}
|
||||
} else if (value[0] === SPARSE) {
|
||||
// Sparse array encoding: [SPARSE, length, idx, val, idx, val, ...]
|
||||
const len = value[1];
|
||||
|
||||
const array = new Array(len);
|
||||
hydrated[index] = array;
|
||||
|
||||
for (let i = 2; i < value.length; i += 2) {
|
||||
const idx = value[i];
|
||||
array[idx] = hydrate(value[i + 1]);
|
||||
}
|
||||
} else {
|
||||
const array = new Array(value.length);
|
||||
hydrated[index] = array;
|
||||
|
||||
for (let i = 0; i < value.length; i += 1) {
|
||||
const n = value[i];
|
||||
if (n === HOLE) continue;
|
||||
|
||||
array[i] = hydrate(n);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
/** @type {Record<string, any>} */
|
||||
const object = {};
|
||||
hydrated[index] = object;
|
||||
|
||||
for (const key of Object.keys(value)) {
|
||||
if (key === '__proto__') {
|
||||
throw new Error('Cannot parse an object with a `__proto__` property');
|
||||
}
|
||||
|
||||
const n = value[key];
|
||||
object[key] = hydrate(n);
|
||||
}
|
||||
}
|
||||
|
||||
return hydrated[index];
|
||||
}
|
||||
|
||||
return hydrate(0);
|
||||
}
|
||||
|
||||
export { HOLE as H, NAN as N, POSITIVE_INFINITY as P, SPARSE as S, UNDEFINED as U, NEGATIVE_INFINITY as a, NEGATIVE_ZERO as b, encode64 as e, parse as p, unflatten as u };
|
||||
@ -1,112 +0,0 @@
|
||||
globalThis.process ??= {}; globalThis.process.env ??= {};
|
||||
function appendForwardSlash(path) {
|
||||
return path.endsWith("/") ? path : path + "/";
|
||||
}
|
||||
function prependForwardSlash(path) {
|
||||
return path[0] === "/" ? path : "/" + path;
|
||||
}
|
||||
const MANY_TRAILING_SLASHES = /\/{2,}$/g;
|
||||
function collapseDuplicateTrailingSlashes(path, trailingSlash) {
|
||||
if (!path) {
|
||||
return path;
|
||||
}
|
||||
return path.replace(MANY_TRAILING_SLASHES, trailingSlash ? "/" : "") || "/";
|
||||
}
|
||||
function removeTrailingForwardSlash(path) {
|
||||
return path.endsWith("/") ? path.slice(0, path.length - 1) : path;
|
||||
}
|
||||
function removeLeadingForwardSlash(path) {
|
||||
return path.startsWith("/") ? path.substring(1) : path;
|
||||
}
|
||||
function trimSlashes(path) {
|
||||
return path.replace(/^\/|\/$/g, "");
|
||||
}
|
||||
function isString(path) {
|
||||
return typeof path === "string" || path instanceof String;
|
||||
}
|
||||
const INTERNAL_PREFIXES = /* @__PURE__ */ new Set(["/_", "/@", "/.", "//"]);
|
||||
const JUST_SLASHES = /^\/{2,}$/;
|
||||
function isInternalPath(path) {
|
||||
return INTERNAL_PREFIXES.has(path.slice(0, 2)) && !JUST_SLASHES.test(path);
|
||||
}
|
||||
function joinPaths(...paths) {
|
||||
return paths.filter(isString).map((path, i) => {
|
||||
if (i === 0) {
|
||||
return removeTrailingForwardSlash(path);
|
||||
} else if (i === paths.length - 1) {
|
||||
return removeLeadingForwardSlash(path);
|
||||
} else {
|
||||
return trimSlashes(path);
|
||||
}
|
||||
}).join("/");
|
||||
}
|
||||
function isRemotePath(src) {
|
||||
if (!src) return false;
|
||||
const trimmed = src.trim();
|
||||
if (!trimmed) return false;
|
||||
let decoded = trimmed;
|
||||
let previousDecoded = "";
|
||||
let maxIterations = 10;
|
||||
while (decoded !== previousDecoded && maxIterations > 0) {
|
||||
previousDecoded = decoded;
|
||||
try {
|
||||
decoded = decodeURIComponent(decoded);
|
||||
} catch {
|
||||
break;
|
||||
}
|
||||
maxIterations--;
|
||||
}
|
||||
if (/^[a-zA-Z]:/.test(decoded)) {
|
||||
return false;
|
||||
}
|
||||
if (decoded[0] === "/" && decoded[1] !== "/" && decoded[1] !== "\\") {
|
||||
return false;
|
||||
}
|
||||
if (decoded[0] === "\\") {
|
||||
return true;
|
||||
}
|
||||
if (decoded.startsWith("//")) {
|
||||
return true;
|
||||
}
|
||||
try {
|
||||
const url = new URL(decoded, "http://n");
|
||||
if (url.username || url.password) {
|
||||
return true;
|
||||
}
|
||||
if (decoded.includes("@") && !url.pathname.includes("@") && !url.search.includes("@")) {
|
||||
return true;
|
||||
}
|
||||
if (url.origin !== "http://n") {
|
||||
const protocol = url.protocol.toLowerCase();
|
||||
if (protocol === "file:") {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
if (URL.canParse(decoded)) {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
} catch {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
function slash(path) {
|
||||
return path.replace(/\\/g, "/");
|
||||
}
|
||||
function fileExtension(path) {
|
||||
const ext = path.split(".").pop();
|
||||
return ext !== path ? `.${ext}` : "";
|
||||
}
|
||||
function removeBase(path, base) {
|
||||
if (path.startsWith(base)) {
|
||||
return path.slice(removeTrailingForwardSlash(base).length);
|
||||
}
|
||||
return path;
|
||||
}
|
||||
const WITH_FILE_EXT = /\/[^/]+\.\w+$/;
|
||||
function hasFileExtension(path) {
|
||||
return WITH_FILE_EXT.test(path);
|
||||
}
|
||||
|
||||
export { removeTrailingForwardSlash as a, appendForwardSlash as b, isInternalPath as c, collapseDuplicateTrailingSlashes as d, fileExtension as f, hasFileExtension as h, isRemotePath as i, joinPaths as j, prependForwardSlash as p, removeBase as r, slash as s, trimSlashes as t };
|
||||
@ -1,58 +0,0 @@
|
||||
globalThis.process ??= {}; globalThis.process.env ??= {};
|
||||
function matchPattern(url, remotePattern) {
|
||||
return matchProtocol(url, remotePattern.protocol) && matchHostname(url, remotePattern.hostname, true) && matchPort(url, remotePattern.port) && matchPathname(url, remotePattern.pathname, true);
|
||||
}
|
||||
function matchPort(url, port) {
|
||||
return !port || port === url.port;
|
||||
}
|
||||
function matchProtocol(url, protocol) {
|
||||
return !protocol || protocol === url.protocol.slice(0, -1);
|
||||
}
|
||||
function matchHostname(url, hostname, allowWildcard = false) {
|
||||
if (!hostname) {
|
||||
return true;
|
||||
} else if (!allowWildcard || !hostname.startsWith("*")) {
|
||||
return hostname === url.hostname;
|
||||
} else if (hostname.startsWith("**.")) {
|
||||
const slicedHostname = hostname.slice(2);
|
||||
return slicedHostname !== url.hostname && url.hostname.endsWith(slicedHostname);
|
||||
} else if (hostname.startsWith("*.")) {
|
||||
const slicedHostname = hostname.slice(1);
|
||||
if (!url.hostname.endsWith(slicedHostname)) {
|
||||
return false;
|
||||
}
|
||||
const subdomainWithDot = url.hostname.slice(0, -(slicedHostname.length - 1));
|
||||
return subdomainWithDot.endsWith(".") && !subdomainWithDot.slice(0, -1).includes(".");
|
||||
}
|
||||
return false;
|
||||
}
|
||||
function matchPathname(url, pathname, allowWildcard = false) {
|
||||
if (!pathname) {
|
||||
return true;
|
||||
} else if (!allowWildcard || !pathname.endsWith("*")) {
|
||||
return pathname === url.pathname;
|
||||
} else if (pathname.endsWith("/**")) {
|
||||
const slicedPathname = pathname.slice(0, -2);
|
||||
return slicedPathname !== url.pathname && url.pathname.startsWith(slicedPathname);
|
||||
} else if (pathname.endsWith("/*")) {
|
||||
const slicedPathname = pathname.slice(0, -1);
|
||||
const additionalPathChunks = url.pathname.replace(slicedPathname, "").split("/").filter(Boolean);
|
||||
return additionalPathChunks.length === 1;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
function isRemoteAllowed(src, {
|
||||
domains,
|
||||
remotePatterns
|
||||
}) {
|
||||
if (!URL.canParse(src)) {
|
||||
return false;
|
||||
}
|
||||
const url = new URL(src);
|
||||
if (!["http:", "https:", "data:"].includes(url.protocol)) {
|
||||
return false;
|
||||
}
|
||||
return domains.some((domain) => matchHostname(url, domain)) || remotePatterns.some((remotePattern) => matchPattern(url, remotePattern));
|
||||
}
|
||||
|
||||
export { isRemoteAllowed as i, matchPattern as m };
|
||||
@ -1 +0,0 @@
|
||||
// Contents removed by Astro as it's used for prerendering only
|
||||
File diff suppressed because one or more lines are too long
@ -1,4 +0,0 @@
|
||||
globalThis.process ??= {}; globalThis.process.env ??= {};
|
||||
const server = {};
|
||||
|
||||
export { server };
|
||||
@ -1 +0,0 @@
|
||||
// Contents removed by Astro as it's used for prerendering only
|
||||
@ -1 +0,0 @@
|
||||
// Contents removed by Astro as it's used for prerendering only
|
||||
@ -1 +0,0 @@
|
||||
// Contents removed by Astro as it's used for prerendering only
|
||||
@ -1 +0,0 @@
|
||||
// Contents removed by Astro as it's used for prerendering only
|
||||
@ -1 +0,0 @@
|
||||
// Contents removed by Astro as it's used for prerendering only
|
||||
@ -1 +0,0 @@
|
||||
// Contents removed by Astro as it's used for prerendering only
|
||||
@ -1 +0,0 @@
|
||||
// Contents removed by Astro as it's used for prerendering only
|
||||
@ -1 +0,0 @@
|
||||
// Contents removed by Astro as it's used for prerendering only
|
||||
@ -1 +0,0 @@
|
||||
// Contents removed by Astro as it's used for prerendering only
|
||||
@ -1 +0,0 @@
|
||||
// Contents removed by Astro as it's used for prerendering only
|
||||
@ -1 +0,0 @@
|
||||
// Contents removed by Astro as it's used for prerendering only
|
||||
@ -1 +0,0 @@
|
||||
// Contents removed by Astro as it's used for prerendering only
|
||||
@ -1,2 +0,0 @@
|
||||
globalThis.process ??= {}; globalThis.process.env ??= {};
|
||||
export { r as renderers } from './chunks/_@astro-renderers_DRvbqMGm.mjs';
|
||||
Binary file not shown.
Binary file not shown.
Loading…
x
Reference in New Issue
Block a user