root
7448 lines
268 KiB
JavaScript
7448 lines
268 KiB
JavaScript
module.exports = [
|
||
"[externals]/@prisma/client [external] (@prisma/client, cjs, [project]/node_modules/@prisma/client)", ((__turbopack_context__, module, exports) => {
|
||
|
||
const mod = __turbopack_context__.x("@prisma/client-2c3a283f134fdcb6", () => require("@prisma/client-2c3a283f134fdcb6"));
|
||
|
||
module.exports = mod;
|
||
}),
|
||
"[project]/node_modules/@prisma/debug/dist/index.mjs [app-route] (ecmascript)", ((__turbopack_context__) => {
|
||
"use strict";
|
||
|
||
__turbopack_context__.s([
|
||
"Debug",
|
||
()=>Debug,
|
||
"clearLogs",
|
||
()=>clearLogs,
|
||
"default",
|
||
()=>index_default,
|
||
"getLogs",
|
||
()=>getLogs
|
||
]);
|
||
var __defProp = Object.defineProperty;
|
||
var __export = (target, all)=>{
|
||
for(var name in all)__defProp(target, name, {
|
||
get: all[name],
|
||
enumerable: true
|
||
});
|
||
};
|
||
// ../../node_modules/.pnpm/kleur@4.1.5/node_modules/kleur/colors.mjs
|
||
var colors_exports = {};
|
||
__export(colors_exports, {
|
||
$: ()=>$,
|
||
bgBlack: ()=>bgBlack,
|
||
bgBlue: ()=>bgBlue,
|
||
bgCyan: ()=>bgCyan,
|
||
bgGreen: ()=>bgGreen,
|
||
bgMagenta: ()=>bgMagenta,
|
||
bgRed: ()=>bgRed,
|
||
bgWhite: ()=>bgWhite,
|
||
bgYellow: ()=>bgYellow,
|
||
black: ()=>black,
|
||
blue: ()=>blue,
|
||
bold: ()=>bold,
|
||
cyan: ()=>cyan,
|
||
dim: ()=>dim,
|
||
gray: ()=>gray,
|
||
green: ()=>green,
|
||
grey: ()=>grey,
|
||
hidden: ()=>hidden,
|
||
inverse: ()=>inverse,
|
||
italic: ()=>italic,
|
||
magenta: ()=>magenta,
|
||
red: ()=>red,
|
||
reset: ()=>reset,
|
||
strikethrough: ()=>strikethrough,
|
||
underline: ()=>underline,
|
||
white: ()=>white,
|
||
yellow: ()=>yellow
|
||
});
|
||
var FORCE_COLOR;
|
||
var NODE_DISABLE_COLORS;
|
||
var NO_COLOR;
|
||
var TERM;
|
||
var isTTY = true;
|
||
if (typeof process !== "undefined") {
|
||
({ FORCE_COLOR, NODE_DISABLE_COLORS, NO_COLOR, TERM } = process.env || {});
|
||
isTTY = process.stdout && process.stdout.isTTY;
|
||
}
|
||
var $ = {
|
||
enabled: !NODE_DISABLE_COLORS && NO_COLOR == null && TERM !== "dumb" && (FORCE_COLOR != null && FORCE_COLOR !== "0" || isTTY)
|
||
};
|
||
function init(x, y) {
|
||
let rgx = new RegExp(`\\x1b\\[${y}m`, "g");
|
||
let open = `\x1B[${x}m`, close = `\x1B[${y}m`;
|
||
return function(txt) {
|
||
if (!$.enabled || txt == null) return txt;
|
||
return open + (!!~("" + txt).indexOf(close) ? txt.replace(rgx, close + open) : txt) + close;
|
||
};
|
||
}
|
||
var reset = init(0, 0);
|
||
var bold = init(1, 22);
|
||
var dim = init(2, 22);
|
||
var italic = init(3, 23);
|
||
var underline = init(4, 24);
|
||
var inverse = init(7, 27);
|
||
var hidden = init(8, 28);
|
||
var strikethrough = init(9, 29);
|
||
var black = init(30, 39);
|
||
var red = init(31, 39);
|
||
var green = init(32, 39);
|
||
var yellow = init(33, 39);
|
||
var blue = init(34, 39);
|
||
var magenta = init(35, 39);
|
||
var cyan = init(36, 39);
|
||
var white = init(37, 39);
|
||
var gray = init(90, 39);
|
||
var grey = init(90, 39);
|
||
var bgBlack = init(40, 49);
|
||
var bgRed = init(41, 49);
|
||
var bgGreen = init(42, 49);
|
||
var bgYellow = init(43, 49);
|
||
var bgBlue = init(44, 49);
|
||
var bgMagenta = init(45, 49);
|
||
var bgCyan = init(46, 49);
|
||
var bgWhite = init(47, 49);
|
||
// src/index.ts
|
||
var MAX_ARGS_HISTORY = 100;
|
||
var COLORS = [
|
||
"green",
|
||
"yellow",
|
||
"blue",
|
||
"magenta",
|
||
"cyan",
|
||
"red"
|
||
];
|
||
var argsHistory = [];
|
||
var lastTimestamp = Date.now();
|
||
var lastColor = 0;
|
||
var processEnv = typeof process !== "undefined" ? process.env : {};
|
||
globalThis.DEBUG ??= processEnv.DEBUG ?? "";
|
||
globalThis.DEBUG_COLORS ??= processEnv.DEBUG_COLORS ? processEnv.DEBUG_COLORS === "true" : true;
|
||
var topProps = {
|
||
enable (namespace) {
|
||
if (typeof namespace === "string") {
|
||
globalThis.DEBUG = namespace;
|
||
}
|
||
},
|
||
disable () {
|
||
const prev = globalThis.DEBUG;
|
||
globalThis.DEBUG = "";
|
||
return prev;
|
||
},
|
||
// this is the core logic to check if logging should happen or not
|
||
enabled (namespace) {
|
||
const listenedNamespaces = globalThis.DEBUG.split(",").map((s)=>{
|
||
return s.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
|
||
});
|
||
const isListened = listenedNamespaces.some((listenedNamespace)=>{
|
||
if (listenedNamespace === "" || listenedNamespace[0] === "-") return false;
|
||
return namespace.match(RegExp(listenedNamespace.split("*").join(".*") + "$"));
|
||
});
|
||
const isExcluded = listenedNamespaces.some((listenedNamespace)=>{
|
||
if (listenedNamespace === "" || listenedNamespace[0] !== "-") return false;
|
||
return namespace.match(RegExp(listenedNamespace.slice(1).split("*").join(".*") + "$"));
|
||
});
|
||
return isListened && !isExcluded;
|
||
},
|
||
log: (...args)=>{
|
||
const [namespace, format, ...rest] = args;
|
||
const logWithFormatting = console.warn ?? console.log;
|
||
logWithFormatting(`${namespace} ${format}`, ...rest);
|
||
},
|
||
formatters: {}
|
||
};
|
||
function debugCreate(namespace) {
|
||
const instanceProps = {
|
||
color: COLORS[lastColor++ % COLORS.length],
|
||
enabled: topProps.enabled(namespace),
|
||
namespace,
|
||
log: topProps.log,
|
||
extend: ()=>{}
|
||
};
|
||
const debugCall = (...args)=>{
|
||
const { enabled, namespace: namespace2, color, log } = instanceProps;
|
||
if (args.length !== 0) {
|
||
argsHistory.push([
|
||
namespace2,
|
||
...args
|
||
]);
|
||
}
|
||
if (argsHistory.length > MAX_ARGS_HISTORY) {
|
||
argsHistory.shift();
|
||
}
|
||
if (topProps.enabled(namespace2) || enabled) {
|
||
const stringArgs = args.map((arg)=>{
|
||
if (typeof arg === "string") {
|
||
return arg;
|
||
}
|
||
return safeStringify(arg);
|
||
});
|
||
const ms = `+${Date.now() - lastTimestamp}ms`;
|
||
lastTimestamp = Date.now();
|
||
if (globalThis.DEBUG_COLORS) {
|
||
log(colors_exports[color](bold(namespace2)), ...stringArgs, colors_exports[color](ms));
|
||
} else {
|
||
log(namespace2, ...stringArgs, ms);
|
||
}
|
||
}
|
||
};
|
||
return new Proxy(debugCall, {
|
||
get: (_, prop)=>instanceProps[prop],
|
||
set: (_, prop, value)=>instanceProps[prop] = value
|
||
});
|
||
}
|
||
var Debug = new Proxy(debugCreate, {
|
||
get: (_, prop)=>topProps[prop],
|
||
set: (_, prop, value)=>topProps[prop] = value
|
||
});
|
||
function safeStringify(value, indent = 2) {
|
||
const cache = /* @__PURE__ */ new Set();
|
||
return JSON.stringify(value, (key, value2)=>{
|
||
if (typeof value2 === "object" && value2 !== null) {
|
||
if (cache.has(value2)) {
|
||
return `[Circular *]`;
|
||
}
|
||
cache.add(value2);
|
||
} else if (typeof value2 === "bigint") {
|
||
return value2.toString();
|
||
}
|
||
return value2;
|
||
}, indent);
|
||
}
|
||
function getLogs(numChars = 7500) {
|
||
const logs = argsHistory.map(([namespace, ...args])=>{
|
||
return `${namespace} ${args.map((arg)=>{
|
||
if (typeof arg === "string") {
|
||
return arg;
|
||
} else {
|
||
return JSON.stringify(arg);
|
||
}
|
||
}).join(" ")}`;
|
||
}).join("\n");
|
||
if (logs.length < numChars) {
|
||
return logs;
|
||
}
|
||
return logs.slice(-numChars);
|
||
}
|
||
function clearLogs() {
|
||
argsHistory.length = 0;
|
||
}
|
||
var index_default = Debug;
|
||
;
|
||
}),
|
||
"[project]/node_modules/@prisma/driver-adapter-utils/dist/index.mjs [app-route] (ecmascript) <locals>", ((__turbopack_context__) => {
|
||
"use strict";
|
||
|
||
__turbopack_context__.s([
|
||
"ColumnTypeEnum",
|
||
()=>ColumnTypeEnum,
|
||
"DriverAdapterError",
|
||
()=>DriverAdapterError,
|
||
"bindAdapter",
|
||
()=>bindAdapter,
|
||
"bindMigrationAwareSqlAdapterFactory",
|
||
()=>bindMigrationAwareSqlAdapterFactory,
|
||
"bindSqlAdapterFactory",
|
||
()=>bindSqlAdapterFactory,
|
||
"err",
|
||
()=>err,
|
||
"isDriverAdapterError",
|
||
()=>isDriverAdapterError,
|
||
"mockAdapter",
|
||
()=>mockAdapter,
|
||
"mockAdapterErrors",
|
||
()=>mockAdapterErrors,
|
||
"mockAdapterFactory",
|
||
()=>mockAdapterFactory,
|
||
"mockMigrationAwareAdapterFactory",
|
||
()=>mockMigrationAwareAdapterFactory,
|
||
"ok",
|
||
()=>ok
|
||
]);
|
||
// src/debug.ts
|
||
var __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f40$prisma$2f$debug$2f$dist$2f$index$2e$mjs__$5b$app$2d$route$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[project]/node_modules/@prisma/debug/dist/index.mjs [app-route] (ecmascript)");
|
||
;
|
||
// src/error.ts
|
||
var DriverAdapterError = class extends Error {
|
||
name = "DriverAdapterError";
|
||
cause;
|
||
constructor(payload){
|
||
super(typeof payload["message"] === "string" ? payload["message"] : payload.kind);
|
||
this.cause = payload;
|
||
}
|
||
};
|
||
function isDriverAdapterError(error) {
|
||
return error["name"] === "DriverAdapterError" && typeof error["cause"] === "object";
|
||
}
|
||
// src/result.ts
|
||
function ok(value) {
|
||
return {
|
||
ok: true,
|
||
value,
|
||
map (fn) {
|
||
return ok(fn(value));
|
||
},
|
||
flatMap (fn) {
|
||
return fn(value);
|
||
}
|
||
};
|
||
}
|
||
function err(error) {
|
||
return {
|
||
ok: false,
|
||
error,
|
||
map () {
|
||
return err(error);
|
||
},
|
||
flatMap () {
|
||
return err(error);
|
||
}
|
||
};
|
||
}
|
||
// src/binder.ts
|
||
var debug = (0, __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f40$prisma$2f$debug$2f$dist$2f$index$2e$mjs__$5b$app$2d$route$5d$__$28$ecmascript$29$__["Debug"])("driver-adapter-utils");
|
||
var ErrorRegistryInternal = class {
|
||
registeredErrors = [];
|
||
consumeError(id) {
|
||
return this.registeredErrors[id];
|
||
}
|
||
registerNewError(error) {
|
||
let i = 0;
|
||
while(this.registeredErrors[i] !== void 0){
|
||
i++;
|
||
}
|
||
this.registeredErrors[i] = {
|
||
error
|
||
};
|
||
return i;
|
||
}
|
||
};
|
||
function copySymbolsFromSource(source, target) {
|
||
const symbols = Object.getOwnPropertySymbols(source);
|
||
const symbolObject = Object.fromEntries(symbols.map((symbol)=>[
|
||
symbol,
|
||
true
|
||
]));
|
||
Object.assign(target, symbolObject);
|
||
}
|
||
var bindMigrationAwareSqlAdapterFactory = (adapterFactory)=>{
|
||
const errorRegistry = new ErrorRegistryInternal();
|
||
const boundFactory = {
|
||
adapterName: adapterFactory.adapterName,
|
||
provider: adapterFactory.provider,
|
||
errorRegistry,
|
||
connect: async (...args)=>{
|
||
const ctx = await wrapAsync(errorRegistry, adapterFactory.connect.bind(adapterFactory))(...args);
|
||
return ctx.map((ctx2)=>bindAdapter(ctx2, errorRegistry));
|
||
},
|
||
connectToShadowDb: async (...args)=>{
|
||
const ctx = await wrapAsync(errorRegistry, adapterFactory.connectToShadowDb.bind(adapterFactory))(...args);
|
||
return ctx.map((ctx2)=>bindAdapter(ctx2, errorRegistry));
|
||
}
|
||
};
|
||
copySymbolsFromSource(adapterFactory, boundFactory);
|
||
return boundFactory;
|
||
};
|
||
var bindSqlAdapterFactory = (adapterFactory)=>{
|
||
const errorRegistry = new ErrorRegistryInternal();
|
||
const boundFactory = {
|
||
adapterName: adapterFactory.adapterName,
|
||
provider: adapterFactory.provider,
|
||
errorRegistry,
|
||
connect: async (...args)=>{
|
||
const ctx = await wrapAsync(errorRegistry, adapterFactory.connect.bind(adapterFactory))(...args);
|
||
return ctx.map((ctx2)=>bindAdapter(ctx2, errorRegistry));
|
||
}
|
||
};
|
||
copySymbolsFromSource(adapterFactory, boundFactory);
|
||
return boundFactory;
|
||
};
|
||
var bindAdapter = (adapter, errorRegistry = new ErrorRegistryInternal())=>{
|
||
const boundAdapter = {
|
||
adapterName: adapter.adapterName,
|
||
errorRegistry,
|
||
queryRaw: wrapAsync(errorRegistry, adapter.queryRaw.bind(adapter)),
|
||
executeRaw: wrapAsync(errorRegistry, adapter.executeRaw.bind(adapter)),
|
||
executeScript: wrapAsync(errorRegistry, adapter.executeScript.bind(adapter)),
|
||
dispose: wrapAsync(errorRegistry, adapter.dispose.bind(adapter)),
|
||
provider: adapter.provider,
|
||
startTransaction: async (...args)=>{
|
||
const ctx = await wrapAsync(errorRegistry, adapter.startTransaction.bind(adapter))(...args);
|
||
return ctx.map((ctx2)=>bindTransaction(errorRegistry, ctx2));
|
||
}
|
||
};
|
||
if (adapter.getConnectionInfo) {
|
||
boundAdapter.getConnectionInfo = wrapSync(errorRegistry, adapter.getConnectionInfo.bind(adapter));
|
||
}
|
||
return boundAdapter;
|
||
};
|
||
var bindTransaction = (errorRegistry, transaction)=>{
|
||
const boundTransaction = {
|
||
adapterName: transaction.adapterName,
|
||
provider: transaction.provider,
|
||
options: transaction.options,
|
||
queryRaw: wrapAsync(errorRegistry, transaction.queryRaw.bind(transaction)),
|
||
executeRaw: wrapAsync(errorRegistry, transaction.executeRaw.bind(transaction)),
|
||
commit: wrapAsync(errorRegistry, transaction.commit.bind(transaction)),
|
||
rollback: wrapAsync(errorRegistry, transaction.rollback.bind(transaction))
|
||
};
|
||
if (transaction.createSavepoint) {
|
||
boundTransaction.createSavepoint = wrapAsync(errorRegistry, transaction.createSavepoint.bind(transaction));
|
||
}
|
||
if (transaction.rollbackToSavepoint) {
|
||
boundTransaction.rollbackToSavepoint = wrapAsync(errorRegistry, transaction.rollbackToSavepoint.bind(transaction));
|
||
}
|
||
if (transaction.releaseSavepoint) {
|
||
boundTransaction.releaseSavepoint = wrapAsync(errorRegistry, transaction.releaseSavepoint.bind(transaction));
|
||
}
|
||
return boundTransaction;
|
||
};
|
||
function wrapAsync(registry, fn) {
|
||
return async (...args)=>{
|
||
try {
|
||
return ok(await fn(...args));
|
||
} catch (error) {
|
||
debug("[error@wrapAsync]", error);
|
||
if (isDriverAdapterError(error)) {
|
||
return err(error.cause);
|
||
}
|
||
const id = registry.registerNewError(error);
|
||
return err({
|
||
kind: "GenericJs",
|
||
id
|
||
});
|
||
}
|
||
};
|
||
}
|
||
function wrapSync(registry, fn) {
|
||
return (...args)=>{
|
||
try {
|
||
return ok(fn(...args));
|
||
} catch (error) {
|
||
debug("[error@wrapSync]", error);
|
||
if (isDriverAdapterError(error)) {
|
||
return err(error.cause);
|
||
}
|
||
const id = registry.registerNewError(error);
|
||
return err({
|
||
kind: "GenericJs",
|
||
id
|
||
});
|
||
}
|
||
};
|
||
}
|
||
// src/const.ts
|
||
var ColumnTypeEnum = {
|
||
// Scalars
|
||
Int32: 0,
|
||
Int64: 1,
|
||
Float: 2,
|
||
Double: 3,
|
||
Numeric: 4,
|
||
Boolean: 5,
|
||
Character: 6,
|
||
Text: 7,
|
||
Date: 8,
|
||
Time: 9,
|
||
DateTime: 10,
|
||
Json: 11,
|
||
Enum: 12,
|
||
Bytes: 13,
|
||
Set: 14,
|
||
Uuid: 15,
|
||
// Arrays
|
||
Int32Array: 64,
|
||
Int64Array: 65,
|
||
FloatArray: 66,
|
||
DoubleArray: 67,
|
||
NumericArray: 68,
|
||
BooleanArray: 69,
|
||
CharacterArray: 70,
|
||
TextArray: 71,
|
||
DateArray: 72,
|
||
TimeArray: 73,
|
||
DateTimeArray: 74,
|
||
JsonArray: 75,
|
||
EnumArray: 76,
|
||
BytesArray: 77,
|
||
UuidArray: 78,
|
||
// Custom
|
||
UnknownNumber: 128
|
||
};
|
||
// src/mock.ts
|
||
var mockAdapterErrors = {
|
||
queryRaw: new Error("Not implemented: queryRaw"),
|
||
executeRaw: new Error("Not implemented: executeRaw"),
|
||
startTransaction: new Error("Not implemented: startTransaction"),
|
||
executeScript: new Error("Not implemented: executeScript"),
|
||
dispose: new Error("Not implemented: dispose")
|
||
};
|
||
function mockAdapter(provider) {
|
||
return {
|
||
provider,
|
||
adapterName: "@prisma/adapter-mock",
|
||
queryRaw: ()=>Promise.reject(mockAdapterErrors.queryRaw),
|
||
executeRaw: ()=>Promise.reject(mockAdapterErrors.executeRaw),
|
||
startTransaction: ()=>Promise.reject(mockAdapterErrors.startTransaction),
|
||
executeScript: ()=>Promise.reject(mockAdapterErrors.executeScript),
|
||
dispose: ()=>Promise.reject(mockAdapterErrors.dispose),
|
||
[Symbol.for("adapter.mockAdapter")]: true
|
||
};
|
||
}
|
||
function mockAdapterFactory(provider) {
|
||
return {
|
||
provider,
|
||
adapterName: "@prisma/adapter-mock",
|
||
connect: ()=>Promise.resolve(mockAdapter(provider)),
|
||
[Symbol.for("adapter.mockAdapterFactory")]: true
|
||
};
|
||
}
|
||
function mockMigrationAwareAdapterFactory(provider) {
|
||
return {
|
||
provider,
|
||
adapterName: "@prisma/adapter-mock",
|
||
connect: ()=>Promise.resolve(mockAdapter(provider)),
|
||
connectToShadowDb: ()=>Promise.resolve(mockAdapter(provider)),
|
||
[Symbol.for("adapter.mockMigrationAwareAdapterFactory")]: true
|
||
};
|
||
}
|
||
;
|
||
}),
|
||
"[externals]/pg [external] (pg, esm_import, [project]/node_modules/pg)", ((__turbopack_context__) => {
|
||
"use strict";
|
||
|
||
return __turbopack_context__.a(async (__turbopack_handle_async_dependencies__, __turbopack_async_result__) => { try {
|
||
|
||
const mod = await __turbopack_context__.y("pg-587764f78a6c7a9c");
|
||
|
||
__turbopack_context__.n(mod);
|
||
__turbopack_async_result__();
|
||
} catch(e) { __turbopack_async_result__(e); } }, true);}),
|
||
"[project]/node_modules/postgres-array/index.js [app-route] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
"use strict";
|
||
|
||
const BACKSLASH = '\\';
|
||
const DQUOT = '"';
|
||
const LBRACE = '{';
|
||
const RBRACE = '}';
|
||
const LBRACKET = '[';
|
||
const EQUALS = '=';
|
||
const COMMA = ',';
|
||
/** When the raw value is this, it means a literal `null` */ const NULL_STRING = 'NULL';
|
||
/**
|
||
* Parses an array according to
|
||
* https://www.postgresql.org/docs/17/arrays.html#ARRAYS-IO
|
||
*
|
||
* Trusts the data (mostly), so only hook up to trusted Postgres servers.
|
||
*/ function makeParseArrayWithTransform(transform) {
|
||
const haveTransform = transform != null;
|
||
return function parseArray(str) {
|
||
const rbraceIndex = str.length - 1;
|
||
if (rbraceIndex === 1) {
|
||
return [];
|
||
}
|
||
if (str[rbraceIndex] !== RBRACE) {
|
||
throw new Error('Invalid array text - must end with }');
|
||
}
|
||
// If starts with `[`, it is specifying the index boundas. Skip past first `=`.
|
||
let position = 0;
|
||
if (str[position] === LBRACKET) {
|
||
position = str.indexOf(EQUALS) + 1;
|
||
}
|
||
if (str[position++] !== LBRACE) {
|
||
throw new Error('Invalid array text - must start with {');
|
||
}
|
||
const output = [];
|
||
let current = output;
|
||
const stack = [];
|
||
let currentStringStart = position;
|
||
let currentString = '';
|
||
let expectValue = true;
|
||
for(; position < rbraceIndex; ++position){
|
||
let char = str[position];
|
||
// > The array output routine will put double quotes around element values if
|
||
// > they are empty strings, contain curly braces, delimiter characters, double
|
||
// > quotes, backslashes, or white space, or match the word NULL. Double quotes
|
||
// > and backslashes embedded in element values will be backslash-escaped.
|
||
if (char === DQUOT) {
|
||
// It's escaped
|
||
currentStringStart = ++position;
|
||
let dquot = str.indexOf(DQUOT, currentStringStart);
|
||
let backSlash = str.indexOf(BACKSLASH, currentStringStart);
|
||
while(backSlash !== -1 && backSlash < dquot){
|
||
position = backSlash;
|
||
const part = str.slice(currentStringStart, position);
|
||
currentString += part;
|
||
currentStringStart = ++position;
|
||
if (dquot === position++) {
|
||
// This was an escaped doublequote; find the next one!
|
||
dquot = str.indexOf(DQUOT, position);
|
||
}
|
||
// Either way, find the next backslash
|
||
backSlash = str.indexOf(BACKSLASH, position);
|
||
}
|
||
position = dquot;
|
||
const part = str.slice(currentStringStart, position);
|
||
currentString += part;
|
||
current.push(haveTransform ? transform(currentString) : currentString);
|
||
currentString = '';
|
||
expectValue = false;
|
||
} else if (char === LBRACE) {
|
||
const newArray = [];
|
||
current.push(newArray);
|
||
stack.push(current);
|
||
current = newArray;
|
||
currentStringStart = position + 1;
|
||
expectValue = true;
|
||
} else if (char === COMMA) {
|
||
expectValue = true;
|
||
} else if (char === RBRACE) {
|
||
expectValue = false;
|
||
const arr = stack.pop();
|
||
if (arr === undefined) {
|
||
throw new Error("Invalid array text - too many '}'");
|
||
}
|
||
current = arr;
|
||
} else if (expectValue) {
|
||
currentStringStart = position;
|
||
while((char = str[position]) !== COMMA && char !== RBRACE && position < rbraceIndex){
|
||
++position;
|
||
}
|
||
const part = str.slice(currentStringStart, position--);
|
||
current.push(part === NULL_STRING ? null : haveTransform ? transform(part) : part);
|
||
expectValue = false;
|
||
} else {
|
||
throw new Error('Was expecting delimeter');
|
||
}
|
||
}
|
||
return output;
|
||
};
|
||
}
|
||
const parseArray = makeParseArrayWithTransform();
|
||
exports.parse = (source, transform)=>transform != null ? makeParseArrayWithTransform(transform)(source) : parseArray(source);
|
||
}),
|
||
"[project]/node_modules/@prisma/adapter-pg/dist/index.mjs [app-route] (ecmascript)", ((__turbopack_context__) => {
|
||
"use strict";
|
||
|
||
return __turbopack_context__.a(async (__turbopack_handle_async_dependencies__, __turbopack_async_result__) => { try {
|
||
|
||
__turbopack_context__.s([
|
||
"PrismaPg",
|
||
()=>PrismaPgAdapterFactory
|
||
]);
|
||
// src/pg.ts
|
||
var __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f40$prisma$2f$debug$2f$dist$2f$index$2e$mjs__$5b$app$2d$route$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[project]/node_modules/@prisma/debug/dist/index.mjs [app-route] (ecmascript)");
|
||
var __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f40$prisma$2f$driver$2d$adapter$2d$utils$2f$dist$2f$index$2e$mjs__$5b$app$2d$route$5d$__$28$ecmascript$29$__$3c$locals$3e$__ = __turbopack_context__.i("[project]/node_modules/@prisma/driver-adapter-utils/dist/index.mjs [app-route] (ecmascript) <locals>");
|
||
var __TURBOPACK__imported__module__$5b$externals$5d2f$pg__$5b$external$5d$__$28$pg$2c$__esm_import$2c$__$5b$project$5d2f$node_modules$2f$pg$29$__ = __turbopack_context__.i("[externals]/pg [external] (pg, esm_import, [project]/node_modules/pg)");
|
||
var __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$postgres$2d$array$2f$index$2e$js__$5b$app$2d$route$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[project]/node_modules/postgres-array/index.js [app-route] (ecmascript)");
|
||
var __turbopack_async_dependencies__ = __turbopack_handle_async_dependencies__([
|
||
__TURBOPACK__imported__module__$5b$externals$5d2f$pg__$5b$external$5d$__$28$pg$2c$__esm_import$2c$__$5b$project$5d2f$node_modules$2f$pg$29$__
|
||
]);
|
||
[__TURBOPACK__imported__module__$5b$externals$5d2f$pg__$5b$external$5d$__$28$pg$2c$__esm_import$2c$__$5b$project$5d2f$node_modules$2f$pg$29$__] = __turbopack_async_dependencies__.then ? (await __turbopack_async_dependencies__)() : __turbopack_async_dependencies__;
|
||
;
|
||
;
|
||
// package.json
|
||
var name = "@prisma/adapter-pg";
|
||
// src/constants.ts
|
||
var FIRST_NORMAL_OBJECT_ID = 16384;
|
||
;
|
||
;
|
||
;
|
||
var { types } = __TURBOPACK__imported__module__$5b$externals$5d2f$pg__$5b$external$5d$__$28$pg$2c$__esm_import$2c$__$5b$project$5d2f$node_modules$2f$pg$29$__["default"];
|
||
var { builtins: ScalarColumnType, getTypeParser } = types;
|
||
var AdditionalScalarColumnType = {
|
||
NAME: 19
|
||
};
|
||
var ArrayColumnType = {
|
||
BIT_ARRAY: 1561,
|
||
BOOL_ARRAY: 1e3,
|
||
BYTEA_ARRAY: 1001,
|
||
BPCHAR_ARRAY: 1014,
|
||
CHAR_ARRAY: 1002,
|
||
CIDR_ARRAY: 651,
|
||
DATE_ARRAY: 1182,
|
||
FLOAT4_ARRAY: 1021,
|
||
FLOAT8_ARRAY: 1022,
|
||
INET_ARRAY: 1041,
|
||
INT2_ARRAY: 1005,
|
||
INT4_ARRAY: 1007,
|
||
INT8_ARRAY: 1016,
|
||
JSONB_ARRAY: 3807,
|
||
JSON_ARRAY: 199,
|
||
MONEY_ARRAY: 791,
|
||
NUMERIC_ARRAY: 1231,
|
||
OID_ARRAY: 1028,
|
||
TEXT_ARRAY: 1009,
|
||
TIMESTAMP_ARRAY: 1115,
|
||
TIMESTAMPTZ_ARRAY: 1185,
|
||
TIME_ARRAY: 1183,
|
||
UUID_ARRAY: 2951,
|
||
VARBIT_ARRAY: 1563,
|
||
VARCHAR_ARRAY: 1015,
|
||
XML_ARRAY: 143
|
||
};
|
||
var UnsupportedNativeDataType = class _UnsupportedNativeDataType extends Error {
|
||
// map of type codes to type names
|
||
static typeNames = {
|
||
16: "bool",
|
||
17: "bytea",
|
||
18: "char",
|
||
19: "name",
|
||
20: "int8",
|
||
21: "int2",
|
||
22: "int2vector",
|
||
23: "int4",
|
||
24: "regproc",
|
||
25: "text",
|
||
26: "oid",
|
||
27: "tid",
|
||
28: "xid",
|
||
29: "cid",
|
||
30: "oidvector",
|
||
32: "pg_ddl_command",
|
||
71: "pg_type",
|
||
75: "pg_attribute",
|
||
81: "pg_proc",
|
||
83: "pg_class",
|
||
114: "json",
|
||
142: "xml",
|
||
194: "pg_node_tree",
|
||
269: "table_am_handler",
|
||
325: "index_am_handler",
|
||
600: "point",
|
||
601: "lseg",
|
||
602: "path",
|
||
603: "box",
|
||
604: "polygon",
|
||
628: "line",
|
||
650: "cidr",
|
||
700: "float4",
|
||
701: "float8",
|
||
705: "unknown",
|
||
718: "circle",
|
||
774: "macaddr8",
|
||
790: "money",
|
||
829: "macaddr",
|
||
869: "inet",
|
||
1033: "aclitem",
|
||
1042: "bpchar",
|
||
1043: "varchar",
|
||
1082: "date",
|
||
1083: "time",
|
||
1114: "timestamp",
|
||
1184: "timestamptz",
|
||
1186: "interval",
|
||
1266: "timetz",
|
||
1560: "bit",
|
||
1562: "varbit",
|
||
1700: "numeric",
|
||
1790: "refcursor",
|
||
2202: "regprocedure",
|
||
2203: "regoper",
|
||
2204: "regoperator",
|
||
2205: "regclass",
|
||
2206: "regtype",
|
||
2249: "record",
|
||
2275: "cstring",
|
||
2276: "any",
|
||
2277: "anyarray",
|
||
2278: "void",
|
||
2279: "trigger",
|
||
2280: "language_handler",
|
||
2281: "internal",
|
||
2283: "anyelement",
|
||
2287: "_record",
|
||
2776: "anynonarray",
|
||
2950: "uuid",
|
||
2970: "txid_snapshot",
|
||
3115: "fdw_handler",
|
||
3220: "pg_lsn",
|
||
3310: "tsm_handler",
|
||
3361: "pg_ndistinct",
|
||
3402: "pg_dependencies",
|
||
3500: "anyenum",
|
||
3614: "tsvector",
|
||
3615: "tsquery",
|
||
3642: "gtsvector",
|
||
3734: "regconfig",
|
||
3769: "regdictionary",
|
||
3802: "jsonb",
|
||
3831: "anyrange",
|
||
3838: "event_trigger",
|
||
3904: "int4range",
|
||
3906: "numrange",
|
||
3908: "tsrange",
|
||
3910: "tstzrange",
|
||
3912: "daterange",
|
||
3926: "int8range",
|
||
4072: "jsonpath",
|
||
4089: "regnamespace",
|
||
4096: "regrole",
|
||
4191: "regcollation",
|
||
4451: "int4multirange",
|
||
4532: "nummultirange",
|
||
4533: "tsmultirange",
|
||
4534: "tstzmultirange",
|
||
4535: "datemultirange",
|
||
4536: "int8multirange",
|
||
4537: "anymultirange",
|
||
4538: "anycompatiblemultirange",
|
||
4600: "pg_brin_bloom_summary",
|
||
4601: "pg_brin_minmax_multi_summary",
|
||
5017: "pg_mcv_list",
|
||
5038: "pg_snapshot",
|
||
5069: "xid8",
|
||
5077: "anycompatible",
|
||
5078: "anycompatiblearray",
|
||
5079: "anycompatiblenonarray",
|
||
5080: "anycompatiblerange"
|
||
};
|
||
type;
|
||
constructor(code){
|
||
super();
|
||
this.type = _UnsupportedNativeDataType.typeNames[code] || "Unknown";
|
||
this.message = `Unsupported column type ${this.type}`;
|
||
}
|
||
};
|
||
function fieldToColumnType(fieldTypeId) {
|
||
switch(fieldTypeId){
|
||
case ScalarColumnType.INT2:
|
||
case ScalarColumnType.INT4:
|
||
return __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f40$prisma$2f$driver$2d$adapter$2d$utils$2f$dist$2f$index$2e$mjs__$5b$app$2d$route$5d$__$28$ecmascript$29$__$3c$locals$3e$__["ColumnTypeEnum"].Int32;
|
||
case ScalarColumnType.INT8:
|
||
return __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f40$prisma$2f$driver$2d$adapter$2d$utils$2f$dist$2f$index$2e$mjs__$5b$app$2d$route$5d$__$28$ecmascript$29$__$3c$locals$3e$__["ColumnTypeEnum"].Int64;
|
||
case ScalarColumnType.FLOAT4:
|
||
return __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f40$prisma$2f$driver$2d$adapter$2d$utils$2f$dist$2f$index$2e$mjs__$5b$app$2d$route$5d$__$28$ecmascript$29$__$3c$locals$3e$__["ColumnTypeEnum"].Float;
|
||
case ScalarColumnType.FLOAT8:
|
||
return __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f40$prisma$2f$driver$2d$adapter$2d$utils$2f$dist$2f$index$2e$mjs__$5b$app$2d$route$5d$__$28$ecmascript$29$__$3c$locals$3e$__["ColumnTypeEnum"].Double;
|
||
case ScalarColumnType.BOOL:
|
||
return __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f40$prisma$2f$driver$2d$adapter$2d$utils$2f$dist$2f$index$2e$mjs__$5b$app$2d$route$5d$__$28$ecmascript$29$__$3c$locals$3e$__["ColumnTypeEnum"].Boolean;
|
||
case ScalarColumnType.DATE:
|
||
return __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f40$prisma$2f$driver$2d$adapter$2d$utils$2f$dist$2f$index$2e$mjs__$5b$app$2d$route$5d$__$28$ecmascript$29$__$3c$locals$3e$__["ColumnTypeEnum"].Date;
|
||
case ScalarColumnType.TIME:
|
||
case ScalarColumnType.TIMETZ:
|
||
return __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f40$prisma$2f$driver$2d$adapter$2d$utils$2f$dist$2f$index$2e$mjs__$5b$app$2d$route$5d$__$28$ecmascript$29$__$3c$locals$3e$__["ColumnTypeEnum"].Time;
|
||
case ScalarColumnType.TIMESTAMP:
|
||
case ScalarColumnType.TIMESTAMPTZ:
|
||
return __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f40$prisma$2f$driver$2d$adapter$2d$utils$2f$dist$2f$index$2e$mjs__$5b$app$2d$route$5d$__$28$ecmascript$29$__$3c$locals$3e$__["ColumnTypeEnum"].DateTime;
|
||
case ScalarColumnType.NUMERIC:
|
||
case ScalarColumnType.MONEY:
|
||
return __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f40$prisma$2f$driver$2d$adapter$2d$utils$2f$dist$2f$index$2e$mjs__$5b$app$2d$route$5d$__$28$ecmascript$29$__$3c$locals$3e$__["ColumnTypeEnum"].Numeric;
|
||
case ScalarColumnType.JSON:
|
||
case ScalarColumnType.JSONB:
|
||
return __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f40$prisma$2f$driver$2d$adapter$2d$utils$2f$dist$2f$index$2e$mjs__$5b$app$2d$route$5d$__$28$ecmascript$29$__$3c$locals$3e$__["ColumnTypeEnum"].Json;
|
||
case ScalarColumnType.UUID:
|
||
return __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f40$prisma$2f$driver$2d$adapter$2d$utils$2f$dist$2f$index$2e$mjs__$5b$app$2d$route$5d$__$28$ecmascript$29$__$3c$locals$3e$__["ColumnTypeEnum"].Uuid;
|
||
case ScalarColumnType.OID:
|
||
return __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f40$prisma$2f$driver$2d$adapter$2d$utils$2f$dist$2f$index$2e$mjs__$5b$app$2d$route$5d$__$28$ecmascript$29$__$3c$locals$3e$__["ColumnTypeEnum"].Int64;
|
||
case ScalarColumnType.BPCHAR:
|
||
case ScalarColumnType.TEXT:
|
||
case ScalarColumnType.VARCHAR:
|
||
case ScalarColumnType.BIT:
|
||
case ScalarColumnType.VARBIT:
|
||
case ScalarColumnType.INET:
|
||
case ScalarColumnType.CIDR:
|
||
case ScalarColumnType.XML:
|
||
case AdditionalScalarColumnType.NAME:
|
||
return __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f40$prisma$2f$driver$2d$adapter$2d$utils$2f$dist$2f$index$2e$mjs__$5b$app$2d$route$5d$__$28$ecmascript$29$__$3c$locals$3e$__["ColumnTypeEnum"].Text;
|
||
case ScalarColumnType.BYTEA:
|
||
return __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f40$prisma$2f$driver$2d$adapter$2d$utils$2f$dist$2f$index$2e$mjs__$5b$app$2d$route$5d$__$28$ecmascript$29$__$3c$locals$3e$__["ColumnTypeEnum"].Bytes;
|
||
case ArrayColumnType.INT2_ARRAY:
|
||
case ArrayColumnType.INT4_ARRAY:
|
||
return __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f40$prisma$2f$driver$2d$adapter$2d$utils$2f$dist$2f$index$2e$mjs__$5b$app$2d$route$5d$__$28$ecmascript$29$__$3c$locals$3e$__["ColumnTypeEnum"].Int32Array;
|
||
case ArrayColumnType.FLOAT4_ARRAY:
|
||
return __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f40$prisma$2f$driver$2d$adapter$2d$utils$2f$dist$2f$index$2e$mjs__$5b$app$2d$route$5d$__$28$ecmascript$29$__$3c$locals$3e$__["ColumnTypeEnum"].FloatArray;
|
||
case ArrayColumnType.FLOAT8_ARRAY:
|
||
return __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f40$prisma$2f$driver$2d$adapter$2d$utils$2f$dist$2f$index$2e$mjs__$5b$app$2d$route$5d$__$28$ecmascript$29$__$3c$locals$3e$__["ColumnTypeEnum"].DoubleArray;
|
||
case ArrayColumnType.NUMERIC_ARRAY:
|
||
case ArrayColumnType.MONEY_ARRAY:
|
||
return __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f40$prisma$2f$driver$2d$adapter$2d$utils$2f$dist$2f$index$2e$mjs__$5b$app$2d$route$5d$__$28$ecmascript$29$__$3c$locals$3e$__["ColumnTypeEnum"].NumericArray;
|
||
case ArrayColumnType.BOOL_ARRAY:
|
||
return __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f40$prisma$2f$driver$2d$adapter$2d$utils$2f$dist$2f$index$2e$mjs__$5b$app$2d$route$5d$__$28$ecmascript$29$__$3c$locals$3e$__["ColumnTypeEnum"].BooleanArray;
|
||
case ArrayColumnType.CHAR_ARRAY:
|
||
return __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f40$prisma$2f$driver$2d$adapter$2d$utils$2f$dist$2f$index$2e$mjs__$5b$app$2d$route$5d$__$28$ecmascript$29$__$3c$locals$3e$__["ColumnTypeEnum"].CharacterArray;
|
||
case ArrayColumnType.BPCHAR_ARRAY:
|
||
case ArrayColumnType.TEXT_ARRAY:
|
||
case ArrayColumnType.VARCHAR_ARRAY:
|
||
case ArrayColumnType.VARBIT_ARRAY:
|
||
case ArrayColumnType.BIT_ARRAY:
|
||
case ArrayColumnType.INET_ARRAY:
|
||
case ArrayColumnType.CIDR_ARRAY:
|
||
case ArrayColumnType.XML_ARRAY:
|
||
return __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f40$prisma$2f$driver$2d$adapter$2d$utils$2f$dist$2f$index$2e$mjs__$5b$app$2d$route$5d$__$28$ecmascript$29$__$3c$locals$3e$__["ColumnTypeEnum"].TextArray;
|
||
case ArrayColumnType.DATE_ARRAY:
|
||
return __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f40$prisma$2f$driver$2d$adapter$2d$utils$2f$dist$2f$index$2e$mjs__$5b$app$2d$route$5d$__$28$ecmascript$29$__$3c$locals$3e$__["ColumnTypeEnum"].DateArray;
|
||
case ArrayColumnType.TIME_ARRAY:
|
||
return __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f40$prisma$2f$driver$2d$adapter$2d$utils$2f$dist$2f$index$2e$mjs__$5b$app$2d$route$5d$__$28$ecmascript$29$__$3c$locals$3e$__["ColumnTypeEnum"].TimeArray;
|
||
case ArrayColumnType.TIMESTAMP_ARRAY:
|
||
return __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f40$prisma$2f$driver$2d$adapter$2d$utils$2f$dist$2f$index$2e$mjs__$5b$app$2d$route$5d$__$28$ecmascript$29$__$3c$locals$3e$__["ColumnTypeEnum"].DateTimeArray;
|
||
case ArrayColumnType.TIMESTAMPTZ_ARRAY:
|
||
return __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f40$prisma$2f$driver$2d$adapter$2d$utils$2f$dist$2f$index$2e$mjs__$5b$app$2d$route$5d$__$28$ecmascript$29$__$3c$locals$3e$__["ColumnTypeEnum"].DateTimeArray;
|
||
case ArrayColumnType.JSON_ARRAY:
|
||
case ArrayColumnType.JSONB_ARRAY:
|
||
return __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f40$prisma$2f$driver$2d$adapter$2d$utils$2f$dist$2f$index$2e$mjs__$5b$app$2d$route$5d$__$28$ecmascript$29$__$3c$locals$3e$__["ColumnTypeEnum"].JsonArray;
|
||
case ArrayColumnType.BYTEA_ARRAY:
|
||
return __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f40$prisma$2f$driver$2d$adapter$2d$utils$2f$dist$2f$index$2e$mjs__$5b$app$2d$route$5d$__$28$ecmascript$29$__$3c$locals$3e$__["ColumnTypeEnum"].BytesArray;
|
||
case ArrayColumnType.UUID_ARRAY:
|
||
return __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f40$prisma$2f$driver$2d$adapter$2d$utils$2f$dist$2f$index$2e$mjs__$5b$app$2d$route$5d$__$28$ecmascript$29$__$3c$locals$3e$__["ColumnTypeEnum"].UuidArray;
|
||
case ArrayColumnType.INT8_ARRAY:
|
||
case ArrayColumnType.OID_ARRAY:
|
||
return __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f40$prisma$2f$driver$2d$adapter$2d$utils$2f$dist$2f$index$2e$mjs__$5b$app$2d$route$5d$__$28$ecmascript$29$__$3c$locals$3e$__["ColumnTypeEnum"].Int64Array;
|
||
default:
|
||
if (fieldTypeId >= FIRST_NORMAL_OBJECT_ID) {
|
||
return __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f40$prisma$2f$driver$2d$adapter$2d$utils$2f$dist$2f$index$2e$mjs__$5b$app$2d$route$5d$__$28$ecmascript$29$__$3c$locals$3e$__["ColumnTypeEnum"].Text;
|
||
}
|
||
throw new UnsupportedNativeDataType(fieldTypeId);
|
||
}
|
||
}
|
||
function normalize_array(element_normalizer) {
|
||
return (str)=>(0, __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$postgres$2d$array$2f$index$2e$js__$5b$app$2d$route$5d$__$28$ecmascript$29$__["parse"])(str, element_normalizer);
|
||
}
|
||
function normalize_numeric(numeric) {
|
||
return numeric;
|
||
}
|
||
function normalize_date(date) {
|
||
return date;
|
||
}
|
||
function normalize_timestamp(time) {
|
||
return `${time.replace(" ", "T")}+00:00`;
|
||
}
|
||
function normalize_timestamptz(time) {
|
||
return time.replace(" ", "T").replace(/[+-]\d{2}(:\d{2})?$/, "+00:00");
|
||
}
|
||
function normalize_time(time) {
|
||
return time;
|
||
}
|
||
function normalize_timez(time) {
|
||
return time.replace(/[+-]\d{2}(:\d{2})?$/, "");
|
||
}
|
||
function normalize_money(money) {
|
||
return money.slice(1);
|
||
}
|
||
function normalize_xml(xml) {
|
||
return xml;
|
||
}
|
||
function toJson(json) {
|
||
return json;
|
||
}
|
||
var parsePgBytes = getTypeParser(ScalarColumnType.BYTEA);
|
||
var normalizeByteaArray = getTypeParser(ArrayColumnType.BYTEA_ARRAY);
|
||
function convertBytes(serializedBytes) {
|
||
return parsePgBytes(serializedBytes);
|
||
}
|
||
function normalizeBit(bit) {
|
||
return bit;
|
||
}
|
||
var customParsers = {
|
||
[ScalarColumnType.NUMERIC]: normalize_numeric,
|
||
[ArrayColumnType.NUMERIC_ARRAY]: normalize_array(normalize_numeric),
|
||
[ScalarColumnType.TIME]: normalize_time,
|
||
[ArrayColumnType.TIME_ARRAY]: normalize_array(normalize_time),
|
||
[ScalarColumnType.TIMETZ]: normalize_timez,
|
||
[ScalarColumnType.DATE]: normalize_date,
|
||
[ArrayColumnType.DATE_ARRAY]: normalize_array(normalize_date),
|
||
[ScalarColumnType.TIMESTAMP]: normalize_timestamp,
|
||
[ArrayColumnType.TIMESTAMP_ARRAY]: normalize_array(normalize_timestamp),
|
||
[ScalarColumnType.TIMESTAMPTZ]: normalize_timestamptz,
|
||
[ArrayColumnType.TIMESTAMPTZ_ARRAY]: normalize_array(normalize_timestamptz),
|
||
[ScalarColumnType.MONEY]: normalize_money,
|
||
[ArrayColumnType.MONEY_ARRAY]: normalize_array(normalize_money),
|
||
[ScalarColumnType.JSON]: toJson,
|
||
[ArrayColumnType.JSON_ARRAY]: normalize_array(toJson),
|
||
[ScalarColumnType.JSONB]: toJson,
|
||
[ArrayColumnType.JSONB_ARRAY]: normalize_array(toJson),
|
||
[ScalarColumnType.BYTEA]: convertBytes,
|
||
[ArrayColumnType.BYTEA_ARRAY]: normalizeByteaArray,
|
||
[ArrayColumnType.BIT_ARRAY]: normalize_array(normalizeBit),
|
||
[ArrayColumnType.VARBIT_ARRAY]: normalize_array(normalizeBit),
|
||
[ArrayColumnType.XML_ARRAY]: normalize_array(normalize_xml)
|
||
};
|
||
function mapArg(arg, argType) {
|
||
if (arg === null) {
|
||
return null;
|
||
}
|
||
if (Array.isArray(arg) && argType.arity === "list") {
|
||
return arg.map((value)=>mapArg(value, argType));
|
||
}
|
||
if (typeof arg === "string" && argType.scalarType === "datetime") {
|
||
arg = new Date(arg);
|
||
}
|
||
if (arg instanceof Date) {
|
||
switch(argType.dbType){
|
||
case "TIME":
|
||
case "TIMETZ":
|
||
return formatTime(arg);
|
||
case "DATE":
|
||
return formatDate(arg);
|
||
default:
|
||
return formatDateTime(arg);
|
||
}
|
||
}
|
||
if (typeof arg === "string" && argType.scalarType === "bytes") {
|
||
return Buffer.from(arg, "base64");
|
||
}
|
||
if (ArrayBuffer.isView(arg)) {
|
||
return new Uint8Array(arg.buffer, arg.byteOffset, arg.byteLength);
|
||
}
|
||
return arg;
|
||
}
|
||
function formatDateTime(date) {
|
||
const pad = (n, z = 2)=>String(n).padStart(z, "0");
|
||
const ms = date.getUTCMilliseconds();
|
||
return pad(date.getUTCFullYear(), 4) + "-" + pad(date.getUTCMonth() + 1) + "-" + pad(date.getUTCDate()) + " " + pad(date.getUTCHours()) + ":" + pad(date.getUTCMinutes()) + ":" + pad(date.getUTCSeconds()) + (ms ? "." + String(ms).padStart(3, "0") : "");
|
||
}
|
||
function formatDate(date) {
|
||
const pad = (n, z = 2)=>String(n).padStart(z, "0");
|
||
return pad(date.getUTCFullYear(), 4) + "-" + pad(date.getUTCMonth() + 1) + "-" + pad(date.getUTCDate());
|
||
}
|
||
function formatTime(date) {
|
||
const pad = (n, z = 2)=>String(n).padStart(z, "0");
|
||
const ms = date.getUTCMilliseconds();
|
||
return pad(date.getUTCHours()) + ":" + pad(date.getUTCMinutes()) + ":" + pad(date.getUTCSeconds()) + (ms ? "." + String(ms).padStart(3, "0") : "");
|
||
}
|
||
// src/errors.ts
|
||
var TLS_ERRORS = /* @__PURE__ */ new Set([
|
||
"UNABLE_TO_GET_ISSUER_CERT",
|
||
"UNABLE_TO_GET_CRL",
|
||
"UNABLE_TO_DECRYPT_CERT_SIGNATURE",
|
||
"UNABLE_TO_DECRYPT_CRL_SIGNATURE",
|
||
"UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY",
|
||
"CERT_SIGNATURE_FAILURE",
|
||
"CRL_SIGNATURE_FAILURE",
|
||
"CERT_NOT_YET_VALID",
|
||
"CERT_HAS_EXPIRED",
|
||
"CRL_NOT_YET_VALID",
|
||
"CRL_HAS_EXPIRED",
|
||
"ERROR_IN_CERT_NOT_BEFORE_FIELD",
|
||
"ERROR_IN_CERT_NOT_AFTER_FIELD",
|
||
"ERROR_IN_CRL_LAST_UPDATE_FIELD",
|
||
"ERROR_IN_CRL_NEXT_UPDATE_FIELD",
|
||
"DEPTH_ZERO_SELF_SIGNED_CERT",
|
||
"SELF_SIGNED_CERT_IN_CHAIN",
|
||
"UNABLE_TO_GET_ISSUER_CERT_LOCALLY",
|
||
"UNABLE_TO_VERIFY_LEAF_SIGNATURE",
|
||
"CERT_CHAIN_TOO_LONG",
|
||
"CERT_REVOKED",
|
||
"INVALID_CA",
|
||
"INVALID_PURPOSE",
|
||
"CERT_UNTRUSTED",
|
||
"CERT_REJECTED",
|
||
"HOSTNAME_MISMATCH",
|
||
"ERR_TLS_CERT_ALTNAME_FORMAT",
|
||
"ERR_TLS_CERT_ALTNAME_INVALID"
|
||
]);
|
||
var SOCKET_ERRORS = /* @__PURE__ */ new Set([
|
||
"ENOTFOUND",
|
||
"ECONNREFUSED",
|
||
"ECONNRESET",
|
||
"ETIMEDOUT"
|
||
]);
|
||
function convertDriverError(error) {
|
||
if (isSocketError(error)) {
|
||
return mapSocketError(error);
|
||
}
|
||
if (isTlsError(error)) {
|
||
return {
|
||
kind: "TlsConnectionError",
|
||
reason: error.message
|
||
};
|
||
}
|
||
if (isDriverError(error)) {
|
||
return {
|
||
originalCode: error.code,
|
||
originalMessage: error.message,
|
||
...mapDriverError(error)
|
||
};
|
||
}
|
||
throw error;
|
||
}
|
||
function mapDriverError(error) {
|
||
switch(error.code){
|
||
case "22001":
|
||
return {
|
||
kind: "LengthMismatch",
|
||
column: error.column
|
||
};
|
||
case "22003":
|
||
return {
|
||
kind: "ValueOutOfRange",
|
||
cause: error.message
|
||
};
|
||
case "22P02":
|
||
return {
|
||
kind: "InvalidInputValue",
|
||
message: error.message
|
||
};
|
||
case "23505":
|
||
{
|
||
const fields = error.detail?.match(/Key \(([^)]+)\)/)?.at(1)?.split(", ");
|
||
return {
|
||
kind: "UniqueConstraintViolation",
|
||
constraint: fields !== void 0 ? {
|
||
fields
|
||
} : void 0
|
||
};
|
||
}
|
||
case "23502":
|
||
{
|
||
const fields = error.detail?.match(/Key \(([^)]+)\)/)?.at(1)?.split(", ");
|
||
return {
|
||
kind: "NullConstraintViolation",
|
||
constraint: fields !== void 0 ? {
|
||
fields
|
||
} : void 0
|
||
};
|
||
}
|
||
case "23503":
|
||
{
|
||
let constraint;
|
||
if (error.column) {
|
||
constraint = {
|
||
fields: [
|
||
error.column
|
||
]
|
||
};
|
||
} else if (error.constraint) {
|
||
constraint = {
|
||
index: error.constraint
|
||
};
|
||
}
|
||
return {
|
||
kind: "ForeignKeyConstraintViolation",
|
||
constraint
|
||
};
|
||
}
|
||
case "3D000":
|
||
return {
|
||
kind: "DatabaseDoesNotExist",
|
||
db: error.message.split(" ").at(1)?.split('"').at(1)
|
||
};
|
||
case "28000":
|
||
return {
|
||
kind: "DatabaseAccessDenied",
|
||
db: error.message.split(",").find((s)=>s.startsWith(" database"))?.split('"').at(1)
|
||
};
|
||
case "28P01":
|
||
return {
|
||
kind: "AuthenticationFailed",
|
||
user: error.message.split(" ").pop()?.split('"').at(1)
|
||
};
|
||
case "40001":
|
||
return {
|
||
kind: "TransactionWriteConflict"
|
||
};
|
||
case "42P01":
|
||
return {
|
||
kind: "TableDoesNotExist",
|
||
table: error.message.split(" ").at(1)?.split('"').at(1)
|
||
};
|
||
case "42703":
|
||
{
|
||
const rawColumn = error.message.match(/^column (.+) does not exist$/)?.at(1);
|
||
return {
|
||
kind: "ColumnNotFound",
|
||
column: rawColumn?.replace(/"((?:""|[^"])*)"/g, (_, id)=>id.replaceAll('""', '"'))
|
||
};
|
||
}
|
||
case "42P04":
|
||
return {
|
||
kind: "DatabaseAlreadyExists",
|
||
db: error.message.split(" ").at(1)?.split('"').at(1)
|
||
};
|
||
case "53300":
|
||
return {
|
||
kind: "TooManyConnections",
|
||
cause: error.message
|
||
};
|
||
default:
|
||
return {
|
||
kind: "postgres",
|
||
code: error.code ?? "N/A",
|
||
severity: error.severity ?? "N/A",
|
||
message: error.message,
|
||
detail: error.detail,
|
||
column: error.column,
|
||
hint: error.hint
|
||
};
|
||
}
|
||
}
|
||
function isDriverError(error) {
|
||
return typeof error.code === "string" && typeof error.message === "string" && typeof error.severity === "string" && (typeof error.detail === "string" || error.detail === void 0) && (typeof error.column === "string" || error.column === void 0) && (typeof error.hint === "string" || error.hint === void 0);
|
||
}
|
||
function mapSocketError(error) {
|
||
switch(error.code){
|
||
case "ENOTFOUND":
|
||
case "ECONNREFUSED":
|
||
return {
|
||
kind: "DatabaseNotReachable",
|
||
host: error.address ?? error.hostname,
|
||
port: error.port
|
||
};
|
||
case "ECONNRESET":
|
||
return {
|
||
kind: "ConnectionClosed"
|
||
};
|
||
case "ETIMEDOUT":
|
||
return {
|
||
kind: "SocketTimeout"
|
||
};
|
||
}
|
||
}
|
||
function isSocketError(error) {
|
||
return typeof error.code === "string" && typeof error.syscall === "string" && typeof error.errno === "number" && SOCKET_ERRORS.has(error.code);
|
||
}
|
||
function isTlsError(error) {
|
||
if (typeof error.code === "string") {
|
||
return TLS_ERRORS.has(error.code);
|
||
}
|
||
switch(error.message){
|
||
case "The server does not support SSL connections":
|
||
case "There was an error establishing an SSL connection":
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
// src/pg.ts
|
||
var types2 = __TURBOPACK__imported__module__$5b$externals$5d2f$pg__$5b$external$5d$__$28$pg$2c$__esm_import$2c$__$5b$project$5d2f$node_modules$2f$pg$29$__["default"].types;
|
||
var debug = (0, __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f40$prisma$2f$debug$2f$dist$2f$index$2e$mjs__$5b$app$2d$route$5d$__$28$ecmascript$29$__["Debug"])("prisma:driver-adapter:pg");
|
||
var PgQueryable = class {
|
||
constructor(client, pgOptions){
|
||
this.client = client;
|
||
this.pgOptions = pgOptions;
|
||
}
|
||
provider = "postgres";
|
||
adapterName = name;
|
||
/**
|
||
* Execute a query given as SQL, interpolating the given parameters.
|
||
*/ async queryRaw(query) {
|
||
const tag = "[js::query_raw]";
|
||
debug(`${tag} %O`, query);
|
||
const { fields, rows } = await this.performIO(query);
|
||
const columnNames = fields.map((field)=>field.name);
|
||
let columnTypes = [];
|
||
try {
|
||
columnTypes = fields.map((field)=>fieldToColumnType(field.dataTypeID));
|
||
} catch (e) {
|
||
if (e instanceof UnsupportedNativeDataType) {
|
||
throw new __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f40$prisma$2f$driver$2d$adapter$2d$utils$2f$dist$2f$index$2e$mjs__$5b$app$2d$route$5d$__$28$ecmascript$29$__$3c$locals$3e$__["DriverAdapterError"]({
|
||
kind: "UnsupportedNativeDataType",
|
||
type: e.type
|
||
});
|
||
}
|
||
throw e;
|
||
}
|
||
const udtParser = this.pgOptions?.userDefinedTypeParser;
|
||
if (udtParser) {
|
||
for(let i = 0; i < fields.length; i++){
|
||
const field = fields[i];
|
||
if (field.dataTypeID >= FIRST_NORMAL_OBJECT_ID && !Object.hasOwn(customParsers, field.dataTypeID)) {
|
||
for(let j = 0; j < rows.length; j++){
|
||
rows[j][i] = await udtParser(field.dataTypeID, rows[j][i], this);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return {
|
||
columnNames,
|
||
columnTypes,
|
||
rows
|
||
};
|
||
}
|
||
/**
|
||
* Execute a query given as SQL, interpolating the given parameters and
|
||
* returning the number of affected rows.
|
||
* Note: Queryable expects a u64, but napi.rs only supports u32.
|
||
*/ async executeRaw(query) {
|
||
const tag = "[js::execute_raw]";
|
||
debug(`${tag} %O`, query);
|
||
return (await this.performIO(query)).rowCount ?? 0;
|
||
}
|
||
/**
|
||
* Run a query against the database, returning the result set.
|
||
* Should the query fail due to a connection error, the connection is
|
||
* marked as unhealthy.
|
||
*/ async performIO(query) {
|
||
const { sql, args } = query;
|
||
const values = args.map((arg, i)=>mapArg(arg, query.argTypes[i]));
|
||
try {
|
||
const result = await this.client.query({
|
||
name: this.pgOptions?.statementNameGenerator?.(query),
|
||
text: sql,
|
||
values,
|
||
rowMode: "array",
|
||
types: {
|
||
getTypeParser: (oid, format)=>{
|
||
if (format === "text" && customParsers[oid]) {
|
||
return customParsers[oid];
|
||
}
|
||
return types2.getTypeParser(oid, format);
|
||
}
|
||
}
|
||
}, values);
|
||
return result;
|
||
} catch (e) {
|
||
this.onError(e);
|
||
}
|
||
}
|
||
onError(error) {
|
||
debug("Error in performIO: %O", error);
|
||
throw new __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f40$prisma$2f$driver$2d$adapter$2d$utils$2f$dist$2f$index$2e$mjs__$5b$app$2d$route$5d$__$28$ecmascript$29$__$3c$locals$3e$__["DriverAdapterError"](convertDriverError(error));
|
||
}
|
||
};
|
||
var PgTransaction = class extends PgQueryable {
|
||
constructor(client, options, pgOptions, cleanup){
|
||
super(client, pgOptions);
|
||
this.options = options;
|
||
this.pgOptions = pgOptions;
|
||
this.cleanup = cleanup;
|
||
}
|
||
async commit() {
|
||
debug(`[js::commit]`);
|
||
this.cleanup?.();
|
||
this.client.release();
|
||
}
|
||
async rollback() {
|
||
debug(`[js::rollback]`);
|
||
this.cleanup?.();
|
||
this.client.release();
|
||
}
|
||
async createSavepoint(name2) {
|
||
await this.executeRaw({
|
||
sql: `SAVEPOINT ${name2}`,
|
||
args: [],
|
||
argTypes: []
|
||
});
|
||
}
|
||
async rollbackToSavepoint(name2) {
|
||
await this.executeRaw({
|
||
sql: `ROLLBACK TO SAVEPOINT ${name2}`,
|
||
args: [],
|
||
argTypes: []
|
||
});
|
||
}
|
||
async releaseSavepoint(name2) {
|
||
await this.executeRaw({
|
||
sql: `RELEASE SAVEPOINT ${name2}`,
|
||
args: [],
|
||
argTypes: []
|
||
});
|
||
}
|
||
};
|
||
var PrismaPgAdapter = class extends PgQueryable {
|
||
constructor(client, pgOptions, release){
|
||
super(client);
|
||
this.pgOptions = pgOptions;
|
||
this.release = release;
|
||
}
|
||
async startTransaction(isolationLevel) {
|
||
const options = {
|
||
usePhantomQuery: false
|
||
};
|
||
const tag = "[js::startTransaction]";
|
||
debug("%s options: %O", tag, options);
|
||
const conn = await this.client.connect().catch((error)=>this.onError(error));
|
||
const onError = (err)=>{
|
||
debug(`Error from pool connection: ${err.message} %O`, err);
|
||
this.pgOptions?.onConnectionError?.(err);
|
||
};
|
||
conn.on("error", onError);
|
||
const cleanup = ()=>{
|
||
conn.removeListener("error", onError);
|
||
};
|
||
try {
|
||
const tx = new PgTransaction(conn, options, this.pgOptions, cleanup);
|
||
await tx.executeRaw({
|
||
sql: "BEGIN",
|
||
args: [],
|
||
argTypes: []
|
||
});
|
||
if (isolationLevel) {
|
||
await tx.executeRaw({
|
||
sql: `SET TRANSACTION ISOLATION LEVEL ${isolationLevel}`,
|
||
args: [],
|
||
argTypes: []
|
||
});
|
||
}
|
||
return tx;
|
||
} catch (error) {
|
||
cleanup();
|
||
conn.release(error);
|
||
this.onError(error);
|
||
}
|
||
}
|
||
async executeScript(script) {
|
||
const statements = script.split(";").map((stmt)=>stmt.trim()).filter((stmt)=>stmt.length > 0);
|
||
for (const stmt of statements){
|
||
try {
|
||
await this.client.query(stmt);
|
||
} catch (error) {
|
||
this.onError(error);
|
||
}
|
||
}
|
||
}
|
||
getConnectionInfo() {
|
||
return {
|
||
schemaName: this.pgOptions?.schema,
|
||
supportsRelationJoins: true
|
||
};
|
||
}
|
||
async dispose() {
|
||
return this.release?.();
|
||
}
|
||
underlyingDriver() {
|
||
return this.client;
|
||
}
|
||
};
|
||
var PrismaPgAdapterFactory = class {
|
||
constructor(poolOrConfig, options){
|
||
this.options = options;
|
||
if (poolOrConfig instanceof __TURBOPACK__imported__module__$5b$externals$5d2f$pg__$5b$external$5d$__$28$pg$2c$__esm_import$2c$__$5b$project$5d2f$node_modules$2f$pg$29$__["default"].Pool) {
|
||
this.externalPool = poolOrConfig;
|
||
this.config = poolOrConfig.options;
|
||
} else if (typeof poolOrConfig === "string") {
|
||
this.externalPool = null;
|
||
this.config = {
|
||
connectionString: poolOrConfig
|
||
};
|
||
} else {
|
||
this.externalPool = null;
|
||
this.config = poolOrConfig;
|
||
}
|
||
}
|
||
provider = "postgres";
|
||
adapterName = name;
|
||
config;
|
||
externalPool;
|
||
async connect() {
|
||
const client = this.externalPool ?? new __TURBOPACK__imported__module__$5b$externals$5d2f$pg__$5b$external$5d$__$28$pg$2c$__esm_import$2c$__$5b$project$5d2f$node_modules$2f$pg$29$__["default"].Pool(this.config);
|
||
const onIdleClientError = (err)=>{
|
||
debug(`Error from idle pool client: ${err.message} %O`, err);
|
||
this.options?.onPoolError?.(err);
|
||
};
|
||
client.on("error", onIdleClientError);
|
||
return new PrismaPgAdapter(client, this.options, async ()=>{
|
||
if (this.externalPool) {
|
||
if (this.options?.disposeExternalPool) {
|
||
await this.externalPool.end();
|
||
this.externalPool = null;
|
||
} else {
|
||
this.externalPool.removeListener("error", onIdleClientError);
|
||
}
|
||
} else {
|
||
await client.end();
|
||
}
|
||
});
|
||
}
|
||
async connectToShadowDb() {
|
||
const conn = await this.connect();
|
||
const database = `prisma_migrate_shadow_db_${globalThis.crypto.randomUUID()}`;
|
||
await conn.executeScript(`CREATE DATABASE "${database}"`);
|
||
const client = new __TURBOPACK__imported__module__$5b$externals$5d2f$pg__$5b$external$5d$__$28$pg$2c$__esm_import$2c$__$5b$project$5d2f$node_modules$2f$pg$29$__["default"].Pool({
|
||
...this.config,
|
||
database
|
||
});
|
||
return new PrismaPgAdapter(client, void 0, async ()=>{
|
||
await conn.executeScript(`DROP DATABASE "${database}"`);
|
||
await client.end();
|
||
});
|
||
}
|
||
};
|
||
;
|
||
__turbopack_async_result__();
|
||
} catch(e) { __turbopack_async_result__(e); } }, false);}),
|
||
"[project]/node_modules/bcryptjs/index.js [app-route] (ecmascript)", ((__turbopack_context__) => {
|
||
"use strict";
|
||
|
||
__turbopack_context__.s([
|
||
"compare",
|
||
()=>compare,
|
||
"compareSync",
|
||
()=>compareSync,
|
||
"decodeBase64",
|
||
()=>decodeBase64,
|
||
"default",
|
||
()=>__TURBOPACK__default__export__,
|
||
"encodeBase64",
|
||
()=>encodeBase64,
|
||
"genSalt",
|
||
()=>genSalt,
|
||
"genSaltSync",
|
||
()=>genSaltSync,
|
||
"getRounds",
|
||
()=>getRounds,
|
||
"getSalt",
|
||
()=>getSalt,
|
||
"hash",
|
||
()=>hash,
|
||
"hashSync",
|
||
()=>hashSync,
|
||
"setRandomFallback",
|
||
()=>setRandomFallback,
|
||
"truncates",
|
||
()=>truncates
|
||
]);
|
||
/*
|
||
Copyright (c) 2012 Nevins Bartolomeo <nevins.bartolomeo@gmail.com>
|
||
Copyright (c) 2012 Shane Girish <shaneGirish@gmail.com>
|
||
Copyright (c) 2025 Daniel Wirtz <dcode@dcode.io>
|
||
|
||
Redistribution and use in source and binary forms, with or without
|
||
modification, are permitted provided that the following conditions
|
||
are met:
|
||
1. Redistributions of source code must retain the above copyright
|
||
notice, this list of conditions and the following disclaimer.
|
||
2. Redistributions in binary form must reproduce the above copyright
|
||
notice, this list of conditions and the following disclaimer in the
|
||
documentation and/or other materials provided with the distribution.
|
||
3. The name of the author may not be used to endorse or promote products
|
||
derived from this software without specific prior written permission.
|
||
|
||
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
||
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
||
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
||
IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||
*/ // The Node.js crypto module is used as a fallback for the Web Crypto API. When
|
||
// building for the browser, inclusion of the crypto module should be disabled,
|
||
// which the package hints at in its package.json for bundlers that support it.
|
||
var __TURBOPACK__imported__module__$5b$externals$5d2f$crypto__$5b$external$5d$__$28$crypto$2c$__cjs$29$__ = __turbopack_context__.i("[externals]/crypto [external] (crypto, cjs)");
|
||
;
|
||
/**
|
||
* The random implementation to use as a fallback.
|
||
* @type {?function(number):!Array.<number>}
|
||
* @inner
|
||
*/ var randomFallback = null;
|
||
/**
|
||
* Generates cryptographically secure random bytes.
|
||
* @function
|
||
* @param {number} len Bytes length
|
||
* @returns {!Array.<number>} Random bytes
|
||
* @throws {Error} If no random implementation is available
|
||
* @inner
|
||
*/ function randomBytes(len) {
|
||
// Web Crypto API. Globally available in the browser and in Node.js >=23.
|
||
try {
|
||
return crypto.getRandomValues(new Uint8Array(len));
|
||
} catch {}
|
||
// Node.js crypto module for non-browser environments.
|
||
try {
|
||
return __TURBOPACK__imported__module__$5b$externals$5d2f$crypto__$5b$external$5d$__$28$crypto$2c$__cjs$29$__["default"].randomBytes(len);
|
||
} catch {}
|
||
// Custom fallback specified with `setRandomFallback`.
|
||
if (!randomFallback) {
|
||
throw Error("Neither WebCryptoAPI nor a crypto module is available. Use bcrypt.setRandomFallback to set an alternative");
|
||
}
|
||
return randomFallback(len);
|
||
}
|
||
function setRandomFallback(random) {
|
||
randomFallback = random;
|
||
}
|
||
function genSaltSync(rounds, seed_length) {
|
||
rounds = rounds || GENSALT_DEFAULT_LOG2_ROUNDS;
|
||
if (typeof rounds !== "number") throw Error("Illegal arguments: " + typeof rounds + ", " + typeof seed_length);
|
||
if (rounds < 4) rounds = 4;
|
||
else if (rounds > 31) rounds = 31;
|
||
var salt = [];
|
||
salt.push("$2b$");
|
||
if (rounds < 10) salt.push("0");
|
||
salt.push(rounds.toString());
|
||
salt.push("$");
|
||
salt.push(base64_encode(randomBytes(BCRYPT_SALT_LEN), BCRYPT_SALT_LEN)); // May throw
|
||
return salt.join("");
|
||
}
|
||
function genSalt(rounds, seed_length, callback) {
|
||
if (typeof seed_length === "function") callback = seed_length, seed_length = undefined; // Not supported.
|
||
if (typeof rounds === "function") callback = rounds, rounds = undefined;
|
||
if (typeof rounds === "undefined") rounds = GENSALT_DEFAULT_LOG2_ROUNDS;
|
||
else if (typeof rounds !== "number") throw Error("illegal arguments: " + typeof rounds);
|
||
function _async(callback) {
|
||
nextTick(function() {
|
||
// Pretty thin, but salting is fast enough
|
||
try {
|
||
callback(null, genSaltSync(rounds));
|
||
} catch (err) {
|
||
callback(err);
|
||
}
|
||
});
|
||
}
|
||
if (callback) {
|
||
if (typeof callback !== "function") throw Error("Illegal callback: " + typeof callback);
|
||
_async(callback);
|
||
} else return new Promise(function(resolve, reject) {
|
||
_async(function(err, res) {
|
||
if (err) {
|
||
reject(err);
|
||
return;
|
||
}
|
||
resolve(res);
|
||
});
|
||
});
|
||
}
|
||
function hashSync(password, salt) {
|
||
if (typeof salt === "undefined") salt = GENSALT_DEFAULT_LOG2_ROUNDS;
|
||
if (typeof salt === "number") salt = genSaltSync(salt);
|
||
if (typeof password !== "string" || typeof salt !== "string") throw Error("Illegal arguments: " + typeof password + ", " + typeof salt);
|
||
return _hash(password, salt);
|
||
}
|
||
function hash(password, salt, callback, progressCallback) {
|
||
function _async(callback) {
|
||
if (typeof password === "string" && typeof salt === "number") genSalt(salt, function(err, salt) {
|
||
_hash(password, salt, callback, progressCallback);
|
||
});
|
||
else if (typeof password === "string" && typeof salt === "string") _hash(password, salt, callback, progressCallback);
|
||
else nextTick(callback.bind(this, Error("Illegal arguments: " + typeof password + ", " + typeof salt)));
|
||
}
|
||
if (callback) {
|
||
if (typeof callback !== "function") throw Error("Illegal callback: " + typeof callback);
|
||
_async(callback);
|
||
} else return new Promise(function(resolve, reject) {
|
||
_async(function(err, res) {
|
||
if (err) {
|
||
reject(err);
|
||
return;
|
||
}
|
||
resolve(res);
|
||
});
|
||
});
|
||
}
|
||
/**
|
||
* Compares two strings of the same length in constant time.
|
||
* @param {string} known Must be of the correct length
|
||
* @param {string} unknown Must be the same length as `known`
|
||
* @returns {boolean}
|
||
* @inner
|
||
*/ function safeStringCompare(known, unknown) {
|
||
var diff = known.length ^ unknown.length;
|
||
for(var i = 0; i < known.length; ++i){
|
||
diff |= known.charCodeAt(i) ^ unknown.charCodeAt(i);
|
||
}
|
||
return diff === 0;
|
||
}
|
||
function compareSync(password, hash) {
|
||
if (typeof password !== "string" || typeof hash !== "string") throw Error("Illegal arguments: " + typeof password + ", " + typeof hash);
|
||
if (hash.length !== 60) return false;
|
||
return safeStringCompare(hashSync(password, hash.substring(0, hash.length - 31)), hash);
|
||
}
|
||
function compare(password, hashValue, callback, progressCallback) {
|
||
function _async(callback) {
|
||
if (typeof password !== "string" || typeof hashValue !== "string") {
|
||
nextTick(callback.bind(this, Error("Illegal arguments: " + typeof password + ", " + typeof hashValue)));
|
||
return;
|
||
}
|
||
if (hashValue.length !== 60) {
|
||
nextTick(callback.bind(this, null, false));
|
||
return;
|
||
}
|
||
hash(password, hashValue.substring(0, 29), function(err, comp) {
|
||
if (err) callback(err);
|
||
else callback(null, safeStringCompare(comp, hashValue));
|
||
}, progressCallback);
|
||
}
|
||
if (callback) {
|
||
if (typeof callback !== "function") throw Error("Illegal callback: " + typeof callback);
|
||
_async(callback);
|
||
} else return new Promise(function(resolve, reject) {
|
||
_async(function(err, res) {
|
||
if (err) {
|
||
reject(err);
|
||
return;
|
||
}
|
||
resolve(res);
|
||
});
|
||
});
|
||
}
|
||
function getRounds(hash) {
|
||
if (typeof hash !== "string") throw Error("Illegal arguments: " + typeof hash);
|
||
return parseInt(hash.split("$")[2], 10);
|
||
}
|
||
function getSalt(hash) {
|
||
if (typeof hash !== "string") throw Error("Illegal arguments: " + typeof hash);
|
||
if (hash.length !== 60) throw Error("Illegal hash length: " + hash.length + " != 60");
|
||
return hash.substring(0, 29);
|
||
}
|
||
function truncates(password) {
|
||
if (typeof password !== "string") throw Error("Illegal arguments: " + typeof password);
|
||
return utf8Length(password) > 72;
|
||
}
|
||
/**
|
||
* Continues with the callback after yielding to the event loop.
|
||
* @function
|
||
* @param {function(...[*])} callback Callback to execute
|
||
* @inner
|
||
*/ var nextTick = typeof setImmediate === "function" ? setImmediate : typeof scheduler === "object" && typeof scheduler.postTask === "function" ? scheduler.postTask.bind(scheduler) : setTimeout;
|
||
/** Calculates the byte length of a string encoded as UTF8. */ function utf8Length(string) {
|
||
var len = 0, c = 0;
|
||
for(var i = 0; i < string.length; ++i){
|
||
c = string.charCodeAt(i);
|
||
if (c < 128) len += 1;
|
||
else if (c < 2048) len += 2;
|
||
else if ((c & 0xfc00) === 0xd800 && (string.charCodeAt(i + 1) & 0xfc00) === 0xdc00) {
|
||
++i;
|
||
len += 4;
|
||
} else len += 3;
|
||
}
|
||
return len;
|
||
}
|
||
/** Converts a string to an array of UTF8 bytes. */ function utf8Array(string) {
|
||
var offset = 0, c1, c2;
|
||
var buffer = new Array(utf8Length(string));
|
||
for(var i = 0, k = string.length; i < k; ++i){
|
||
c1 = string.charCodeAt(i);
|
||
if (c1 < 128) {
|
||
buffer[offset++] = c1;
|
||
} else if (c1 < 2048) {
|
||
buffer[offset++] = c1 >> 6 | 192;
|
||
buffer[offset++] = c1 & 63 | 128;
|
||
} else if ((c1 & 0xfc00) === 0xd800 && ((c2 = string.charCodeAt(i + 1)) & 0xfc00) === 0xdc00) {
|
||
c1 = 0x10000 + ((c1 & 0x03ff) << 10) + (c2 & 0x03ff);
|
||
++i;
|
||
buffer[offset++] = c1 >> 18 | 240;
|
||
buffer[offset++] = c1 >> 12 & 63 | 128;
|
||
buffer[offset++] = c1 >> 6 & 63 | 128;
|
||
buffer[offset++] = c1 & 63 | 128;
|
||
} else {
|
||
buffer[offset++] = c1 >> 12 | 224;
|
||
buffer[offset++] = c1 >> 6 & 63 | 128;
|
||
buffer[offset++] = c1 & 63 | 128;
|
||
}
|
||
}
|
||
return buffer;
|
||
}
|
||
// A base64 implementation for the bcrypt algorithm. This is partly non-standard.
|
||
/**
|
||
* bcrypt's own non-standard base64 dictionary.
|
||
* @type {!Array.<string>}
|
||
* @const
|
||
* @inner
|
||
**/ var BASE64_CODE = "./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789".split("");
|
||
/**
|
||
* @type {!Array.<number>}
|
||
* @const
|
||
* @inner
|
||
**/ var BASE64_INDEX = [
|
||
-1,
|
||
-1,
|
||
-1,
|
||
-1,
|
||
-1,
|
||
-1,
|
||
-1,
|
||
-1,
|
||
-1,
|
||
-1,
|
||
-1,
|
||
-1,
|
||
-1,
|
||
-1,
|
||
-1,
|
||
-1,
|
||
-1,
|
||
-1,
|
||
-1,
|
||
-1,
|
||
-1,
|
||
-1,
|
||
-1,
|
||
-1,
|
||
-1,
|
||
-1,
|
||
-1,
|
||
-1,
|
||
-1,
|
||
-1,
|
||
-1,
|
||
-1,
|
||
-1,
|
||
-1,
|
||
-1,
|
||
-1,
|
||
-1,
|
||
-1,
|
||
-1,
|
||
-1,
|
||
-1,
|
||
-1,
|
||
-1,
|
||
-1,
|
||
-1,
|
||
-1,
|
||
0,
|
||
1,
|
||
54,
|
||
55,
|
||
56,
|
||
57,
|
||
58,
|
||
59,
|
||
60,
|
||
61,
|
||
62,
|
||
63,
|
||
-1,
|
||
-1,
|
||
-1,
|
||
-1,
|
||
-1,
|
||
-1,
|
||
-1,
|
||
2,
|
||
3,
|
||
4,
|
||
5,
|
||
6,
|
||
7,
|
||
8,
|
||
9,
|
||
10,
|
||
11,
|
||
12,
|
||
13,
|
||
14,
|
||
15,
|
||
16,
|
||
17,
|
||
18,
|
||
19,
|
||
20,
|
||
21,
|
||
22,
|
||
23,
|
||
24,
|
||
25,
|
||
26,
|
||
27,
|
||
-1,
|
||
-1,
|
||
-1,
|
||
-1,
|
||
-1,
|
||
-1,
|
||
28,
|
||
29,
|
||
30,
|
||
31,
|
||
32,
|
||
33,
|
||
34,
|
||
35,
|
||
36,
|
||
37,
|
||
38,
|
||
39,
|
||
40,
|
||
41,
|
||
42,
|
||
43,
|
||
44,
|
||
45,
|
||
46,
|
||
47,
|
||
48,
|
||
49,
|
||
50,
|
||
51,
|
||
52,
|
||
53,
|
||
-1,
|
||
-1,
|
||
-1,
|
||
-1,
|
||
-1
|
||
];
|
||
/**
|
||
* Encodes a byte array to base64 with up to len bytes of input.
|
||
* @param {!Array.<number>} b Byte array
|
||
* @param {number} len Maximum input length
|
||
* @returns {string}
|
||
* @inner
|
||
*/ function base64_encode(b, len) {
|
||
var off = 0, rs = [], c1, c2;
|
||
if (len <= 0 || len > b.length) throw Error("Illegal len: " + len);
|
||
while(off < len){
|
||
c1 = b[off++] & 0xff;
|
||
rs.push(BASE64_CODE[c1 >> 2 & 0x3f]);
|
||
c1 = (c1 & 0x03) << 4;
|
||
if (off >= len) {
|
||
rs.push(BASE64_CODE[c1 & 0x3f]);
|
||
break;
|
||
}
|
||
c2 = b[off++] & 0xff;
|
||
c1 |= c2 >> 4 & 0x0f;
|
||
rs.push(BASE64_CODE[c1 & 0x3f]);
|
||
c1 = (c2 & 0x0f) << 2;
|
||
if (off >= len) {
|
||
rs.push(BASE64_CODE[c1 & 0x3f]);
|
||
break;
|
||
}
|
||
c2 = b[off++] & 0xff;
|
||
c1 |= c2 >> 6 & 0x03;
|
||
rs.push(BASE64_CODE[c1 & 0x3f]);
|
||
rs.push(BASE64_CODE[c2 & 0x3f]);
|
||
}
|
||
return rs.join("");
|
||
}
|
||
/**
|
||
* Decodes a base64 encoded string to up to len bytes of output.
|
||
* @param {string} s String to decode
|
||
* @param {number} len Maximum output length
|
||
* @returns {!Array.<number>}
|
||
* @inner
|
||
*/ function base64_decode(s, len) {
|
||
var off = 0, slen = s.length, olen = 0, rs = [], c1, c2, c3, c4, o, code;
|
||
if (len <= 0) throw Error("Illegal len: " + len);
|
||
while(off < slen - 1 && olen < len){
|
||
code = s.charCodeAt(off++);
|
||
c1 = code < BASE64_INDEX.length ? BASE64_INDEX[code] : -1;
|
||
code = s.charCodeAt(off++);
|
||
c2 = code < BASE64_INDEX.length ? BASE64_INDEX[code] : -1;
|
||
if (c1 == -1 || c2 == -1) break;
|
||
o = c1 << 2 >>> 0;
|
||
o |= (c2 & 0x30) >> 4;
|
||
rs.push(String.fromCharCode(o));
|
||
if (++olen >= len || off >= slen) break;
|
||
code = s.charCodeAt(off++);
|
||
c3 = code < BASE64_INDEX.length ? BASE64_INDEX[code] : -1;
|
||
if (c3 == -1) break;
|
||
o = (c2 & 0x0f) << 4 >>> 0;
|
||
o |= (c3 & 0x3c) >> 2;
|
||
rs.push(String.fromCharCode(o));
|
||
if (++olen >= len || off >= slen) break;
|
||
code = s.charCodeAt(off++);
|
||
c4 = code < BASE64_INDEX.length ? BASE64_INDEX[code] : -1;
|
||
o = (c3 & 0x03) << 6 >>> 0;
|
||
o |= c4;
|
||
rs.push(String.fromCharCode(o));
|
||
++olen;
|
||
}
|
||
var res = [];
|
||
for(off = 0; off < olen; off++)res.push(rs[off].charCodeAt(0));
|
||
return res;
|
||
}
|
||
/**
|
||
* @type {number}
|
||
* @const
|
||
* @inner
|
||
*/ var BCRYPT_SALT_LEN = 16;
|
||
/**
|
||
* @type {number}
|
||
* @const
|
||
* @inner
|
||
*/ var GENSALT_DEFAULT_LOG2_ROUNDS = 10;
|
||
/**
|
||
* @type {number}
|
||
* @const
|
||
* @inner
|
||
*/ var BLOWFISH_NUM_ROUNDS = 16;
|
||
/**
|
||
* @type {number}
|
||
* @const
|
||
* @inner
|
||
*/ var MAX_EXECUTION_TIME = 100;
|
||
/**
|
||
* @type {Array.<number>}
|
||
* @const
|
||
* @inner
|
||
*/ var P_ORIG = [
|
||
0x243f6a88,
|
||
0x85a308d3,
|
||
0x13198a2e,
|
||
0x03707344,
|
||
0xa4093822,
|
||
0x299f31d0,
|
||
0x082efa98,
|
||
0xec4e6c89,
|
||
0x452821e6,
|
||
0x38d01377,
|
||
0xbe5466cf,
|
||
0x34e90c6c,
|
||
0xc0ac29b7,
|
||
0xc97c50dd,
|
||
0x3f84d5b5,
|
||
0xb5470917,
|
||
0x9216d5d9,
|
||
0x8979fb1b
|
||
];
|
||
/**
|
||
* @type {Array.<number>}
|
||
* @const
|
||
* @inner
|
||
*/ var S_ORIG = [
|
||
0xd1310ba6,
|
||
0x98dfb5ac,
|
||
0x2ffd72db,
|
||
0xd01adfb7,
|
||
0xb8e1afed,
|
||
0x6a267e96,
|
||
0xba7c9045,
|
||
0xf12c7f99,
|
||
0x24a19947,
|
||
0xb3916cf7,
|
||
0x0801f2e2,
|
||
0x858efc16,
|
||
0x636920d8,
|
||
0x71574e69,
|
||
0xa458fea3,
|
||
0xf4933d7e,
|
||
0x0d95748f,
|
||
0x728eb658,
|
||
0x718bcd58,
|
||
0x82154aee,
|
||
0x7b54a41d,
|
||
0xc25a59b5,
|
||
0x9c30d539,
|
||
0x2af26013,
|
||
0xc5d1b023,
|
||
0x286085f0,
|
||
0xca417918,
|
||
0xb8db38ef,
|
||
0x8e79dcb0,
|
||
0x603a180e,
|
||
0x6c9e0e8b,
|
||
0xb01e8a3e,
|
||
0xd71577c1,
|
||
0xbd314b27,
|
||
0x78af2fda,
|
||
0x55605c60,
|
||
0xe65525f3,
|
||
0xaa55ab94,
|
||
0x57489862,
|
||
0x63e81440,
|
||
0x55ca396a,
|
||
0x2aab10b6,
|
||
0xb4cc5c34,
|
||
0x1141e8ce,
|
||
0xa15486af,
|
||
0x7c72e993,
|
||
0xb3ee1411,
|
||
0x636fbc2a,
|
||
0x2ba9c55d,
|
||
0x741831f6,
|
||
0xce5c3e16,
|
||
0x9b87931e,
|
||
0xafd6ba33,
|
||
0x6c24cf5c,
|
||
0x7a325381,
|
||
0x28958677,
|
||
0x3b8f4898,
|
||
0x6b4bb9af,
|
||
0xc4bfe81b,
|
||
0x66282193,
|
||
0x61d809cc,
|
||
0xfb21a991,
|
||
0x487cac60,
|
||
0x5dec8032,
|
||
0xef845d5d,
|
||
0xe98575b1,
|
||
0xdc262302,
|
||
0xeb651b88,
|
||
0x23893e81,
|
||
0xd396acc5,
|
||
0x0f6d6ff3,
|
||
0x83f44239,
|
||
0x2e0b4482,
|
||
0xa4842004,
|
||
0x69c8f04a,
|
||
0x9e1f9b5e,
|
||
0x21c66842,
|
||
0xf6e96c9a,
|
||
0x670c9c61,
|
||
0xabd388f0,
|
||
0x6a51a0d2,
|
||
0xd8542f68,
|
||
0x960fa728,
|
||
0xab5133a3,
|
||
0x6eef0b6c,
|
||
0x137a3be4,
|
||
0xba3bf050,
|
||
0x7efb2a98,
|
||
0xa1f1651d,
|
||
0x39af0176,
|
||
0x66ca593e,
|
||
0x82430e88,
|
||
0x8cee8619,
|
||
0x456f9fb4,
|
||
0x7d84a5c3,
|
||
0x3b8b5ebe,
|
||
0xe06f75d8,
|
||
0x85c12073,
|
||
0x401a449f,
|
||
0x56c16aa6,
|
||
0x4ed3aa62,
|
||
0x363f7706,
|
||
0x1bfedf72,
|
||
0x429b023d,
|
||
0x37d0d724,
|
||
0xd00a1248,
|
||
0xdb0fead3,
|
||
0x49f1c09b,
|
||
0x075372c9,
|
||
0x80991b7b,
|
||
0x25d479d8,
|
||
0xf6e8def7,
|
||
0xe3fe501a,
|
||
0xb6794c3b,
|
||
0x976ce0bd,
|
||
0x04c006ba,
|
||
0xc1a94fb6,
|
||
0x409f60c4,
|
||
0x5e5c9ec2,
|
||
0x196a2463,
|
||
0x68fb6faf,
|
||
0x3e6c53b5,
|
||
0x1339b2eb,
|
||
0x3b52ec6f,
|
||
0x6dfc511f,
|
||
0x9b30952c,
|
||
0xcc814544,
|
||
0xaf5ebd09,
|
||
0xbee3d004,
|
||
0xde334afd,
|
||
0x660f2807,
|
||
0x192e4bb3,
|
||
0xc0cba857,
|
||
0x45c8740f,
|
||
0xd20b5f39,
|
||
0xb9d3fbdb,
|
||
0x5579c0bd,
|
||
0x1a60320a,
|
||
0xd6a100c6,
|
||
0x402c7279,
|
||
0x679f25fe,
|
||
0xfb1fa3cc,
|
||
0x8ea5e9f8,
|
||
0xdb3222f8,
|
||
0x3c7516df,
|
||
0xfd616b15,
|
||
0x2f501ec8,
|
||
0xad0552ab,
|
||
0x323db5fa,
|
||
0xfd238760,
|
||
0x53317b48,
|
||
0x3e00df82,
|
||
0x9e5c57bb,
|
||
0xca6f8ca0,
|
||
0x1a87562e,
|
||
0xdf1769db,
|
||
0xd542a8f6,
|
||
0x287effc3,
|
||
0xac6732c6,
|
||
0x8c4f5573,
|
||
0x695b27b0,
|
||
0xbbca58c8,
|
||
0xe1ffa35d,
|
||
0xb8f011a0,
|
||
0x10fa3d98,
|
||
0xfd2183b8,
|
||
0x4afcb56c,
|
||
0x2dd1d35b,
|
||
0x9a53e479,
|
||
0xb6f84565,
|
||
0xd28e49bc,
|
||
0x4bfb9790,
|
||
0xe1ddf2da,
|
||
0xa4cb7e33,
|
||
0x62fb1341,
|
||
0xcee4c6e8,
|
||
0xef20cada,
|
||
0x36774c01,
|
||
0xd07e9efe,
|
||
0x2bf11fb4,
|
||
0x95dbda4d,
|
||
0xae909198,
|
||
0xeaad8e71,
|
||
0x6b93d5a0,
|
||
0xd08ed1d0,
|
||
0xafc725e0,
|
||
0x8e3c5b2f,
|
||
0x8e7594b7,
|
||
0x8ff6e2fb,
|
||
0xf2122b64,
|
||
0x8888b812,
|
||
0x900df01c,
|
||
0x4fad5ea0,
|
||
0x688fc31c,
|
||
0xd1cff191,
|
||
0xb3a8c1ad,
|
||
0x2f2f2218,
|
||
0xbe0e1777,
|
||
0xea752dfe,
|
||
0x8b021fa1,
|
||
0xe5a0cc0f,
|
||
0xb56f74e8,
|
||
0x18acf3d6,
|
||
0xce89e299,
|
||
0xb4a84fe0,
|
||
0xfd13e0b7,
|
||
0x7cc43b81,
|
||
0xd2ada8d9,
|
||
0x165fa266,
|
||
0x80957705,
|
||
0x93cc7314,
|
||
0x211a1477,
|
||
0xe6ad2065,
|
||
0x77b5fa86,
|
||
0xc75442f5,
|
||
0xfb9d35cf,
|
||
0xebcdaf0c,
|
||
0x7b3e89a0,
|
||
0xd6411bd3,
|
||
0xae1e7e49,
|
||
0x00250e2d,
|
||
0x2071b35e,
|
||
0x226800bb,
|
||
0x57b8e0af,
|
||
0x2464369b,
|
||
0xf009b91e,
|
||
0x5563911d,
|
||
0x59dfa6aa,
|
||
0x78c14389,
|
||
0xd95a537f,
|
||
0x207d5ba2,
|
||
0x02e5b9c5,
|
||
0x83260376,
|
||
0x6295cfa9,
|
||
0x11c81968,
|
||
0x4e734a41,
|
||
0xb3472dca,
|
||
0x7b14a94a,
|
||
0x1b510052,
|
||
0x9a532915,
|
||
0xd60f573f,
|
||
0xbc9bc6e4,
|
||
0x2b60a476,
|
||
0x81e67400,
|
||
0x08ba6fb5,
|
||
0x571be91f,
|
||
0xf296ec6b,
|
||
0x2a0dd915,
|
||
0xb6636521,
|
||
0xe7b9f9b6,
|
||
0xff34052e,
|
||
0xc5855664,
|
||
0x53b02d5d,
|
||
0xa99f8fa1,
|
||
0x08ba4799,
|
||
0x6e85076a,
|
||
0x4b7a70e9,
|
||
0xb5b32944,
|
||
0xdb75092e,
|
||
0xc4192623,
|
||
0xad6ea6b0,
|
||
0x49a7df7d,
|
||
0x9cee60b8,
|
||
0x8fedb266,
|
||
0xecaa8c71,
|
||
0x699a17ff,
|
||
0x5664526c,
|
||
0xc2b19ee1,
|
||
0x193602a5,
|
||
0x75094c29,
|
||
0xa0591340,
|
||
0xe4183a3e,
|
||
0x3f54989a,
|
||
0x5b429d65,
|
||
0x6b8fe4d6,
|
||
0x99f73fd6,
|
||
0xa1d29c07,
|
||
0xefe830f5,
|
||
0x4d2d38e6,
|
||
0xf0255dc1,
|
||
0x4cdd2086,
|
||
0x8470eb26,
|
||
0x6382e9c6,
|
||
0x021ecc5e,
|
||
0x09686b3f,
|
||
0x3ebaefc9,
|
||
0x3c971814,
|
||
0x6b6a70a1,
|
||
0x687f3584,
|
||
0x52a0e286,
|
||
0xb79c5305,
|
||
0xaa500737,
|
||
0x3e07841c,
|
||
0x7fdeae5c,
|
||
0x8e7d44ec,
|
||
0x5716f2b8,
|
||
0xb03ada37,
|
||
0xf0500c0d,
|
||
0xf01c1f04,
|
||
0x0200b3ff,
|
||
0xae0cf51a,
|
||
0x3cb574b2,
|
||
0x25837a58,
|
||
0xdc0921bd,
|
||
0xd19113f9,
|
||
0x7ca92ff6,
|
||
0x94324773,
|
||
0x22f54701,
|
||
0x3ae5e581,
|
||
0x37c2dadc,
|
||
0xc8b57634,
|
||
0x9af3dda7,
|
||
0xa9446146,
|
||
0x0fd0030e,
|
||
0xecc8c73e,
|
||
0xa4751e41,
|
||
0xe238cd99,
|
||
0x3bea0e2f,
|
||
0x3280bba1,
|
||
0x183eb331,
|
||
0x4e548b38,
|
||
0x4f6db908,
|
||
0x6f420d03,
|
||
0xf60a04bf,
|
||
0x2cb81290,
|
||
0x24977c79,
|
||
0x5679b072,
|
||
0xbcaf89af,
|
||
0xde9a771f,
|
||
0xd9930810,
|
||
0xb38bae12,
|
||
0xdccf3f2e,
|
||
0x5512721f,
|
||
0x2e6b7124,
|
||
0x501adde6,
|
||
0x9f84cd87,
|
||
0x7a584718,
|
||
0x7408da17,
|
||
0xbc9f9abc,
|
||
0xe94b7d8c,
|
||
0xec7aec3a,
|
||
0xdb851dfa,
|
||
0x63094366,
|
||
0xc464c3d2,
|
||
0xef1c1847,
|
||
0x3215d908,
|
||
0xdd433b37,
|
||
0x24c2ba16,
|
||
0x12a14d43,
|
||
0x2a65c451,
|
||
0x50940002,
|
||
0x133ae4dd,
|
||
0x71dff89e,
|
||
0x10314e55,
|
||
0x81ac77d6,
|
||
0x5f11199b,
|
||
0x043556f1,
|
||
0xd7a3c76b,
|
||
0x3c11183b,
|
||
0x5924a509,
|
||
0xf28fe6ed,
|
||
0x97f1fbfa,
|
||
0x9ebabf2c,
|
||
0x1e153c6e,
|
||
0x86e34570,
|
||
0xeae96fb1,
|
||
0x860e5e0a,
|
||
0x5a3e2ab3,
|
||
0x771fe71c,
|
||
0x4e3d06fa,
|
||
0x2965dcb9,
|
||
0x99e71d0f,
|
||
0x803e89d6,
|
||
0x5266c825,
|
||
0x2e4cc978,
|
||
0x9c10b36a,
|
||
0xc6150eba,
|
||
0x94e2ea78,
|
||
0xa5fc3c53,
|
||
0x1e0a2df4,
|
||
0xf2f74ea7,
|
||
0x361d2b3d,
|
||
0x1939260f,
|
||
0x19c27960,
|
||
0x5223a708,
|
||
0xf71312b6,
|
||
0xebadfe6e,
|
||
0xeac31f66,
|
||
0xe3bc4595,
|
||
0xa67bc883,
|
||
0xb17f37d1,
|
||
0x018cff28,
|
||
0xc332ddef,
|
||
0xbe6c5aa5,
|
||
0x65582185,
|
||
0x68ab9802,
|
||
0xeecea50f,
|
||
0xdb2f953b,
|
||
0x2aef7dad,
|
||
0x5b6e2f84,
|
||
0x1521b628,
|
||
0x29076170,
|
||
0xecdd4775,
|
||
0x619f1510,
|
||
0x13cca830,
|
||
0xeb61bd96,
|
||
0x0334fe1e,
|
||
0xaa0363cf,
|
||
0xb5735c90,
|
||
0x4c70a239,
|
||
0xd59e9e0b,
|
||
0xcbaade14,
|
||
0xeecc86bc,
|
||
0x60622ca7,
|
||
0x9cab5cab,
|
||
0xb2f3846e,
|
||
0x648b1eaf,
|
||
0x19bdf0ca,
|
||
0xa02369b9,
|
||
0x655abb50,
|
||
0x40685a32,
|
||
0x3c2ab4b3,
|
||
0x319ee9d5,
|
||
0xc021b8f7,
|
||
0x9b540b19,
|
||
0x875fa099,
|
||
0x95f7997e,
|
||
0x623d7da8,
|
||
0xf837889a,
|
||
0x97e32d77,
|
||
0x11ed935f,
|
||
0x16681281,
|
||
0x0e358829,
|
||
0xc7e61fd6,
|
||
0x96dedfa1,
|
||
0x7858ba99,
|
||
0x57f584a5,
|
||
0x1b227263,
|
||
0x9b83c3ff,
|
||
0x1ac24696,
|
||
0xcdb30aeb,
|
||
0x532e3054,
|
||
0x8fd948e4,
|
||
0x6dbc3128,
|
||
0x58ebf2ef,
|
||
0x34c6ffea,
|
||
0xfe28ed61,
|
||
0xee7c3c73,
|
||
0x5d4a14d9,
|
||
0xe864b7e3,
|
||
0x42105d14,
|
||
0x203e13e0,
|
||
0x45eee2b6,
|
||
0xa3aaabea,
|
||
0xdb6c4f15,
|
||
0xfacb4fd0,
|
||
0xc742f442,
|
||
0xef6abbb5,
|
||
0x654f3b1d,
|
||
0x41cd2105,
|
||
0xd81e799e,
|
||
0x86854dc7,
|
||
0xe44b476a,
|
||
0x3d816250,
|
||
0xcf62a1f2,
|
||
0x5b8d2646,
|
||
0xfc8883a0,
|
||
0xc1c7b6a3,
|
||
0x7f1524c3,
|
||
0x69cb7492,
|
||
0x47848a0b,
|
||
0x5692b285,
|
||
0x095bbf00,
|
||
0xad19489d,
|
||
0x1462b174,
|
||
0x23820e00,
|
||
0x58428d2a,
|
||
0x0c55f5ea,
|
||
0x1dadf43e,
|
||
0x233f7061,
|
||
0x3372f092,
|
||
0x8d937e41,
|
||
0xd65fecf1,
|
||
0x6c223bdb,
|
||
0x7cde3759,
|
||
0xcbee7460,
|
||
0x4085f2a7,
|
||
0xce77326e,
|
||
0xa6078084,
|
||
0x19f8509e,
|
||
0xe8efd855,
|
||
0x61d99735,
|
||
0xa969a7aa,
|
||
0xc50c06c2,
|
||
0x5a04abfc,
|
||
0x800bcadc,
|
||
0x9e447a2e,
|
||
0xc3453484,
|
||
0xfdd56705,
|
||
0x0e1e9ec9,
|
||
0xdb73dbd3,
|
||
0x105588cd,
|
||
0x675fda79,
|
||
0xe3674340,
|
||
0xc5c43465,
|
||
0x713e38d8,
|
||
0x3d28f89e,
|
||
0xf16dff20,
|
||
0x153e21e7,
|
||
0x8fb03d4a,
|
||
0xe6e39f2b,
|
||
0xdb83adf7,
|
||
0xe93d5a68,
|
||
0x948140f7,
|
||
0xf64c261c,
|
||
0x94692934,
|
||
0x411520f7,
|
||
0x7602d4f7,
|
||
0xbcf46b2e,
|
||
0xd4a20068,
|
||
0xd4082471,
|
||
0x3320f46a,
|
||
0x43b7d4b7,
|
||
0x500061af,
|
||
0x1e39f62e,
|
||
0x97244546,
|
||
0x14214f74,
|
||
0xbf8b8840,
|
||
0x4d95fc1d,
|
||
0x96b591af,
|
||
0x70f4ddd3,
|
||
0x66a02f45,
|
||
0xbfbc09ec,
|
||
0x03bd9785,
|
||
0x7fac6dd0,
|
||
0x31cb8504,
|
||
0x96eb27b3,
|
||
0x55fd3941,
|
||
0xda2547e6,
|
||
0xabca0a9a,
|
||
0x28507825,
|
||
0x530429f4,
|
||
0x0a2c86da,
|
||
0xe9b66dfb,
|
||
0x68dc1462,
|
||
0xd7486900,
|
||
0x680ec0a4,
|
||
0x27a18dee,
|
||
0x4f3ffea2,
|
||
0xe887ad8c,
|
||
0xb58ce006,
|
||
0x7af4d6b6,
|
||
0xaace1e7c,
|
||
0xd3375fec,
|
||
0xce78a399,
|
||
0x406b2a42,
|
||
0x20fe9e35,
|
||
0xd9f385b9,
|
||
0xee39d7ab,
|
||
0x3b124e8b,
|
||
0x1dc9faf7,
|
||
0x4b6d1856,
|
||
0x26a36631,
|
||
0xeae397b2,
|
||
0x3a6efa74,
|
||
0xdd5b4332,
|
||
0x6841e7f7,
|
||
0xca7820fb,
|
||
0xfb0af54e,
|
||
0xd8feb397,
|
||
0x454056ac,
|
||
0xba489527,
|
||
0x55533a3a,
|
||
0x20838d87,
|
||
0xfe6ba9b7,
|
||
0xd096954b,
|
||
0x55a867bc,
|
||
0xa1159a58,
|
||
0xcca92963,
|
||
0x99e1db33,
|
||
0xa62a4a56,
|
||
0x3f3125f9,
|
||
0x5ef47e1c,
|
||
0x9029317c,
|
||
0xfdf8e802,
|
||
0x04272f70,
|
||
0x80bb155c,
|
||
0x05282ce3,
|
||
0x95c11548,
|
||
0xe4c66d22,
|
||
0x48c1133f,
|
||
0xc70f86dc,
|
||
0x07f9c9ee,
|
||
0x41041f0f,
|
||
0x404779a4,
|
||
0x5d886e17,
|
||
0x325f51eb,
|
||
0xd59bc0d1,
|
||
0xf2bcc18f,
|
||
0x41113564,
|
||
0x257b7834,
|
||
0x602a9c60,
|
||
0xdff8e8a3,
|
||
0x1f636c1b,
|
||
0x0e12b4c2,
|
||
0x02e1329e,
|
||
0xaf664fd1,
|
||
0xcad18115,
|
||
0x6b2395e0,
|
||
0x333e92e1,
|
||
0x3b240b62,
|
||
0xeebeb922,
|
||
0x85b2a20e,
|
||
0xe6ba0d99,
|
||
0xde720c8c,
|
||
0x2da2f728,
|
||
0xd0127845,
|
||
0x95b794fd,
|
||
0x647d0862,
|
||
0xe7ccf5f0,
|
||
0x5449a36f,
|
||
0x877d48fa,
|
||
0xc39dfd27,
|
||
0xf33e8d1e,
|
||
0x0a476341,
|
||
0x992eff74,
|
||
0x3a6f6eab,
|
||
0xf4f8fd37,
|
||
0xa812dc60,
|
||
0xa1ebddf8,
|
||
0x991be14c,
|
||
0xdb6e6b0d,
|
||
0xc67b5510,
|
||
0x6d672c37,
|
||
0x2765d43b,
|
||
0xdcd0e804,
|
||
0xf1290dc7,
|
||
0xcc00ffa3,
|
||
0xb5390f92,
|
||
0x690fed0b,
|
||
0x667b9ffb,
|
||
0xcedb7d9c,
|
||
0xa091cf0b,
|
||
0xd9155ea3,
|
||
0xbb132f88,
|
||
0x515bad24,
|
||
0x7b9479bf,
|
||
0x763bd6eb,
|
||
0x37392eb3,
|
||
0xcc115979,
|
||
0x8026e297,
|
||
0xf42e312d,
|
||
0x6842ada7,
|
||
0xc66a2b3b,
|
||
0x12754ccc,
|
||
0x782ef11c,
|
||
0x6a124237,
|
||
0xb79251e7,
|
||
0x06a1bbe6,
|
||
0x4bfb6350,
|
||
0x1a6b1018,
|
||
0x11caedfa,
|
||
0x3d25bdd8,
|
||
0xe2e1c3c9,
|
||
0x44421659,
|
||
0x0a121386,
|
||
0xd90cec6e,
|
||
0xd5abea2a,
|
||
0x64af674e,
|
||
0xda86a85f,
|
||
0xbebfe988,
|
||
0x64e4c3fe,
|
||
0x9dbc8057,
|
||
0xf0f7c086,
|
||
0x60787bf8,
|
||
0x6003604d,
|
||
0xd1fd8346,
|
||
0xf6381fb0,
|
||
0x7745ae04,
|
||
0xd736fccc,
|
||
0x83426b33,
|
||
0xf01eab71,
|
||
0xb0804187,
|
||
0x3c005e5f,
|
||
0x77a057be,
|
||
0xbde8ae24,
|
||
0x55464299,
|
||
0xbf582e61,
|
||
0x4e58f48f,
|
||
0xf2ddfda2,
|
||
0xf474ef38,
|
||
0x8789bdc2,
|
||
0x5366f9c3,
|
||
0xc8b38e74,
|
||
0xb475f255,
|
||
0x46fcd9b9,
|
||
0x7aeb2661,
|
||
0x8b1ddf84,
|
||
0x846a0e79,
|
||
0x915f95e2,
|
||
0x466e598e,
|
||
0x20b45770,
|
||
0x8cd55591,
|
||
0xc902de4c,
|
||
0xb90bace1,
|
||
0xbb8205d0,
|
||
0x11a86248,
|
||
0x7574a99e,
|
||
0xb77f19b6,
|
||
0xe0a9dc09,
|
||
0x662d09a1,
|
||
0xc4324633,
|
||
0xe85a1f02,
|
||
0x09f0be8c,
|
||
0x4a99a025,
|
||
0x1d6efe10,
|
||
0x1ab93d1d,
|
||
0x0ba5a4df,
|
||
0xa186f20f,
|
||
0x2868f169,
|
||
0xdcb7da83,
|
||
0x573906fe,
|
||
0xa1e2ce9b,
|
||
0x4fcd7f52,
|
||
0x50115e01,
|
||
0xa70683fa,
|
||
0xa002b5c4,
|
||
0x0de6d027,
|
||
0x9af88c27,
|
||
0x773f8641,
|
||
0xc3604c06,
|
||
0x61a806b5,
|
||
0xf0177a28,
|
||
0xc0f586e0,
|
||
0x006058aa,
|
||
0x30dc7d62,
|
||
0x11e69ed7,
|
||
0x2338ea63,
|
||
0x53c2dd94,
|
||
0xc2c21634,
|
||
0xbbcbee56,
|
||
0x90bcb6de,
|
||
0xebfc7da1,
|
||
0xce591d76,
|
||
0x6f05e409,
|
||
0x4b7c0188,
|
||
0x39720a3d,
|
||
0x7c927c24,
|
||
0x86e3725f,
|
||
0x724d9db9,
|
||
0x1ac15bb4,
|
||
0xd39eb8fc,
|
||
0xed545578,
|
||
0x08fca5b5,
|
||
0xd83d7cd3,
|
||
0x4dad0fc4,
|
||
0x1e50ef5e,
|
||
0xb161e6f8,
|
||
0xa28514d9,
|
||
0x6c51133c,
|
||
0x6fd5c7e7,
|
||
0x56e14ec4,
|
||
0x362abfce,
|
||
0xddc6c837,
|
||
0xd79a3234,
|
||
0x92638212,
|
||
0x670efa8e,
|
||
0x406000e0,
|
||
0x3a39ce37,
|
||
0xd3faf5cf,
|
||
0xabc27737,
|
||
0x5ac52d1b,
|
||
0x5cb0679e,
|
||
0x4fa33742,
|
||
0xd3822740,
|
||
0x99bc9bbe,
|
||
0xd5118e9d,
|
||
0xbf0f7315,
|
||
0xd62d1c7e,
|
||
0xc700c47b,
|
||
0xb78c1b6b,
|
||
0x21a19045,
|
||
0xb26eb1be,
|
||
0x6a366eb4,
|
||
0x5748ab2f,
|
||
0xbc946e79,
|
||
0xc6a376d2,
|
||
0x6549c2c8,
|
||
0x530ff8ee,
|
||
0x468dde7d,
|
||
0xd5730a1d,
|
||
0x4cd04dc6,
|
||
0x2939bbdb,
|
||
0xa9ba4650,
|
||
0xac9526e8,
|
||
0xbe5ee304,
|
||
0xa1fad5f0,
|
||
0x6a2d519a,
|
||
0x63ef8ce2,
|
||
0x9a86ee22,
|
||
0xc089c2b8,
|
||
0x43242ef6,
|
||
0xa51e03aa,
|
||
0x9cf2d0a4,
|
||
0x83c061ba,
|
||
0x9be96a4d,
|
||
0x8fe51550,
|
||
0xba645bd6,
|
||
0x2826a2f9,
|
||
0xa73a3ae1,
|
||
0x4ba99586,
|
||
0xef5562e9,
|
||
0xc72fefd3,
|
||
0xf752f7da,
|
||
0x3f046f69,
|
||
0x77fa0a59,
|
||
0x80e4a915,
|
||
0x87b08601,
|
||
0x9b09e6ad,
|
||
0x3b3ee593,
|
||
0xe990fd5a,
|
||
0x9e34d797,
|
||
0x2cf0b7d9,
|
||
0x022b8b51,
|
||
0x96d5ac3a,
|
||
0x017da67d,
|
||
0xd1cf3ed6,
|
||
0x7c7d2d28,
|
||
0x1f9f25cf,
|
||
0xadf2b89b,
|
||
0x5ad6b472,
|
||
0x5a88f54c,
|
||
0xe029ac71,
|
||
0xe019a5e6,
|
||
0x47b0acfd,
|
||
0xed93fa9b,
|
||
0xe8d3c48d,
|
||
0x283b57cc,
|
||
0xf8d56629,
|
||
0x79132e28,
|
||
0x785f0191,
|
||
0xed756055,
|
||
0xf7960e44,
|
||
0xe3d35e8c,
|
||
0x15056dd4,
|
||
0x88f46dba,
|
||
0x03a16125,
|
||
0x0564f0bd,
|
||
0xc3eb9e15,
|
||
0x3c9057a2,
|
||
0x97271aec,
|
||
0xa93a072a,
|
||
0x1b3f6d9b,
|
||
0x1e6321f5,
|
||
0xf59c66fb,
|
||
0x26dcf319,
|
||
0x7533d928,
|
||
0xb155fdf5,
|
||
0x03563482,
|
||
0x8aba3cbb,
|
||
0x28517711,
|
||
0xc20ad9f8,
|
||
0xabcc5167,
|
||
0xccad925f,
|
||
0x4de81751,
|
||
0x3830dc8e,
|
||
0x379d5862,
|
||
0x9320f991,
|
||
0xea7a90c2,
|
||
0xfb3e7bce,
|
||
0x5121ce64,
|
||
0x774fbe32,
|
||
0xa8b6e37e,
|
||
0xc3293d46,
|
||
0x48de5369,
|
||
0x6413e680,
|
||
0xa2ae0810,
|
||
0xdd6db224,
|
||
0x69852dfd,
|
||
0x09072166,
|
||
0xb39a460a,
|
||
0x6445c0dd,
|
||
0x586cdecf,
|
||
0x1c20c8ae,
|
||
0x5bbef7dd,
|
||
0x1b588d40,
|
||
0xccd2017f,
|
||
0x6bb4e3bb,
|
||
0xdda26a7e,
|
||
0x3a59ff45,
|
||
0x3e350a44,
|
||
0xbcb4cdd5,
|
||
0x72eacea8,
|
||
0xfa6484bb,
|
||
0x8d6612ae,
|
||
0xbf3c6f47,
|
||
0xd29be463,
|
||
0x542f5d9e,
|
||
0xaec2771b,
|
||
0xf64e6370,
|
||
0x740e0d8d,
|
||
0xe75b1357,
|
||
0xf8721671,
|
||
0xaf537d5d,
|
||
0x4040cb08,
|
||
0x4eb4e2cc,
|
||
0x34d2466a,
|
||
0x0115af84,
|
||
0xe1b00428,
|
||
0x95983a1d,
|
||
0x06b89fb4,
|
||
0xce6ea048,
|
||
0x6f3f3b82,
|
||
0x3520ab82,
|
||
0x011a1d4b,
|
||
0x277227f8,
|
||
0x611560b1,
|
||
0xe7933fdc,
|
||
0xbb3a792b,
|
||
0x344525bd,
|
||
0xa08839e1,
|
||
0x51ce794b,
|
||
0x2f32c9b7,
|
||
0xa01fbac9,
|
||
0xe01cc87e,
|
||
0xbcc7d1f6,
|
||
0xcf0111c3,
|
||
0xa1e8aac7,
|
||
0x1a908749,
|
||
0xd44fbd9a,
|
||
0xd0dadecb,
|
||
0xd50ada38,
|
||
0x0339c32a,
|
||
0xc6913667,
|
||
0x8df9317c,
|
||
0xe0b12b4f,
|
||
0xf79e59b7,
|
||
0x43f5bb3a,
|
||
0xf2d519ff,
|
||
0x27d9459c,
|
||
0xbf97222c,
|
||
0x15e6fc2a,
|
||
0x0f91fc71,
|
||
0x9b941525,
|
||
0xfae59361,
|
||
0xceb69ceb,
|
||
0xc2a86459,
|
||
0x12baa8d1,
|
||
0xb6c1075e,
|
||
0xe3056a0c,
|
||
0x10d25065,
|
||
0xcb03a442,
|
||
0xe0ec6e0e,
|
||
0x1698db3b,
|
||
0x4c98a0be,
|
||
0x3278e964,
|
||
0x9f1f9532,
|
||
0xe0d392df,
|
||
0xd3a0342b,
|
||
0x8971f21e,
|
||
0x1b0a7441,
|
||
0x4ba3348c,
|
||
0xc5be7120,
|
||
0xc37632d8,
|
||
0xdf359f8d,
|
||
0x9b992f2e,
|
||
0xe60b6f47,
|
||
0x0fe3f11d,
|
||
0xe54cda54,
|
||
0x1edad891,
|
||
0xce6279cf,
|
||
0xcd3e7e6f,
|
||
0x1618b166,
|
||
0xfd2c1d05,
|
||
0x848fd2c5,
|
||
0xf6fb2299,
|
||
0xf523f357,
|
||
0xa6327623,
|
||
0x93a83531,
|
||
0x56cccd02,
|
||
0xacf08162,
|
||
0x5a75ebb5,
|
||
0x6e163697,
|
||
0x88d273cc,
|
||
0xde966292,
|
||
0x81b949d0,
|
||
0x4c50901b,
|
||
0x71c65614,
|
||
0xe6c6c7bd,
|
||
0x327a140a,
|
||
0x45e1d006,
|
||
0xc3f27b9a,
|
||
0xc9aa53fd,
|
||
0x62a80f00,
|
||
0xbb25bfe2,
|
||
0x35bdd2f6,
|
||
0x71126905,
|
||
0xb2040222,
|
||
0xb6cbcf7c,
|
||
0xcd769c2b,
|
||
0x53113ec0,
|
||
0x1640e3d3,
|
||
0x38abbd60,
|
||
0x2547adf0,
|
||
0xba38209c,
|
||
0xf746ce76,
|
||
0x77afa1c5,
|
||
0x20756060,
|
||
0x85cbfe4e,
|
||
0x8ae88dd8,
|
||
0x7aaaf9b0,
|
||
0x4cf9aa7e,
|
||
0x1948c25c,
|
||
0x02fb8a8c,
|
||
0x01c36ae4,
|
||
0xd6ebe1f9,
|
||
0x90d4f869,
|
||
0xa65cdea0,
|
||
0x3f09252d,
|
||
0xc208e69f,
|
||
0xb74e6132,
|
||
0xce77e25b,
|
||
0x578fdfe3,
|
||
0x3ac372e6
|
||
];
|
||
/**
|
||
* @type {Array.<number>}
|
||
* @const
|
||
* @inner
|
||
*/ var C_ORIG = [
|
||
0x4f727068,
|
||
0x65616e42,
|
||
0x65686f6c,
|
||
0x64657253,
|
||
0x63727944,
|
||
0x6f756274
|
||
];
|
||
/**
|
||
* @param {Array.<number>} lr
|
||
* @param {number} off
|
||
* @param {Array.<number>} P
|
||
* @param {Array.<number>} S
|
||
* @returns {Array.<number>}
|
||
* @inner
|
||
*/ function _encipher(lr, off, P, S) {
|
||
// This is our bottleneck: 1714/1905 ticks / 90% - see profile.txt
|
||
var n, l = lr[off], r = lr[off + 1];
|
||
l ^= P[0];
|
||
/*
|
||
for (var i=0, k=BLOWFISH_NUM_ROUNDS-2; i<=k;)
|
||
// Feistel substitution on left word
|
||
n = S[l >>> 24],
|
||
n += S[0x100 | ((l >> 16) & 0xff)],
|
||
n ^= S[0x200 | ((l >> 8) & 0xff)],
|
||
n += S[0x300 | (l & 0xff)],
|
||
r ^= n ^ P[++i],
|
||
// Feistel substitution on right word
|
||
n = S[r >>> 24],
|
||
n += S[0x100 | ((r >> 16) & 0xff)],
|
||
n ^= S[0x200 | ((r >> 8) & 0xff)],
|
||
n += S[0x300 | (r & 0xff)],
|
||
l ^= n ^ P[++i];
|
||
*/ //The following is an unrolled version of the above loop.
|
||
//Iteration 0
|
||
n = S[l >>> 24];
|
||
n += S[0x100 | l >> 16 & 0xff];
|
||
n ^= S[0x200 | l >> 8 & 0xff];
|
||
n += S[0x300 | l & 0xff];
|
||
r ^= n ^ P[1];
|
||
n = S[r >>> 24];
|
||
n += S[0x100 | r >> 16 & 0xff];
|
||
n ^= S[0x200 | r >> 8 & 0xff];
|
||
n += S[0x300 | r & 0xff];
|
||
l ^= n ^ P[2];
|
||
//Iteration 1
|
||
n = S[l >>> 24];
|
||
n += S[0x100 | l >> 16 & 0xff];
|
||
n ^= S[0x200 | l >> 8 & 0xff];
|
||
n += S[0x300 | l & 0xff];
|
||
r ^= n ^ P[3];
|
||
n = S[r >>> 24];
|
||
n += S[0x100 | r >> 16 & 0xff];
|
||
n ^= S[0x200 | r >> 8 & 0xff];
|
||
n += S[0x300 | r & 0xff];
|
||
l ^= n ^ P[4];
|
||
//Iteration 2
|
||
n = S[l >>> 24];
|
||
n += S[0x100 | l >> 16 & 0xff];
|
||
n ^= S[0x200 | l >> 8 & 0xff];
|
||
n += S[0x300 | l & 0xff];
|
||
r ^= n ^ P[5];
|
||
n = S[r >>> 24];
|
||
n += S[0x100 | r >> 16 & 0xff];
|
||
n ^= S[0x200 | r >> 8 & 0xff];
|
||
n += S[0x300 | r & 0xff];
|
||
l ^= n ^ P[6];
|
||
//Iteration 3
|
||
n = S[l >>> 24];
|
||
n += S[0x100 | l >> 16 & 0xff];
|
||
n ^= S[0x200 | l >> 8 & 0xff];
|
||
n += S[0x300 | l & 0xff];
|
||
r ^= n ^ P[7];
|
||
n = S[r >>> 24];
|
||
n += S[0x100 | r >> 16 & 0xff];
|
||
n ^= S[0x200 | r >> 8 & 0xff];
|
||
n += S[0x300 | r & 0xff];
|
||
l ^= n ^ P[8];
|
||
//Iteration 4
|
||
n = S[l >>> 24];
|
||
n += S[0x100 | l >> 16 & 0xff];
|
||
n ^= S[0x200 | l >> 8 & 0xff];
|
||
n += S[0x300 | l & 0xff];
|
||
r ^= n ^ P[9];
|
||
n = S[r >>> 24];
|
||
n += S[0x100 | r >> 16 & 0xff];
|
||
n ^= S[0x200 | r >> 8 & 0xff];
|
||
n += S[0x300 | r & 0xff];
|
||
l ^= n ^ P[10];
|
||
//Iteration 5
|
||
n = S[l >>> 24];
|
||
n += S[0x100 | l >> 16 & 0xff];
|
||
n ^= S[0x200 | l >> 8 & 0xff];
|
||
n += S[0x300 | l & 0xff];
|
||
r ^= n ^ P[11];
|
||
n = S[r >>> 24];
|
||
n += S[0x100 | r >> 16 & 0xff];
|
||
n ^= S[0x200 | r >> 8 & 0xff];
|
||
n += S[0x300 | r & 0xff];
|
||
l ^= n ^ P[12];
|
||
//Iteration 6
|
||
n = S[l >>> 24];
|
||
n += S[0x100 | l >> 16 & 0xff];
|
||
n ^= S[0x200 | l >> 8 & 0xff];
|
||
n += S[0x300 | l & 0xff];
|
||
r ^= n ^ P[13];
|
||
n = S[r >>> 24];
|
||
n += S[0x100 | r >> 16 & 0xff];
|
||
n ^= S[0x200 | r >> 8 & 0xff];
|
||
n += S[0x300 | r & 0xff];
|
||
l ^= n ^ P[14];
|
||
//Iteration 7
|
||
n = S[l >>> 24];
|
||
n += S[0x100 | l >> 16 & 0xff];
|
||
n ^= S[0x200 | l >> 8 & 0xff];
|
||
n += S[0x300 | l & 0xff];
|
||
r ^= n ^ P[15];
|
||
n = S[r >>> 24];
|
||
n += S[0x100 | r >> 16 & 0xff];
|
||
n ^= S[0x200 | r >> 8 & 0xff];
|
||
n += S[0x300 | r & 0xff];
|
||
l ^= n ^ P[16];
|
||
lr[off] = r ^ P[BLOWFISH_NUM_ROUNDS + 1];
|
||
lr[off + 1] = l;
|
||
return lr;
|
||
}
|
||
/**
|
||
* @param {Array.<number>} data
|
||
* @param {number} offp
|
||
* @returns {{key: number, offp: number}}
|
||
* @inner
|
||
*/ function _streamtoword(data, offp) {
|
||
for(var i = 0, word = 0; i < 4; ++i)word = word << 8 | data[offp] & 0xff, offp = (offp + 1) % data.length;
|
||
return {
|
||
key: word,
|
||
offp: offp
|
||
};
|
||
}
|
||
/**
|
||
* @param {Array.<number>} key
|
||
* @param {Array.<number>} P
|
||
* @param {Array.<number>} S
|
||
* @inner
|
||
*/ function _key(key, P, S) {
|
||
var offset = 0, lr = [
|
||
0,
|
||
0
|
||
], plen = P.length, slen = S.length, sw;
|
||
for(var i = 0; i < plen; i++)sw = _streamtoword(key, offset), offset = sw.offp, P[i] = P[i] ^ sw.key;
|
||
for(i = 0; i < plen; i += 2)lr = _encipher(lr, 0, P, S), P[i] = lr[0], P[i + 1] = lr[1];
|
||
for(i = 0; i < slen; i += 2)lr = _encipher(lr, 0, P, S), S[i] = lr[0], S[i + 1] = lr[1];
|
||
}
|
||
/**
|
||
* Expensive key schedule Blowfish.
|
||
* @param {Array.<number>} data
|
||
* @param {Array.<number>} key
|
||
* @param {Array.<number>} P
|
||
* @param {Array.<number>} S
|
||
* @inner
|
||
*/ function _ekskey(data, key, P, S) {
|
||
var offp = 0, lr = [
|
||
0,
|
||
0
|
||
], plen = P.length, slen = S.length, sw;
|
||
for(var i = 0; i < plen; i++)sw = _streamtoword(key, offp), offp = sw.offp, P[i] = P[i] ^ sw.key;
|
||
offp = 0;
|
||
for(i = 0; i < plen; i += 2)sw = _streamtoword(data, offp), offp = sw.offp, lr[0] ^= sw.key, sw = _streamtoword(data, offp), offp = sw.offp, lr[1] ^= sw.key, lr = _encipher(lr, 0, P, S), P[i] = lr[0], P[i + 1] = lr[1];
|
||
for(i = 0; i < slen; i += 2)sw = _streamtoword(data, offp), offp = sw.offp, lr[0] ^= sw.key, sw = _streamtoword(data, offp), offp = sw.offp, lr[1] ^= sw.key, lr = _encipher(lr, 0, P, S), S[i] = lr[0], S[i + 1] = lr[1];
|
||
}
|
||
/**
|
||
* Internaly crypts a string.
|
||
* @param {Array.<number>} b Bytes to crypt
|
||
* @param {Array.<number>} salt Salt bytes to use
|
||
* @param {number} rounds Number of rounds
|
||
* @param {function(Error, Array.<number>=)=} callback Callback receiving the error, if any, and the resulting bytes. If
|
||
* omitted, the operation will be performed synchronously.
|
||
* @param {function(number)=} progressCallback Callback called with the current progress
|
||
* @returns {!Array.<number>|undefined} Resulting bytes if callback has been omitted, otherwise `undefined`
|
||
* @inner
|
||
*/ function _crypt(b, salt, rounds, callback, progressCallback) {
|
||
var cdata = C_ORIG.slice(), clen = cdata.length, err;
|
||
// Validate
|
||
if (rounds < 4 || rounds > 31) {
|
||
err = Error("Illegal number of rounds (4-31): " + rounds);
|
||
if (callback) {
|
||
nextTick(callback.bind(this, err));
|
||
return;
|
||
} else throw err;
|
||
}
|
||
if (salt.length !== BCRYPT_SALT_LEN) {
|
||
err = Error("Illegal salt length: " + salt.length + " != " + BCRYPT_SALT_LEN);
|
||
if (callback) {
|
||
nextTick(callback.bind(this, err));
|
||
return;
|
||
} else throw err;
|
||
}
|
||
rounds = 1 << rounds >>> 0;
|
||
var P, S, i = 0, j;
|
||
//Use typed arrays when available - huge speedup!
|
||
if (typeof Int32Array === "function") {
|
||
P = new Int32Array(P_ORIG);
|
||
S = new Int32Array(S_ORIG);
|
||
} else {
|
||
P = P_ORIG.slice();
|
||
S = S_ORIG.slice();
|
||
}
|
||
_ekskey(salt, b, P, S);
|
||
/**
|
||
* Calcualtes the next round.
|
||
* @returns {Array.<number>|undefined} Resulting array if callback has been omitted, otherwise `undefined`
|
||
* @inner
|
||
*/ function next() {
|
||
if (progressCallback) progressCallback(i / rounds);
|
||
if (i < rounds) {
|
||
var start = Date.now();
|
||
for(; i < rounds;){
|
||
i = i + 1;
|
||
_key(b, P, S);
|
||
_key(salt, P, S);
|
||
if (Date.now() - start > MAX_EXECUTION_TIME) break;
|
||
}
|
||
} else {
|
||
for(i = 0; i < 64; i++)for(j = 0; j < clen >> 1; j++)_encipher(cdata, j << 1, P, S);
|
||
var ret = [];
|
||
for(i = 0; i < clen; i++)ret.push((cdata[i] >> 24 & 0xff) >>> 0), ret.push((cdata[i] >> 16 & 0xff) >>> 0), ret.push((cdata[i] >> 8 & 0xff) >>> 0), ret.push((cdata[i] & 0xff) >>> 0);
|
||
if (callback) {
|
||
callback(null, ret);
|
||
return;
|
||
} else return ret;
|
||
}
|
||
if (callback) nextTick(next);
|
||
}
|
||
// Async
|
||
if (typeof callback !== "undefined") {
|
||
next();
|
||
// Sync
|
||
} else {
|
||
var res;
|
||
while(true)if (typeof (res = next()) !== "undefined") return res || [];
|
||
}
|
||
}
|
||
/**
|
||
* Internally hashes a password.
|
||
* @param {string} password Password to hash
|
||
* @param {?string} salt Salt to use, actually never null
|
||
* @param {function(Error, string=)=} callback Callback receiving the error, if any, and the resulting hash. If omitted,
|
||
* hashing is performed synchronously.
|
||
* @param {function(number)=} progressCallback Callback called with the current progress
|
||
* @returns {string|undefined} Resulting hash if callback has been omitted, otherwise `undefined`
|
||
* @inner
|
||
*/ function _hash(password, salt, callback, progressCallback) {
|
||
var err;
|
||
if (typeof password !== "string" || typeof salt !== "string") {
|
||
err = Error("Invalid string / salt: Not a string");
|
||
if (callback) {
|
||
nextTick(callback.bind(this, err));
|
||
return;
|
||
} else throw err;
|
||
}
|
||
// Validate the salt
|
||
var minor, offset;
|
||
if (salt.charAt(0) !== "$" || salt.charAt(1) !== "2") {
|
||
err = Error("Invalid salt version: " + salt.substring(0, 2));
|
||
if (callback) {
|
||
nextTick(callback.bind(this, err));
|
||
return;
|
||
} else throw err;
|
||
}
|
||
if (salt.charAt(2) === "$") minor = String.fromCharCode(0), offset = 3;
|
||
else {
|
||
minor = salt.charAt(2);
|
||
if (minor !== "a" && minor !== "b" && minor !== "y" || salt.charAt(3) !== "$") {
|
||
err = Error("Invalid salt revision: " + salt.substring(2, 4));
|
||
if (callback) {
|
||
nextTick(callback.bind(this, err));
|
||
return;
|
||
} else throw err;
|
||
}
|
||
offset = 4;
|
||
}
|
||
// Extract number of rounds
|
||
if (salt.charAt(offset + 2) > "$") {
|
||
err = Error("Missing salt rounds");
|
||
if (callback) {
|
||
nextTick(callback.bind(this, err));
|
||
return;
|
||
} else throw err;
|
||
}
|
||
var r1 = parseInt(salt.substring(offset, offset + 1), 10) * 10, r2 = parseInt(salt.substring(offset + 1, offset + 2), 10), rounds = r1 + r2, real_salt = salt.substring(offset + 3, offset + 25);
|
||
password += minor >= "a" ? "\x00" : "";
|
||
var passwordb = utf8Array(password), saltb = base64_decode(real_salt, BCRYPT_SALT_LEN);
|
||
/**
|
||
* Finishes hashing.
|
||
* @param {Array.<number>} bytes Byte array
|
||
* @returns {string}
|
||
* @inner
|
||
*/ function finish(bytes) {
|
||
var res = [];
|
||
res.push("$2");
|
||
if (minor >= "a") res.push(minor);
|
||
res.push("$");
|
||
if (rounds < 10) res.push("0");
|
||
res.push(rounds.toString());
|
||
res.push("$");
|
||
res.push(base64_encode(saltb, saltb.length));
|
||
res.push(base64_encode(bytes, C_ORIG.length * 4 - 1));
|
||
return res.join("");
|
||
}
|
||
// Sync
|
||
if (typeof callback == "undefined") return finish(_crypt(passwordb, saltb, rounds));
|
||
else {
|
||
_crypt(passwordb, saltb, rounds, function(err, bytes) {
|
||
if (err) callback(err, null);
|
||
else callback(null, finish(bytes));
|
||
}, progressCallback);
|
||
}
|
||
}
|
||
function encodeBase64(bytes, length) {
|
||
return base64_encode(bytes, length);
|
||
}
|
||
function decodeBase64(string, length) {
|
||
return base64_decode(string, length);
|
||
}
|
||
const __TURBOPACK__default__export__ = {
|
||
setRandomFallback,
|
||
genSaltSync,
|
||
genSalt,
|
||
hashSync,
|
||
hash,
|
||
compareSync,
|
||
compare,
|
||
getRounds,
|
||
getSalt,
|
||
truncates,
|
||
encodeBase64,
|
||
decodeBase64
|
||
};
|
||
}),
|
||
"[project]/node_modules/@babel/runtime/helpers/interopRequireDefault.js [app-route] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
|
||
function _interopRequireDefault(e) {
|
||
return e && e.__esModule ? e : {
|
||
"default": e
|
||
};
|
||
}
|
||
module.exports = _interopRequireDefault, module.exports.__esModule = true, module.exports["default"] = module.exports;
|
||
}),
|
||
"[project]/node_modules/@babel/runtime/helpers/OverloadYield.js [app-route] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
|
||
function _OverloadYield(e, d) {
|
||
this.v = e, this.k = d;
|
||
}
|
||
module.exports = _OverloadYield, module.exports.__esModule = true, module.exports["default"] = module.exports;
|
||
}),
|
||
"[project]/node_modules/@babel/runtime/helpers/regeneratorDefine.js [app-route] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
|
||
function _regeneratorDefine(e, r, n, t) {
|
||
var i = Object.defineProperty;
|
||
try {
|
||
i({}, "", {});
|
||
} catch (e) {
|
||
i = 0;
|
||
}
|
||
module.exports = _regeneratorDefine = function regeneratorDefine(e, r, n, t) {
|
||
function o(r, n) {
|
||
_regeneratorDefine(e, r, function(e) {
|
||
return this._invoke(r, n, e);
|
||
});
|
||
}
|
||
r ? i ? i(e, r, {
|
||
value: n,
|
||
enumerable: !t,
|
||
configurable: !t,
|
||
writable: !t
|
||
}) : e[r] = n : (o("next", 0), o("throw", 1), o("return", 2));
|
||
}, module.exports.__esModule = true, module.exports["default"] = module.exports, _regeneratorDefine(e, r, n, t);
|
||
}
|
||
module.exports = _regeneratorDefine, module.exports.__esModule = true, module.exports["default"] = module.exports;
|
||
}),
|
||
"[project]/node_modules/@babel/runtime/helpers/regenerator.js [app-route] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
|
||
var regeneratorDefine = __turbopack_context__.r("[project]/node_modules/@babel/runtime/helpers/regeneratorDefine.js [app-route] (ecmascript)");
|
||
function _regenerator() {
|
||
/*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/babel/babel/blob/main/packages/babel-helpers/LICENSE */ var e, t, r = "function" == typeof Symbol ? Symbol : {}, n = r.iterator || "@@iterator", o = r.toStringTag || "@@toStringTag";
|
||
function i(r, n, o, i) {
|
||
var c = n && n.prototype instanceof Generator ? n : Generator, u = Object.create(c.prototype);
|
||
return regeneratorDefine(u, "_invoke", function(r, n, o) {
|
||
var i, c, u, f = 0, p = o || [], y = !1, G = {
|
||
p: 0,
|
||
n: 0,
|
||
v: e,
|
||
a: d,
|
||
f: d.bind(e, 4),
|
||
d: function d(t, r) {
|
||
return i = t, c = 0, u = e, G.n = r, a;
|
||
}
|
||
};
|
||
function d(r, n) {
|
||
for(c = r, u = n, t = 0; !y && f && !o && t < p.length; t++){
|
||
var o, i = p[t], d = G.p, l = i[2];
|
||
r > 3 ? (o = l === n) && (u = i[(c = i[4]) ? 5 : (c = 3, 3)], i[4] = i[5] = e) : i[0] <= d && ((o = r < 2 && d < i[1]) ? (c = 0, G.v = n, G.n = i[1]) : d < l && (o = r < 3 || i[0] > n || n > l) && (i[4] = r, i[5] = n, G.n = l, c = 0));
|
||
}
|
||
if (o || r > 1) return a;
|
||
throw y = !0, n;
|
||
}
|
||
return function(o, p, l) {
|
||
if (f > 1) throw TypeError("Generator is already running");
|
||
for(y && 1 === p && d(p, l), c = p, u = l; (t = c < 2 ? e : u) || !y;){
|
||
i || (c ? c < 3 ? (c > 1 && (G.n = -1), d(c, u)) : G.n = u : G.v = u);
|
||
try {
|
||
if (f = 2, i) {
|
||
if (c || (o = "next"), t = i[o]) {
|
||
if (!(t = t.call(i, u))) throw TypeError("iterator result is not an object");
|
||
if (!t.done) return t;
|
||
u = t.value, c < 2 && (c = 0);
|
||
} else 1 === c && (t = i["return"]) && t.call(i), c < 2 && (u = TypeError("The iterator does not provide a '" + o + "' method"), c = 1);
|
||
i = e;
|
||
} else if ((t = (y = G.n < 0) ? u : r.call(n, G)) !== a) break;
|
||
} catch (t) {
|
||
i = e, c = 1, u = t;
|
||
} finally{
|
||
f = 1;
|
||
}
|
||
}
|
||
return {
|
||
value: t,
|
||
done: y
|
||
};
|
||
};
|
||
}(r, o, i), !0), u;
|
||
}
|
||
var a = {};
|
||
function Generator() {}
|
||
function GeneratorFunction() {}
|
||
function GeneratorFunctionPrototype() {}
|
||
t = Object.getPrototypeOf;
|
||
var c = [][n] ? t(t([][n]())) : (regeneratorDefine(t = {}, n, function() {
|
||
return this;
|
||
}), t), u = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(c);
|
||
function f(e) {
|
||
return Object.setPrototypeOf ? Object.setPrototypeOf(e, GeneratorFunctionPrototype) : (e.__proto__ = GeneratorFunctionPrototype, regeneratorDefine(e, o, "GeneratorFunction")), e.prototype = Object.create(u), e;
|
||
}
|
||
return GeneratorFunction.prototype = GeneratorFunctionPrototype, regeneratorDefine(u, "constructor", GeneratorFunctionPrototype), regeneratorDefine(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = "GeneratorFunction", regeneratorDefine(GeneratorFunctionPrototype, o, "GeneratorFunction"), regeneratorDefine(u), regeneratorDefine(u, o, "Generator"), regeneratorDefine(u, n, function() {
|
||
return this;
|
||
}), regeneratorDefine(u, "toString", function() {
|
||
return "[object Generator]";
|
||
}), (module.exports = _regenerator = function _regenerator() {
|
||
return {
|
||
w: i,
|
||
m: f
|
||
};
|
||
}, module.exports.__esModule = true, module.exports["default"] = module.exports)();
|
||
}
|
||
module.exports = _regenerator, module.exports.__esModule = true, module.exports["default"] = module.exports;
|
||
}),
|
||
"[project]/node_modules/@babel/runtime/helpers/regeneratorAsyncIterator.js [app-route] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
|
||
var OverloadYield = __turbopack_context__.r("[project]/node_modules/@babel/runtime/helpers/OverloadYield.js [app-route] (ecmascript)");
|
||
var regeneratorDefine = __turbopack_context__.r("[project]/node_modules/@babel/runtime/helpers/regeneratorDefine.js [app-route] (ecmascript)");
|
||
function AsyncIterator(t, e) {
|
||
function n(r, o, i, f) {
|
||
try {
|
||
var c = t[r](o), u = c.value;
|
||
return u instanceof OverloadYield ? e.resolve(u.v).then(function(t) {
|
||
n("next", t, i, f);
|
||
}, function(t) {
|
||
n("throw", t, i, f);
|
||
}) : e.resolve(u).then(function(t) {
|
||
c.value = t, i(c);
|
||
}, function(t) {
|
||
return n("throw", t, i, f);
|
||
});
|
||
} catch (t) {
|
||
f(t);
|
||
}
|
||
}
|
||
var r;
|
||
this.next || (regeneratorDefine(AsyncIterator.prototype), regeneratorDefine(AsyncIterator.prototype, "function" == typeof Symbol && Symbol.asyncIterator || "@asyncIterator", function() {
|
||
return this;
|
||
})), regeneratorDefine(this, "_invoke", function(t, o, i) {
|
||
function f() {
|
||
return new e(function(e, r) {
|
||
n(t, i, e, r);
|
||
});
|
||
}
|
||
return r = r ? r.then(f, f) : f();
|
||
}, !0);
|
||
}
|
||
module.exports = AsyncIterator, module.exports.__esModule = true, module.exports["default"] = module.exports;
|
||
}),
|
||
"[project]/node_modules/@babel/runtime/helpers/regeneratorAsyncGen.js [app-route] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
|
||
var regenerator = __turbopack_context__.r("[project]/node_modules/@babel/runtime/helpers/regenerator.js [app-route] (ecmascript)");
|
||
var regeneratorAsyncIterator = __turbopack_context__.r("[project]/node_modules/@babel/runtime/helpers/regeneratorAsyncIterator.js [app-route] (ecmascript)");
|
||
function _regeneratorAsyncGen(r, e, t, o, n) {
|
||
return new regeneratorAsyncIterator(regenerator().w(r, e, t, o), n || Promise);
|
||
}
|
||
module.exports = _regeneratorAsyncGen, module.exports.__esModule = true, module.exports["default"] = module.exports;
|
||
}),
|
||
"[project]/node_modules/@babel/runtime/helpers/regeneratorAsync.js [app-route] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
|
||
var regeneratorAsyncGen = __turbopack_context__.r("[project]/node_modules/@babel/runtime/helpers/regeneratorAsyncGen.js [app-route] (ecmascript)");
|
||
function _regeneratorAsync(n, e, r, t, o) {
|
||
var a = regeneratorAsyncGen(n, e, r, t, o);
|
||
return a.next().then(function(n) {
|
||
return n.done ? n.value : a.next();
|
||
});
|
||
}
|
||
module.exports = _regeneratorAsync, module.exports.__esModule = true, module.exports["default"] = module.exports;
|
||
}),
|
||
"[project]/node_modules/@babel/runtime/helpers/regeneratorKeys.js [app-route] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
|
||
function _regeneratorKeys(e) {
|
||
var n = Object(e), r = [];
|
||
for(var t in n)r.unshift(t);
|
||
return function e() {
|
||
for(; r.length;)if ((t = r.pop()) in n) return e.value = t, e.done = !1, e;
|
||
return e.done = !0, e;
|
||
};
|
||
}
|
||
module.exports = _regeneratorKeys, module.exports.__esModule = true, module.exports["default"] = module.exports;
|
||
}),
|
||
"[project]/node_modules/@babel/runtime/helpers/typeof.js [app-route] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
|
||
function _typeof(o) {
|
||
"@babel/helpers - typeof";
|
||
return module.exports = _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
|
||
return typeof o;
|
||
} : function(o) {
|
||
return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
|
||
}, module.exports.__esModule = true, module.exports["default"] = module.exports, _typeof(o);
|
||
}
|
||
module.exports = _typeof, module.exports.__esModule = true, module.exports["default"] = module.exports;
|
||
}),
|
||
"[project]/node_modules/@babel/runtime/helpers/regeneratorValues.js [app-route] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
|
||
var _typeof = __turbopack_context__.r("[project]/node_modules/@babel/runtime/helpers/typeof.js [app-route] (ecmascript)")["default"];
|
||
function _regeneratorValues(e) {
|
||
if (null != e) {
|
||
var t = e["function" == typeof Symbol && Symbol.iterator || "@@iterator"], r = 0;
|
||
if (t) return t.call(e);
|
||
if ("function" == typeof e.next) return e;
|
||
if (!isNaN(e.length)) return {
|
||
next: function next() {
|
||
return e && r >= e.length && (e = void 0), {
|
||
value: e && e[r++],
|
||
done: !e
|
||
};
|
||
}
|
||
};
|
||
}
|
||
throw new TypeError(_typeof(e) + " is not iterable");
|
||
}
|
||
module.exports = _regeneratorValues, module.exports.__esModule = true, module.exports["default"] = module.exports;
|
||
}),
|
||
"[project]/node_modules/@babel/runtime/helpers/regeneratorRuntime.js [app-route] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
|
||
var OverloadYield = __turbopack_context__.r("[project]/node_modules/@babel/runtime/helpers/OverloadYield.js [app-route] (ecmascript)");
|
||
var regenerator = __turbopack_context__.r("[project]/node_modules/@babel/runtime/helpers/regenerator.js [app-route] (ecmascript)");
|
||
var regeneratorAsync = __turbopack_context__.r("[project]/node_modules/@babel/runtime/helpers/regeneratorAsync.js [app-route] (ecmascript)");
|
||
var regeneratorAsyncGen = __turbopack_context__.r("[project]/node_modules/@babel/runtime/helpers/regeneratorAsyncGen.js [app-route] (ecmascript)");
|
||
var regeneratorAsyncIterator = __turbopack_context__.r("[project]/node_modules/@babel/runtime/helpers/regeneratorAsyncIterator.js [app-route] (ecmascript)");
|
||
var regeneratorKeys = __turbopack_context__.r("[project]/node_modules/@babel/runtime/helpers/regeneratorKeys.js [app-route] (ecmascript)");
|
||
var regeneratorValues = __turbopack_context__.r("[project]/node_modules/@babel/runtime/helpers/regeneratorValues.js [app-route] (ecmascript)");
|
||
function _regeneratorRuntime() {
|
||
"use strict";
|
||
var r = regenerator(), e = r.m(_regeneratorRuntime), t = (Object.getPrototypeOf ? Object.getPrototypeOf(e) : e.__proto__).constructor;
|
||
function n(r) {
|
||
var e = "function" == typeof r && r.constructor;
|
||
return !!e && (e === t || "GeneratorFunction" === (e.displayName || e.name));
|
||
}
|
||
var o = {
|
||
"throw": 1,
|
||
"return": 2,
|
||
"break": 3,
|
||
"continue": 3
|
||
};
|
||
function a(r) {
|
||
var e, t;
|
||
return function(n) {
|
||
e || (e = {
|
||
stop: function stop() {
|
||
return t(n.a, 2);
|
||
},
|
||
"catch": function _catch() {
|
||
return n.v;
|
||
},
|
||
abrupt: function abrupt(r, e) {
|
||
return t(n.a, o[r], e);
|
||
},
|
||
delegateYield: function delegateYield(r, o, a) {
|
||
return e.resultName = o, t(n.d, regeneratorValues(r), a);
|
||
},
|
||
finish: function finish(r) {
|
||
return t(n.f, r);
|
||
}
|
||
}, t = function t(r, _t, o) {
|
||
n.p = e.prev, n.n = e.next;
|
||
try {
|
||
return r(_t, o);
|
||
} finally{
|
||
e.next = n.n;
|
||
}
|
||
}), e.resultName && (e[e.resultName] = n.v, e.resultName = void 0), e.sent = n.v, e.next = n.n;
|
||
try {
|
||
return r.call(this, e);
|
||
} finally{
|
||
n.p = e.prev, n.n = e.next;
|
||
}
|
||
};
|
||
}
|
||
return (module.exports = _regeneratorRuntime = function _regeneratorRuntime() {
|
||
return {
|
||
wrap: function wrap(e, t, n, o) {
|
||
return r.w(a(e), t, n, o && o.reverse());
|
||
},
|
||
isGeneratorFunction: n,
|
||
mark: r.m,
|
||
awrap: function awrap(r, e) {
|
||
return new OverloadYield(r, e);
|
||
},
|
||
AsyncIterator: regeneratorAsyncIterator,
|
||
async: function async(r, e, t, o, u) {
|
||
return (n(e) ? regeneratorAsyncGen : regeneratorAsync)(a(r), e, t, o, u);
|
||
},
|
||
keys: regeneratorKeys,
|
||
values: regeneratorValues
|
||
};
|
||
}, module.exports.__esModule = true, module.exports["default"] = module.exports)();
|
||
}
|
||
module.exports = _regeneratorRuntime, module.exports.__esModule = true, module.exports["default"] = module.exports;
|
||
}),
|
||
"[project]/node_modules/@babel/runtime/regenerator/index.js [app-route] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
|
||
// TODO(Babel 8): Remove this file.
|
||
var runtime = __turbopack_context__.r("[project]/node_modules/@babel/runtime/helpers/regeneratorRuntime.js [app-route] (ecmascript)")();
|
||
module.exports = runtime;
|
||
// Copied from https://github.com/facebook/regenerator/blob/main/packages/runtime/runtime.js#L736=
|
||
try {
|
||
regeneratorRuntime = runtime;
|
||
} catch (accidentalStrictMode) {
|
||
if (typeof globalThis === "object") {
|
||
globalThis.regeneratorRuntime = runtime;
|
||
} else {
|
||
Function("r", "regeneratorRuntime = r")(runtime);
|
||
}
|
||
}
|
||
}),
|
||
"[project]/node_modules/@babel/runtime/helpers/toPrimitive.js [app-route] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
|
||
var _typeof = __turbopack_context__.r("[project]/node_modules/@babel/runtime/helpers/typeof.js [app-route] (ecmascript)")["default"];
|
||
function toPrimitive(t, r) {
|
||
if ("object" != _typeof(t) || !t) return t;
|
||
var e = t[Symbol.toPrimitive];
|
||
if (void 0 !== e) {
|
||
var i = e.call(t, r || "default");
|
||
if ("object" != _typeof(i)) return i;
|
||
throw new TypeError("@@toPrimitive must return a primitive value.");
|
||
}
|
||
return ("string" === r ? String : Number)(t);
|
||
}
|
||
module.exports = toPrimitive, module.exports.__esModule = true, module.exports["default"] = module.exports;
|
||
}),
|
||
"[project]/node_modules/@babel/runtime/helpers/toPropertyKey.js [app-route] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
|
||
var _typeof = __turbopack_context__.r("[project]/node_modules/@babel/runtime/helpers/typeof.js [app-route] (ecmascript)")["default"];
|
||
var toPrimitive = __turbopack_context__.r("[project]/node_modules/@babel/runtime/helpers/toPrimitive.js [app-route] (ecmascript)");
|
||
function toPropertyKey(t) {
|
||
var i = toPrimitive(t, "string");
|
||
return "symbol" == _typeof(i) ? i : i + "";
|
||
}
|
||
module.exports = toPropertyKey, module.exports.__esModule = true, module.exports["default"] = module.exports;
|
||
}),
|
||
"[project]/node_modules/@babel/runtime/helpers/defineProperty.js [app-route] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
|
||
var toPropertyKey = __turbopack_context__.r("[project]/node_modules/@babel/runtime/helpers/toPropertyKey.js [app-route] (ecmascript)");
|
||
function _defineProperty(e, r, t) {
|
||
return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
|
||
value: t,
|
||
enumerable: !0,
|
||
configurable: !0,
|
||
writable: !0
|
||
}) : e[r] = t, e;
|
||
}
|
||
module.exports = _defineProperty, module.exports.__esModule = true, module.exports["default"] = module.exports;
|
||
}),
|
||
"[project]/node_modules/@babel/runtime/helpers/asyncToGenerator.js [app-route] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
|
||
function asyncGeneratorStep(n, t, e, r, o, a, c) {
|
||
try {
|
||
var i = n[a](c), u = i.value;
|
||
} catch (n) {
|
||
return void e(n);
|
||
}
|
||
i.done ? t(u) : Promise.resolve(u).then(r, o);
|
||
}
|
||
function _asyncToGenerator(n) {
|
||
return function() {
|
||
var t = this, e = arguments;
|
||
return new Promise(function(r, o) {
|
||
var a = n.apply(t, e);
|
||
function _next(n) {
|
||
asyncGeneratorStep(a, r, o, _next, _throw, "next", n);
|
||
}
|
||
function _throw(n) {
|
||
asyncGeneratorStep(a, r, o, _next, _throw, "throw", n);
|
||
}
|
||
_next(void 0);
|
||
});
|
||
};
|
||
}
|
||
module.exports = _asyncToGenerator, module.exports.__esModule = true, module.exports["default"] = module.exports;
|
||
}),
|
||
"[project]/node_modules/@babel/runtime/helpers/classCallCheck.js [app-route] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
|
||
function _classCallCheck(a, n) {
|
||
if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
|
||
}
|
||
module.exports = _classCallCheck, module.exports.__esModule = true, module.exports["default"] = module.exports;
|
||
}),
|
||
"[project]/node_modules/@babel/runtime/helpers/createClass.js [app-route] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
|
||
var toPropertyKey = __turbopack_context__.r("[project]/node_modules/@babel/runtime/helpers/toPropertyKey.js [app-route] (ecmascript)");
|
||
function _defineProperties(e, r) {
|
||
for(var t = 0; t < r.length; t++){
|
||
var o = r[t];
|
||
o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, toPropertyKey(o.key), o);
|
||
}
|
||
}
|
||
function _createClass(e, r, t) {
|
||
return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", {
|
||
writable: !1
|
||
}), e;
|
||
}
|
||
module.exports = _createClass, module.exports.__esModule = true, module.exports["default"] = module.exports;
|
||
}),
|
||
"[project]/node_modules/@babel/runtime/helpers/assertThisInitialized.js [app-route] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
|
||
function _assertThisInitialized(e) {
|
||
if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
|
||
return e;
|
||
}
|
||
module.exports = _assertThisInitialized, module.exports.__esModule = true, module.exports["default"] = module.exports;
|
||
}),
|
||
"[project]/node_modules/@babel/runtime/helpers/possibleConstructorReturn.js [app-route] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
|
||
var _typeof = __turbopack_context__.r("[project]/node_modules/@babel/runtime/helpers/typeof.js [app-route] (ecmascript)")["default"];
|
||
var assertThisInitialized = __turbopack_context__.r("[project]/node_modules/@babel/runtime/helpers/assertThisInitialized.js [app-route] (ecmascript)");
|
||
function _possibleConstructorReturn(t, e) {
|
||
if (e && ("object" == _typeof(e) || "function" == typeof e)) return e;
|
||
if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined");
|
||
return assertThisInitialized(t);
|
||
}
|
||
module.exports = _possibleConstructorReturn, module.exports.__esModule = true, module.exports["default"] = module.exports;
|
||
}),
|
||
"[project]/node_modules/@babel/runtime/helpers/getPrototypeOf.js [app-route] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
|
||
function _getPrototypeOf(t) {
|
||
return module.exports = _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function(t) {
|
||
return t.__proto__ || Object.getPrototypeOf(t);
|
||
}, module.exports.__esModule = true, module.exports["default"] = module.exports, _getPrototypeOf(t);
|
||
}
|
||
module.exports = _getPrototypeOf, module.exports.__esModule = true, module.exports["default"] = module.exports;
|
||
}),
|
||
"[project]/node_modules/@babel/runtime/helpers/setPrototypeOf.js [app-route] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
|
||
function _setPrototypeOf(t, e) {
|
||
return module.exports = _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(t, e) {
|
||
return t.__proto__ = e, t;
|
||
}, module.exports.__esModule = true, module.exports["default"] = module.exports, _setPrototypeOf(t, e);
|
||
}
|
||
module.exports = _setPrototypeOf, module.exports.__esModule = true, module.exports["default"] = module.exports;
|
||
}),
|
||
"[project]/node_modules/@babel/runtime/helpers/inherits.js [app-route] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
|
||
var setPrototypeOf = __turbopack_context__.r("[project]/node_modules/@babel/runtime/helpers/setPrototypeOf.js [app-route] (ecmascript)");
|
||
function _inherits(t, e) {
|
||
if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function");
|
||
t.prototype = Object.create(e && e.prototype, {
|
||
constructor: {
|
||
value: t,
|
||
writable: !0,
|
||
configurable: !0
|
||
}
|
||
}), Object.defineProperty(t, "prototype", {
|
||
writable: !1
|
||
}), e && setPrototypeOf(t, e);
|
||
}
|
||
module.exports = _inherits, module.exports.__esModule = true, module.exports["default"] = module.exports;
|
||
}),
|
||
"[project]/node_modules/@babel/runtime/helpers/isNativeFunction.js [app-route] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
|
||
function _isNativeFunction(t) {
|
||
try {
|
||
return -1 !== Function.toString.call(t).indexOf("[native code]");
|
||
} catch (n) {
|
||
return "function" == typeof t;
|
||
}
|
||
}
|
||
module.exports = _isNativeFunction, module.exports.__esModule = true, module.exports["default"] = module.exports;
|
||
}),
|
||
"[project]/node_modules/@babel/runtime/helpers/isNativeReflectConstruct.js [app-route] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
|
||
function _isNativeReflectConstruct() {
|
||
try {
|
||
var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
|
||
} catch (t) {}
|
||
return (module.exports = _isNativeReflectConstruct = function _isNativeReflectConstruct() {
|
||
return !!t;
|
||
}, module.exports.__esModule = true, module.exports["default"] = module.exports)();
|
||
}
|
||
module.exports = _isNativeReflectConstruct, module.exports.__esModule = true, module.exports["default"] = module.exports;
|
||
}),
|
||
"[project]/node_modules/@babel/runtime/helpers/construct.js [app-route] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
|
||
var isNativeReflectConstruct = __turbopack_context__.r("[project]/node_modules/@babel/runtime/helpers/isNativeReflectConstruct.js [app-route] (ecmascript)");
|
||
var setPrototypeOf = __turbopack_context__.r("[project]/node_modules/@babel/runtime/helpers/setPrototypeOf.js [app-route] (ecmascript)");
|
||
function _construct(t, e, r) {
|
||
if (isNativeReflectConstruct()) return Reflect.construct.apply(null, arguments);
|
||
var o = [
|
||
null
|
||
];
|
||
o.push.apply(o, e);
|
||
var p = new (t.bind.apply(t, o))();
|
||
return r && setPrototypeOf(p, r.prototype), p;
|
||
}
|
||
module.exports = _construct, module.exports.__esModule = true, module.exports["default"] = module.exports;
|
||
}),
|
||
"[project]/node_modules/@babel/runtime/helpers/wrapNativeSuper.js [app-route] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
|
||
var getPrototypeOf = __turbopack_context__.r("[project]/node_modules/@babel/runtime/helpers/getPrototypeOf.js [app-route] (ecmascript)");
|
||
var setPrototypeOf = __turbopack_context__.r("[project]/node_modules/@babel/runtime/helpers/setPrototypeOf.js [app-route] (ecmascript)");
|
||
var isNativeFunction = __turbopack_context__.r("[project]/node_modules/@babel/runtime/helpers/isNativeFunction.js [app-route] (ecmascript)");
|
||
var construct = __turbopack_context__.r("[project]/node_modules/@babel/runtime/helpers/construct.js [app-route] (ecmascript)");
|
||
function _wrapNativeSuper(t) {
|
||
var r = "function" == typeof Map ? new Map() : void 0;
|
||
return module.exports = _wrapNativeSuper = function _wrapNativeSuper(t) {
|
||
if (null === t || !isNativeFunction(t)) return t;
|
||
if ("function" != typeof t) throw new TypeError("Super expression must either be null or a function");
|
||
if (void 0 !== r) {
|
||
if (r.has(t)) return r.get(t);
|
||
r.set(t, Wrapper);
|
||
}
|
||
function Wrapper() {
|
||
return construct(t, arguments, getPrototypeOf(this).constructor);
|
||
}
|
||
return Wrapper.prototype = Object.create(t.prototype, {
|
||
constructor: {
|
||
value: Wrapper,
|
||
enumerable: !1,
|
||
writable: !0,
|
||
configurable: !0
|
||
}
|
||
}), setPrototypeOf(Wrapper, t);
|
||
}, module.exports.__esModule = true, module.exports["default"] = module.exports, _wrapNativeSuper(t);
|
||
}
|
||
module.exports = _wrapNativeSuper, module.exports.__esModule = true, module.exports["default"] = module.exports;
|
||
}),
|
||
"[project]/node_modules/@babel/runtime/helpers/extends.js [app-route] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
|
||
function _extends() {
|
||
return module.exports = _extends = ("TURBOPACK compile-time truthy", 1) ? Object.assign.bind() : "TURBOPACK unreachable", module.exports.__esModule = true, module.exports["default"] = module.exports, _extends.apply(null, arguments);
|
||
}
|
||
module.exports = _extends, module.exports.__esModule = true, module.exports["default"] = module.exports;
|
||
}),
|
||
"[project]/node_modules/oidc-token-hash/lib/index.js [app-route] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
|
||
const { strict: assert } = __turbopack_context__.r("[externals]/assert [external] (assert, cjs)");
|
||
const { createHash } = __turbopack_context__.r("[externals]/crypto [external] (crypto, cjs)");
|
||
const { format } = __turbopack_context__.r("[externals]/util [external] (util, cjs)");
|
||
let encode;
|
||
if (Buffer.isEncoding('base64url')) {
|
||
encode = (input)=>input.toString('base64url');
|
||
} else {
|
||
const fromBase64 = (base64)=>base64.replace(/=/g, '').replace(/\+/g, '-').replace(/\//g, '_');
|
||
encode = (input)=>fromBase64(input.toString('base64'));
|
||
}
|
||
/** SPECIFICATION
|
||
* Its (_hash) value is the base64url encoding of the left-most half of the hash of the octets of
|
||
* the ASCII representation of the token value, where the hash algorithm used is the hash algorithm
|
||
* used in the alg Header Parameter of the ID Token's JOSE Header. For instance, if the alg is
|
||
* RS256, hash the token value with SHA-256, then take the left-most 128 bits and base64url encode
|
||
* them. The _hash value is a case sensitive string.
|
||
*/ /**
|
||
* @name getHash
|
||
* @api private
|
||
*
|
||
* returns the sha length based off the JOSE alg heade value, defaults to sha256
|
||
*
|
||
* @param token {String} token value to generate the hash from
|
||
* @param alg {String} ID Token JOSE header alg value (i.e. RS256, HS384, ES512, PS256)
|
||
* @param [crv] {String} For EdDSA the curve decides what hash algorithm is used. Required for EdDSA
|
||
*/ function getHash(alg, crv) {
|
||
switch(alg){
|
||
case 'HS256':
|
||
case 'RS256':
|
||
case 'PS256':
|
||
case 'ES256':
|
||
case 'ES256K':
|
||
return createHash('sha256');
|
||
case 'HS384':
|
||
case 'RS384':
|
||
case 'PS384':
|
||
case 'ES384':
|
||
return createHash('sha384');
|
||
case 'HS512':
|
||
case 'RS512':
|
||
case 'PS512':
|
||
case 'ES512':
|
||
case 'Ed25519':
|
||
return createHash('sha512');
|
||
case 'Ed448':
|
||
return createHash('shake256', {
|
||
outputLength: 114
|
||
});
|
||
case 'ML-DSA-44':
|
||
case 'ML-DSA-65':
|
||
case 'ML-DSA-87':
|
||
return createHash('shake256', {
|
||
outputLength: 64
|
||
});
|
||
case 'EdDSA':
|
||
switch(crv){
|
||
case 'Ed25519':
|
||
return createHash('sha512');
|
||
case 'Ed448':
|
||
return createHash('shake256', {
|
||
outputLength: 114
|
||
});
|
||
default:
|
||
throw new TypeError('unrecognized or invalid EdDSA curve provided');
|
||
}
|
||
default:
|
||
throw new TypeError('unrecognized or invalid JWS algorithm provided');
|
||
}
|
||
}
|
||
function generate(token, alg, crv) {
|
||
const digest = getHash(alg, crv).update(token).digest();
|
||
return encode(digest.slice(0, digest.length / 2));
|
||
}
|
||
function validate(names, actual, source, alg, crv) {
|
||
if (typeof names.claim !== 'string' || !names.claim) {
|
||
throw new TypeError('names.claim must be a non-empty string');
|
||
}
|
||
if (typeof names.source !== 'string' || !names.source) {
|
||
throw new TypeError('names.source must be a non-empty string');
|
||
}
|
||
assert(typeof actual === 'string' && actual, `${names.claim} must be a non-empty string`);
|
||
assert(typeof source === 'string' && source, `${names.source} must be a non-empty string`);
|
||
let expected;
|
||
let msg;
|
||
try {
|
||
expected = generate(source, alg, crv);
|
||
} catch (err) {
|
||
msg = format('%s could not be validated (%s)', names.claim, err.message);
|
||
}
|
||
msg = msg || format('%s mismatch, expected %s, got: %s', names.claim, expected, actual);
|
||
assert.equal(expected, actual, msg);
|
||
}
|
||
module.exports = {
|
||
validate,
|
||
generate
|
||
};
|
||
}),
|
||
"[project]/node_modules/openid-client/node_modules/yallist/iterator.js [app-route] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
"use strict";
|
||
|
||
module.exports = function(Yallist) {
|
||
Yallist.prototype[Symbol.iterator] = function*() {
|
||
for(let walker = this.head; walker; walker = walker.next){
|
||
yield walker.value;
|
||
}
|
||
};
|
||
};
|
||
}),
|
||
"[project]/node_modules/openid-client/node_modules/yallist/yallist.js [app-route] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
"use strict";
|
||
|
||
module.exports = Yallist;
|
||
Yallist.Node = Node;
|
||
Yallist.create = Yallist;
|
||
function Yallist(list) {
|
||
var self = this;
|
||
if (!(self instanceof Yallist)) {
|
||
self = new Yallist();
|
||
}
|
||
self.tail = null;
|
||
self.head = null;
|
||
self.length = 0;
|
||
if (list && typeof list.forEach === 'function') {
|
||
list.forEach(function(item) {
|
||
self.push(item);
|
||
});
|
||
} else if (arguments.length > 0) {
|
||
for(var i = 0, l = arguments.length; i < l; i++){
|
||
self.push(arguments[i]);
|
||
}
|
||
}
|
||
return self;
|
||
}
|
||
Yallist.prototype.removeNode = function(node) {
|
||
if (node.list !== this) {
|
||
throw new Error('removing node which does not belong to this list');
|
||
}
|
||
var next = node.next;
|
||
var prev = node.prev;
|
||
if (next) {
|
||
next.prev = prev;
|
||
}
|
||
if (prev) {
|
||
prev.next = next;
|
||
}
|
||
if (node === this.head) {
|
||
this.head = next;
|
||
}
|
||
if (node === this.tail) {
|
||
this.tail = prev;
|
||
}
|
||
node.list.length--;
|
||
node.next = null;
|
||
node.prev = null;
|
||
node.list = null;
|
||
return next;
|
||
};
|
||
Yallist.prototype.unshiftNode = function(node) {
|
||
if (node === this.head) {
|
||
return;
|
||
}
|
||
if (node.list) {
|
||
node.list.removeNode(node);
|
||
}
|
||
var head = this.head;
|
||
node.list = this;
|
||
node.next = head;
|
||
if (head) {
|
||
head.prev = node;
|
||
}
|
||
this.head = node;
|
||
if (!this.tail) {
|
||
this.tail = node;
|
||
}
|
||
this.length++;
|
||
};
|
||
Yallist.prototype.pushNode = function(node) {
|
||
if (node === this.tail) {
|
||
return;
|
||
}
|
||
if (node.list) {
|
||
node.list.removeNode(node);
|
||
}
|
||
var tail = this.tail;
|
||
node.list = this;
|
||
node.prev = tail;
|
||
if (tail) {
|
||
tail.next = node;
|
||
}
|
||
this.tail = node;
|
||
if (!this.head) {
|
||
this.head = node;
|
||
}
|
||
this.length++;
|
||
};
|
||
Yallist.prototype.push = function() {
|
||
for(var i = 0, l = arguments.length; i < l; i++){
|
||
push(this, arguments[i]);
|
||
}
|
||
return this.length;
|
||
};
|
||
Yallist.prototype.unshift = function() {
|
||
for(var i = 0, l = arguments.length; i < l; i++){
|
||
unshift(this, arguments[i]);
|
||
}
|
||
return this.length;
|
||
};
|
||
Yallist.prototype.pop = function() {
|
||
if (!this.tail) {
|
||
return undefined;
|
||
}
|
||
var res = this.tail.value;
|
||
this.tail = this.tail.prev;
|
||
if (this.tail) {
|
||
this.tail.next = null;
|
||
} else {
|
||
this.head = null;
|
||
}
|
||
this.length--;
|
||
return res;
|
||
};
|
||
Yallist.prototype.shift = function() {
|
||
if (!this.head) {
|
||
return undefined;
|
||
}
|
||
var res = this.head.value;
|
||
this.head = this.head.next;
|
||
if (this.head) {
|
||
this.head.prev = null;
|
||
} else {
|
||
this.tail = null;
|
||
}
|
||
this.length--;
|
||
return res;
|
||
};
|
||
Yallist.prototype.forEach = function(fn, thisp) {
|
||
thisp = thisp || this;
|
||
for(var walker = this.head, i = 0; walker !== null; i++){
|
||
fn.call(thisp, walker.value, i, this);
|
||
walker = walker.next;
|
||
}
|
||
};
|
||
Yallist.prototype.forEachReverse = function(fn, thisp) {
|
||
thisp = thisp || this;
|
||
for(var walker = this.tail, i = this.length - 1; walker !== null; i--){
|
||
fn.call(thisp, walker.value, i, this);
|
||
walker = walker.prev;
|
||
}
|
||
};
|
||
Yallist.prototype.get = function(n) {
|
||
for(var i = 0, walker = this.head; walker !== null && i < n; i++){
|
||
// abort out of the list early if we hit a cycle
|
||
walker = walker.next;
|
||
}
|
||
if (i === n && walker !== null) {
|
||
return walker.value;
|
||
}
|
||
};
|
||
Yallist.prototype.getReverse = function(n) {
|
||
for(var i = 0, walker = this.tail; walker !== null && i < n; i++){
|
||
// abort out of the list early if we hit a cycle
|
||
walker = walker.prev;
|
||
}
|
||
if (i === n && walker !== null) {
|
||
return walker.value;
|
||
}
|
||
};
|
||
Yallist.prototype.map = function(fn, thisp) {
|
||
thisp = thisp || this;
|
||
var res = new Yallist();
|
||
for(var walker = this.head; walker !== null;){
|
||
res.push(fn.call(thisp, walker.value, this));
|
||
walker = walker.next;
|
||
}
|
||
return res;
|
||
};
|
||
Yallist.prototype.mapReverse = function(fn, thisp) {
|
||
thisp = thisp || this;
|
||
var res = new Yallist();
|
||
for(var walker = this.tail; walker !== null;){
|
||
res.push(fn.call(thisp, walker.value, this));
|
||
walker = walker.prev;
|
||
}
|
||
return res;
|
||
};
|
||
Yallist.prototype.reduce = function(fn, initial) {
|
||
var acc;
|
||
var walker = this.head;
|
||
if (arguments.length > 1) {
|
||
acc = initial;
|
||
} else if (this.head) {
|
||
walker = this.head.next;
|
||
acc = this.head.value;
|
||
} else {
|
||
throw new TypeError('Reduce of empty list with no initial value');
|
||
}
|
||
for(var i = 0; walker !== null; i++){
|
||
acc = fn(acc, walker.value, i);
|
||
walker = walker.next;
|
||
}
|
||
return acc;
|
||
};
|
||
Yallist.prototype.reduceReverse = function(fn, initial) {
|
||
var acc;
|
||
var walker = this.tail;
|
||
if (arguments.length > 1) {
|
||
acc = initial;
|
||
} else if (this.tail) {
|
||
walker = this.tail.prev;
|
||
acc = this.tail.value;
|
||
} else {
|
||
throw new TypeError('Reduce of empty list with no initial value');
|
||
}
|
||
for(var i = this.length - 1; walker !== null; i--){
|
||
acc = fn(acc, walker.value, i);
|
||
walker = walker.prev;
|
||
}
|
||
return acc;
|
||
};
|
||
Yallist.prototype.toArray = function() {
|
||
var arr = new Array(this.length);
|
||
for(var i = 0, walker = this.head; walker !== null; i++){
|
||
arr[i] = walker.value;
|
||
walker = walker.next;
|
||
}
|
||
return arr;
|
||
};
|
||
Yallist.prototype.toArrayReverse = function() {
|
||
var arr = new Array(this.length);
|
||
for(var i = 0, walker = this.tail; walker !== null; i++){
|
||
arr[i] = walker.value;
|
||
walker = walker.prev;
|
||
}
|
||
return arr;
|
||
};
|
||
Yallist.prototype.slice = function(from, to) {
|
||
to = to || this.length;
|
||
if (to < 0) {
|
||
to += this.length;
|
||
}
|
||
from = from || 0;
|
||
if (from < 0) {
|
||
from += this.length;
|
||
}
|
||
var ret = new Yallist();
|
||
if (to < from || to < 0) {
|
||
return ret;
|
||
}
|
||
if (from < 0) {
|
||
from = 0;
|
||
}
|
||
if (to > this.length) {
|
||
to = this.length;
|
||
}
|
||
for(var i = 0, walker = this.head; walker !== null && i < from; i++){
|
||
walker = walker.next;
|
||
}
|
||
for(; walker !== null && i < to; i++, walker = walker.next){
|
||
ret.push(walker.value);
|
||
}
|
||
return ret;
|
||
};
|
||
Yallist.prototype.sliceReverse = function(from, to) {
|
||
to = to || this.length;
|
||
if (to < 0) {
|
||
to += this.length;
|
||
}
|
||
from = from || 0;
|
||
if (from < 0) {
|
||
from += this.length;
|
||
}
|
||
var ret = new Yallist();
|
||
if (to < from || to < 0) {
|
||
return ret;
|
||
}
|
||
if (from < 0) {
|
||
from = 0;
|
||
}
|
||
if (to > this.length) {
|
||
to = this.length;
|
||
}
|
||
for(var i = this.length, walker = this.tail; walker !== null && i > to; i--){
|
||
walker = walker.prev;
|
||
}
|
||
for(; walker !== null && i > from; i--, walker = walker.prev){
|
||
ret.push(walker.value);
|
||
}
|
||
return ret;
|
||
};
|
||
Yallist.prototype.splice = function(start, deleteCount, ...nodes) {
|
||
if (start > this.length) {
|
||
start = this.length - 1;
|
||
}
|
||
if (start < 0) {
|
||
start = this.length + start;
|
||
}
|
||
for(var i = 0, walker = this.head; walker !== null && i < start; i++){
|
||
walker = walker.next;
|
||
}
|
||
var ret = [];
|
||
for(var i = 0; walker && i < deleteCount; i++){
|
||
ret.push(walker.value);
|
||
walker = this.removeNode(walker);
|
||
}
|
||
if (walker === null) {
|
||
walker = this.tail;
|
||
}
|
||
if (walker !== this.head && walker !== this.tail) {
|
||
walker = walker.prev;
|
||
}
|
||
for(var i = 0; i < nodes.length; i++){
|
||
walker = insert(this, walker, nodes[i]);
|
||
}
|
||
return ret;
|
||
};
|
||
Yallist.prototype.reverse = function() {
|
||
var head = this.head;
|
||
var tail = this.tail;
|
||
for(var walker = head; walker !== null; walker = walker.prev){
|
||
var p = walker.prev;
|
||
walker.prev = walker.next;
|
||
walker.next = p;
|
||
}
|
||
this.head = tail;
|
||
this.tail = head;
|
||
return this;
|
||
};
|
||
function insert(self, node, value) {
|
||
var inserted = node === self.head ? new Node(value, null, node, self) : new Node(value, node, node.next, self);
|
||
if (inserted.next === null) {
|
||
self.tail = inserted;
|
||
}
|
||
if (inserted.prev === null) {
|
||
self.head = inserted;
|
||
}
|
||
self.length++;
|
||
return inserted;
|
||
}
|
||
function push(self, item) {
|
||
self.tail = new Node(item, self.tail, null, self);
|
||
if (!self.head) {
|
||
self.head = self.tail;
|
||
}
|
||
self.length++;
|
||
}
|
||
function unshift(self, item) {
|
||
self.head = new Node(item, null, self.head, self);
|
||
if (!self.tail) {
|
||
self.tail = self.head;
|
||
}
|
||
self.length++;
|
||
}
|
||
function Node(value, prev, next, list) {
|
||
if (!(this instanceof Node)) {
|
||
return new Node(value, prev, next, list);
|
||
}
|
||
this.list = list;
|
||
this.value = value;
|
||
if (prev) {
|
||
prev.next = this;
|
||
this.prev = prev;
|
||
} else {
|
||
this.prev = null;
|
||
}
|
||
if (next) {
|
||
next.prev = this;
|
||
this.next = next;
|
||
} else {
|
||
this.next = null;
|
||
}
|
||
}
|
||
try {
|
||
// add if support for Symbol.iterator is present
|
||
__turbopack_context__.r("[project]/node_modules/openid-client/node_modules/yallist/iterator.js [app-route] (ecmascript)")(Yallist);
|
||
} catch (er) {}
|
||
}),
|
||
"[project]/node_modules/openid-client/node_modules/lru-cache/index.js [app-route] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
"use strict";
|
||
|
||
// A linked list to keep track of recently-used-ness
|
||
const Yallist = __turbopack_context__.r("[project]/node_modules/openid-client/node_modules/yallist/yallist.js [app-route] (ecmascript)");
|
||
const MAX = Symbol('max');
|
||
const LENGTH = Symbol('length');
|
||
const LENGTH_CALCULATOR = Symbol('lengthCalculator');
|
||
const ALLOW_STALE = Symbol('allowStale');
|
||
const MAX_AGE = Symbol('maxAge');
|
||
const DISPOSE = Symbol('dispose');
|
||
const NO_DISPOSE_ON_SET = Symbol('noDisposeOnSet');
|
||
const LRU_LIST = Symbol('lruList');
|
||
const CACHE = Symbol('cache');
|
||
const UPDATE_AGE_ON_GET = Symbol('updateAgeOnGet');
|
||
const naiveLength = ()=>1;
|
||
// lruList is a yallist where the head is the youngest
|
||
// item, and the tail is the oldest. the list contains the Hit
|
||
// objects as the entries.
|
||
// Each Hit object has a reference to its Yallist.Node. This
|
||
// never changes.
|
||
//
|
||
// cache is a Map (or PseudoMap) that matches the keys to
|
||
// the Yallist.Node object.
|
||
class LRUCache {
|
||
constructor(options){
|
||
if (typeof options === 'number') options = {
|
||
max: options
|
||
};
|
||
if (!options) options = {};
|
||
if (options.max && (typeof options.max !== 'number' || options.max < 0)) throw new TypeError('max must be a non-negative number');
|
||
// Kind of weird to have a default max of Infinity, but oh well.
|
||
const max = this[MAX] = options.max || Infinity;
|
||
const lc = options.length || naiveLength;
|
||
this[LENGTH_CALCULATOR] = typeof lc !== 'function' ? naiveLength : lc;
|
||
this[ALLOW_STALE] = options.stale || false;
|
||
if (options.maxAge && typeof options.maxAge !== 'number') throw new TypeError('maxAge must be a number');
|
||
this[MAX_AGE] = options.maxAge || 0;
|
||
this[DISPOSE] = options.dispose;
|
||
this[NO_DISPOSE_ON_SET] = options.noDisposeOnSet || false;
|
||
this[UPDATE_AGE_ON_GET] = options.updateAgeOnGet || false;
|
||
this.reset();
|
||
}
|
||
// resize the cache when the max changes.
|
||
set max(mL) {
|
||
if (typeof mL !== 'number' || mL < 0) throw new TypeError('max must be a non-negative number');
|
||
this[MAX] = mL || Infinity;
|
||
trim(this);
|
||
}
|
||
get max() {
|
||
return this[MAX];
|
||
}
|
||
set allowStale(allowStale) {
|
||
this[ALLOW_STALE] = !!allowStale;
|
||
}
|
||
get allowStale() {
|
||
return this[ALLOW_STALE];
|
||
}
|
||
set maxAge(mA) {
|
||
if (typeof mA !== 'number') throw new TypeError('maxAge must be a non-negative number');
|
||
this[MAX_AGE] = mA;
|
||
trim(this);
|
||
}
|
||
get maxAge() {
|
||
return this[MAX_AGE];
|
||
}
|
||
// resize the cache when the lengthCalculator changes.
|
||
set lengthCalculator(lC) {
|
||
if (typeof lC !== 'function') lC = naiveLength;
|
||
if (lC !== this[LENGTH_CALCULATOR]) {
|
||
this[LENGTH_CALCULATOR] = lC;
|
||
this[LENGTH] = 0;
|
||
this[LRU_LIST].forEach((hit)=>{
|
||
hit.length = this[LENGTH_CALCULATOR](hit.value, hit.key);
|
||
this[LENGTH] += hit.length;
|
||
});
|
||
}
|
||
trim(this);
|
||
}
|
||
get lengthCalculator() {
|
||
return this[LENGTH_CALCULATOR];
|
||
}
|
||
get length() {
|
||
return this[LENGTH];
|
||
}
|
||
get itemCount() {
|
||
return this[LRU_LIST].length;
|
||
}
|
||
rforEach(fn, thisp) {
|
||
thisp = thisp || this;
|
||
for(let walker = this[LRU_LIST].tail; walker !== null;){
|
||
const prev = walker.prev;
|
||
forEachStep(this, fn, walker, thisp);
|
||
walker = prev;
|
||
}
|
||
}
|
||
forEach(fn, thisp) {
|
||
thisp = thisp || this;
|
||
for(let walker = this[LRU_LIST].head; walker !== null;){
|
||
const next = walker.next;
|
||
forEachStep(this, fn, walker, thisp);
|
||
walker = next;
|
||
}
|
||
}
|
||
keys() {
|
||
return this[LRU_LIST].toArray().map((k)=>k.key);
|
||
}
|
||
values() {
|
||
return this[LRU_LIST].toArray().map((k)=>k.value);
|
||
}
|
||
reset() {
|
||
if (this[DISPOSE] && this[LRU_LIST] && this[LRU_LIST].length) {
|
||
this[LRU_LIST].forEach((hit)=>this[DISPOSE](hit.key, hit.value));
|
||
}
|
||
this[CACHE] = new Map(); // hash of items by key
|
||
this[LRU_LIST] = new Yallist(); // list of items in order of use recency
|
||
this[LENGTH] = 0; // length of items in the list
|
||
}
|
||
dump() {
|
||
return this[LRU_LIST].map((hit)=>isStale(this, hit) ? false : {
|
||
k: hit.key,
|
||
v: hit.value,
|
||
e: hit.now + (hit.maxAge || 0)
|
||
}).toArray().filter((h)=>h);
|
||
}
|
||
dumpLru() {
|
||
return this[LRU_LIST];
|
||
}
|
||
set(key, value, maxAge) {
|
||
maxAge = maxAge || this[MAX_AGE];
|
||
if (maxAge && typeof maxAge !== 'number') throw new TypeError('maxAge must be a number');
|
||
const now = maxAge ? Date.now() : 0;
|
||
const len = this[LENGTH_CALCULATOR](value, key);
|
||
if (this[CACHE].has(key)) {
|
||
if (len > this[MAX]) {
|
||
del(this, this[CACHE].get(key));
|
||
return false;
|
||
}
|
||
const node = this[CACHE].get(key);
|
||
const item = node.value;
|
||
// dispose of the old one before overwriting
|
||
// split out into 2 ifs for better coverage tracking
|
||
if (this[DISPOSE]) {
|
||
if (!this[NO_DISPOSE_ON_SET]) this[DISPOSE](key, item.value);
|
||
}
|
||
item.now = now;
|
||
item.maxAge = maxAge;
|
||
item.value = value;
|
||
this[LENGTH] += len - item.length;
|
||
item.length = len;
|
||
this.get(key);
|
||
trim(this);
|
||
return true;
|
||
}
|
||
const hit = new Entry(key, value, len, now, maxAge);
|
||
// oversized objects fall out of cache automatically.
|
||
if (hit.length > this[MAX]) {
|
||
if (this[DISPOSE]) this[DISPOSE](key, value);
|
||
return false;
|
||
}
|
||
this[LENGTH] += hit.length;
|
||
this[LRU_LIST].unshift(hit);
|
||
this[CACHE].set(key, this[LRU_LIST].head);
|
||
trim(this);
|
||
return true;
|
||
}
|
||
has(key) {
|
||
if (!this[CACHE].has(key)) return false;
|
||
const hit = this[CACHE].get(key).value;
|
||
return !isStale(this, hit);
|
||
}
|
||
get(key) {
|
||
return get(this, key, true);
|
||
}
|
||
peek(key) {
|
||
return get(this, key, false);
|
||
}
|
||
pop() {
|
||
const node = this[LRU_LIST].tail;
|
||
if (!node) return null;
|
||
del(this, node);
|
||
return node.value;
|
||
}
|
||
del(key) {
|
||
del(this, this[CACHE].get(key));
|
||
}
|
||
load(arr) {
|
||
// reset the cache
|
||
this.reset();
|
||
const now = Date.now();
|
||
// A previous serialized cache has the most recent items first
|
||
for(let l = arr.length - 1; l >= 0; l--){
|
||
const hit = arr[l];
|
||
const expiresAt = hit.e || 0;
|
||
if (expiresAt === 0) // the item was created without expiration in a non aged cache
|
||
this.set(hit.k, hit.v);
|
||
else {
|
||
const maxAge = expiresAt - now;
|
||
// dont add already expired items
|
||
if (maxAge > 0) {
|
||
this.set(hit.k, hit.v, maxAge);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
prune() {
|
||
this[CACHE].forEach((value, key)=>get(this, key, false));
|
||
}
|
||
}
|
||
const get = (self, key, doUse)=>{
|
||
const node = self[CACHE].get(key);
|
||
if (node) {
|
||
const hit = node.value;
|
||
if (isStale(self, hit)) {
|
||
del(self, node);
|
||
if (!self[ALLOW_STALE]) return undefined;
|
||
} else {
|
||
if (doUse) {
|
||
if (self[UPDATE_AGE_ON_GET]) node.value.now = Date.now();
|
||
self[LRU_LIST].unshiftNode(node);
|
||
}
|
||
}
|
||
return hit.value;
|
||
}
|
||
};
|
||
const isStale = (self, hit)=>{
|
||
if (!hit || !hit.maxAge && !self[MAX_AGE]) return false;
|
||
const diff = Date.now() - hit.now;
|
||
return hit.maxAge ? diff > hit.maxAge : self[MAX_AGE] && diff > self[MAX_AGE];
|
||
};
|
||
const trim = (self)=>{
|
||
if (self[LENGTH] > self[MAX]) {
|
||
for(let walker = self[LRU_LIST].tail; self[LENGTH] > self[MAX] && walker !== null;){
|
||
// We know that we're about to delete this one, and also
|
||
// what the next least recently used key will be, so just
|
||
// go ahead and set it now.
|
||
const prev = walker.prev;
|
||
del(self, walker);
|
||
walker = prev;
|
||
}
|
||
}
|
||
};
|
||
const del = (self, node)=>{
|
||
if (node) {
|
||
const hit = node.value;
|
||
if (self[DISPOSE]) self[DISPOSE](hit.key, hit.value);
|
||
self[LENGTH] -= hit.length;
|
||
self[CACHE].delete(hit.key);
|
||
self[LRU_LIST].removeNode(node);
|
||
}
|
||
};
|
||
class Entry {
|
||
constructor(key, value, length, now, maxAge){
|
||
this.key = key;
|
||
this.value = value;
|
||
this.length = length;
|
||
this.now = now;
|
||
this.maxAge = maxAge || 0;
|
||
}
|
||
}
|
||
const forEachStep = (self, fn, node, thisp)=>{
|
||
let hit = node.value;
|
||
if (isStale(self, hit)) {
|
||
del(self, node);
|
||
if (!self[ALLOW_STALE]) hit = undefined;
|
||
}
|
||
if (hit) fn.call(thisp, hit.value, hit.key, self);
|
||
};
|
||
module.exports = LRUCache;
|
||
}),
|
||
"[project]/node_modules/object-hash/index.js [app-route] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
"use strict";
|
||
|
||
var crypto = __turbopack_context__.r("[externals]/crypto [external] (crypto, cjs)");
|
||
/**
|
||
* Exported function
|
||
*
|
||
* Options:
|
||
*
|
||
* - `algorithm` hash algo to be used by this instance: *'sha1', 'md5'
|
||
* - `excludeValues` {true|*false} hash object keys, values ignored
|
||
* - `encoding` hash encoding, supports 'buffer', '*hex', 'binary', 'base64'
|
||
* - `ignoreUnknown` {true|*false} ignore unknown object types
|
||
* - `replacer` optional function that replaces values before hashing
|
||
* - `respectFunctionProperties` {*true|false} consider function properties when hashing
|
||
* - `respectFunctionNames` {*true|false} consider 'name' property of functions for hashing
|
||
* - `respectType` {*true|false} Respect special properties (prototype, constructor)
|
||
* when hashing to distinguish between types
|
||
* - `unorderedArrays` {true|*false} Sort all arrays before hashing
|
||
* - `unorderedSets` {*true|false} Sort `Set` and `Map` instances before hashing
|
||
* * = default
|
||
*
|
||
* @param {object} object value to hash
|
||
* @param {object} options hashing options
|
||
* @return {string} hash value
|
||
* @api public
|
||
*/ exports = module.exports = objectHash;
|
||
function objectHash(object, options) {
|
||
options = applyDefaults(object, options);
|
||
return hash(object, options);
|
||
}
|
||
/**
|
||
* Exported sugar methods
|
||
*
|
||
* @param {object} object value to hash
|
||
* @return {string} hash value
|
||
* @api public
|
||
*/ exports.sha1 = function(object) {
|
||
return objectHash(object);
|
||
};
|
||
exports.keys = function(object) {
|
||
return objectHash(object, {
|
||
excludeValues: true,
|
||
algorithm: 'sha1',
|
||
encoding: 'hex'
|
||
});
|
||
};
|
||
exports.MD5 = function(object) {
|
||
return objectHash(object, {
|
||
algorithm: 'md5',
|
||
encoding: 'hex'
|
||
});
|
||
};
|
||
exports.keysMD5 = function(object) {
|
||
return objectHash(object, {
|
||
algorithm: 'md5',
|
||
encoding: 'hex',
|
||
excludeValues: true
|
||
});
|
||
};
|
||
// Internals
|
||
var hashes = crypto.getHashes ? crypto.getHashes().slice() : [
|
||
'sha1',
|
||
'md5'
|
||
];
|
||
hashes.push('passthrough');
|
||
var encodings = [
|
||
'buffer',
|
||
'hex',
|
||
'binary',
|
||
'base64'
|
||
];
|
||
function applyDefaults(object, sourceOptions) {
|
||
sourceOptions = sourceOptions || {};
|
||
// create a copy rather than mutating
|
||
var options = {};
|
||
options.algorithm = sourceOptions.algorithm || 'sha1';
|
||
options.encoding = sourceOptions.encoding || 'hex';
|
||
options.excludeValues = sourceOptions.excludeValues ? true : false;
|
||
options.algorithm = options.algorithm.toLowerCase();
|
||
options.encoding = options.encoding.toLowerCase();
|
||
options.ignoreUnknown = sourceOptions.ignoreUnknown !== true ? false : true; // default to false
|
||
options.respectType = sourceOptions.respectType === false ? false : true; // default to true
|
||
options.respectFunctionNames = sourceOptions.respectFunctionNames === false ? false : true;
|
||
options.respectFunctionProperties = sourceOptions.respectFunctionProperties === false ? false : true;
|
||
options.unorderedArrays = sourceOptions.unorderedArrays !== true ? false : true; // default to false
|
||
options.unorderedSets = sourceOptions.unorderedSets === false ? false : true; // default to false
|
||
options.unorderedObjects = sourceOptions.unorderedObjects === false ? false : true; // default to true
|
||
options.replacer = sourceOptions.replacer || undefined;
|
||
options.excludeKeys = sourceOptions.excludeKeys || undefined;
|
||
if (typeof object === 'undefined') {
|
||
throw new Error('Object argument required.');
|
||
}
|
||
// if there is a case-insensitive match in the hashes list, accept it
|
||
// (i.e. SHA256 for sha256)
|
||
for(var i = 0; i < hashes.length; ++i){
|
||
if (hashes[i].toLowerCase() === options.algorithm.toLowerCase()) {
|
||
options.algorithm = hashes[i];
|
||
}
|
||
}
|
||
if (hashes.indexOf(options.algorithm) === -1) {
|
||
throw new Error('Algorithm "' + options.algorithm + '" not supported. ' + 'supported values: ' + hashes.join(', '));
|
||
}
|
||
if (encodings.indexOf(options.encoding) === -1 && options.algorithm !== 'passthrough') {
|
||
throw new Error('Encoding "' + options.encoding + '" not supported. ' + 'supported values: ' + encodings.join(', '));
|
||
}
|
||
return options;
|
||
}
|
||
/** Check if the given function is a native function */ function isNativeFunction(f) {
|
||
if (typeof f !== 'function') {
|
||
return false;
|
||
}
|
||
var exp = /^function\s+\w*\s*\(\s*\)\s*{\s+\[native code\]\s+}$/i;
|
||
return exp.exec(Function.prototype.toString.call(f)) != null;
|
||
}
|
||
function hash(object, options) {
|
||
var hashingStream;
|
||
if (options.algorithm !== 'passthrough') {
|
||
hashingStream = crypto.createHash(options.algorithm);
|
||
} else {
|
||
hashingStream = new PassThrough();
|
||
}
|
||
if (typeof hashingStream.write === 'undefined') {
|
||
hashingStream.write = hashingStream.update;
|
||
hashingStream.end = hashingStream.update;
|
||
}
|
||
var hasher = typeHasher(options, hashingStream);
|
||
hasher.dispatch(object);
|
||
if (!hashingStream.update) {
|
||
hashingStream.end('');
|
||
}
|
||
if (hashingStream.digest) {
|
||
return hashingStream.digest(options.encoding === 'buffer' ? undefined : options.encoding);
|
||
}
|
||
var buf = hashingStream.read();
|
||
if (options.encoding === 'buffer') {
|
||
return buf;
|
||
}
|
||
return buf.toString(options.encoding);
|
||
}
|
||
/**
|
||
* Expose streaming API
|
||
*
|
||
* @param {object} object Value to serialize
|
||
* @param {object} options Options, as for hash()
|
||
* @param {object} stream A stream to write the serializiation to
|
||
* @api public
|
||
*/ exports.writeToStream = function(object, options, stream) {
|
||
if (typeof stream === 'undefined') {
|
||
stream = options;
|
||
options = {};
|
||
}
|
||
options = applyDefaults(object, options);
|
||
return typeHasher(options, stream).dispatch(object);
|
||
};
|
||
function typeHasher(options, writeTo, context) {
|
||
context = context || [];
|
||
var write = function(str) {
|
||
if (writeTo.update) {
|
||
return writeTo.update(str, 'utf8');
|
||
} else {
|
||
return writeTo.write(str, 'utf8');
|
||
}
|
||
};
|
||
return {
|
||
dispatch: function(value) {
|
||
if (options.replacer) {
|
||
value = options.replacer(value);
|
||
}
|
||
var type = typeof value;
|
||
if (value === null) {
|
||
type = 'null';
|
||
}
|
||
//console.log("[DEBUG] Dispatch: ", value, "->", type, " -> ", "_" + type);
|
||
return this['_' + type](value);
|
||
},
|
||
_object: function(object) {
|
||
var pattern = /\[object (.*)\]/i;
|
||
var objString = Object.prototype.toString.call(object);
|
||
var objType = pattern.exec(objString);
|
||
if (!objType) {
|
||
objType = 'unknown:[' + objString + ']';
|
||
} else {
|
||
objType = objType[1]; // take only the class name
|
||
}
|
||
objType = objType.toLowerCase();
|
||
var objectNumber = null;
|
||
if ((objectNumber = context.indexOf(object)) >= 0) {
|
||
return this.dispatch('[CIRCULAR:' + objectNumber + ']');
|
||
} else {
|
||
context.push(object);
|
||
}
|
||
if (typeof Buffer !== 'undefined' && Buffer.isBuffer && Buffer.isBuffer(object)) {
|
||
write('buffer:');
|
||
return write(object);
|
||
}
|
||
if (objType !== 'object' && objType !== 'function' && objType !== 'asyncfunction') {
|
||
if (this['_' + objType]) {
|
||
this['_' + objType](object);
|
||
} else if (options.ignoreUnknown) {
|
||
return write('[' + objType + ']');
|
||
} else {
|
||
throw new Error('Unknown object type "' + objType + '"');
|
||
}
|
||
} else {
|
||
var keys = Object.keys(object);
|
||
if (options.unorderedObjects) {
|
||
keys = keys.sort();
|
||
}
|
||
// Make sure to incorporate special properties, so
|
||
// Types with different prototypes will produce
|
||
// a different hash and objects derived from
|
||
// different functions (`new Foo`, `new Bar`) will
|
||
// produce different hashes.
|
||
// We never do this for native functions since some
|
||
// seem to break because of that.
|
||
if (options.respectType !== false && !isNativeFunction(object)) {
|
||
keys.splice(0, 0, 'prototype', '__proto__', 'constructor');
|
||
}
|
||
if (options.excludeKeys) {
|
||
keys = keys.filter(function(key) {
|
||
return !options.excludeKeys(key);
|
||
});
|
||
}
|
||
write('object:' + keys.length + ':');
|
||
var self = this;
|
||
return keys.forEach(function(key) {
|
||
self.dispatch(key);
|
||
write(':');
|
||
if (!options.excludeValues) {
|
||
self.dispatch(object[key]);
|
||
}
|
||
write(',');
|
||
});
|
||
}
|
||
},
|
||
_array: function(arr, unordered) {
|
||
unordered = typeof unordered !== 'undefined' ? unordered : options.unorderedArrays !== false; // default to options.unorderedArrays
|
||
var self = this;
|
||
write('array:' + arr.length + ':');
|
||
if (!unordered || arr.length <= 1) {
|
||
return arr.forEach(function(entry) {
|
||
return self.dispatch(entry);
|
||
});
|
||
}
|
||
// the unordered case is a little more complicated:
|
||
// since there is no canonical ordering on objects,
|
||
// i.e. {a:1} < {a:2} and {a:1} > {a:2} are both false,
|
||
// we first serialize each entry using a PassThrough stream
|
||
// before sorting.
|
||
// also: we can’t use the same context array for all entries
|
||
// since the order of hashing should *not* matter. instead,
|
||
// we keep track of the additions to a copy of the context array
|
||
// and add all of them to the global context array when we’re done
|
||
var contextAdditions = [];
|
||
var entries = arr.map(function(entry) {
|
||
var strm = new PassThrough();
|
||
var localContext = context.slice(); // make copy
|
||
var hasher = typeHasher(options, strm, localContext);
|
||
hasher.dispatch(entry);
|
||
// take only what was added to localContext and append it to contextAdditions
|
||
contextAdditions = contextAdditions.concat(localContext.slice(context.length));
|
||
return strm.read().toString();
|
||
});
|
||
context = context.concat(contextAdditions);
|
||
entries.sort();
|
||
return this._array(entries, false);
|
||
},
|
||
_date: function(date) {
|
||
return write('date:' + date.toJSON());
|
||
},
|
||
_symbol: function(sym) {
|
||
return write('symbol:' + sym.toString());
|
||
},
|
||
_error: function(err) {
|
||
return write('error:' + err.toString());
|
||
},
|
||
_boolean: function(bool) {
|
||
return write('bool:' + bool.toString());
|
||
},
|
||
_string: function(string) {
|
||
write('string:' + string.length + ':');
|
||
write(string.toString());
|
||
},
|
||
_function: function(fn) {
|
||
write('fn:');
|
||
if (isNativeFunction(fn)) {
|
||
this.dispatch('[native]');
|
||
} else {
|
||
this.dispatch(fn.toString());
|
||
}
|
||
if (options.respectFunctionNames !== false) {
|
||
// Make sure we can still distinguish native functions
|
||
// by their name, otherwise String and Function will
|
||
// have the same hash
|
||
this.dispatch("function-name:" + String(fn.name));
|
||
}
|
||
if (options.respectFunctionProperties) {
|
||
this._object(fn);
|
||
}
|
||
},
|
||
_number: function(number) {
|
||
return write('number:' + number.toString());
|
||
},
|
||
_xml: function(xml) {
|
||
return write('xml:' + xml.toString());
|
||
},
|
||
_null: function() {
|
||
return write('Null');
|
||
},
|
||
_undefined: function() {
|
||
return write('Undefined');
|
||
},
|
||
_regexp: function(regex) {
|
||
return write('regex:' + regex.toString());
|
||
},
|
||
_uint8array: function(arr) {
|
||
write('uint8array:');
|
||
return this.dispatch(Array.prototype.slice.call(arr));
|
||
},
|
||
_uint8clampedarray: function(arr) {
|
||
write('uint8clampedarray:');
|
||
return this.dispatch(Array.prototype.slice.call(arr));
|
||
},
|
||
_int8array: function(arr) {
|
||
write('uint8array:');
|
||
return this.dispatch(Array.prototype.slice.call(arr));
|
||
},
|
||
_uint16array: function(arr) {
|
||
write('uint16array:');
|
||
return this.dispatch(Array.prototype.slice.call(arr));
|
||
},
|
||
_int16array: function(arr) {
|
||
write('uint16array:');
|
||
return this.dispatch(Array.prototype.slice.call(arr));
|
||
},
|
||
_uint32array: function(arr) {
|
||
write('uint32array:');
|
||
return this.dispatch(Array.prototype.slice.call(arr));
|
||
},
|
||
_int32array: function(arr) {
|
||
write('uint32array:');
|
||
return this.dispatch(Array.prototype.slice.call(arr));
|
||
},
|
||
_float32array: function(arr) {
|
||
write('float32array:');
|
||
return this.dispatch(Array.prototype.slice.call(arr));
|
||
},
|
||
_float64array: function(arr) {
|
||
write('float64array:');
|
||
return this.dispatch(Array.prototype.slice.call(arr));
|
||
},
|
||
_arraybuffer: function(arr) {
|
||
write('arraybuffer:');
|
||
return this.dispatch(new Uint8Array(arr));
|
||
},
|
||
_url: function(url) {
|
||
return write('url:' + url.toString(), 'utf8');
|
||
},
|
||
_map: function(map) {
|
||
write('map:');
|
||
var arr = Array.from(map);
|
||
return this._array(arr, options.unorderedSets !== false);
|
||
},
|
||
_set: function(set) {
|
||
write('set:');
|
||
var arr = Array.from(set);
|
||
return this._array(arr, options.unorderedSets !== false);
|
||
},
|
||
_file: function(file) {
|
||
write('file:');
|
||
return this.dispatch([
|
||
file.name,
|
||
file.size,
|
||
file.type,
|
||
file.lastModfied
|
||
]);
|
||
},
|
||
_blob: function() {
|
||
if (options.ignoreUnknown) {
|
||
return write('[blob]');
|
||
}
|
||
throw Error('Hashing Blob objects is currently not supported\n' + '(see https://github.com/puleos/object-hash/issues/26)\n' + 'Use "options.replacer" or "options.ignoreUnknown"\n');
|
||
},
|
||
_domwindow: function() {
|
||
return write('domwindow');
|
||
},
|
||
_bigint: function(number) {
|
||
return write('bigint:' + number.toString());
|
||
},
|
||
/* Node.js standard native objects */ _process: function() {
|
||
return write('process');
|
||
},
|
||
_timer: function() {
|
||
return write('timer');
|
||
},
|
||
_pipe: function() {
|
||
return write('pipe');
|
||
},
|
||
_tcp: function() {
|
||
return write('tcp');
|
||
},
|
||
_udp: function() {
|
||
return write('udp');
|
||
},
|
||
_tty: function() {
|
||
return write('tty');
|
||
},
|
||
_statwatcher: function() {
|
||
return write('statwatcher');
|
||
},
|
||
_securecontext: function() {
|
||
return write('securecontext');
|
||
},
|
||
_connection: function() {
|
||
return write('connection');
|
||
},
|
||
_zlib: function() {
|
||
return write('zlib');
|
||
},
|
||
_context: function() {
|
||
return write('context');
|
||
},
|
||
_nodescript: function() {
|
||
return write('nodescript');
|
||
},
|
||
_httpparser: function() {
|
||
return write('httpparser');
|
||
},
|
||
_dataview: function() {
|
||
return write('dataview');
|
||
},
|
||
_signal: function() {
|
||
return write('signal');
|
||
},
|
||
_fsevent: function() {
|
||
return write('fsevent');
|
||
},
|
||
_tlswrap: function() {
|
||
return write('tlswrap');
|
||
}
|
||
};
|
||
}
|
||
// Mini-implementation of stream.PassThrough
|
||
// We are far from having need for the full implementation, and we can
|
||
// make assumptions like "many writes, then only one final read"
|
||
// and we can ignore encoding specifics
|
||
function PassThrough() {
|
||
return {
|
||
buf: '',
|
||
write: function(b) {
|
||
this.buf += b;
|
||
},
|
||
end: function(b) {
|
||
this.buf += b;
|
||
},
|
||
read: function() {
|
||
return this.buf;
|
||
}
|
||
};
|
||
}
|
||
}),
|
||
"[project]/node_modules/oauth/lib/sha1.js [app-route] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
|
||
/*
|
||
* A JavaScript implementation of the Secure Hash Algorithm, SHA-1, as defined
|
||
* in FIPS 180-1
|
||
* Version 2.2 Copyright Paul Johnston 2000 - 2009.
|
||
* Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
|
||
* Distributed under the BSD License
|
||
* See http://pajhome.org.uk/crypt/md5 for details.
|
||
*/ /*
|
||
* Configurable variables. You may need to tweak these to be compatible with
|
||
* the server-side, but the defaults work in most cases.
|
||
*/ var hexcase = 1; /* hex output format. 0 - lowercase; 1 - uppercase */
|
||
var b64pad = "="; /* base-64 pad character. "=" for strict RFC compliance */
|
||
/*
|
||
* These are the functions you'll usually want to call
|
||
* They take string arguments and return either hex or base-64 encoded strings
|
||
*/ function hex_sha1(s) {
|
||
return rstr2hex(rstr_sha1(str2rstr_utf8(s)));
|
||
}
|
||
function b64_sha1(s) {
|
||
return rstr2b64(rstr_sha1(str2rstr_utf8(s)));
|
||
}
|
||
function any_sha1(s, e) {
|
||
return rstr2any(rstr_sha1(str2rstr_utf8(s)), e);
|
||
}
|
||
function hex_hmac_sha1(k, d) {
|
||
return rstr2hex(rstr_hmac_sha1(str2rstr_utf8(k), str2rstr_utf8(d)));
|
||
}
|
||
function b64_hmac_sha1(k, d) {
|
||
return rstr2b64(rstr_hmac_sha1(str2rstr_utf8(k), str2rstr_utf8(d)));
|
||
}
|
||
function any_hmac_sha1(k, d, e) {
|
||
return rstr2any(rstr_hmac_sha1(str2rstr_utf8(k), str2rstr_utf8(d)), e);
|
||
}
|
||
/*
|
||
* Perform a simple self-test to see if the VM is working
|
||
*/ function sha1_vm_test() {
|
||
return hex_sha1("abc").toLowerCase() == "a9993e364706816aba3e25717850c26c9cd0d89d";
|
||
}
|
||
/*
|
||
* Calculate the SHA1 of a raw string
|
||
*/ function rstr_sha1(s) {
|
||
return binb2rstr(binb_sha1(rstr2binb(s), s.length * 8));
|
||
}
|
||
/*
|
||
* Calculate the HMAC-SHA1 of a key and some data (raw strings)
|
||
*/ function rstr_hmac_sha1(key, data) {
|
||
var bkey = rstr2binb(key);
|
||
if (bkey.length > 16) bkey = binb_sha1(bkey, key.length * 8);
|
||
var ipad = Array(16), opad = Array(16);
|
||
for(var i = 0; i < 16; i++){
|
||
ipad[i] = bkey[i] ^ 0x36363636;
|
||
opad[i] = bkey[i] ^ 0x5C5C5C5C;
|
||
}
|
||
var hash = binb_sha1(ipad.concat(rstr2binb(data)), 512 + data.length * 8);
|
||
return binb2rstr(binb_sha1(opad.concat(hash), 512 + 160));
|
||
}
|
||
/*
|
||
* Convert a raw string to a hex string
|
||
*/ function rstr2hex(input) {
|
||
try {
|
||
hexcase;
|
||
} catch (e) {
|
||
hexcase = 0;
|
||
}
|
||
var hex_tab = hexcase ? "0123456789ABCDEF" : "0123456789abcdef";
|
||
var output = "";
|
||
var x;
|
||
for(var i = 0; i < input.length; i++){
|
||
x = input.charCodeAt(i);
|
||
output += hex_tab.charAt(x >>> 4 & 0x0F) + hex_tab.charAt(x & 0x0F);
|
||
}
|
||
return output;
|
||
}
|
||
/*
|
||
* Convert a raw string to a base-64 string
|
||
*/ function rstr2b64(input) {
|
||
try {
|
||
b64pad;
|
||
} catch (e) {
|
||
b64pad = '';
|
||
}
|
||
var tab = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
||
var output = "";
|
||
var len = input.length;
|
||
for(var i = 0; i < len; i += 3){
|
||
var triplet = input.charCodeAt(i) << 16 | (i + 1 < len ? input.charCodeAt(i + 1) << 8 : 0) | (i + 2 < len ? input.charCodeAt(i + 2) : 0);
|
||
for(var j = 0; j < 4; j++){
|
||
if (i * 8 + j * 6 > input.length * 8) output += b64pad;
|
||
else output += tab.charAt(triplet >>> 6 * (3 - j) & 0x3F);
|
||
}
|
||
}
|
||
return output;
|
||
}
|
||
/*
|
||
* Convert a raw string to an arbitrary string encoding
|
||
*/ function rstr2any(input, encoding) {
|
||
var divisor = encoding.length;
|
||
var remainders = Array();
|
||
var i, q, x, quotient;
|
||
/* Convert to an array of 16-bit big-endian values, forming the dividend */ var dividend = Array(Math.ceil(input.length / 2));
|
||
for(i = 0; i < dividend.length; i++){
|
||
dividend[i] = input.charCodeAt(i * 2) << 8 | input.charCodeAt(i * 2 + 1);
|
||
}
|
||
/*
|
||
* Repeatedly perform a long division. The binary array forms the dividend,
|
||
* the length of the encoding is the divisor. Once computed, the quotient
|
||
* forms the dividend for the next step. We stop when the dividend is zero.
|
||
* All remainders are stored for later use.
|
||
*/ while(dividend.length > 0){
|
||
quotient = Array();
|
||
x = 0;
|
||
for(i = 0; i < dividend.length; i++){
|
||
x = (x << 16) + dividend[i];
|
||
q = Math.floor(x / divisor);
|
||
x -= q * divisor;
|
||
if (quotient.length > 0 || q > 0) quotient[quotient.length] = q;
|
||
}
|
||
remainders[remainders.length] = x;
|
||
dividend = quotient;
|
||
}
|
||
/* Convert the remainders to the output string */ var output = "";
|
||
for(i = remainders.length - 1; i >= 0; i--)output += encoding.charAt(remainders[i]);
|
||
/* Append leading zero equivalents */ var full_length = Math.ceil(input.length * 8 / (Math.log(encoding.length) / Math.log(2)));
|
||
for(i = output.length; i < full_length; i++)output = encoding[0] + output;
|
||
return output;
|
||
}
|
||
/*
|
||
* Encode a string as utf-8.
|
||
* For efficiency, this assumes the input is valid utf-16.
|
||
*/ function str2rstr_utf8(input) {
|
||
var output = "";
|
||
var i = -1;
|
||
var x, y;
|
||
while(++i < input.length){
|
||
/* Decode utf-16 surrogate pairs */ x = input.charCodeAt(i);
|
||
y = i + 1 < input.length ? input.charCodeAt(i + 1) : 0;
|
||
if (0xD800 <= x && x <= 0xDBFF && 0xDC00 <= y && y <= 0xDFFF) {
|
||
x = 0x10000 + ((x & 0x03FF) << 10) + (y & 0x03FF);
|
||
i++;
|
||
}
|
||
/* Encode output as utf-8 */ if (x <= 0x7F) output += String.fromCharCode(x);
|
||
else if (x <= 0x7FF) output += String.fromCharCode(0xC0 | x >>> 6 & 0x1F, 0x80 | x & 0x3F);
|
||
else if (x <= 0xFFFF) output += String.fromCharCode(0xE0 | x >>> 12 & 0x0F, 0x80 | x >>> 6 & 0x3F, 0x80 | x & 0x3F);
|
||
else if (x <= 0x1FFFFF) output += String.fromCharCode(0xF0 | x >>> 18 & 0x07, 0x80 | x >>> 12 & 0x3F, 0x80 | x >>> 6 & 0x3F, 0x80 | x & 0x3F);
|
||
}
|
||
return output;
|
||
}
|
||
/*
|
||
* Encode a string as utf-16
|
||
*/ function str2rstr_utf16le(input) {
|
||
var output = "";
|
||
for(var i = 0; i < input.length; i++)output += String.fromCharCode(input.charCodeAt(i) & 0xFF, input.charCodeAt(i) >>> 8 & 0xFF);
|
||
return output;
|
||
}
|
||
function str2rstr_utf16be(input) {
|
||
var output = "";
|
||
for(var i = 0; i < input.length; i++)output += String.fromCharCode(input.charCodeAt(i) >>> 8 & 0xFF, input.charCodeAt(i) & 0xFF);
|
||
return output;
|
||
}
|
||
/*
|
||
* Convert a raw string to an array of big-endian words
|
||
* Characters >255 have their high-byte silently ignored.
|
||
*/ function rstr2binb(input) {
|
||
var output = Array(input.length >> 2);
|
||
for(var i = 0; i < output.length; i++)output[i] = 0;
|
||
for(var i = 0; i < input.length * 8; i += 8)output[i >> 5] |= (input.charCodeAt(i / 8) & 0xFF) << 24 - i % 32;
|
||
return output;
|
||
}
|
||
/*
|
||
* Convert an array of big-endian words to a string
|
||
*/ function binb2rstr(input) {
|
||
var output = "";
|
||
for(var i = 0; i < input.length * 32; i += 8)output += String.fromCharCode(input[i >> 5] >>> 24 - i % 32 & 0xFF);
|
||
return output;
|
||
}
|
||
/*
|
||
* Calculate the SHA-1 of an array of big-endian words, and a bit length
|
||
*/ function binb_sha1(x, len) {
|
||
/* append padding */ x[len >> 5] |= 0x80 << 24 - len % 32;
|
||
x[(len + 64 >> 9 << 4) + 15] = len;
|
||
var w = Array(80);
|
||
var a = 1732584193;
|
||
var b = -271733879;
|
||
var c = -1732584194;
|
||
var d = 271733878;
|
||
var e = -1009589776;
|
||
for(var i = 0; i < x.length; i += 16){
|
||
var olda = a;
|
||
var oldb = b;
|
||
var oldc = c;
|
||
var oldd = d;
|
||
var olde = e;
|
||
for(var j = 0; j < 80; j++){
|
||
if (j < 16) w[j] = x[i + j];
|
||
else w[j] = bit_rol(w[j - 3] ^ w[j - 8] ^ w[j - 14] ^ w[j - 16], 1);
|
||
var t = safe_add(safe_add(bit_rol(a, 5), sha1_ft(j, b, c, d)), safe_add(safe_add(e, w[j]), sha1_kt(j)));
|
||
e = d;
|
||
d = c;
|
||
c = bit_rol(b, 30);
|
||
b = a;
|
||
a = t;
|
||
}
|
||
a = safe_add(a, olda);
|
||
b = safe_add(b, oldb);
|
||
c = safe_add(c, oldc);
|
||
d = safe_add(d, oldd);
|
||
e = safe_add(e, olde);
|
||
}
|
||
return Array(a, b, c, d, e);
|
||
}
|
||
/*
|
||
* Perform the appropriate triplet combination function for the current
|
||
* iteration
|
||
*/ function sha1_ft(t, b, c, d) {
|
||
if (t < 20) return b & c | ~b & d;
|
||
if (t < 40) return b ^ c ^ d;
|
||
if (t < 60) return b & c | b & d | c & d;
|
||
return b ^ c ^ d;
|
||
}
|
||
/*
|
||
* Determine the appropriate additive constant for the current iteration
|
||
*/ function sha1_kt(t) {
|
||
return t < 20 ? 1518500249 : t < 40 ? 1859775393 : t < 60 ? -1894007588 : -899497514;
|
||
}
|
||
/*
|
||
* Add integers, wrapping at 2^32. This uses 16-bit operations internally
|
||
* to work around bugs in some JS interpreters.
|
||
*/ function safe_add(x, y) {
|
||
var lsw = (x & 0xFFFF) + (y & 0xFFFF);
|
||
var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
|
||
return msw << 16 | lsw & 0xFFFF;
|
||
}
|
||
/*
|
||
* Bitwise rotate a 32-bit number to the left.
|
||
*/ function bit_rol(num, cnt) {
|
||
return num << cnt | num >>> 32 - cnt;
|
||
}
|
||
exports.HMACSHA1 = function(key, data) {
|
||
return b64_hmac_sha1(key, data);
|
||
};
|
||
}),
|
||
"[project]/node_modules/oauth/lib/_utils.js [app-route] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
|
||
// Returns true if this is a host that closes *before* it ends?!?!
|
||
module.exports.isAnEarlyCloseHost = function(hostName) {
|
||
return hostName && hostName.match(".*google(apis)?.com$");
|
||
};
|
||
}),
|
||
"[project]/node_modules/oauth/lib/oauth.js [app-route] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
|
||
var crypto = __turbopack_context__.r("[externals]/crypto [external] (crypto, cjs)"), sha1 = __turbopack_context__.r("[project]/node_modules/oauth/lib/sha1.js [app-route] (ecmascript)"), http = __turbopack_context__.r("[externals]/http [external] (http, cjs)"), https = __turbopack_context__.r("[externals]/https [external] (https, cjs)"), URL = __turbopack_context__.r("[externals]/url [external] (url, cjs)"), querystring = __turbopack_context__.r("[externals]/querystring [external] (querystring, cjs)"), OAuthUtils = __turbopack_context__.r("[project]/node_modules/oauth/lib/_utils.js [app-route] (ecmascript)");
|
||
exports.OAuth = function(requestUrl, accessUrl, consumerKey, consumerSecret, version, authorize_callback, signatureMethod, nonceSize, customHeaders) {
|
||
this._isEcho = false;
|
||
this._requestUrl = requestUrl;
|
||
this._accessUrl = accessUrl;
|
||
this._consumerKey = consumerKey;
|
||
this._consumerSecret = this._encodeData(consumerSecret);
|
||
if (signatureMethod == "RSA-SHA1") {
|
||
this._privateKey = consumerSecret;
|
||
}
|
||
this._version = version;
|
||
if (authorize_callback === undefined) {
|
||
this._authorize_callback = "oob";
|
||
} else {
|
||
this._authorize_callback = authorize_callback;
|
||
}
|
||
if (signatureMethod != "PLAINTEXT" && signatureMethod != "HMAC-SHA1" && signatureMethod != "RSA-SHA1") throw new Error("Un-supported signature method: " + signatureMethod);
|
||
this._signatureMethod = signatureMethod;
|
||
this._nonceSize = nonceSize || 32;
|
||
this._headers = customHeaders || {
|
||
"Accept": "*/*",
|
||
"Connection": "close",
|
||
"User-Agent": "Node authentication"
|
||
};
|
||
this._clientOptions = this._defaultClientOptions = {
|
||
"requestTokenHttpMethod": "POST",
|
||
"accessTokenHttpMethod": "POST",
|
||
"followRedirects": true
|
||
};
|
||
this._oauthParameterSeperator = ",";
|
||
};
|
||
exports.OAuthEcho = function(realm, verify_credentials, consumerKey, consumerSecret, version, signatureMethod, nonceSize, customHeaders) {
|
||
this._isEcho = true;
|
||
this._realm = realm;
|
||
this._verifyCredentials = verify_credentials;
|
||
this._consumerKey = consumerKey;
|
||
this._consumerSecret = this._encodeData(consumerSecret);
|
||
if (signatureMethod == "RSA-SHA1") {
|
||
this._privateKey = consumerSecret;
|
||
}
|
||
this._version = version;
|
||
if (signatureMethod != "PLAINTEXT" && signatureMethod != "HMAC-SHA1" && signatureMethod != "RSA-SHA1") throw new Error("Un-supported signature method: " + signatureMethod);
|
||
this._signatureMethod = signatureMethod;
|
||
this._nonceSize = nonceSize || 32;
|
||
this._headers = customHeaders || {
|
||
"Accept": "*/*",
|
||
"Connection": "close",
|
||
"User-Agent": "Node authentication"
|
||
};
|
||
this._oauthParameterSeperator = ",";
|
||
};
|
||
exports.OAuthEcho.prototype = exports.OAuth.prototype;
|
||
exports.OAuth.prototype._getTimestamp = function() {
|
||
return Math.floor(new Date().getTime() / 1000);
|
||
};
|
||
exports.OAuth.prototype._encodeData = function(toEncode) {
|
||
if (toEncode == null || toEncode == "") return "";
|
||
else {
|
||
var result = encodeURIComponent(toEncode);
|
||
// Fix the mismatch between OAuth's RFC3986's and Javascript's beliefs in what is right and wrong ;)
|
||
return result.replace(/\!/g, "%21").replace(/\'/g, "%27").replace(/\(/g, "%28").replace(/\)/g, "%29").replace(/\*/g, "%2A");
|
||
}
|
||
};
|
||
exports.OAuth.prototype._decodeData = function(toDecode) {
|
||
if (toDecode != null) {
|
||
toDecode = toDecode.replace(/\+/g, " ");
|
||
}
|
||
return decodeURIComponent(toDecode);
|
||
};
|
||
exports.OAuth.prototype._getSignature = function(method, url, parameters, tokenSecret) {
|
||
var signatureBase = this._createSignatureBase(method, url, parameters);
|
||
return this._createSignature(signatureBase, tokenSecret);
|
||
};
|
||
exports.OAuth.prototype._normalizeUrl = function(url) {
|
||
var parsedUrl = URL.parse(url, true);
|
||
var port = "";
|
||
if (parsedUrl.port) {
|
||
if (parsedUrl.protocol == "http:" && parsedUrl.port != "80" || parsedUrl.protocol == "https:" && parsedUrl.port != "443") {
|
||
port = ":" + parsedUrl.port;
|
||
}
|
||
}
|
||
if (!parsedUrl.pathname || parsedUrl.pathname == "") parsedUrl.pathname = "/";
|
||
return parsedUrl.protocol + "//" + parsedUrl.hostname + port + parsedUrl.pathname;
|
||
};
|
||
// Is the parameter considered an OAuth parameter
|
||
exports.OAuth.prototype._isParameterNameAnOAuthParameter = function(parameter) {
|
||
var m = parameter.match('^oauth_');
|
||
if (m && m[0] === "oauth_") {
|
||
return true;
|
||
} else {
|
||
return false;
|
||
}
|
||
};
|
||
// build the OAuth request authorization header
|
||
exports.OAuth.prototype._buildAuthorizationHeaders = function(orderedParameters) {
|
||
var authHeader = "OAuth ";
|
||
if (this._isEcho) {
|
||
authHeader += 'realm="' + this._realm + '",';
|
||
}
|
||
for(var i = 0; i < orderedParameters.length; i++){
|
||
// Whilst the all the parameters should be included within the signature, only the oauth_ arguments
|
||
// should appear within the authorization header.
|
||
if (this._isParameterNameAnOAuthParameter(orderedParameters[i][0])) {
|
||
authHeader += "" + this._encodeData(orderedParameters[i][0]) + "=\"" + this._encodeData(orderedParameters[i][1]) + "\"" + this._oauthParameterSeperator;
|
||
}
|
||
}
|
||
authHeader = authHeader.substring(0, authHeader.length - this._oauthParameterSeperator.length);
|
||
return authHeader;
|
||
};
|
||
// Takes an object literal that represents the arguments, and returns an array
|
||
// of argument/value pairs.
|
||
exports.OAuth.prototype._makeArrayOfArgumentsHash = function(argumentsHash) {
|
||
var argument_pairs = [];
|
||
for(var key in argumentsHash){
|
||
if (argumentsHash.hasOwnProperty(key)) {
|
||
var value = argumentsHash[key];
|
||
if (Array.isArray(value)) {
|
||
for(var i = 0; i < value.length; i++){
|
||
argument_pairs[argument_pairs.length] = [
|
||
key,
|
||
value[i]
|
||
];
|
||
}
|
||
} else {
|
||
argument_pairs[argument_pairs.length] = [
|
||
key,
|
||
value
|
||
];
|
||
}
|
||
}
|
||
}
|
||
return argument_pairs;
|
||
};
|
||
// Sorts the encoded key value pairs by encoded name, then encoded value
|
||
exports.OAuth.prototype._sortRequestParams = function(argument_pairs) {
|
||
// Sort by name, then value.
|
||
argument_pairs.sort(function(a, b) {
|
||
if (a[0] == b[0]) {
|
||
return a[1] < b[1] ? -1 : 1;
|
||
} else return a[0] < b[0] ? -1 : 1;
|
||
});
|
||
return argument_pairs;
|
||
};
|
||
exports.OAuth.prototype._normaliseRequestParams = function(args) {
|
||
var argument_pairs = this._makeArrayOfArgumentsHash(args);
|
||
// First encode them #3.4.1.3.2 .1
|
||
for(var i = 0; i < argument_pairs.length; i++){
|
||
argument_pairs[i][0] = this._encodeData(argument_pairs[i][0]);
|
||
argument_pairs[i][1] = this._encodeData(argument_pairs[i][1]);
|
||
}
|
||
// Then sort them #3.4.1.3.2 .2
|
||
argument_pairs = this._sortRequestParams(argument_pairs);
|
||
// Then concatenate together #3.4.1.3.2 .3 & .4
|
||
var args = "";
|
||
for(var i = 0; i < argument_pairs.length; i++){
|
||
args += argument_pairs[i][0];
|
||
args += "=";
|
||
args += argument_pairs[i][1];
|
||
if (i < argument_pairs.length - 1) args += "&";
|
||
}
|
||
return args;
|
||
};
|
||
exports.OAuth.prototype._createSignatureBase = function(method, url, parameters) {
|
||
url = this._encodeData(this._normalizeUrl(url));
|
||
parameters = this._encodeData(parameters);
|
||
return method.toUpperCase() + "&" + url + "&" + parameters;
|
||
};
|
||
exports.OAuth.prototype._createSignature = function(signatureBase, tokenSecret) {
|
||
if (tokenSecret === undefined) var tokenSecret = "";
|
||
else tokenSecret = this._encodeData(tokenSecret);
|
||
// consumerSecret is already encoded
|
||
var key = this._consumerSecret + "&" + tokenSecret;
|
||
var hash = "";
|
||
if (this._signatureMethod == "PLAINTEXT") {
|
||
hash = key;
|
||
} else if (this._signatureMethod == "RSA-SHA1") {
|
||
key = this._privateKey || "";
|
||
hash = crypto.createSign("RSA-SHA1").update(signatureBase).sign(key, 'base64');
|
||
} else {
|
||
if (crypto.Hmac) {
|
||
hash = crypto.createHmac("sha1", key).update(signatureBase).digest("base64");
|
||
} else {
|
||
hash = sha1.HMACSHA1(key, signatureBase);
|
||
}
|
||
}
|
||
return hash;
|
||
};
|
||
exports.OAuth.prototype.NONCE_CHARS = [
|
||
'a',
|
||
'b',
|
||
'c',
|
||
'd',
|
||
'e',
|
||
'f',
|
||
'g',
|
||
'h',
|
||
'i',
|
||
'j',
|
||
'k',
|
||
'l',
|
||
'm',
|
||
'n',
|
||
'o',
|
||
'p',
|
||
'q',
|
||
'r',
|
||
's',
|
||
't',
|
||
'u',
|
||
'v',
|
||
'w',
|
||
'x',
|
||
'y',
|
||
'z',
|
||
'A',
|
||
'B',
|
||
'C',
|
||
'D',
|
||
'E',
|
||
'F',
|
||
'G',
|
||
'H',
|
||
'I',
|
||
'J',
|
||
'K',
|
||
'L',
|
||
'M',
|
||
'N',
|
||
'O',
|
||
'P',
|
||
'Q',
|
||
'R',
|
||
'S',
|
||
'T',
|
||
'U',
|
||
'V',
|
||
'W',
|
||
'X',
|
||
'Y',
|
||
'Z',
|
||
'0',
|
||
'1',
|
||
'2',
|
||
'3',
|
||
'4',
|
||
'5',
|
||
'6',
|
||
'7',
|
||
'8',
|
||
'9'
|
||
];
|
||
exports.OAuth.prototype._getNonce = function(nonceSize) {
|
||
var result = [];
|
||
var chars = this.NONCE_CHARS;
|
||
var char_pos;
|
||
var nonce_chars_length = chars.length;
|
||
for(var i = 0; i < nonceSize; i++){
|
||
char_pos = Math.floor(Math.random() * nonce_chars_length);
|
||
result[i] = chars[char_pos];
|
||
}
|
||
return result.join('');
|
||
};
|
||
exports.OAuth.prototype._createClient = function(port, hostname, method, path, headers, sslEnabled) {
|
||
var options = {
|
||
host: hostname,
|
||
port: port,
|
||
path: path,
|
||
method: method,
|
||
headers: headers
|
||
};
|
||
var httpModel;
|
||
if (sslEnabled) {
|
||
httpModel = https;
|
||
} else {
|
||
httpModel = http;
|
||
}
|
||
return httpModel.request(options);
|
||
};
|
||
exports.OAuth.prototype._prepareParameters = function(oauth_token, oauth_token_secret, method, url, extra_params) {
|
||
var oauthParameters = {
|
||
"oauth_timestamp": this._getTimestamp(),
|
||
"oauth_nonce": this._getNonce(this._nonceSize),
|
||
"oauth_version": this._version,
|
||
"oauth_signature_method": this._signatureMethod,
|
||
"oauth_consumer_key": this._consumerKey
|
||
};
|
||
if (oauth_token) {
|
||
oauthParameters["oauth_token"] = oauth_token;
|
||
}
|
||
var sig;
|
||
if (this._isEcho) {
|
||
sig = this._getSignature("GET", this._verifyCredentials, this._normaliseRequestParams(oauthParameters), oauth_token_secret);
|
||
} else {
|
||
if (extra_params) {
|
||
for(var key in extra_params){
|
||
if (extra_params.hasOwnProperty(key)) oauthParameters[key] = extra_params[key];
|
||
}
|
||
}
|
||
var parsedUrl = URL.parse(url, false);
|
||
if (parsedUrl.query) {
|
||
var key2;
|
||
var extraParameters = querystring.parse(parsedUrl.query);
|
||
for(var key in extraParameters){
|
||
var value = extraParameters[key];
|
||
if (typeof value == "object") {
|
||
// TODO: This probably should be recursive
|
||
for(key2 in value){
|
||
oauthParameters[key + "[" + key2 + "]"] = value[key2];
|
||
}
|
||
} else {
|
||
oauthParameters[key] = value;
|
||
}
|
||
}
|
||
}
|
||
sig = this._getSignature(method, url, this._normaliseRequestParams(oauthParameters), oauth_token_secret);
|
||
}
|
||
var orderedParameters = this._sortRequestParams(this._makeArrayOfArgumentsHash(oauthParameters));
|
||
orderedParameters[orderedParameters.length] = [
|
||
"oauth_signature",
|
||
sig
|
||
];
|
||
return orderedParameters;
|
||
};
|
||
exports.OAuth.prototype._performSecureRequest = function(oauth_token, oauth_token_secret, method, url, extra_params, post_body, post_content_type, callback) {
|
||
var orderedParameters = this._prepareParameters(oauth_token, oauth_token_secret, method, url, extra_params);
|
||
if (!post_content_type) {
|
||
post_content_type = "application/x-www-form-urlencoded";
|
||
}
|
||
var parsedUrl = URL.parse(url, false);
|
||
if (parsedUrl.protocol == "http:" && !parsedUrl.port) parsedUrl.port = 80;
|
||
if (parsedUrl.protocol == "https:" && !parsedUrl.port) parsedUrl.port = 443;
|
||
var headers = {};
|
||
var authorization = this._buildAuthorizationHeaders(orderedParameters);
|
||
if (this._isEcho) {
|
||
headers["X-Verify-Credentials-Authorization"] = authorization;
|
||
} else {
|
||
headers["Authorization"] = authorization;
|
||
}
|
||
headers["Host"] = parsedUrl.host;
|
||
for(var key in this._headers){
|
||
if (this._headers.hasOwnProperty(key)) {
|
||
headers[key] = this._headers[key];
|
||
}
|
||
}
|
||
// Filter out any passed extra_params that are really to do with OAuth
|
||
for(var key in extra_params){
|
||
if (this._isParameterNameAnOAuthParameter(key)) {
|
||
delete extra_params[key];
|
||
}
|
||
}
|
||
if ((method == "POST" || method == "PUT") && post_body == null && extra_params != null) {
|
||
// Fix the mismatch between the output of querystring.stringify() and this._encodeData()
|
||
post_body = querystring.stringify(extra_params).replace(/\!/g, "%21").replace(/\'/g, "%27").replace(/\(/g, "%28").replace(/\)/g, "%29").replace(/\*/g, "%2A");
|
||
}
|
||
if (post_body) {
|
||
if (Buffer.isBuffer(post_body)) {
|
||
headers["Content-length"] = post_body.length;
|
||
} else {
|
||
headers["Content-length"] = Buffer.byteLength(post_body);
|
||
}
|
||
} else {
|
||
headers["Content-length"] = 0;
|
||
}
|
||
headers["Content-Type"] = post_content_type;
|
||
var path;
|
||
if (!parsedUrl.pathname || parsedUrl.pathname == "") parsedUrl.pathname = "/";
|
||
if (parsedUrl.query) path = parsedUrl.pathname + "?" + parsedUrl.query;
|
||
else path = parsedUrl.pathname;
|
||
var request;
|
||
if (parsedUrl.protocol == "https:") {
|
||
request = this._createClient(parsedUrl.port, parsedUrl.hostname, method, path, headers, true);
|
||
} else {
|
||
request = this._createClient(parsedUrl.port, parsedUrl.hostname, method, path, headers);
|
||
}
|
||
var clientOptions = this._clientOptions;
|
||
if (callback) {
|
||
var data = "";
|
||
var self = this;
|
||
// Some hosts *cough* google appear to close the connection early / send no content-length header
|
||
// allow this behaviour.
|
||
var allowEarlyClose = OAuthUtils.isAnEarlyCloseHost(parsedUrl.hostname);
|
||
var callbackCalled = false;
|
||
var passBackControl = function(response) {
|
||
if (!callbackCalled) {
|
||
callbackCalled = true;
|
||
if (response.statusCode >= 200 && response.statusCode <= 299) {
|
||
callback(null, data, response);
|
||
} else {
|
||
// Follow 301 or 302 redirects with Location HTTP header
|
||
if ((response.statusCode == 301 || response.statusCode == 302) && clientOptions.followRedirects && response.headers && response.headers.location) {
|
||
self._performSecureRequest(oauth_token, oauth_token_secret, method, response.headers.location, extra_params, post_body, post_content_type, callback);
|
||
} else {
|
||
callback({
|
||
statusCode: response.statusCode,
|
||
data: data
|
||
}, data, response);
|
||
}
|
||
}
|
||
}
|
||
};
|
||
request.on('response', function(response) {
|
||
response.setEncoding('utf8');
|
||
response.on('data', function(chunk) {
|
||
data += chunk;
|
||
});
|
||
response.on('end', function() {
|
||
passBackControl(response);
|
||
});
|
||
response.on('close', function() {
|
||
if (allowEarlyClose) {
|
||
passBackControl(response);
|
||
}
|
||
});
|
||
});
|
||
request.on("error", function(err) {
|
||
if (!callbackCalled) {
|
||
callbackCalled = true;
|
||
callback(err);
|
||
}
|
||
});
|
||
if ((method == "POST" || method == "PUT") && post_body != null && post_body != "") {
|
||
request.write(post_body);
|
||
}
|
||
request.end();
|
||
} else {
|
||
if ((method == "POST" || method == "PUT") && post_body != null && post_body != "") {
|
||
request.write(post_body);
|
||
}
|
||
return request;
|
||
}
|
||
return;
|
||
};
|
||
exports.OAuth.prototype.setClientOptions = function(options) {
|
||
var key, mergedOptions = {}, hasOwnProperty = Object.prototype.hasOwnProperty;
|
||
for(key in this._defaultClientOptions){
|
||
if (!hasOwnProperty.call(options, key)) {
|
||
mergedOptions[key] = this._defaultClientOptions[key];
|
||
} else {
|
||
mergedOptions[key] = options[key];
|
||
}
|
||
}
|
||
this._clientOptions = mergedOptions;
|
||
};
|
||
exports.OAuth.prototype.getOAuthAccessToken = function(oauth_token, oauth_token_secret, oauth_verifier, callback) {
|
||
var extraParams = {};
|
||
if (typeof oauth_verifier == "function") {
|
||
callback = oauth_verifier;
|
||
} else {
|
||
extraParams.oauth_verifier = oauth_verifier;
|
||
}
|
||
this._performSecureRequest(oauth_token, oauth_token_secret, this._clientOptions.accessTokenHttpMethod, this._accessUrl, extraParams, null, null, function(error, data, response) {
|
||
if (error) callback(error);
|
||
else {
|
||
var results = querystring.parse(data);
|
||
var oauth_access_token = results["oauth_token"];
|
||
delete results["oauth_token"];
|
||
var oauth_access_token_secret = results["oauth_token_secret"];
|
||
delete results["oauth_token_secret"];
|
||
callback(null, oauth_access_token, oauth_access_token_secret, results);
|
||
}
|
||
});
|
||
};
|
||
// Deprecated
|
||
exports.OAuth.prototype.getProtectedResource = function(url, method, oauth_token, oauth_token_secret, callback) {
|
||
this._performSecureRequest(oauth_token, oauth_token_secret, method, url, null, "", null, callback);
|
||
};
|
||
exports.OAuth.prototype.delete = function(url, oauth_token, oauth_token_secret, callback) {
|
||
return this._performSecureRequest(oauth_token, oauth_token_secret, "DELETE", url, null, "", null, callback);
|
||
};
|
||
exports.OAuth.prototype.get = function(url, oauth_token, oauth_token_secret, callback) {
|
||
return this._performSecureRequest(oauth_token, oauth_token_secret, "GET", url, null, "", null, callback);
|
||
};
|
||
exports.OAuth.prototype._putOrPost = function(method, url, oauth_token, oauth_token_secret, post_body, post_content_type, callback) {
|
||
var extra_params = null;
|
||
if (typeof post_content_type == "function") {
|
||
callback = post_content_type;
|
||
post_content_type = null;
|
||
}
|
||
if (typeof post_body != "string" && !Buffer.isBuffer(post_body)) {
|
||
post_content_type = "application/x-www-form-urlencoded";
|
||
extra_params = post_body;
|
||
post_body = null;
|
||
}
|
||
return this._performSecureRequest(oauth_token, oauth_token_secret, method, url, extra_params, post_body, post_content_type, callback);
|
||
};
|
||
exports.OAuth.prototype.put = function(url, oauth_token, oauth_token_secret, post_body, post_content_type, callback) {
|
||
return this._putOrPost("PUT", url, oauth_token, oauth_token_secret, post_body, post_content_type, callback);
|
||
};
|
||
exports.OAuth.prototype.post = function(url, oauth_token, oauth_token_secret, post_body, post_content_type, callback) {
|
||
return this._putOrPost("POST", url, oauth_token, oauth_token_secret, post_body, post_content_type, callback);
|
||
};
|
||
/**
|
||
* Gets a request token from the OAuth provider and passes that information back
|
||
* to the calling code.
|
||
*
|
||
* The callback should expect a function of the following form:
|
||
*
|
||
* function(err, token, token_secret, parsedQueryString) {}
|
||
*
|
||
* This method has optional parameters so can be called in the following 2 ways:
|
||
*
|
||
* 1) Primary use case: Does a basic request with no extra parameters
|
||
* getOAuthRequestToken( callbackFunction )
|
||
*
|
||
* 2) As above but allows for provision of extra parameters to be sent as part of the query to the server.
|
||
* getOAuthRequestToken( extraParams, callbackFunction )
|
||
*
|
||
* N.B. This method will HTTP POST verbs by default, if you wish to override this behaviour you will
|
||
* need to provide a requestTokenHttpMethod option when creating the client.
|
||
*
|
||
**/ exports.OAuth.prototype.getOAuthRequestToken = function(extraParams, callback) {
|
||
if (typeof extraParams == "function") {
|
||
callback = extraParams;
|
||
extraParams = {};
|
||
}
|
||
// Callbacks are 1.0A related
|
||
if (this._authorize_callback) {
|
||
extraParams["oauth_callback"] = this._authorize_callback;
|
||
}
|
||
this._performSecureRequest(null, null, this._clientOptions.requestTokenHttpMethod, this._requestUrl, extraParams, null, null, function(error, data, response) {
|
||
if (error) callback(error);
|
||
else {
|
||
var results = querystring.parse(data);
|
||
var oauth_token = results["oauth_token"];
|
||
var oauth_token_secret = results["oauth_token_secret"];
|
||
delete results["oauth_token"];
|
||
delete results["oauth_token_secret"];
|
||
callback(null, oauth_token, oauth_token_secret, results);
|
||
}
|
||
});
|
||
};
|
||
exports.OAuth.prototype.signUrl = function(url, oauth_token, oauth_token_secret, method) {
|
||
if (method === undefined) {
|
||
var method = "GET";
|
||
}
|
||
var orderedParameters = this._prepareParameters(oauth_token, oauth_token_secret, method, url, {});
|
||
var parsedUrl = URL.parse(url, false);
|
||
var query = "";
|
||
for(var i = 0; i < orderedParameters.length; i++){
|
||
query += orderedParameters[i][0] + "=" + this._encodeData(orderedParameters[i][1]) + "&";
|
||
}
|
||
query = query.substring(0, query.length - 1);
|
||
return parsedUrl.protocol + "//" + parsedUrl.host + parsedUrl.pathname + "?" + query;
|
||
};
|
||
exports.OAuth.prototype.authHeader = function(url, oauth_token, oauth_token_secret, method) {
|
||
if (method === undefined) {
|
||
var method = "GET";
|
||
}
|
||
var orderedParameters = this._prepareParameters(oauth_token, oauth_token_secret, method, url, {});
|
||
return this._buildAuthorizationHeaders(orderedParameters);
|
||
};
|
||
}),
|
||
"[project]/node_modules/oauth/lib/oauth2.js [app-route] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
|
||
var querystring = __turbopack_context__.r("[externals]/querystring [external] (querystring, cjs)"), crypto = __turbopack_context__.r("[externals]/crypto [external] (crypto, cjs)"), https = __turbopack_context__.r("[externals]/https [external] (https, cjs)"), http = __turbopack_context__.r("[externals]/http [external] (http, cjs)"), URL = __turbopack_context__.r("[externals]/url [external] (url, cjs)"), OAuthUtils = __turbopack_context__.r("[project]/node_modules/oauth/lib/_utils.js [app-route] (ecmascript)");
|
||
exports.OAuth2 = function(clientId, clientSecret, baseSite, authorizePath, accessTokenPath, customHeaders) {
|
||
this._clientId = clientId;
|
||
this._clientSecret = clientSecret;
|
||
this._baseSite = baseSite;
|
||
this._authorizeUrl = authorizePath || "/oauth/authorize";
|
||
this._accessTokenUrl = accessTokenPath || "/oauth/access_token";
|
||
this._accessTokenName = "access_token";
|
||
this._authMethod = "Bearer";
|
||
this._customHeaders = customHeaders || {};
|
||
this._useAuthorizationHeaderForGET = false;
|
||
//our agent
|
||
this._agent = undefined;
|
||
};
|
||
// Allows you to set an agent to use instead of the default HTTP or
|
||
// HTTPS agents. Useful when dealing with your own certificates.
|
||
exports.OAuth2.prototype.setAgent = function(agent) {
|
||
this._agent = agent;
|
||
};
|
||
// This 'hack' method is required for sites that don't use
|
||
// 'access_token' as the name of the access token (for requests).
|
||
// ( http://tools.ietf.org/html/draft-ietf-oauth-v2-16#section-7 )
|
||
// it isn't clear what the correct value should be atm, so allowing
|
||
// for specific (temporary?) override for now.
|
||
exports.OAuth2.prototype.setAccessTokenName = function(name) {
|
||
this._accessTokenName = name;
|
||
};
|
||
// Sets the authorization method for Authorization header.
|
||
// e.g. Authorization: Bearer <token> # "Bearer" is the authorization method.
|
||
exports.OAuth2.prototype.setAuthMethod = function(authMethod) {
|
||
this._authMethod = authMethod;
|
||
};
|
||
// If you use the OAuth2 exposed 'get' method (and don't construct your own _request call )
|
||
// this will specify whether to use an 'Authorize' header instead of passing the access_token as a query parameter
|
||
exports.OAuth2.prototype.useAuthorizationHeaderforGET = function(useIt) {
|
||
this._useAuthorizationHeaderForGET = useIt;
|
||
};
|
||
exports.OAuth2.prototype._getAccessTokenUrl = function() {
|
||
return this._baseSite + this._accessTokenUrl; /* + "?" + querystring.stringify(params); */
|
||
};
|
||
// Build the authorization header. In particular, build the part after the colon.
|
||
// e.g. Authorization: Bearer <token> # Build "Bearer <token>"
|
||
exports.OAuth2.prototype.buildAuthHeader = function(token) {
|
||
return this._authMethod + ' ' + token;
|
||
};
|
||
exports.OAuth2.prototype._chooseHttpLibrary = function(parsedUrl) {
|
||
var http_library = https;
|
||
// As this is OAUth2, we *assume* https unless told explicitly otherwise.
|
||
if (parsedUrl.protocol != "https:") {
|
||
http_library = http;
|
||
}
|
||
return http_library;
|
||
};
|
||
exports.OAuth2.prototype._request = function(method, url, headers, post_body, access_token, callback) {
|
||
var parsedUrl = URL.parse(url, true);
|
||
if (parsedUrl.protocol == "https:" && !parsedUrl.port) {
|
||
parsedUrl.port = 443;
|
||
}
|
||
var http_library = this._chooseHttpLibrary(parsedUrl);
|
||
var realHeaders = {};
|
||
for(var key in this._customHeaders){
|
||
realHeaders[key] = this._customHeaders[key];
|
||
}
|
||
if (headers) {
|
||
for(var key in headers){
|
||
realHeaders[key] = headers[key];
|
||
}
|
||
}
|
||
realHeaders['Host'] = parsedUrl.host;
|
||
if (!realHeaders['User-Agent']) {
|
||
realHeaders['User-Agent'] = 'Node-oauth';
|
||
}
|
||
if (post_body) {
|
||
if (Buffer.isBuffer(post_body)) {
|
||
realHeaders["Content-Length"] = post_body.length;
|
||
} else {
|
||
realHeaders["Content-Length"] = Buffer.byteLength(post_body);
|
||
}
|
||
} else {
|
||
realHeaders["Content-length"] = 0;
|
||
}
|
||
if (access_token && !('Authorization' in realHeaders)) {
|
||
if (!parsedUrl.query) parsedUrl.query = {};
|
||
parsedUrl.query[this._accessTokenName] = access_token;
|
||
}
|
||
var queryStr = querystring.stringify(parsedUrl.query);
|
||
if (queryStr) queryStr = "?" + queryStr;
|
||
var options = {
|
||
host: parsedUrl.hostname,
|
||
port: parsedUrl.port,
|
||
path: parsedUrl.pathname + queryStr,
|
||
method: method,
|
||
headers: realHeaders
|
||
};
|
||
this._executeRequest(http_library, options, post_body, callback);
|
||
};
|
||
exports.OAuth2.prototype._executeRequest = function(http_library, options, post_body, callback) {
|
||
// Some hosts *cough* google appear to close the connection early / send no content-length header
|
||
// allow this behaviour.
|
||
var allowEarlyClose = OAuthUtils.isAnEarlyCloseHost(options.host);
|
||
var callbackCalled = false;
|
||
function passBackControl(response, result) {
|
||
if (!callbackCalled) {
|
||
callbackCalled = true;
|
||
if (!(response.statusCode >= 200 && response.statusCode <= 299) && response.statusCode != 301 && response.statusCode != 302) {
|
||
callback({
|
||
statusCode: response.statusCode,
|
||
data: result
|
||
});
|
||
} else {
|
||
callback(null, result, response);
|
||
}
|
||
}
|
||
}
|
||
var result = "";
|
||
//set the agent on the request options
|
||
if (this._agent) {
|
||
options.agent = this._agent;
|
||
}
|
||
var request = http_library.request(options);
|
||
request.on('response', function(response) {
|
||
response.on("data", function(chunk) {
|
||
result += chunk;
|
||
});
|
||
response.on("close", function(err) {
|
||
if (allowEarlyClose) {
|
||
passBackControl(response, result);
|
||
}
|
||
});
|
||
response.addListener("end", function() {
|
||
passBackControl(response, result);
|
||
});
|
||
});
|
||
request.on('error', function(e) {
|
||
callbackCalled = true;
|
||
callback(e);
|
||
});
|
||
if ((options.method == 'POST' || options.method == 'PUT') && post_body) {
|
||
request.write(post_body);
|
||
}
|
||
request.end();
|
||
};
|
||
exports.OAuth2.prototype.getAuthorizeUrl = function(params) {
|
||
var params = params || {};
|
||
params['client_id'] = this._clientId;
|
||
return this._baseSite + this._authorizeUrl + "?" + querystring.stringify(params);
|
||
};
|
||
exports.OAuth2.prototype.getOAuthAccessToken = function(code, params, callback) {
|
||
var params = params || {};
|
||
params['client_id'] = this._clientId;
|
||
params['client_secret'] = this._clientSecret;
|
||
var codeParam = params.grant_type === 'refresh_token' ? 'refresh_token' : 'code';
|
||
params[codeParam] = code;
|
||
var post_data = querystring.stringify(params);
|
||
var post_headers = {
|
||
'Content-Type': 'application/x-www-form-urlencoded'
|
||
};
|
||
this._request("POST", this._getAccessTokenUrl(), post_headers, post_data, null, function(error, data, response) {
|
||
if (error) callback(error);
|
||
else {
|
||
var results;
|
||
try {
|
||
// As of http://tools.ietf.org/html/draft-ietf-oauth-v2-07
|
||
// responses should be in JSON
|
||
results = JSON.parse(data);
|
||
} catch (e) {
|
||
// .... However both Facebook + Github currently use rev05 of the spec
|
||
// and neither seem to specify a content-type correctly in their response headers :(
|
||
// clients of these services will suffer a *minor* performance cost of the exception
|
||
// being thrown
|
||
results = querystring.parse(data);
|
||
}
|
||
var access_token = results["access_token"];
|
||
var refresh_token = results["refresh_token"];
|
||
delete results["refresh_token"];
|
||
callback(null, access_token, refresh_token, results); // callback results =-=
|
||
}
|
||
});
|
||
};
|
||
// Deprecated
|
||
exports.OAuth2.prototype.getProtectedResource = function(url, access_token, callback) {
|
||
this._request("GET", url, {}, "", access_token, callback);
|
||
};
|
||
exports.OAuth2.prototype.get = function(url, access_token, callback) {
|
||
if (this._useAuthorizationHeaderForGET) {
|
||
var headers = {
|
||
'Authorization': this.buildAuthHeader(access_token)
|
||
};
|
||
access_token = null;
|
||
} else {
|
||
headers = {};
|
||
}
|
||
this._request("GET", url, headers, "", access_token, callback);
|
||
};
|
||
}),
|
||
"[project]/node_modules/oauth/index.js [app-route] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
|
||
exports.OAuth = __turbopack_context__.r("[project]/node_modules/oauth/lib/oauth.js [app-route] (ecmascript)").OAuth;
|
||
exports.OAuthEcho = __turbopack_context__.r("[project]/node_modules/oauth/lib/oauth.js [app-route] (ecmascript)").OAuthEcho;
|
||
exports.OAuth2 = __turbopack_context__.r("[project]/node_modules/oauth/lib/oauth2.js [app-route] (ecmascript)").OAuth2;
|
||
}),
|
||
"[project]/node_modules/@panva/hkdf/dist/node/cjs/runtime/fallback.js [app-route] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
"use strict";
|
||
|
||
Object.defineProperty(exports, "__esModule", {
|
||
value: true
|
||
});
|
||
const crypto_1 = __turbopack_context__.r("[externals]/crypto [external] (crypto, cjs)");
|
||
exports.default = (digest, ikm, salt, info, keylen)=>{
|
||
const hashlen = parseInt(digest.substr(3), 10) >> 3 || 20;
|
||
const prk = (0, crypto_1.createHmac)(digest, salt.byteLength ? salt : new Uint8Array(hashlen)).update(ikm).digest();
|
||
const N = Math.ceil(keylen / hashlen);
|
||
const T = new Uint8Array(hashlen * N + info.byteLength + 1);
|
||
let prev = 0;
|
||
let start = 0;
|
||
for(let c = 1; c <= N; c++){
|
||
T.set(info, start);
|
||
T[start + info.byteLength] = c;
|
||
T.set((0, crypto_1.createHmac)(digest, prk).update(T.subarray(prev, start + info.byteLength + 1)).digest(), start);
|
||
prev = start;
|
||
start += hashlen;
|
||
}
|
||
return T.slice(0, keylen);
|
||
};
|
||
}),
|
||
"[project]/node_modules/@panva/hkdf/dist/node/cjs/runtime/hkdf.js [app-route] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
"use strict";
|
||
|
||
Object.defineProperty(exports, "__esModule", {
|
||
value: true
|
||
});
|
||
const crypto = __turbopack_context__.r("[externals]/crypto [external] (crypto, cjs)");
|
||
const fallback_js_1 = __turbopack_context__.r("[project]/node_modules/@panva/hkdf/dist/node/cjs/runtime/fallback.js [app-route] (ecmascript)");
|
||
let hkdf;
|
||
if (typeof crypto.hkdf === 'function' && !process.versions.electron) {
|
||
hkdf = async (...args)=>new Promise((resolve, reject)=>{
|
||
crypto.hkdf(...args, (err, arrayBuffer)=>{
|
||
if (err) reject(err);
|
||
else resolve(new Uint8Array(arrayBuffer));
|
||
});
|
||
});
|
||
}
|
||
exports.default = async (digest, ikm, salt, info, keylen)=>(hkdf || fallback_js_1.default)(digest, ikm, salt, info, keylen);
|
||
}),
|
||
"[project]/node_modules/@panva/hkdf/dist/node/cjs/index.js [app-route] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
"use strict";
|
||
|
||
Object.defineProperty(exports, "__esModule", {
|
||
value: true
|
||
});
|
||
exports.default = exports.hkdf = void 0;
|
||
const hkdf_js_1 = __turbopack_context__.r("[project]/node_modules/@panva/hkdf/dist/node/cjs/runtime/hkdf.js [app-route] (ecmascript)");
|
||
function normalizeDigest(digest) {
|
||
switch(digest){
|
||
case 'sha256':
|
||
case 'sha384':
|
||
case 'sha512':
|
||
case 'sha1':
|
||
return digest;
|
||
default:
|
||
throw new TypeError('unsupported "digest" value');
|
||
}
|
||
}
|
||
function normalizeUint8Array(input, label) {
|
||
if (typeof input === 'string') return new TextEncoder().encode(input);
|
||
if (!(input instanceof Uint8Array)) throw new TypeError(`"${label}"" must be an instance of Uint8Array or a string`);
|
||
return input;
|
||
}
|
||
function normalizeIkm(input) {
|
||
const ikm = normalizeUint8Array(input, 'ikm');
|
||
if (!ikm.byteLength) throw new TypeError(`"ikm" must be at least one byte in length`);
|
||
return ikm;
|
||
}
|
||
function normalizeInfo(input) {
|
||
const info = normalizeUint8Array(input, 'info');
|
||
if (info.byteLength > 1024) {
|
||
throw TypeError('"info" must not contain more than 1024 bytes');
|
||
}
|
||
return info;
|
||
}
|
||
function normalizeKeylen(input, digest) {
|
||
if (typeof input !== 'number' || !Number.isInteger(input) || input < 1) {
|
||
throw new TypeError('"keylen" must be a positive integer');
|
||
}
|
||
const hashlen = parseInt(digest.substr(3), 10) >> 3 || 20;
|
||
if (input > 255 * hashlen) {
|
||
throw new TypeError('"keylen" too large');
|
||
}
|
||
return input;
|
||
}
|
||
async function hkdf(digest, ikm, salt, info, keylen) {
|
||
return (0, hkdf_js_1.default)(normalizeDigest(digest), normalizeIkm(ikm), normalizeUint8Array(salt, 'salt'), normalizeInfo(info), normalizeKeylen(keylen, digest));
|
||
}
|
||
exports.hkdf = hkdf;
|
||
exports.default = hkdf;
|
||
}),
|
||
"[project]/node_modules/uuid/dist/esm-node/index.js [app-route] (ecmascript) <locals>", ((__turbopack_context__) => {
|
||
"use strict";
|
||
|
||
__turbopack_context__.s([]);
|
||
;
|
||
;
|
||
;
|
||
;
|
||
;
|
||
;
|
||
;
|
||
;
|
||
;
|
||
}),
|
||
"[project]/node_modules/uuid/dist/esm-node/rng.js [app-route] (ecmascript)", ((__turbopack_context__) => {
|
||
"use strict";
|
||
|
||
__turbopack_context__.s([
|
||
"default",
|
||
()=>rng
|
||
]);
|
||
var __TURBOPACK__imported__module__$5b$externals$5d2f$crypto__$5b$external$5d$__$28$crypto$2c$__cjs$29$__ = __turbopack_context__.i("[externals]/crypto [external] (crypto, cjs)");
|
||
;
|
||
const rnds8Pool = new Uint8Array(256); // # of random values to pre-allocate
|
||
let poolPtr = rnds8Pool.length;
|
||
function rng() {
|
||
if (poolPtr > rnds8Pool.length - 16) {
|
||
__TURBOPACK__imported__module__$5b$externals$5d2f$crypto__$5b$external$5d$__$28$crypto$2c$__cjs$29$__["default"].randomFillSync(rnds8Pool);
|
||
poolPtr = 0;
|
||
}
|
||
return rnds8Pool.slice(poolPtr, poolPtr += 16);
|
||
}
|
||
}),
|
||
"[project]/node_modules/uuid/dist/esm-node/regex.js [app-route] (ecmascript)", ((__turbopack_context__) => {
|
||
"use strict";
|
||
|
||
__turbopack_context__.s([
|
||
"default",
|
||
()=>__TURBOPACK__default__export__
|
||
]);
|
||
const __TURBOPACK__default__export__ = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;
|
||
}),
|
||
"[project]/node_modules/uuid/dist/esm-node/validate.js [app-route] (ecmascript)", ((__turbopack_context__) => {
|
||
"use strict";
|
||
|
||
__turbopack_context__.s([
|
||
"default",
|
||
()=>__TURBOPACK__default__export__
|
||
]);
|
||
var __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$uuid$2f$dist$2f$esm$2d$node$2f$regex$2e$js__$5b$app$2d$route$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[project]/node_modules/uuid/dist/esm-node/regex.js [app-route] (ecmascript)");
|
||
;
|
||
function validate(uuid) {
|
||
return typeof uuid === 'string' && __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$uuid$2f$dist$2f$esm$2d$node$2f$regex$2e$js__$5b$app$2d$route$5d$__$28$ecmascript$29$__["default"].test(uuid);
|
||
}
|
||
const __TURBOPACK__default__export__ = validate;
|
||
}),
|
||
"[project]/node_modules/uuid/dist/esm-node/stringify.js [app-route] (ecmascript)", ((__turbopack_context__) => {
|
||
"use strict";
|
||
|
||
__turbopack_context__.s([
|
||
"default",
|
||
()=>__TURBOPACK__default__export__
|
||
]);
|
||
var __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$uuid$2f$dist$2f$esm$2d$node$2f$validate$2e$js__$5b$app$2d$route$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[project]/node_modules/uuid/dist/esm-node/validate.js [app-route] (ecmascript)");
|
||
;
|
||
/**
|
||
* Convert array of 16 byte values to UUID string format of the form:
|
||
* XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
|
||
*/ const byteToHex = [];
|
||
for(let i = 0; i < 256; ++i){
|
||
byteToHex.push((i + 0x100).toString(16).substr(1));
|
||
}
|
||
function stringify(arr, offset = 0) {
|
||
// Note: Be careful editing this code! It's been tuned for performance
|
||
// and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434
|
||
const uuid = (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase(); // Consistency check for valid UUID. If this throws, it's likely due to one
|
||
// of the following:
|
||
// - One or more input array values don't map to a hex octet (leading to
|
||
// "undefined" in the uuid)
|
||
// - Invalid input values for the RFC `version` or `variant` fields
|
||
if (!(0, __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$uuid$2f$dist$2f$esm$2d$node$2f$validate$2e$js__$5b$app$2d$route$5d$__$28$ecmascript$29$__["default"])(uuid)) {
|
||
throw TypeError('Stringified UUID is invalid');
|
||
}
|
||
return uuid;
|
||
}
|
||
const __TURBOPACK__default__export__ = stringify;
|
||
}),
|
||
"[project]/node_modules/uuid/dist/esm-node/v1.js [app-route] (ecmascript)", ((__turbopack_context__) => {
|
||
"use strict";
|
||
|
||
__turbopack_context__.s([
|
||
"default",
|
||
()=>__TURBOPACK__default__export__
|
||
]);
|
||
var __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$uuid$2f$dist$2f$esm$2d$node$2f$rng$2e$js__$5b$app$2d$route$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[project]/node_modules/uuid/dist/esm-node/rng.js [app-route] (ecmascript)");
|
||
var __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$uuid$2f$dist$2f$esm$2d$node$2f$stringify$2e$js__$5b$app$2d$route$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[project]/node_modules/uuid/dist/esm-node/stringify.js [app-route] (ecmascript)"); // **`v1()` - Generate time-based UUID**
|
||
;
|
||
;
|
||
//
|
||
// Inspired by https://github.com/LiosK/UUID.js
|
||
// and http://docs.python.org/library/uuid.html
|
||
let _nodeId;
|
||
let _clockseq; // Previous uuid creation time
|
||
let _lastMSecs = 0;
|
||
let _lastNSecs = 0; // See https://github.com/uuidjs/uuid for API details
|
||
function v1(options, buf, offset) {
|
||
let i = buf && offset || 0;
|
||
const b = buf || new Array(16);
|
||
options = options || {};
|
||
let node = options.node || _nodeId;
|
||
let clockseq = options.clockseq !== undefined ? options.clockseq : _clockseq; // node and clockseq need to be initialized to random values if they're not
|
||
// specified. We do this lazily to minimize issues related to insufficient
|
||
// system entropy. See #189
|
||
if (node == null || clockseq == null) {
|
||
const seedBytes = options.random || (options.rng || __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$uuid$2f$dist$2f$esm$2d$node$2f$rng$2e$js__$5b$app$2d$route$5d$__$28$ecmascript$29$__["default"])();
|
||
if (node == null) {
|
||
// Per 4.5, create and 48-bit node id, (47 random bits + multicast bit = 1)
|
||
node = _nodeId = [
|
||
seedBytes[0] | 0x01,
|
||
seedBytes[1],
|
||
seedBytes[2],
|
||
seedBytes[3],
|
||
seedBytes[4],
|
||
seedBytes[5]
|
||
];
|
||
}
|
||
if (clockseq == null) {
|
||
// Per 4.2.2, randomize (14 bit) clockseq
|
||
clockseq = _clockseq = (seedBytes[6] << 8 | seedBytes[7]) & 0x3fff;
|
||
}
|
||
} // UUID timestamps are 100 nano-second units since the Gregorian epoch,
|
||
// (1582-10-15 00:00). JSNumbers aren't precise enough for this, so
|
||
// time is handled internally as 'msecs' (integer milliseconds) and 'nsecs'
|
||
// (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01 00:00.
|
||
let msecs = options.msecs !== undefined ? options.msecs : Date.now(); // Per 4.2.1.2, use count of uuid's generated during the current clock
|
||
// cycle to simulate higher resolution clock
|
||
let nsecs = options.nsecs !== undefined ? options.nsecs : _lastNSecs + 1; // Time since last uuid creation (in msecs)
|
||
const dt = msecs - _lastMSecs + (nsecs - _lastNSecs) / 10000; // Per 4.2.1.2, Bump clockseq on clock regression
|
||
if (dt < 0 && options.clockseq === undefined) {
|
||
clockseq = clockseq + 1 & 0x3fff;
|
||
} // Reset nsecs if clock regresses (new clockseq) or we've moved onto a new
|
||
// time interval
|
||
if ((dt < 0 || msecs > _lastMSecs) && options.nsecs === undefined) {
|
||
nsecs = 0;
|
||
} // Per 4.2.1.2 Throw error if too many uuids are requested
|
||
if (nsecs >= 10000) {
|
||
throw new Error("uuid.v1(): Can't create more than 10M uuids/sec");
|
||
}
|
||
_lastMSecs = msecs;
|
||
_lastNSecs = nsecs;
|
||
_clockseq = clockseq; // Per 4.1.4 - Convert from unix epoch to Gregorian epoch
|
||
msecs += 12219292800000; // `time_low`
|
||
const tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000;
|
||
b[i++] = tl >>> 24 & 0xff;
|
||
b[i++] = tl >>> 16 & 0xff;
|
||
b[i++] = tl >>> 8 & 0xff;
|
||
b[i++] = tl & 0xff; // `time_mid`
|
||
const tmh = msecs / 0x100000000 * 10000 & 0xfffffff;
|
||
b[i++] = tmh >>> 8 & 0xff;
|
||
b[i++] = tmh & 0xff; // `time_high_and_version`
|
||
b[i++] = tmh >>> 24 & 0xf | 0x10; // include version
|
||
b[i++] = tmh >>> 16 & 0xff; // `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant)
|
||
b[i++] = clockseq >>> 8 | 0x80; // `clock_seq_low`
|
||
b[i++] = clockseq & 0xff; // `node`
|
||
for(let n = 0; n < 6; ++n){
|
||
b[i + n] = node[n];
|
||
}
|
||
return buf || (0, __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$uuid$2f$dist$2f$esm$2d$node$2f$stringify$2e$js__$5b$app$2d$route$5d$__$28$ecmascript$29$__["default"])(b);
|
||
}
|
||
const __TURBOPACK__default__export__ = v1;
|
||
}),
|
||
"[project]/node_modules/uuid/dist/esm-node/parse.js [app-route] (ecmascript)", ((__turbopack_context__) => {
|
||
"use strict";
|
||
|
||
__turbopack_context__.s([
|
||
"default",
|
||
()=>__TURBOPACK__default__export__
|
||
]);
|
||
var __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$uuid$2f$dist$2f$esm$2d$node$2f$validate$2e$js__$5b$app$2d$route$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[project]/node_modules/uuid/dist/esm-node/validate.js [app-route] (ecmascript)");
|
||
;
|
||
function parse(uuid) {
|
||
if (!(0, __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$uuid$2f$dist$2f$esm$2d$node$2f$validate$2e$js__$5b$app$2d$route$5d$__$28$ecmascript$29$__["default"])(uuid)) {
|
||
throw TypeError('Invalid UUID');
|
||
}
|
||
let v;
|
||
const arr = new Uint8Array(16); // Parse ########-....-....-....-............
|
||
arr[0] = (v = parseInt(uuid.slice(0, 8), 16)) >>> 24;
|
||
arr[1] = v >>> 16 & 0xff;
|
||
arr[2] = v >>> 8 & 0xff;
|
||
arr[3] = v & 0xff; // Parse ........-####-....-....-............
|
||
arr[4] = (v = parseInt(uuid.slice(9, 13), 16)) >>> 8;
|
||
arr[5] = v & 0xff; // Parse ........-....-####-....-............
|
||
arr[6] = (v = parseInt(uuid.slice(14, 18), 16)) >>> 8;
|
||
arr[7] = v & 0xff; // Parse ........-....-....-####-............
|
||
arr[8] = (v = parseInt(uuid.slice(19, 23), 16)) >>> 8;
|
||
arr[9] = v & 0xff; // Parse ........-....-....-....-############
|
||
// (Use "/" to avoid 32-bit truncation when bit-shifting high-order bytes)
|
||
arr[10] = (v = parseInt(uuid.slice(24, 36), 16)) / 0x10000000000 & 0xff;
|
||
arr[11] = v / 0x100000000 & 0xff;
|
||
arr[12] = v >>> 24 & 0xff;
|
||
arr[13] = v >>> 16 & 0xff;
|
||
arr[14] = v >>> 8 & 0xff;
|
||
arr[15] = v & 0xff;
|
||
return arr;
|
||
}
|
||
const __TURBOPACK__default__export__ = parse;
|
||
}),
|
||
"[project]/node_modules/uuid/dist/esm-node/v35.js [app-route] (ecmascript)", ((__turbopack_context__) => {
|
||
"use strict";
|
||
|
||
__turbopack_context__.s([
|
||
"DNS",
|
||
()=>DNS,
|
||
"URL",
|
||
()=>URL,
|
||
"default",
|
||
()=>__TURBOPACK__default__export__
|
||
]);
|
||
var __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$uuid$2f$dist$2f$esm$2d$node$2f$stringify$2e$js__$5b$app$2d$route$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[project]/node_modules/uuid/dist/esm-node/stringify.js [app-route] (ecmascript)");
|
||
var __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$uuid$2f$dist$2f$esm$2d$node$2f$parse$2e$js__$5b$app$2d$route$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[project]/node_modules/uuid/dist/esm-node/parse.js [app-route] (ecmascript)");
|
||
;
|
||
;
|
||
function stringToBytes(str) {
|
||
str = unescape(encodeURIComponent(str)); // UTF8 escape
|
||
const bytes = [];
|
||
for(let i = 0; i < str.length; ++i){
|
||
bytes.push(str.charCodeAt(i));
|
||
}
|
||
return bytes;
|
||
}
|
||
const DNS = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
|
||
const URL = '6ba7b811-9dad-11d1-80b4-00c04fd430c8';
|
||
function __TURBOPACK__default__export__(name, version, hashfunc) {
|
||
function generateUUID(value, namespace, buf, offset) {
|
||
if (typeof value === 'string') {
|
||
value = stringToBytes(value);
|
||
}
|
||
if (typeof namespace === 'string') {
|
||
namespace = (0, __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$uuid$2f$dist$2f$esm$2d$node$2f$parse$2e$js__$5b$app$2d$route$5d$__$28$ecmascript$29$__["default"])(namespace);
|
||
}
|
||
if (namespace.length !== 16) {
|
||
throw TypeError('Namespace must be array-like (16 iterable integer values, 0-255)');
|
||
} // Compute hash of namespace and value, Per 4.3
|
||
// Future: Use spread syntax when supported on all platforms, e.g. `bytes =
|
||
// hashfunc([...namespace, ... value])`
|
||
let bytes = new Uint8Array(16 + value.length);
|
||
bytes.set(namespace);
|
||
bytes.set(value, namespace.length);
|
||
bytes = hashfunc(bytes);
|
||
bytes[6] = bytes[6] & 0x0f | version;
|
||
bytes[8] = bytes[8] & 0x3f | 0x80;
|
||
if (buf) {
|
||
offset = offset || 0;
|
||
for(let i = 0; i < 16; ++i){
|
||
buf[offset + i] = bytes[i];
|
||
}
|
||
return buf;
|
||
}
|
||
return (0, __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$uuid$2f$dist$2f$esm$2d$node$2f$stringify$2e$js__$5b$app$2d$route$5d$__$28$ecmascript$29$__["default"])(bytes);
|
||
} // Function#name is not settable on some platforms (#270)
|
||
try {
|
||
generateUUID.name = name; // eslint-disable-next-line no-empty
|
||
} catch (err) {} // For CommonJS default export support
|
||
generateUUID.DNS = DNS;
|
||
generateUUID.URL = URL;
|
||
return generateUUID;
|
||
}
|
||
}),
|
||
"[project]/node_modules/uuid/dist/esm-node/md5.js [app-route] (ecmascript)", ((__turbopack_context__) => {
|
||
"use strict";
|
||
|
||
__turbopack_context__.s([
|
||
"default",
|
||
()=>__TURBOPACK__default__export__
|
||
]);
|
||
var __TURBOPACK__imported__module__$5b$externals$5d2f$crypto__$5b$external$5d$__$28$crypto$2c$__cjs$29$__ = __turbopack_context__.i("[externals]/crypto [external] (crypto, cjs)");
|
||
;
|
||
function md5(bytes) {
|
||
if (Array.isArray(bytes)) {
|
||
bytes = Buffer.from(bytes);
|
||
} else if (typeof bytes === 'string') {
|
||
bytes = Buffer.from(bytes, 'utf8');
|
||
}
|
||
return __TURBOPACK__imported__module__$5b$externals$5d2f$crypto__$5b$external$5d$__$28$crypto$2c$__cjs$29$__["default"].createHash('md5').update(bytes).digest();
|
||
}
|
||
const __TURBOPACK__default__export__ = md5;
|
||
}),
|
||
"[project]/node_modules/uuid/dist/esm-node/v3.js [app-route] (ecmascript)", ((__turbopack_context__) => {
|
||
"use strict";
|
||
|
||
__turbopack_context__.s([
|
||
"default",
|
||
()=>__TURBOPACK__default__export__
|
||
]);
|
||
var __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$uuid$2f$dist$2f$esm$2d$node$2f$v35$2e$js__$5b$app$2d$route$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[project]/node_modules/uuid/dist/esm-node/v35.js [app-route] (ecmascript)");
|
||
var __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$uuid$2f$dist$2f$esm$2d$node$2f$md5$2e$js__$5b$app$2d$route$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[project]/node_modules/uuid/dist/esm-node/md5.js [app-route] (ecmascript)");
|
||
;
|
||
;
|
||
const v3 = (0, __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$uuid$2f$dist$2f$esm$2d$node$2f$v35$2e$js__$5b$app$2d$route$5d$__$28$ecmascript$29$__["default"])('v3', 0x30, __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$uuid$2f$dist$2f$esm$2d$node$2f$md5$2e$js__$5b$app$2d$route$5d$__$28$ecmascript$29$__["default"]);
|
||
const __TURBOPACK__default__export__ = v3;
|
||
}),
|
||
"[project]/node_modules/uuid/dist/esm-node/v4.js [app-route] (ecmascript)", ((__turbopack_context__) => {
|
||
"use strict";
|
||
|
||
__turbopack_context__.s([
|
||
"default",
|
||
()=>__TURBOPACK__default__export__
|
||
]);
|
||
var __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$uuid$2f$dist$2f$esm$2d$node$2f$rng$2e$js__$5b$app$2d$route$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[project]/node_modules/uuid/dist/esm-node/rng.js [app-route] (ecmascript)");
|
||
var __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$uuid$2f$dist$2f$esm$2d$node$2f$stringify$2e$js__$5b$app$2d$route$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[project]/node_modules/uuid/dist/esm-node/stringify.js [app-route] (ecmascript)");
|
||
;
|
||
;
|
||
function v4(options, buf, offset) {
|
||
options = options || {};
|
||
const rnds = options.random || (options.rng || __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$uuid$2f$dist$2f$esm$2d$node$2f$rng$2e$js__$5b$app$2d$route$5d$__$28$ecmascript$29$__["default"])(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
|
||
rnds[6] = rnds[6] & 0x0f | 0x40;
|
||
rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided
|
||
if (buf) {
|
||
offset = offset || 0;
|
||
for(let i = 0; i < 16; ++i){
|
||
buf[offset + i] = rnds[i];
|
||
}
|
||
return buf;
|
||
}
|
||
return (0, __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$uuid$2f$dist$2f$esm$2d$node$2f$stringify$2e$js__$5b$app$2d$route$5d$__$28$ecmascript$29$__["default"])(rnds);
|
||
}
|
||
const __TURBOPACK__default__export__ = v4;
|
||
}),
|
||
"[project]/node_modules/uuid/dist/esm-node/sha1.js [app-route] (ecmascript)", ((__turbopack_context__) => {
|
||
"use strict";
|
||
|
||
__turbopack_context__.s([
|
||
"default",
|
||
()=>__TURBOPACK__default__export__
|
||
]);
|
||
var __TURBOPACK__imported__module__$5b$externals$5d2f$crypto__$5b$external$5d$__$28$crypto$2c$__cjs$29$__ = __turbopack_context__.i("[externals]/crypto [external] (crypto, cjs)");
|
||
;
|
||
function sha1(bytes) {
|
||
if (Array.isArray(bytes)) {
|
||
bytes = Buffer.from(bytes);
|
||
} else if (typeof bytes === 'string') {
|
||
bytes = Buffer.from(bytes, 'utf8');
|
||
}
|
||
return __TURBOPACK__imported__module__$5b$externals$5d2f$crypto__$5b$external$5d$__$28$crypto$2c$__cjs$29$__["default"].createHash('sha1').update(bytes).digest();
|
||
}
|
||
const __TURBOPACK__default__export__ = sha1;
|
||
}),
|
||
"[project]/node_modules/uuid/dist/esm-node/v5.js [app-route] (ecmascript)", ((__turbopack_context__) => {
|
||
"use strict";
|
||
|
||
__turbopack_context__.s([
|
||
"default",
|
||
()=>__TURBOPACK__default__export__
|
||
]);
|
||
var __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$uuid$2f$dist$2f$esm$2d$node$2f$v35$2e$js__$5b$app$2d$route$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[project]/node_modules/uuid/dist/esm-node/v35.js [app-route] (ecmascript)");
|
||
var __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$uuid$2f$dist$2f$esm$2d$node$2f$sha1$2e$js__$5b$app$2d$route$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[project]/node_modules/uuid/dist/esm-node/sha1.js [app-route] (ecmascript)");
|
||
;
|
||
;
|
||
const v5 = (0, __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$uuid$2f$dist$2f$esm$2d$node$2f$v35$2e$js__$5b$app$2d$route$5d$__$28$ecmascript$29$__["default"])('v5', 0x50, __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$uuid$2f$dist$2f$esm$2d$node$2f$sha1$2e$js__$5b$app$2d$route$5d$__$28$ecmascript$29$__["default"]);
|
||
const __TURBOPACK__default__export__ = v5;
|
||
}),
|
||
"[project]/node_modules/uuid/dist/esm-node/nil.js [app-route] (ecmascript)", ((__turbopack_context__) => {
|
||
"use strict";
|
||
|
||
__turbopack_context__.s([
|
||
"default",
|
||
()=>__TURBOPACK__default__export__
|
||
]);
|
||
const __TURBOPACK__default__export__ = '00000000-0000-0000-0000-000000000000';
|
||
}),
|
||
"[project]/node_modules/uuid/dist/esm-node/version.js [app-route] (ecmascript)", ((__turbopack_context__) => {
|
||
"use strict";
|
||
|
||
__turbopack_context__.s([
|
||
"default",
|
||
()=>__TURBOPACK__default__export__
|
||
]);
|
||
var __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$uuid$2f$dist$2f$esm$2d$node$2f$validate$2e$js__$5b$app$2d$route$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[project]/node_modules/uuid/dist/esm-node/validate.js [app-route] (ecmascript)");
|
||
;
|
||
function version(uuid) {
|
||
if (!(0, __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$uuid$2f$dist$2f$esm$2d$node$2f$validate$2e$js__$5b$app$2d$route$5d$__$28$ecmascript$29$__["default"])(uuid)) {
|
||
throw TypeError('Invalid UUID');
|
||
}
|
||
return parseInt(uuid.substr(14, 1), 16);
|
||
}
|
||
const __TURBOPACK__default__export__ = version;
|
||
}),
|
||
"[project]/node_modules/uuid/dist/esm-node/index.js [app-route] (ecmascript)", ((__turbopack_context__) => {
|
||
"use strict";
|
||
|
||
__turbopack_context__.s([
|
||
"NIL",
|
||
()=>__TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$uuid$2f$dist$2f$esm$2d$node$2f$nil$2e$js__$5b$app$2d$route$5d$__$28$ecmascript$29$__["default"],
|
||
"parse",
|
||
()=>__TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$uuid$2f$dist$2f$esm$2d$node$2f$parse$2e$js__$5b$app$2d$route$5d$__$28$ecmascript$29$__["default"],
|
||
"stringify",
|
||
()=>__TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$uuid$2f$dist$2f$esm$2d$node$2f$stringify$2e$js__$5b$app$2d$route$5d$__$28$ecmascript$29$__["default"],
|
||
"v1",
|
||
()=>__TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$uuid$2f$dist$2f$esm$2d$node$2f$v1$2e$js__$5b$app$2d$route$5d$__$28$ecmascript$29$__["default"],
|
||
"v3",
|
||
()=>__TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$uuid$2f$dist$2f$esm$2d$node$2f$v3$2e$js__$5b$app$2d$route$5d$__$28$ecmascript$29$__["default"],
|
||
"v4",
|
||
()=>__TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$uuid$2f$dist$2f$esm$2d$node$2f$v4$2e$js__$5b$app$2d$route$5d$__$28$ecmascript$29$__["default"],
|
||
"v5",
|
||
()=>__TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$uuid$2f$dist$2f$esm$2d$node$2f$v5$2e$js__$5b$app$2d$route$5d$__$28$ecmascript$29$__["default"],
|
||
"validate",
|
||
()=>__TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$uuid$2f$dist$2f$esm$2d$node$2f$validate$2e$js__$5b$app$2d$route$5d$__$28$ecmascript$29$__["default"],
|
||
"version",
|
||
()=>__TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$uuid$2f$dist$2f$esm$2d$node$2f$version$2e$js__$5b$app$2d$route$5d$__$28$ecmascript$29$__["default"]
|
||
]);
|
||
var __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$uuid$2f$dist$2f$esm$2d$node$2f$index$2e$js__$5b$app$2d$route$5d$__$28$ecmascript$29$__$3c$locals$3e$__ = __turbopack_context__.i("[project]/node_modules/uuid/dist/esm-node/index.js [app-route] (ecmascript) <locals>");
|
||
var __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$uuid$2f$dist$2f$esm$2d$node$2f$v1$2e$js__$5b$app$2d$route$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[project]/node_modules/uuid/dist/esm-node/v1.js [app-route] (ecmascript)");
|
||
var __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$uuid$2f$dist$2f$esm$2d$node$2f$v3$2e$js__$5b$app$2d$route$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[project]/node_modules/uuid/dist/esm-node/v3.js [app-route] (ecmascript)");
|
||
var __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$uuid$2f$dist$2f$esm$2d$node$2f$v4$2e$js__$5b$app$2d$route$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[project]/node_modules/uuid/dist/esm-node/v4.js [app-route] (ecmascript)");
|
||
var __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$uuid$2f$dist$2f$esm$2d$node$2f$v5$2e$js__$5b$app$2d$route$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[project]/node_modules/uuid/dist/esm-node/v5.js [app-route] (ecmascript)");
|
||
var __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$uuid$2f$dist$2f$esm$2d$node$2f$nil$2e$js__$5b$app$2d$route$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[project]/node_modules/uuid/dist/esm-node/nil.js [app-route] (ecmascript)");
|
||
var __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$uuid$2f$dist$2f$esm$2d$node$2f$version$2e$js__$5b$app$2d$route$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[project]/node_modules/uuid/dist/esm-node/version.js [app-route] (ecmascript)");
|
||
var __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$uuid$2f$dist$2f$esm$2d$node$2f$validate$2e$js__$5b$app$2d$route$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[project]/node_modules/uuid/dist/esm-node/validate.js [app-route] (ecmascript)");
|
||
var __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$uuid$2f$dist$2f$esm$2d$node$2f$stringify$2e$js__$5b$app$2d$route$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[project]/node_modules/uuid/dist/esm-node/stringify.js [app-route] (ecmascript)");
|
||
var __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f$uuid$2f$dist$2f$esm$2d$node$2f$parse$2e$js__$5b$app$2d$route$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[project]/node_modules/uuid/dist/esm-node/parse.js [app-route] (ecmascript)");
|
||
}),
|
||
"[project]/node_modules/preact/dist/preact.js [app-route] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
|
||
var n, l, t, u, r, i, o, e, f, c, s, a, h, p, v, y, d = {}, w = [], _ = /acit|ex(?:s|g|n|p|$)|rph|grid|ows|mnc|ntw|ine[ch]|zoo|^ord|itera/i, g = Array.isArray;
|
||
function x(n, l) {
|
||
for(var t in l)n[t] = l[t];
|
||
return n;
|
||
}
|
||
function m(n) {
|
||
n && n.parentNode && n.parentNode.removeChild(n);
|
||
}
|
||
function b(l, t, u) {
|
||
var r, i, o, e = {};
|
||
for(o in t)"key" == o ? r = t[o] : "ref" == o ? i = t[o] : e[o] = t[o];
|
||
if (arguments.length > 2 && (e.children = arguments.length > 3 ? n.call(arguments, 2) : u), "function" == typeof l && null != l.defaultProps) for(o in l.defaultProps)void 0 === e[o] && (e[o] = l.defaultProps[o]);
|
||
return k(l, e, r, i, null);
|
||
}
|
||
function k(n, u, r, i, o) {
|
||
var e = {
|
||
type: n,
|
||
props: u,
|
||
key: r,
|
||
ref: i,
|
||
__k: null,
|
||
__: null,
|
||
__b: 0,
|
||
__e: null,
|
||
__c: null,
|
||
constructor: void 0,
|
||
__v: null == o ? ++t : o,
|
||
__i: -1,
|
||
__u: 0
|
||
};
|
||
return null == o && null != l.vnode && l.vnode(e), e;
|
||
}
|
||
function M(n) {
|
||
return n.children;
|
||
}
|
||
function S(n, l) {
|
||
this.props = n, this.context = l;
|
||
}
|
||
function $(n, l) {
|
||
if (null == l) return n.__ ? $(n.__, n.__i + 1) : null;
|
||
for(var t; l < n.__k.length; l++)if (null != (t = n.__k[l]) && null != t.__e) return t.__e;
|
||
return "function" == typeof n.type ? $(n) : null;
|
||
}
|
||
function C(n) {
|
||
if (n.__P && n.__d) {
|
||
var t = n.__v, u = t.__e, r = [], i = [], o = x({}, t);
|
||
o.__v = t.__v + 1, l.vnode && l.vnode(o), N(n.__P, o, t, n.__n, n.__P.namespaceURI, 32 & t.__u ? [
|
||
u
|
||
] : null, r, null == u ? $(t) : u, !!(32 & t.__u), i), o.__v = t.__v, o.__.__k[o.__i] = o, q(r, o, i), t.__e = t.__ = null, o.__e != u && I(o);
|
||
}
|
||
}
|
||
function I(n) {
|
||
if (null != (n = n.__) && null != n.__c) return n.__e = n.__c.base = null, n.__k.some(function(l) {
|
||
if (null != l && null != l.__e) return n.__e = n.__c.base = l.__e;
|
||
}), I(n);
|
||
}
|
||
function P(n) {
|
||
(!n.__d && (n.__d = !0) && r.push(n) && !A.__r++ || i != l.debounceRendering) && ((i = l.debounceRendering) || o)(A);
|
||
}
|
||
function A() {
|
||
try {
|
||
for(var n, l = 1; r.length;)r.length > l && r.sort(e), n = r.shift(), l = r.length, C(n);
|
||
} finally{
|
||
r.length = A.__r = 0;
|
||
}
|
||
}
|
||
function H(n, l, t, u, r, i, o, e, f, c, s) {
|
||
var a, h, p, v, y, _, g, x = u && u.__k || w, m = l.length;
|
||
for(f = L(t, l, x, f, m), a = 0; a < m; a++)null != (p = t.__k[a]) && (h = -1 != p.__i && x[p.__i] || d, p.__i = a, _ = N(n, p, h, r, i, o, e, f, c, s), v = p.__e, p.ref && h.ref != p.ref && (h.ref && E(h.ref, null, p), s.push(p.ref, p.__c || v, p)), null == y && null != v && (y = v), (g = !!(4 & p.__u)) || h.__k === p.__k ? (f = T(p, f, n, g), g && h.__e && (h.__e = null)) : "function" == typeof p.type && void 0 !== _ ? f = _ : v && (f = v.nextSibling), p.__u &= -7);
|
||
return t.__e = y, f;
|
||
}
|
||
function L(n, l, t, u, r) {
|
||
var i, o, e, f, c, s = t.length, a = s, h = 0;
|
||
for(n.__k = new Array(r), i = 0; i < r; i++)null != (o = l[i]) && "boolean" != typeof o && "function" != typeof o ? ("string" == typeof o || "number" == typeof o || "bigint" == typeof o || o.constructor == String ? o = n.__k[i] = k(null, o, null, null, null) : g(o) ? o = n.__k[i] = k(M, {
|
||
children: o
|
||
}, null, null, null) : void 0 === o.constructor && o.__b > 0 ? o = n.__k[i] = k(o.type, o.props, o.key, o.ref ? o.ref : null, o.__v) : n.__k[i] = o, f = i + h, o.__ = n, o.__b = n.__b + 1, e = null, -1 != (c = o.__i = j(o, t, f, a)) && (a--, (e = t[c]) && (e.__u |= 2)), null == e || null == e.__v ? (-1 == c && (r > s ? h-- : r < s && h++), "function" != typeof o.type && (o.__u |= 4)) : c != f && (c == f - 1 ? h-- : c == f + 1 ? h++ : (c > f ? h-- : h++, o.__u |= 4))) : n.__k[i] = null;
|
||
if (a) for(i = 0; i < s; i++)null != (e = t[i]) && 0 == (2 & e.__u) && (e.__e == u && (u = $(e)), G(e, e));
|
||
return u;
|
||
}
|
||
function T(n, l, t, u) {
|
||
var r, i;
|
||
if ("function" == typeof n.type) {
|
||
for(r = n.__k, i = 0; r && i < r.length; i++)r[i] && (r[i].__ = n, l = T(r[i], l, t, u));
|
||
return l;
|
||
}
|
||
n.__e != l && (u && (l && n.type && !l.parentNode && (l = $(n)), t.insertBefore(n.__e, l || null)), l = n.__e);
|
||
do {
|
||
l = l && l.nextSibling;
|
||
}while (null != l && 8 == l.nodeType)
|
||
return l;
|
||
}
|
||
function j(n, l, t, u) {
|
||
var r, i, o, e = n.key, f = n.type, c = l[t], s = null != c && 0 == (2 & c.__u);
|
||
if (null === c && null == e || s && e == c.key && f == c.type) return t;
|
||
if (u > (s ? 1 : 0)) {
|
||
for(r = t - 1, i = t + 1; r >= 0 || i < l.length;)if (null != (c = l[o = r >= 0 ? r-- : i++]) && 0 == (2 & c.__u) && e == c.key && f == c.type) return o;
|
||
}
|
||
return -1;
|
||
}
|
||
function F(n, l, t) {
|
||
"-" == l[0] ? n.setProperty(l, null == t ? "" : t) : n[l] = null == t ? "" : "number" != typeof t || _.test(l) ? t : t + "px";
|
||
}
|
||
function O(n, l, t, u, r) {
|
||
var i, o;
|
||
n: if ("style" == l) if ("string" == typeof t) n.style.cssText = t;
|
||
else {
|
||
if ("string" == typeof u && (n.style.cssText = u = ""), u) for(l in u)t && l in t || F(n.style, l, "");
|
||
if (t) for(l in t)u && t[l] == u[l] || F(n.style, l, t[l]);
|
||
}
|
||
else if ("o" == l[0] && "n" == l[1]) i = l != (l = l.replace(a, "$1")), o = l.toLowerCase(), l = o in n || "onFocusOut" == l || "onFocusIn" == l ? o.slice(2) : l.slice(2), n.l || (n.l = {}), n.l[l + i] = t, t ? u ? t[s] = u[s] : (t[s] = h, n.addEventListener(l, i ? v : p, i)) : n.removeEventListener(l, i ? v : p, i);
|
||
else {
|
||
if ("http://www.w3.org/2000/svg" == r) l = l.replace(/xlink(H|:h)/, "h").replace(/sName$/, "s");
|
||
else if ("width" != l && "height" != l && "href" != l && "list" != l && "form" != l && "tabIndex" != l && "download" != l && "rowSpan" != l && "colSpan" != l && "role" != l && "popover" != l && l in n) try {
|
||
n[l] = null == t ? "" : t;
|
||
break n;
|
||
} catch (n) {}
|
||
"function" == typeof t || (null == t || !1 === t && "-" != l[4] ? n.removeAttribute(l) : n.setAttribute(l, "popover" == l && 1 == t ? "" : t));
|
||
}
|
||
}
|
||
function z(n) {
|
||
return function(t) {
|
||
if (this.l) {
|
||
var u = this.l[t.type + n];
|
||
if (null == t[c]) t[c] = h++;
|
||
else if (t[c] < u[s]) return;
|
||
return u(l.event ? l.event(t) : t);
|
||
}
|
||
};
|
||
}
|
||
function N(n, t, u, r, i, o, e, f, c, s) {
|
||
var a, h, p, v, y, d, _, b, k, $, C, I, P, A, L, T = t.type;
|
||
if (void 0 !== t.constructor) return null;
|
||
128 & u.__u && (c = !!(32 & u.__u), o = [
|
||
f = t.__e = u.__e
|
||
]), (a = l.__b) && a(t);
|
||
n: if ("function" == typeof T) try {
|
||
if (b = t.props, k = T.prototype && T.prototype.render, $ = (a = T.contextType) && r[a.__c], C = a ? $ ? $.props.value : a.__ : r, u.__c ? _ = (h = t.__c = u.__c).__ = h.__E : (k ? t.__c = h = new T(b, C) : (t.__c = h = new S(b, C), h.constructor = T, h.render = J), $ && $.sub(h), h.state || (h.state = {}), h.__n = r, p = h.__d = !0, h.__h = [], h._sb = []), k && null == h.__s && (h.__s = h.state), k && null != T.getDerivedStateFromProps && (h.__s == h.state && (h.__s = x({}, h.__s)), x(h.__s, T.getDerivedStateFromProps(b, h.__s))), v = h.props, y = h.state, h.__v = t, p) k && null == T.getDerivedStateFromProps && null != h.componentWillMount && h.componentWillMount(), k && null != h.componentDidMount && h.__h.push(h.componentDidMount);
|
||
else {
|
||
if (k && null == T.getDerivedStateFromProps && b !== v && null != h.componentWillReceiveProps && h.componentWillReceiveProps(b, C), t.__v == u.__v || !h.__e && null != h.shouldComponentUpdate && !1 === h.shouldComponentUpdate(b, h.__s, C)) {
|
||
t.__v != u.__v && (h.props = b, h.state = h.__s, h.__d = !1), t.__e = u.__e, t.__k = u.__k, t.__k.some(function(n) {
|
||
n && (n.__ = t);
|
||
}), w.push.apply(h.__h, h._sb), h._sb = [], h.__h.length && e.push(h);
|
||
break n;
|
||
}
|
||
null != h.componentWillUpdate && h.componentWillUpdate(b, h.__s, C), k && null != h.componentDidUpdate && h.__h.push(function() {
|
||
h.componentDidUpdate(v, y, d);
|
||
});
|
||
}
|
||
if (h.context = C, h.props = b, h.__P = n, h.__e = !1, I = l.__r, P = 0, k) h.state = h.__s, h.__d = !1, I && I(t), a = h.render(h.props, h.state, h.context), w.push.apply(h.__h, h._sb), h._sb = [];
|
||
else do {
|
||
h.__d = !1, I && I(t), a = h.render(h.props, h.state, h.context), h.state = h.__s;
|
||
}while (h.__d && ++P < 25)
|
||
h.state = h.__s, null != h.getChildContext && (r = x(x({}, r), h.getChildContext())), k && !p && null != h.getSnapshotBeforeUpdate && (d = h.getSnapshotBeforeUpdate(v, y)), A = null != a && a.type === M && null == a.key ? B(a.props.children) : a, f = H(n, g(A) ? A : [
|
||
A
|
||
], t, u, r, i, o, e, f, c, s), h.base = t.__e, t.__u &= -161, h.__h.length && e.push(h), _ && (h.__E = h.__ = null);
|
||
} catch (n) {
|
||
if (t.__v = null, c || null != o) if (n.then) {
|
||
for(t.__u |= c ? 160 : 128; f && 8 == f.nodeType && f.nextSibling;)f = f.nextSibling;
|
||
o[o.indexOf(f)] = null, t.__e = f;
|
||
} else {
|
||
for(L = o.length; L--;)m(o[L]);
|
||
V(t);
|
||
}
|
||
else t.__e = u.__e, t.__k = u.__k, n.then || V(t);
|
||
l.__e(n, t, u);
|
||
}
|
||
else null == o && t.__v == u.__v ? (t.__k = u.__k, t.__e = u.__e) : f = t.__e = D(u.__e, t, u, r, i, o, e, c, s);
|
||
return (a = l.diffed) && a(t), 128 & t.__u ? void 0 : f;
|
||
}
|
||
function V(n) {
|
||
n && (n.__c && (n.__c.__e = !0), n.__k && n.__k.some(V));
|
||
}
|
||
function q(n, t, u) {
|
||
for(var r = 0; r < u.length; r++)E(u[r], u[++r], u[++r]);
|
||
l.__c && l.__c(t, n), n.some(function(t) {
|
||
try {
|
||
n = t.__h, t.__h = [], n.some(function(n) {
|
||
n.call(t);
|
||
});
|
||
} catch (n) {
|
||
l.__e(n, t.__v);
|
||
}
|
||
});
|
||
}
|
||
function B(n) {
|
||
return "object" != typeof n || null == n || n.__b > 0 ? n : g(n) ? n.map(B) : x({}, n);
|
||
}
|
||
function D(t, u, r, i, o, e, f, c, s) {
|
||
var a, h, p, v, y, w, _, x = r.props || d, b = u.props, k = u.type;
|
||
if ("svg" == k ? o = "http://www.w3.org/2000/svg" : "math" == k ? o = "http://www.w3.org/1998/Math/MathML" : o || (o = "http://www.w3.org/1999/xhtml"), null != e) {
|
||
for(a = 0; a < e.length; a++)if ((y = e[a]) && "setAttribute" in y == !!k && (k ? y.localName == k : 3 == y.nodeType)) {
|
||
t = y, e[a] = null;
|
||
break;
|
||
}
|
||
}
|
||
if (null == t) {
|
||
if (null == k) return document.createTextNode(b);
|
||
t = document.createElementNS(o, k, b.is && b), c && (l.__m && l.__m(u, e), c = !1), e = null;
|
||
}
|
||
if (null == k) x === b || c && t.data == b || (t.data = b);
|
||
else {
|
||
if (e = e && n.call(t.childNodes), !c && null != e) for(x = {}, a = 0; a < t.attributes.length; a++)x[(y = t.attributes[a]).name] = y.value;
|
||
for(a in x)y = x[a], "dangerouslySetInnerHTML" == a ? p = y : "children" == a || a in b || "value" == a && "defaultValue" in b || "checked" == a && "defaultChecked" in b || O(t, a, null, y, o);
|
||
for(a in b)y = b[a], "children" == a ? v = y : "dangerouslySetInnerHTML" == a ? h = y : "value" == a ? w = y : "checked" == a ? _ = y : c && "function" != typeof y || x[a] === y || O(t, a, y, x[a], o);
|
||
if (h) c || p && (h.__html == p.__html || h.__html == t.innerHTML) || (t.innerHTML = h.__html), u.__k = [];
|
||
else if (p && (t.innerHTML = ""), H("template" == u.type ? t.content : t, g(v) ? v : [
|
||
v
|
||
], u, r, i, "foreignObject" == k ? "http://www.w3.org/1999/xhtml" : o, e, f, e ? e[0] : r.__k && $(r, 0), c, s), null != e) for(a = e.length; a--;)m(e[a]);
|
||
c || (a = "value", "progress" == k && null == w ? t.removeAttribute("value") : null != w && (w !== t[a] || "progress" == k && !w || "option" == k && w != x[a]) && O(t, a, w, x[a], o), a = "checked", null != _ && _ != t[a] && O(t, a, _, x[a], o));
|
||
}
|
||
return t;
|
||
}
|
||
function E(n, t, u) {
|
||
try {
|
||
if ("function" == typeof n) {
|
||
var r = "function" == typeof n.__u;
|
||
r && n.__u(), r && null == t || (n.__u = n(t));
|
||
} else n.current = t;
|
||
} catch (n) {
|
||
l.__e(n, u);
|
||
}
|
||
}
|
||
function G(n, t, u) {
|
||
var r, i;
|
||
if (l.unmount && l.unmount(n), (r = n.ref) && (r.current && r.current != n.__e || E(r, null, t)), null != (r = n.__c)) {
|
||
if (r.componentWillUnmount) try {
|
||
r.componentWillUnmount();
|
||
} catch (n) {
|
||
l.__e(n, t);
|
||
}
|
||
r.base = r.__P = null;
|
||
}
|
||
if (r = n.__k) for(i = 0; i < r.length; i++)r[i] && G(r[i], t, u || "function" != typeof n.type);
|
||
u || m(n.__e), n.__c = n.__ = n.__e = void 0;
|
||
}
|
||
function J(n, l, t) {
|
||
return this.constructor(n, t);
|
||
}
|
||
function K(t, u, r) {
|
||
var i, o, e, f;
|
||
u == document && (u = document.documentElement), l.__ && l.__(t, u), o = (i = "function" == typeof r) ? null : r && r.__k || u.__k, e = [], f = [], N(u, t = (!i && r || u).__k = b(M, null, [
|
||
t
|
||
]), o || d, d, u.namespaceURI, !i && r ? [
|
||
r
|
||
] : o ? null : u.firstChild ? n.call(u.childNodes) : null, e, !i && r ? r : o ? o.__e : u.firstChild, i, f), q(e, t, f);
|
||
}
|
||
n = w.slice, l = {
|
||
__e: function(n, l, t, u) {
|
||
for(var r, i, o; l = l.__;)if ((r = l.__c) && !r.__) try {
|
||
if ((i = r.constructor) && null != i.getDerivedStateFromError && (r.setState(i.getDerivedStateFromError(n)), o = r.__d), null != r.componentDidCatch && (r.componentDidCatch(n, u || {}), o = r.__d), o) return r.__E = r;
|
||
} catch (l) {
|
||
n = l;
|
||
}
|
||
throw n;
|
||
}
|
||
}, t = 0, u = function(n) {
|
||
return null != n && void 0 === n.constructor;
|
||
}, S.prototype.setState = function(n, l) {
|
||
var t;
|
||
t = null != this.__s && this.__s != this.state ? this.__s : this.__s = x({}, this.state), "function" == typeof n && (n = n(x({}, t), this.props)), n && x(t, n), null != n && this.__v && (l && this._sb.push(l), P(this));
|
||
}, S.prototype.forceUpdate = function(n) {
|
||
this.__v && (this.__e = !0, n && this.__h.push(n), P(this));
|
||
}, S.prototype.render = M, r = [], o = "function" == typeof Promise ? Promise.prototype.then.bind(Promise.resolve()) : setTimeout, e = function(n, l) {
|
||
return n.__v.__b - l.__v.__b;
|
||
}, A.__r = 0, f = Math.random().toString(8), c = "__d" + f, s = "__a" + f, a = /(PointerCapture)$|Capture$/i, h = 0, p = z(!1), v = z(!0), y = 0, exports.Component = S, exports.Fragment = M, exports.cloneElement = function(l, t, u) {
|
||
var r, i, o, e, f = x({}, l.props);
|
||
for(o in l.type && l.type.defaultProps && (e = l.type.defaultProps), t)"key" == o ? r = t[o] : "ref" == o ? i = t[o] : f[o] = void 0 === t[o] && null != e ? e[o] : t[o];
|
||
return arguments.length > 2 && (f.children = arguments.length > 3 ? n.call(arguments, 2) : u), k(l.type, f, r || l.key, i || l.ref, null);
|
||
}, exports.createContext = function(n) {
|
||
function l(n) {
|
||
var t, u;
|
||
return this.getChildContext || (t = new Set, (u = {})[l.__c] = this, this.getChildContext = function() {
|
||
return u;
|
||
}, this.componentWillUnmount = function() {
|
||
t = null;
|
||
}, this.shouldComponentUpdate = function(n) {
|
||
this.props.value != n.value && t.forEach(function(n) {
|
||
n.__e = !0, P(n);
|
||
});
|
||
}, this.sub = function(n) {
|
||
t.add(n);
|
||
var l = n.componentWillUnmount;
|
||
n.componentWillUnmount = function() {
|
||
t && t.delete(n), l && l.call(n);
|
||
};
|
||
}), n.children;
|
||
}
|
||
return l.__c = "__cC" + y++, l.__ = n, l.Provider = l.__l = (l.Consumer = function(n, l) {
|
||
return n.children(l);
|
||
}).contextType = l, l;
|
||
}, exports.createElement = b, exports.createRef = function() {
|
||
return {
|
||
current: null
|
||
};
|
||
}, exports.h = b, exports.hydrate = function n(l, t) {
|
||
K(l, t, n);
|
||
}, exports.isValidElement = u, exports.options = l, exports.render = K, exports.toChildArray = function n(l, t) {
|
||
return t = t || [], null == l || "boolean" == typeof l || (g(l) ? l.some(function(l) {
|
||
n(l, t);
|
||
}) : t.push(l)), t;
|
||
};
|
||
}),
|
||
"[project]/node_modules/preact-render-to-string/dist/commonjs.js [app-route] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
|
||
!function(e, t) {
|
||
("TURBOPACK compile-time truthy", 1) ? t(exports, __turbopack_context__.r("[project]/node_modules/preact/dist/preact.js [app-route] (ecmascript)")) : "TURBOPACK unreachable";
|
||
}(/*TURBOPACK member replacement*/ __turbopack_context__.e, function(e, t) {
|
||
var n = /acit|ex(?:s|g|n|p|$)|rph|grid|ows|mnc|ntw|ine[ch]|zoo|^ord|^--/i, r = /^(area|base|br|col|embed|hr|img|input|link|meta|param|source|track|wbr)$/, o = /[\s\n\\/='"\0<>]/, i = /^xlink:?./, s = /["&<]/;
|
||
function a(e) {
|
||
if (!1 === s.test(e += "")) return e;
|
||
for(var t = 0, n = 0, r = "", o = ""; n < e.length; n++){
|
||
switch(e.charCodeAt(n)){
|
||
case 34:
|
||
o = """;
|
||
break;
|
||
case 38:
|
||
o = "&";
|
||
break;
|
||
case 60:
|
||
o = "<";
|
||
break;
|
||
default:
|
||
continue;
|
||
}
|
||
n !== t && (r += e.slice(t, n)), r += o, t = n + 1;
|
||
}
|
||
return n !== t && (r += e.slice(t, n)), r;
|
||
}
|
||
var l = function(e, t) {
|
||
return String(e).replace(/(\n+)/g, "$1" + (t || "\t"));
|
||
}, f = function(e, t, n) {
|
||
return String(e).length > (t || 40) || !n && -1 !== String(e).indexOf("\n") || -1 !== String(e).indexOf("<");
|
||
}, u = {}, p = /([A-Z])/g;
|
||
function c(e) {
|
||
var t = "";
|
||
for(var r in e){
|
||
var o = e[r];
|
||
null != o && "" !== o && (t && (t += " "), t += "-" == r[0] ? r : u[r] || (u[r] = r.replace(p, "-$1").toLowerCase()), t = "number" == typeof o && !1 === n.test(r) ? t + ": " + o + "px;" : t + ": " + o + ";");
|
||
}
|
||
return t || void 0;
|
||
}
|
||
function _(e, t) {
|
||
return Array.isArray(t) ? t.reduce(_, e) : null != t && !1 !== t && e.push(t), e;
|
||
}
|
||
function d() {
|
||
this.__d = !0;
|
||
}
|
||
function v(e, t) {
|
||
return {
|
||
__v: e,
|
||
context: t,
|
||
props: e.props,
|
||
setState: d,
|
||
forceUpdate: d,
|
||
__d: !0,
|
||
__h: []
|
||
};
|
||
}
|
||
function g(e, t) {
|
||
var n = e.contextType, r = n && t[n.__c];
|
||
return null != n ? r ? r.props.value : n.__ : t;
|
||
}
|
||
var h = [];
|
||
function y(e, n, s, u, p, d) {
|
||
if (null == e || "boolean" == typeof e) return "";
|
||
if ("object" != typeof e) return "function" == typeof e ? "" : a(e);
|
||
var m = s.pretty, b = m && "string" == typeof m ? m : "\t";
|
||
if (Array.isArray(e)) {
|
||
for(var x = "", k = 0; k < e.length; k++)m && k > 0 && (x += "\n"), x += y(e[k], n, s, u, p, d);
|
||
return x;
|
||
}
|
||
if (void 0 !== e.constructor) return "";
|
||
var S, w = e.type, C = e.props, O = !1;
|
||
if ("function" == typeof w) {
|
||
if (O = !0, !s.shallow || !u && !1 !== s.renderRootComponent) {
|
||
if (w === t.Fragment) {
|
||
var j = [];
|
||
return _(j, e.props.children), y(j, n, s, !1 !== s.shallowHighOrder, p, d);
|
||
}
|
||
var F, A = e.__c = v(e, n);
|
||
t.options.__b && t.options.__b(e);
|
||
var T = t.options.__r;
|
||
if (w.prototype && "function" == typeof w.prototype.render) {
|
||
var H = g(w, n);
|
||
(A = e.__c = new w(C, H)).__v = e, A._dirty = A.__d = !0, A.props = C, null == A.state && (A.state = {}), null == A._nextState && null == A.__s && (A._nextState = A.__s = A.state), A.context = H, w.getDerivedStateFromProps ? A.state = Object.assign({}, A.state, w.getDerivedStateFromProps(A.props, A.state)) : A.componentWillMount && (A.componentWillMount(), A.state = A._nextState !== A.state ? A._nextState : A.__s !== A.state ? A.__s : A.state), T && T(e), F = A.render(A.props, A.state, A.context);
|
||
} else for(var M = g(w, n), L = 0; A.__d && L++ < 25;)A.__d = !1, T && T(e), F = w.call(e.__c, C, M);
|
||
return A.getChildContext && (n = Object.assign({}, n, A.getChildContext())), t.options.diffed && t.options.diffed(e), y(F, n, s, !1 !== s.shallowHighOrder, p, d);
|
||
}
|
||
w = (S = w).displayName || S !== Function && S.name || function(e) {
|
||
var t = (Function.prototype.toString.call(e).match(/^\s*function\s+([^( ]+)/) || "")[1];
|
||
if (!t) {
|
||
for(var n = -1, r = h.length; r--;)if (h[r] === e) {
|
||
n = r;
|
||
break;
|
||
}
|
||
n < 0 && (n = h.push(e) - 1), t = "UnnamedComponent" + n;
|
||
}
|
||
return t;
|
||
}(S);
|
||
}
|
||
var E, $, D = "<" + w;
|
||
if (C) {
|
||
var N = Object.keys(C);
|
||
s && !0 === s.sortAttributes && N.sort();
|
||
for(var P = 0; P < N.length; P++){
|
||
var R = N[P], W = C[R];
|
||
if ("children" !== R) {
|
||
if (!o.test(R) && (s && s.allAttributes || "key" !== R && "ref" !== R && "__self" !== R && "__source" !== R)) {
|
||
if ("defaultValue" === R) R = "value";
|
||
else if ("defaultChecked" === R) R = "checked";
|
||
else if ("defaultSelected" === R) R = "selected";
|
||
else if ("className" === R) {
|
||
if (void 0 !== C.class) continue;
|
||
R = "class";
|
||
} else p && i.test(R) && (R = R.toLowerCase().replace(/^xlink:?/, "xlink:"));
|
||
if ("htmlFor" === R) {
|
||
if (C.for) continue;
|
||
R = "for";
|
||
}
|
||
"style" === R && W && "object" == typeof W && (W = c(W)), "a" === R[0] && "r" === R[1] && "boolean" == typeof W && (W = String(W));
|
||
var q = s.attributeHook && s.attributeHook(R, W, n, s, O);
|
||
if (q || "" === q) D += q;
|
||
else if ("dangerouslySetInnerHTML" === R) $ = W && W.__html;
|
||
else if ("textarea" === w && "value" === R) E = W;
|
||
else if ((W || 0 === W || "" === W) && "function" != typeof W) {
|
||
if (!(!0 !== W && "" !== W || (W = R, s && s.xml))) {
|
||
D = D + " " + R;
|
||
continue;
|
||
}
|
||
if ("value" === R) {
|
||
if ("select" === w) {
|
||
d = W;
|
||
continue;
|
||
}
|
||
"option" === w && d == W && void 0 === C.selected && (D += " selected");
|
||
}
|
||
D = D + " " + R + '="' + a(W) + '"';
|
||
}
|
||
}
|
||
} else E = W;
|
||
}
|
||
}
|
||
if (m) {
|
||
var I = D.replace(/\n\s*/, " ");
|
||
I === D || ~I.indexOf("\n") ? m && ~D.indexOf("\n") && (D += "\n") : D = I;
|
||
}
|
||
if (D += ">", o.test(w)) throw new Error(w + " is not a valid HTML tag name in " + D);
|
||
var U, V = r.test(w) || s.voidElements && s.voidElements.test(w), z = [];
|
||
if ($) m && f($) && ($ = "\n" + b + l($, b)), D += $;
|
||
else if (null != E && _(U = [], E).length) {
|
||
for(var Z = m && ~D.indexOf("\n"), B = !1, G = 0; G < U.length; G++){
|
||
var J = U[G];
|
||
if (null != J && !1 !== J) {
|
||
var K = y(J, n, s, !0, "svg" === w || "foreignObject" !== w && p, d);
|
||
if (m && !Z && f(K) && (Z = !0), K) if (m) {
|
||
var Q = K.length > 0 && "<" != K[0];
|
||
B && Q ? z[z.length - 1] += K : z.push(K), B = Q;
|
||
} else z.push(K);
|
||
}
|
||
}
|
||
if (m && Z) for(var X = z.length; X--;)z[X] = "\n" + b + l(z[X], b);
|
||
}
|
||
if (z.length || $) D += z.join("");
|
||
else if (s && s.xml) return D.substring(0, D.length - 1) + " />";
|
||
return !V || U || $ ? (m && ~D.indexOf("\n") && (D += "\n"), D = D + "</" + w + ">") : D = D.replace(/>$/, " />"), D;
|
||
}
|
||
var m = {
|
||
shallow: !0
|
||
};
|
||
k.render = k;
|
||
var b = function(e, t) {
|
||
return k(e, t, m);
|
||
}, x = [];
|
||
function k(e, n, r) {
|
||
n = n || {};
|
||
var o = t.options.__s;
|
||
t.options.__s = !0;
|
||
var i, s = t.h(t.Fragment, null);
|
||
return s.__k = [
|
||
e
|
||
], i = r && (r.pretty || r.voidElements || r.sortAttributes || r.shallow || r.allAttributes || r.xml || r.attributeHook) ? y(e, n, r) : F(e, n, !1, void 0, s), t.options.__c && t.options.__c(e, x), t.options.__s = o, x.length = 0, i;
|
||
}
|
||
function S(e) {
|
||
return null == e || "boolean" == typeof e ? null : "string" == typeof e || "number" == typeof e || "bigint" == typeof e ? t.h(null, null, e) : e;
|
||
}
|
||
function w(e, t) {
|
||
return "className" === e ? "class" : "htmlFor" === e ? "for" : "defaultValue" === e ? "value" : "defaultChecked" === e ? "checked" : "defaultSelected" === e ? "selected" : t && i.test(e) ? e.toLowerCase().replace(/^xlink:?/, "xlink:") : e;
|
||
}
|
||
function C(e, t) {
|
||
return "style" === e && null != t && "object" == typeof t ? c(t) : "a" === e[0] && "r" === e[1] && "boolean" == typeof t ? String(t) : t;
|
||
}
|
||
var O = Array.isArray, j = Object.assign;
|
||
function F(e, n, i, s, l) {
|
||
if (null == e || !0 === e || !1 === e || "" === e) return "";
|
||
if ("object" != typeof e) return "function" == typeof e ? "" : a(e);
|
||
if (O(e)) {
|
||
var f = "";
|
||
l.__k = e;
|
||
for(var u = 0; u < e.length; u++)f += F(e[u], n, i, s, l), e[u] = S(e[u]);
|
||
return f;
|
||
}
|
||
if (void 0 !== e.constructor) return "";
|
||
e.__ = l, t.options.__b && t.options.__b(e);
|
||
var p = e.type, c = e.props;
|
||
if ("function" == typeof p) {
|
||
var _;
|
||
if (p === t.Fragment) _ = c.children;
|
||
else {
|
||
_ = p.prototype && "function" == typeof p.prototype.render ? function(e, n) {
|
||
var r = e.type, o = g(r, n), i = new r(e.props, o);
|
||
e.__c = i, i.__v = e, i.__d = !0, i.props = e.props, null == i.state && (i.state = {}), null == i.__s && (i.__s = i.state), i.context = o, r.getDerivedStateFromProps ? i.state = j({}, i.state, r.getDerivedStateFromProps(i.props, i.state)) : i.componentWillMount && (i.componentWillMount(), i.state = i.__s !== i.state ? i.__s : i.state);
|
||
var s = t.options.__r;
|
||
return s && s(e), i.render(i.props, i.state, i.context);
|
||
}(e, n) : function(e, n) {
|
||
var r, o = v(e, n), i = g(e.type, n);
|
||
e.__c = o;
|
||
for(var s = t.options.__r, a = 0; o.__d && a++ < 25;)o.__d = !1, s && s(e), r = e.type.call(o, e.props, i);
|
||
return r;
|
||
}(e, n);
|
||
var d = e.__c;
|
||
d.getChildContext && (n = j({}, n, d.getChildContext()));
|
||
}
|
||
var h = F(_ = null != _ && _.type === t.Fragment && null == _.key ? _.props.children : _, n, i, s, e);
|
||
return t.options.diffed && t.options.diffed(e), e.__ = void 0, t.options.unmount && t.options.unmount(e), h;
|
||
}
|
||
var y, m, b = "<";
|
||
if (b += p, c) for(var x in y = c.children, c){
|
||
var k = c[x];
|
||
if (!("key" === x || "ref" === x || "__self" === x || "__source" === x || "children" === x || "className" === x && "class" in c || "htmlFor" === x && "for" in c || o.test(x))) {
|
||
if (k = C(x = w(x, i), k), "dangerouslySetInnerHTML" === x) m = k && k.__html;
|
||
else if ("textarea" === p && "value" === x) y = k;
|
||
else if ((k || 0 === k || "" === k) && "function" != typeof k) {
|
||
if (!0 === k || "" === k) {
|
||
k = x, b = b + " " + x;
|
||
continue;
|
||
}
|
||
if ("value" === x) {
|
||
if ("select" === p) {
|
||
s = k;
|
||
continue;
|
||
}
|
||
"option" !== p || s != k || "selected" in c || (b += " selected");
|
||
}
|
||
b = b + " " + x + '="' + a(k) + '"';
|
||
}
|
||
}
|
||
}
|
||
var A = b;
|
||
if (b += ">", o.test(p)) throw new Error(p + " is not a valid HTML tag name in " + b);
|
||
var T = "", H = !1;
|
||
if (m) T += m, H = !0;
|
||
else if ("string" == typeof y) T += a(y), H = !0;
|
||
else if (O(y)) {
|
||
e.__k = y;
|
||
for(var M = 0; M < y.length; M++){
|
||
var L = y[M];
|
||
if (y[M] = S(L), null != L && !1 !== L) {
|
||
var E = F(L, n, "svg" === p || "foreignObject" !== p && i, s, e);
|
||
E && (T += E, H = !0);
|
||
}
|
||
}
|
||
} else if (null != y && !1 !== y && !0 !== y) {
|
||
e.__k = [
|
||
S(y)
|
||
];
|
||
var $ = F(y, n, "svg" === p || "foreignObject" !== p && i, s, e);
|
||
$ && (T += $, H = !0);
|
||
}
|
||
if (t.options.diffed && t.options.diffed(e), e.__ = void 0, t.options.unmount && t.options.unmount(e), H) b += T;
|
||
else if (r.test(p)) return A + " />";
|
||
return b + "</" + p + ">";
|
||
}
|
||
k.shallowRender = b, e.default = k, e.render = k, e.renderToStaticMarkup = k, e.renderToString = k, e.shallowRender = b;
|
||
});
|
||
}),
|
||
"[project]/node_modules/preact-render-to-string/dist/index.js [app-route] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
|
||
module.exports = __turbopack_context__.r("[project]/node_modules/preact-render-to-string/dist/commonjs.js [app-route] (ecmascript)").default;
|
||
}),
|
||
"[project]/node_modules/cookie/index.js [app-route] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
"use strict";
|
||
|
||
/*!
|
||
* cookie
|
||
* Copyright(c) 2012-2014 Roman Shtylman
|
||
* Copyright(c) 2015 Douglas Christopher Wilson
|
||
* MIT Licensed
|
||
*/ /**
|
||
* Module exports.
|
||
* @public
|
||
*/ exports.parse = parse;
|
||
exports.serialize = serialize;
|
||
/**
|
||
* Module variables.
|
||
* @private
|
||
*/ var __toString = Object.prototype.toString;
|
||
var __hasOwnProperty = Object.prototype.hasOwnProperty;
|
||
/**
|
||
* RegExp to match cookie-name in RFC 6265 sec 4.1.1
|
||
* This refers out to the obsoleted definition of token in RFC 2616 sec 2.2
|
||
* which has been replaced by the token definition in RFC 7230 appendix B.
|
||
*
|
||
* cookie-name = token
|
||
* token = 1*tchar
|
||
* tchar = "!" / "#" / "$" / "%" / "&" / "'" /
|
||
* "*" / "+" / "-" / "." / "^" / "_" /
|
||
* "`" / "|" / "~" / DIGIT / ALPHA
|
||
*/ var cookieNameRegExp = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
|
||
/**
|
||
* RegExp to match cookie-value in RFC 6265 sec 4.1.1
|
||
*
|
||
* cookie-value = *cookie-octet / ( DQUOTE *cookie-octet DQUOTE )
|
||
* cookie-octet = %x21 / %x23-2B / %x2D-3A / %x3C-5B / %x5D-7E
|
||
* ; US-ASCII characters excluding CTLs,
|
||
* ; whitespace DQUOTE, comma, semicolon,
|
||
* ; and backslash
|
||
*/ var cookieValueRegExp = /^("?)[\u0021\u0023-\u002B\u002D-\u003A\u003C-\u005B\u005D-\u007E]*\1$/;
|
||
/**
|
||
* RegExp to match domain-value in RFC 6265 sec 4.1.1
|
||
*
|
||
* domain-value = <subdomain>
|
||
* ; defined in [RFC1034], Section 3.5, as
|
||
* ; enhanced by [RFC1123], Section 2.1
|
||
* <subdomain> = <label> | <subdomain> "." <label>
|
||
* <label> = <let-dig> [ [ <ldh-str> ] <let-dig> ]
|
||
* Labels must be 63 characters or less.
|
||
* 'let-dig' not 'letter' in the first char, per RFC1123
|
||
* <ldh-str> = <let-dig-hyp> | <let-dig-hyp> <ldh-str>
|
||
* <let-dig-hyp> = <let-dig> | "-"
|
||
* <let-dig> = <letter> | <digit>
|
||
* <letter> = any one of the 52 alphabetic characters A through Z in
|
||
* upper case and a through z in lower case
|
||
* <digit> = any one of the ten digits 0 through 9
|
||
*
|
||
* Keep support for leading dot: https://github.com/jshttp/cookie/issues/173
|
||
*
|
||
* > (Note that a leading %x2E ("."), if present, is ignored even though that
|
||
* character is not permitted, but a trailing %x2E ("."), if present, will
|
||
* cause the user agent to ignore the attribute.)
|
||
*/ var domainValueRegExp = /^([.]?[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)([.][a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)*$/i;
|
||
/**
|
||
* RegExp to match path-value in RFC 6265 sec 4.1.1
|
||
*
|
||
* path-value = <any CHAR except CTLs or ";">
|
||
* CHAR = %x01-7F
|
||
* ; defined in RFC 5234 appendix B.1
|
||
*/ var pathValueRegExp = /^[\u0020-\u003A\u003D-\u007E]*$/;
|
||
/**
|
||
* Parse a cookie header.
|
||
*
|
||
* Parse the given cookie header string into an object
|
||
* The object has the various cookies as keys(names) => values
|
||
*
|
||
* @param {string} str
|
||
* @param {object} [opt]
|
||
* @return {object}
|
||
* @public
|
||
*/ function parse(str, opt) {
|
||
if (typeof str !== 'string') {
|
||
throw new TypeError('argument str must be a string');
|
||
}
|
||
var obj = {};
|
||
var len = str.length;
|
||
// RFC 6265 sec 4.1.1, RFC 2616 2.2 defines a cookie name consists of one char minimum, plus '='.
|
||
if (len < 2) return obj;
|
||
var dec = opt && opt.decode || decode;
|
||
var index = 0;
|
||
var eqIdx = 0;
|
||
var endIdx = 0;
|
||
do {
|
||
eqIdx = str.indexOf('=', index);
|
||
if (eqIdx === -1) break; // No more cookie pairs.
|
||
endIdx = str.indexOf(';', index);
|
||
if (endIdx === -1) {
|
||
endIdx = len;
|
||
} else if (eqIdx > endIdx) {
|
||
// backtrack on prior semicolon
|
||
index = str.lastIndexOf(';', eqIdx - 1) + 1;
|
||
continue;
|
||
}
|
||
var keyStartIdx = startIndex(str, index, eqIdx);
|
||
var keyEndIdx = endIndex(str, eqIdx, keyStartIdx);
|
||
var key = str.slice(keyStartIdx, keyEndIdx);
|
||
// only assign once
|
||
if (!__hasOwnProperty.call(obj, key)) {
|
||
var valStartIdx = startIndex(str, eqIdx + 1, endIdx);
|
||
var valEndIdx = endIndex(str, endIdx, valStartIdx);
|
||
if (str.charCodeAt(valStartIdx) === 0x22 /* " */ && str.charCodeAt(valEndIdx - 1) === 0x22 /* " */ ) {
|
||
valStartIdx++;
|
||
valEndIdx--;
|
||
}
|
||
var val = str.slice(valStartIdx, valEndIdx);
|
||
obj[key] = tryDecode(val, dec);
|
||
}
|
||
index = endIdx + 1;
|
||
}while (index < len)
|
||
return obj;
|
||
}
|
||
function startIndex(str, index, max) {
|
||
do {
|
||
var code = str.charCodeAt(index);
|
||
if (code !== 0x20 /* */ && code !== 0x09 /* \t */ ) return index;
|
||
}while (++index < max)
|
||
return max;
|
||
}
|
||
function endIndex(str, index, min) {
|
||
while(index > min){
|
||
var code = str.charCodeAt(--index);
|
||
if (code !== 0x20 /* */ && code !== 0x09 /* \t */ ) return index + 1;
|
||
}
|
||
return min;
|
||
}
|
||
/**
|
||
* Serialize data into a cookie header.
|
||
*
|
||
* Serialize a name value pair into a cookie string suitable for
|
||
* http headers. An optional options object specifies cookie parameters.
|
||
*
|
||
* serialize('foo', 'bar', { httpOnly: true })
|
||
* => "foo=bar; httpOnly"
|
||
*
|
||
* @param {string} name
|
||
* @param {string} val
|
||
* @param {object} [opt]
|
||
* @return {string}
|
||
* @public
|
||
*/ function serialize(name, val, opt) {
|
||
var enc = opt && opt.encode || encodeURIComponent;
|
||
if (typeof enc !== 'function') {
|
||
throw new TypeError('option encode is invalid');
|
||
}
|
||
if (!cookieNameRegExp.test(name)) {
|
||
throw new TypeError('argument name is invalid');
|
||
}
|
||
var value = enc(val);
|
||
if (!cookieValueRegExp.test(value)) {
|
||
throw new TypeError('argument val is invalid');
|
||
}
|
||
var str = name + '=' + value;
|
||
if (!opt) return str;
|
||
if (null != opt.maxAge) {
|
||
var maxAge = Math.floor(opt.maxAge);
|
||
if (!isFinite(maxAge)) {
|
||
throw new TypeError('option maxAge is invalid');
|
||
}
|
||
str += '; Max-Age=' + maxAge;
|
||
}
|
||
if (opt.domain) {
|
||
if (!domainValueRegExp.test(opt.domain)) {
|
||
throw new TypeError('option domain is invalid');
|
||
}
|
||
str += '; Domain=' + opt.domain;
|
||
}
|
||
if (opt.path) {
|
||
if (!pathValueRegExp.test(opt.path)) {
|
||
throw new TypeError('option path is invalid');
|
||
}
|
||
str += '; Path=' + opt.path;
|
||
}
|
||
if (opt.expires) {
|
||
var expires = opt.expires;
|
||
if (!isDate(expires) || isNaN(expires.valueOf())) {
|
||
throw new TypeError('option expires is invalid');
|
||
}
|
||
str += '; Expires=' + expires.toUTCString();
|
||
}
|
||
if (opt.httpOnly) {
|
||
str += '; HttpOnly';
|
||
}
|
||
if (opt.secure) {
|
||
str += '; Secure';
|
||
}
|
||
if (opt.partitioned) {
|
||
str += '; Partitioned';
|
||
}
|
||
if (opt.priority) {
|
||
var priority = typeof opt.priority === 'string' ? opt.priority.toLowerCase() : opt.priority;
|
||
switch(priority){
|
||
case 'low':
|
||
str += '; Priority=Low';
|
||
break;
|
||
case 'medium':
|
||
str += '; Priority=Medium';
|
||
break;
|
||
case 'high':
|
||
str += '; Priority=High';
|
||
break;
|
||
default:
|
||
throw new TypeError('option priority is invalid');
|
||
}
|
||
}
|
||
if (opt.sameSite) {
|
||
var sameSite = typeof opt.sameSite === 'string' ? opt.sameSite.toLowerCase() : opt.sameSite;
|
||
switch(sameSite){
|
||
case true:
|
||
str += '; SameSite=Strict';
|
||
break;
|
||
case 'lax':
|
||
str += '; SameSite=Lax';
|
||
break;
|
||
case 'strict':
|
||
str += '; SameSite=Strict';
|
||
break;
|
||
case 'none':
|
||
str += '; SameSite=None';
|
||
break;
|
||
default:
|
||
throw new TypeError('option sameSite is invalid');
|
||
}
|
||
}
|
||
return str;
|
||
}
|
||
/**
|
||
* URL-decode string value. Optimized to skip native call when no %.
|
||
*
|
||
* @param {string} str
|
||
* @returns {string}
|
||
*/ function decode(str) {
|
||
return str.indexOf('%') !== -1 ? decodeURIComponent(str) : str;
|
||
}
|
||
/**
|
||
* Determine if value is a Date.
|
||
*
|
||
* @param {*} val
|
||
* @private
|
||
*/ function isDate(val) {
|
||
return __toString.call(val) === '[object Date]';
|
||
}
|
||
/**
|
||
* Try decoding a string using a decoding function.
|
||
*
|
||
* @param {string} str
|
||
* @param {function} decode
|
||
* @private
|
||
*/ function tryDecode(str, decode) {
|
||
try {
|
||
return decode(str);
|
||
} catch (e) {
|
||
return str;
|
||
}
|
||
}
|
||
}),
|
||
];
|
||
|
||
//# sourceMappingURL=%5Broot-of-the-server%5D__0.f83zg._.js.map
|