Auto-commit 2026-04-29 16:31

node_modules/next-auth/core/routes/callback.d.ts

@@ -0,0 +1,14 @@
+import type { InternalOptions } from "../types";
+import type { RequestInternal, ResponseInternal } from "..";
+import type { SessionStore } from "../lib/cookie";
+/** Handle callbacks from login services */
+export default function callback(params: {
+    options: InternalOptions;
+    query: RequestInternal["query"];
+    method: Required<RequestInternal>["method"];
+    body: RequestInternal["body"];
+    headers: RequestInternal["headers"];
+    cookies: RequestInternal["cookies"];
+    sessionStore: SessionStore;
+}): Promise<ResponseInternal>;
+//# sourceMappingURL=callback.d.ts.map

node_modules/next-auth/core/routes/callback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"callback.d.ts","sourceRoot":"","sources":["../../src/core/routes/callback.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAC/C,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,IAAI,CAAA;AAC3D,OAAO,KAAK,EAAU,YAAY,EAAE,MAAM,eAAe,CAAA;AAIzD,2CAA2C;AAC3C,wBAA8B,QAAQ,CAAC,MAAM,EAAE;IAC7C,OAAO,EAAE,eAAe,CAAA;IACxB,KAAK,EAAE,eAAe,CAAC,OAAO,CAAC,CAAA;IAC/B,MAAM,EAAE,QAAQ,CAAC,eAAe,CAAC,CAAC,QAAQ,CAAC,CAAA;IAC3C,IAAI,EAAE,eAAe,CAAC,MAAM,CAAC,CAAA;IAC7B,OAAO,EAAE,eAAe,CAAC,SAAS,CAAC,CAAA;IACnC,OAAO,EAAE,eAAe,CAAC,SAAS,CAAC,CAAA;IACnC,YAAY,EAAE,YAAY,CAAA;CAC3B,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAwZ5B"}

node_modules/next-auth/core/routes/callback.js

@@ -0,0 +1,417 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = callback;
+var _callback = _interopRequireDefault(require("../lib/oauth/callback"));
+var _callbackHandler = _interopRequireDefault(require("../lib/callback-handler"));
+var _utils = require("../lib/utils");
+var _getUserFromEmail = _interopRequireDefault(require("../lib/email/getUserFromEmail"));
+async function callback(params) {
+  const {
+    options,
+    query,
+    body,
+    method,
+    headers,
+    sessionStore
+  } = params;
+  const {
+    provider,
+    adapter,
+    url,
+    callbackUrl,
+    pages,
+    jwt,
+    events,
+    callbacks,
+    session: {
+      strategy: sessionStrategy,
+      maxAge: sessionMaxAge
+    },
+    logger
+  } = options;
+  const cookies = [];
+  const useJwtSession = sessionStrategy === "jwt";
+  if (provider.type === "oauth") {
+    try {
+      const {
+        profile,
+        account,
+        OAuthProfile,
+        cookies: oauthCookies
+      } = await (0, _callback.default)({
+        query,
+        body,
+        method,
+        options,
+        cookies: params.cookies
+      });
+      if (oauthCookies.length) cookies.push(...oauthCookies);
+      try {
+        var _events$signIn;
+        logger.debug("OAUTH_CALLBACK_RESPONSE", {
+          profile,
+          account,
+          OAuthProfile
+        });
+        if (!profile || !account || !OAuthProfile) {
+          return {
+            redirect: `${url}/signin`,
+            cookies
+          };
+        }
+        let userOrProfile = profile;
+        if (adapter) {
+          const {
+            getUserByAccount
+          } = adapter;
+          const userByAccount = await getUserByAccount({
+            providerAccountId: account.providerAccountId,
+            provider: provider.id
+          });
+          if (userByAccount) userOrProfile = userByAccount;
+        }
+        try {
+          const isAllowed = await callbacks.signIn({
+            user: userOrProfile,
+            account,
+            profile: OAuthProfile
+          });
+          if (!isAllowed) {
+            return {
+              redirect: `${url}/error?error=AccessDenied`,
+              cookies
+            };
+          } else if (typeof isAllowed === "string") {
+            return {
+              redirect: isAllowed,
+              cookies
+            };
+          }
+        } catch (error) {
+          return {
+            redirect: `${url}/error?error=${encodeURIComponent(error.message)}`,
+            cookies
+          };
+        }
+        const {
+          user,
+          session,
+          isNewUser
+        } = await (0, _callbackHandler.default)({
+          sessionToken: sessionStore.value,
+          profile,
+          account,
+          options
+        });
+        if (useJwtSession) {
+          var _user$id;
+          const defaultToken = {
+            name: user.name,
+            email: user.email,
+            picture: user.image,
+            sub: (_user$id = user.id) === null || _user$id === void 0 ? void 0 : _user$id.toString()
+          };
+          const token = await callbacks.jwt({
+            token: defaultToken,
+            user,
+            account,
+            profile: OAuthProfile,
+            isNewUser,
+            trigger: isNewUser ? "signUp" : "signIn"
+          });
+          const newToken = await jwt.encode({
+            ...jwt,
+            token
+          });
+          const cookieExpires = new Date();
+          cookieExpires.setTime(cookieExpires.getTime() + sessionMaxAge * 1000);
+          const sessionCookies = sessionStore.chunk(newToken, {
+            expires: cookieExpires
+          });
+          cookies.push(...sessionCookies);
+        } else {
+          cookies.push({
+            name: options.cookies.sessionToken.name,
+            value: session.sessionToken,
+            options: {
+              ...options.cookies.sessionToken.options,
+              expires: session.expires
+            }
+          });
+        }
+        await ((_events$signIn = events.signIn) === null || _events$signIn === void 0 ? void 0 : _events$signIn.call(events, {
+          user,
+          account,
+          profile,
+          isNewUser
+        }));
+        if (isNewUser && pages.newUser) {
+          return {
+            redirect: `${pages.newUser}${pages.newUser.includes("?") ? "&" : "?"}callbackUrl=${encodeURIComponent(callbackUrl)}`,
+            cookies
+          };
+        }
+        return {
+          redirect: callbackUrl,
+          cookies
+        };
+      } catch (error) {
+        if (error.name === "AccountNotLinkedError") {
+          return {
+            redirect: `${url}/error?error=OAuthAccountNotLinked`,
+            cookies
+          };
+        } else if (error.name === "CreateUserError") {
+          return {
+            redirect: `${url}/error?error=OAuthCreateAccount`,
+            cookies
+          };
+        }
+        logger.error("OAUTH_CALLBACK_HANDLER_ERROR", error);
+        return {
+          redirect: `${url}/error?error=Callback`,
+          cookies
+        };
+      }
+    } catch (error) {
+      if (error.name === "OAuthCallbackError") {
+        logger.error("OAUTH_CALLBACK_ERROR", {
+          error: error,
+          providerId: provider.id
+        });
+        return {
+          redirect: `${url}/error?error=OAuthCallback`,
+          cookies
+        };
+      }
+      logger.error("OAUTH_CALLBACK_ERROR", error);
+      return {
+        redirect: `${url}/error?error=Callback`,
+        cookies
+      };
+    }
+  } else if (provider.type === "email") {
+    try {
+      var _events$signIn2;
+      const paramToken = query === null || query === void 0 ? void 0 : query.token;
+      const paramIdentifier = query === null || query === void 0 ? void 0 : query.email;
+      if (!paramToken) {
+        return {
+          redirect: `${url}/error?error=configuration`,
+          cookies
+        };
+      }
+      const invite = await adapter.useVerificationToken({
+        identifier: paramIdentifier,
+        token: (0, _utils.hashToken)(paramToken, options)
+      });
+      const invalidInvite = !invite || invite.expires.valueOf() < Date.now() || paramIdentifier && invite.identifier !== paramIdentifier;
+      if (invalidInvite) {
+        return {
+          redirect: `${url}/error?error=Verification`,
+          cookies
+        };
+      }
+      const profile = await (0, _getUserFromEmail.default)({
+        email: invite.identifier,
+        adapter
+      });
+      const account = {
+        providerAccountId: profile.email,
+        type: "email",
+        provider: provider.id
+      };
+      try {
+        const signInCallbackResponse = await callbacks.signIn({
+          user: profile,
+          account
+        });
+        if (!signInCallbackResponse) {
+          return {
+            redirect: `${url}/error?error=AccessDenied`,
+            cookies
+          };
+        } else if (typeof signInCallbackResponse === "string") {
+          return {
+            redirect: signInCallbackResponse,
+            cookies
+          };
+        }
+      } catch (error) {
+        return {
+          redirect: `${url}/error?error=${encodeURIComponent(error.message)}`,
+          cookies
+        };
+      }
+      const {
+        user,
+        session,
+        isNewUser
+      } = await (0, _callbackHandler.default)({
+        sessionToken: sessionStore.value,
+        profile,
+        account,
+        options
+      });
+      if (useJwtSession) {
+        var _user$id2;
+        const defaultToken = {
+          name: user.name,
+          email: user.email,
+          picture: user.image,
+          sub: (_user$id2 = user.id) === null || _user$id2 === void 0 ? void 0 : _user$id2.toString()
+        };
+        const token = await callbacks.jwt({
+          token: defaultToken,
+          user,
+          account,
+          isNewUser,
+          trigger: isNewUser ? "signUp" : "signIn"
+        });
+        const newToken = await jwt.encode({
+          ...jwt,
+          token
+        });
+        const cookieExpires = new Date();
+        cookieExpires.setTime(cookieExpires.getTime() + sessionMaxAge * 1000);
+        const sessionCookies = sessionStore.chunk(newToken, {
+          expires: cookieExpires
+        });
+        cookies.push(...sessionCookies);
+      } else {
+        cookies.push({
+          name: options.cookies.sessionToken.name,
+          value: session.sessionToken,
+          options: {
+            ...options.cookies.sessionToken.options,
+            expires: session.expires
+          }
+        });
+      }
+      await ((_events$signIn2 = events.signIn) === null || _events$signIn2 === void 0 ? void 0 : _events$signIn2.call(events, {
+        user,
+        account,
+        isNewUser
+      }));
+      if (isNewUser && pages.newUser) {
+        return {
+          redirect: `${pages.newUser}${pages.newUser.includes("?") ? "&" : "?"}callbackUrl=${encodeURIComponent(callbackUrl)}`,
+          cookies
+        };
+      }
+      return {
+        redirect: callbackUrl,
+        cookies
+      };
+    } catch (error) {
+      if (error.name === "CreateUserError") {
+        return {
+          redirect: `${url}/error?error=EmailCreateAccount`,
+          cookies
+        };
+      }
+      logger.error("CALLBACK_EMAIL_ERROR", error);
+      return {
+        redirect: `${url}/error?error=Callback`,
+        cookies
+      };
+    }
+  } else if (provider.type === "credentials" && method === "POST") {
+    var _user$id3, _events$signIn3;
+    const credentials = body;
+    let user;
+    try {
+      user = await provider.authorize(credentials, {
+        query,
+        body,
+        headers,
+        method
+      });
+      if (!user) {
+        return {
+          status: 401,
+          redirect: `${url}/error?${new URLSearchParams({
+            error: "CredentialsSignin",
+            provider: provider.id
+          })}`,
+          cookies
+        };
+      }
+    } catch (error) {
+      return {
+        status: 401,
+        redirect: `${url}/error?error=${encodeURIComponent(error.message)}`,
+        cookies
+      };
+    }
+    const account = {
+      providerAccountId: user.id,
+      type: "credentials",
+      provider: provider.id
+    };
+    try {
+      const isAllowed = await callbacks.signIn({
+        user,
+        account,
+        credentials
+      });
+      if (!isAllowed) {
+        return {
+          status: 403,
+          redirect: `${url}/error?error=AccessDenied`,
+          cookies
+        };
+      } else if (typeof isAllowed === "string") {
+        return {
+          redirect: isAllowed,
+          cookies
+        };
+      }
+    } catch (error) {
+      return {
+        redirect: `${url}/error?error=${encodeURIComponent(error.message)}`,
+        cookies
+      };
+    }
+    const defaultToken = {
+      name: user.name,
+      email: user.email,
+      picture: user.image,
+      sub: (_user$id3 = user.id) === null || _user$id3 === void 0 ? void 0 : _user$id3.toString()
+    };
+    const token = await callbacks.jwt({
+      token: defaultToken,
+      user,
+      account,
+      isNewUser: false,
+      trigger: "signIn"
+    });
+    const newToken = await jwt.encode({
+      ...jwt,
+      token
+    });
+    const cookieExpires = new Date();
+    cookieExpires.setTime(cookieExpires.getTime() + sessionMaxAge * 1000);
+    const sessionCookies = sessionStore.chunk(newToken, {
+      expires: cookieExpires
+    });
+    cookies.push(...sessionCookies);
+    await ((_events$signIn3 = events.signIn) === null || _events$signIn3 === void 0 ? void 0 : _events$signIn3.call(events, {
+      user,
+      account
+    }));
+    return {
+      redirect: callbackUrl,
+      cookies
+    };
+  }
+  return {
+    status: 500,
+    body: `Error: Callback for provider type ${provider.type} not supported`,
+    cookies
+  };
+}

node_modules/next-auth/core/routes/index.d.ts

@@ -0,0 +1,6 @@
+export { default as callback } from './callback';
+export { default as signin } from './signin';
+export { default as signout } from './signout';
+export { default as session } from './session';
+export { default as providers } from './providers';
+//# sourceMappingURL=index.d.ts.map

node_modules/next-auth/core/routes/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/routes/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,YAAY,CAAA;AAChD,OAAO,EAAE,OAAO,IAAI,MAAM,EAAE,MAAM,UAAU,CAAA;AAC5C,OAAO,EAAE,OAAO,IAAI,OAAO,EAAE,MAAM,WAAW,CAAA;AAC9C,OAAO,EAAE,OAAO,IAAI,OAAO,EAAE,MAAM,WAAW,CAAA;AAC9C,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,aAAa,CAAA"}

node_modules/next-auth/core/routes/index.js

@@ -0,0 +1,41 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "callback", {
+  enumerable: true,
+  get: function () {
+    return _callback.default;
+  }
+});
+Object.defineProperty(exports, "providers", {
+  enumerable: true,
+  get: function () {
+    return _providers.default;
+  }
+});
+Object.defineProperty(exports, "session", {
+  enumerable: true,
+  get: function () {
+    return _session.default;
+  }
+});
+Object.defineProperty(exports, "signin", {
+  enumerable: true,
+  get: function () {
+    return _signin.default;
+  }
+});
+Object.defineProperty(exports, "signout", {
+  enumerable: true,
+  get: function () {
+    return _signout.default;
+  }
+});
+var _callback = _interopRequireDefault(require("./callback"));
+var _signin = _interopRequireDefault(require("./signin"));
+var _signout = _interopRequireDefault(require("./signout"));
+var _session = _interopRequireDefault(require("./session"));
+var _providers = _interopRequireDefault(require("./providers"));

node_modules/next-auth/core/routes/providers.d.ts

@@ -0,0 +1,16 @@
+import type { ResponseInternal } from "..";
+import type { InternalProvider } from "../types";
+export interface PublicProvider {
+    id: string;
+    name: string;
+    type: string;
+    signinUrl: string;
+    callbackUrl: string;
+}
+/**
+ * Return a JSON object with a list of all OAuth providers currently configured
+ * and their signin and callback URLs. This makes it possible to automatically
+ * generate buttons for all providers when rendering client side.
+ */
+export default function providers(providers: InternalProvider[]): ResponseInternal<Record<string, PublicProvider>>;
+//# sourceMappingURL=providers.d.ts.map

node_modules/next-auth/core/routes/providers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"providers.d.ts","sourceRoot":"","sources":["../../src/core/routes/providers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,IAAI,CAAA;AAC1C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AAEhD,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,EAAE,MAAM,CAAA;IACjB,WAAW,EAAE,MAAM,CAAA;CACpB;AAED;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,SAAS,CAC/B,SAAS,EAAE,gBAAgB,EAAE,GAC5B,gBAAgB,CAAC,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC,CAWlD"}

node_modules/next-auth/core/routes/providers.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = providers;
+function providers(providers) {
+  return {
+    headers: [{
+      key: "Content-Type",
+      value: "application/json"
+    }],
+    body: providers.reduce((acc, {
+      id,
+      name,
+      type,
+      signinUrl,
+      callbackUrl
+    }) => {
+      acc[id] = {
+        id,
+        name,
+        type,
+        signinUrl,
+        callbackUrl
+      };
+      return acc;
+    }, {})
+  };
+}

node_modules/next-auth/core/routes/session.d.ts

@@ -0,0 +1,17 @@
+import type { InternalOptions } from "../types";
+import type { ResponseInternal } from "..";
+import type { Session } from "../..";
+import type { SessionStore } from "../lib/cookie";
+interface SessionParams {
+    options: InternalOptions;
+    sessionStore: SessionStore;
+    isUpdate?: boolean;
+    newSession?: any;
+}
+/**
+ * Return a session object (without any private fields)
+ * for Single Page App clients
+ */
+export default function session(params: SessionParams): Promise<ResponseInternal<Session | {}>>;
+export {};
+//# sourceMappingURL=session.d.ts.map

node_modules/next-auth/core/routes/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../src/core/routes/session.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAC/C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,IAAI,CAAA;AAC1C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,OAAO,CAAA;AACpC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AAEjD,UAAU,aAAa;IACrB,OAAO,EAAE,eAAe,CAAA;IACxB,YAAY,EAAE,YAAY,CAAA;IAC1B,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,UAAU,CAAC,EAAE,GAAG,CAAA;CACjB;AAED;;;GAGG;AAEH,wBAA8B,OAAO,CACnC,MAAM,EAAE,aAAa,GACpB,OAAO,CAAC,gBAAgB,CAAC,OAAO,GAAG,EAAE,CAAC,CAAC,CAyKzC"}

node_modules/next-auth/core/routes/session.js

@@ -0,0 +1,154 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = session;
+var _utils = require("../lib/utils");
+async function session(params) {
+  const {
+    options,
+    sessionStore,
+    newSession,
+    isUpdate
+  } = params;
+  const {
+    adapter,
+    jwt,
+    events,
+    callbacks,
+    logger,
+    session: {
+      strategy: sessionStrategy,
+      maxAge: sessionMaxAge
+    }
+  } = options;
+  const response = {
+    body: {},
+    headers: [{
+      key: "Content-Type",
+      value: "application/json"
+    }, ...(isUpdate ? [] : [{
+      key: "Cache-Control",
+      value: "private, no-cache, no-store"
+    }, {
+      key: "Pragma",
+      value: "no-cache"
+    }, {
+      key: "Expires",
+      value: "0"
+    }])].filter(Boolean),
+    cookies: []
+  };
+  const sessionToken = sessionStore.value;
+  if (!sessionToken) return response;
+  if (sessionStrategy === "jwt") {
+    try {
+      var _response$cookies, _events$session;
+      const decodedToken = await jwt.decode({
+        ...jwt,
+        token: sessionToken
+      });
+      if (!decodedToken) throw new Error("JWT invalid");
+      const token = await callbacks.jwt({
+        token: decodedToken,
+        ...(isUpdate && {
+          trigger: "update"
+        }),
+        session: newSession
+      });
+      const newExpires = (0, _utils.fromDate)(sessionMaxAge);
+      const updatedSession = await callbacks.session({
+        session: {
+          user: {
+            name: decodedToken === null || decodedToken === void 0 ? void 0 : decodedToken.name,
+            email: decodedToken === null || decodedToken === void 0 ? void 0 : decodedToken.email,
+            image: decodedToken === null || decodedToken === void 0 ? void 0 : decodedToken.picture
+          },
+          expires: newExpires.toISOString()
+        },
+        token
+      });
+      response.body = updatedSession;
+      const newToken = await jwt.encode({
+        ...jwt,
+        token,
+        maxAge: options.session.maxAge
+      });
+      const sessionCookies = sessionStore.chunk(newToken, {
+        expires: newExpires
+      });
+      (_response$cookies = response.cookies) === null || _response$cookies === void 0 || _response$cookies.push(...sessionCookies);
+      await ((_events$session = events.session) === null || _events$session === void 0 ? void 0 : _events$session.call(events, {
+        session: updatedSession,
+        token
+      }));
+    } catch (error) {
+      var _response$cookies2;
+      logger.error("JWT_SESSION_ERROR", error);
+      (_response$cookies2 = response.cookies) === null || _response$cookies2 === void 0 || _response$cookies2.push(...sessionStore.clean());
+    }
+  } else {
+    try {
+      const {
+        getSessionAndUser,
+        deleteSession,
+        updateSession
+      } = adapter;
+      let userAndSession = await getSessionAndUser(sessionToken);
+      if (userAndSession && userAndSession.session.expires.valueOf() < Date.now()) {
+        await deleteSession(sessionToken);
+        userAndSession = null;
+      }
+      if (userAndSession) {
+        var _response$cookies3, _events$session2;
+        const {
+          user,
+          session
+        } = userAndSession;
+        const sessionUpdateAge = options.session.updateAge;
+        const sessionIsDueToBeUpdatedDate = session.expires.valueOf() - sessionMaxAge * 1000 + sessionUpdateAge * 1000;
+        const newExpires = (0, _utils.fromDate)(sessionMaxAge);
+        if (sessionIsDueToBeUpdatedDate <= Date.now()) {
+          await updateSession({
+            sessionToken,
+            expires: newExpires
+          });
+        }
+        const sessionPayload = await callbacks.session({
+          session: {
+            user: {
+              name: user.name,
+              email: user.email,
+              image: user.image
+            },
+            expires: session.expires.toISOString()
+          },
+          user,
+          newSession,
+          ...(isUpdate ? {
+            trigger: "update"
+          } : {})
+        });
+        response.body = sessionPayload;
+        (_response$cookies3 = response.cookies) === null || _response$cookies3 === void 0 || _response$cookies3.push({
+          name: options.cookies.sessionToken.name,
+          value: sessionToken,
+          options: {
+            ...options.cookies.sessionToken.options,
+            expires: newExpires
+          }
+        });
+        await ((_events$session2 = events.session) === null || _events$session2 === void 0 ? void 0 : _events$session2.call(events, {
+          session: sessionPayload
+        }));
+      } else if (sessionToken) {
+        var _response$cookies4;
+        (_response$cookies4 = response.cookies) === null || _response$cookies4 === void 0 || _response$cookies4.push(...sessionStore.clean());
+      }
+    } catch (error) {
+      logger.error("SESSION_ERROR", error);
+    }
+  }
+  return response;
+}

node_modules/next-auth/core/routes/signin.d.ts

@@ -0,0 +1,9 @@
+import type { RequestInternal, ResponseInternal } from "..";
+import type { InternalOptions } from "../types";
+/** Handle requests to /api/auth/signin */
+export default function signin(params: {
+    options: InternalOptions<"oauth" | "email">;
+    query: RequestInternal["query"];
+    body: RequestInternal["body"];
+}): Promise<ResponseInternal>;
+//# sourceMappingURL=signin.d.ts.map

node_modules/next-auth/core/routes/signin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signin.d.ts","sourceRoot":"","sources":["../../src/core/routes/signin.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,IAAI,CAAA;AAC3D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAG/C,0CAA0C;AAC1C,wBAA8B,MAAM,CAAC,MAAM,EAAE;IAC3C,OAAO,EAAE,eAAe,CAAC,OAAO,GAAG,OAAO,CAAC,CAAA;IAC3C,KAAK,EAAE,eAAe,CAAC,OAAO,CAAC,CAAA;IAC/B,IAAI,EAAE,eAAe,CAAC,MAAM,CAAC,CAAA;CAC9B,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAiH5B"}

node_modules/next-auth/core/routes/signin.js

@@ -0,0 +1,134 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = signin;
+var _authorizationUrl = _interopRequireDefault(require("../lib/oauth/authorization-url"));
+var _signin = _interopRequireDefault(require("../lib/email/signin"));
+var _getUserFromEmail = _interopRequireDefault(require("../lib/email/getUserFromEmail"));
+async function signin(params) {
+  const {
+    options,
+    query,
+    body
+  } = params;
+  const {
+    url,
+    callbacks,
+    logger,
+    provider
+  } = options;
+  if (!provider.type) {
+    return {
+      status: 500,
+      text: `Error: Type not specified for ${provider.name}`
+    };
+  }
+  if (provider.type === "oauth") {
+    try {
+      const response = await (0, _authorizationUrl.default)({
+        options,
+        query
+      });
+      return response;
+    } catch (error) {
+      logger.error("SIGNIN_OAUTH_ERROR", {
+        error: error,
+        providerId: provider.id
+      });
+      return {
+        redirect: `${url}/error?error=OAuthSignin`
+      };
+    }
+  } else if (provider.type === "email") {
+    var _provider$normalizeId;
+    let email = body === null || body === void 0 ? void 0 : body.email;
+    if (!email) return {
+      redirect: `${url}/error?error=EmailSignin`
+    };
+    const normalizer = (_provider$normalizeId = provider.normalizeIdentifier) !== null && _provider$normalizeId !== void 0 ? _provider$normalizeId : identifier => {
+      var _trimmedEmail$match;
+      const trimmedEmail = identifier.trim();
+      const atCount = ((_trimmedEmail$match = trimmedEmail.match(/@/g)) !== null && _trimmedEmail$match !== void 0 ? _trimmedEmail$match : []).length;
+      if (atCount !== 1) {
+        throw new Error("Invalid email address format.");
+      }
+      if (trimmedEmail.includes('"')) {
+        throw new Error("Invalid email address format.");
+      }
+      let [local, domain] = trimmedEmail.toLowerCase().split("@");
+      if (!local || !domain) {
+        throw new Error("Invalid email address format.");
+      }
+      domain = domain.split(",")[0];
+      if (!domain.includes(".")) {
+        throw new Error("Invalid email address format.");
+      }
+      return `${local}@${domain}`;
+    };
+    try {
+      email = normalizer(body === null || body === void 0 ? void 0 : body.email);
+    } catch (error) {
+      logger.error("SIGNIN_EMAIL_ERROR", {
+        error,
+        providerId: provider.id
+      });
+      return {
+        redirect: `${url}/error?error=EmailSignin`
+      };
+    }
+    const user = await (0, _getUserFromEmail.default)({
+      email,
+      adapter: options.adapter
+    });
+    const account = {
+      providerAccountId: email,
+      userId: email,
+      type: "email",
+      provider: provider.id
+    };
+    try {
+      const signInCallbackResponse = await callbacks.signIn({
+        user,
+        account,
+        email: {
+          verificationRequest: true
+        }
+      });
+      if (!signInCallbackResponse) {
+        return {
+          redirect: `${url}/error?error=AccessDenied`
+        };
+      } else if (typeof signInCallbackResponse === "string") {
+        return {
+          redirect: signInCallbackResponse
+        };
+      }
+    } catch (error) {
+      return {
+        redirect: `${url}/error?${new URLSearchParams({
+          error: error
+        })}`
+      };
+    }
+    try {
+      const redirect = await (0, _signin.default)(email, options);
+      return {
+        redirect
+      };
+    } catch (error) {
+      logger.error("SIGNIN_EMAIL_ERROR", {
+        error,
+        providerId: provider.id
+      });
+      return {
+        redirect: `${url}/error?error=EmailSignin`
+      };
+    }
+  }
+  return {
+    redirect: `${url}/signin`
+  };
+}

node_modules/next-auth/core/routes/signout.d.ts

@@ -0,0 +1,9 @@
+import type { InternalOptions } from "../types";
+import type { ResponseInternal } from "..";
+import type { SessionStore } from "../lib/cookie";
+/** Handle requests to /api/auth/signout */
+export default function signout(params: {
+    options: InternalOptions;
+    sessionStore: SessionStore;
+}): Promise<ResponseInternal>;
+//# sourceMappingURL=signout.d.ts.map

node_modules/next-auth/core/routes/signout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signout.d.ts","sourceRoot":"","sources":["../../src/core/routes/signout.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAC/C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,IAAI,CAAA;AAC1C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AAEjD,2CAA2C;AAC3C,wBAA8B,OAAO,CAAC,MAAM,EAAE;IAC5C,OAAO,EAAE,eAAe,CAAA;IACxB,YAAY,EAAE,YAAY,CAAA;CAC3B,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAoC5B"}

node_modules/next-auth/core/routes/signout.js

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = signout;
+async function signout(params) {
+  const {
+    options,
+    sessionStore
+  } = params;
+  const {
+    adapter,
+    events,
+    jwt,
+    callbackUrl,
+    logger,
+    session
+  } = options;
+  const sessionToken = sessionStore === null || sessionStore === void 0 ? void 0 : sessionStore.value;
+  if (!sessionToken) {
+    return {
+      redirect: callbackUrl
+    };
+  }
+  if (session.strategy === "jwt") {
+    try {
+      var _events$signOut;
+      const decodedJwt = await jwt.decode({
+        ...jwt,
+        token: sessionToken
+      });
+      await ((_events$signOut = events.signOut) === null || _events$signOut === void 0 ? void 0 : _events$signOut.call(events, {
+        token: decodedJwt
+      }));
+    } catch (error) {
+      logger.error("SIGNOUT_ERROR", error);
+    }
+  } else {
+    try {
+      var _events$signOut2;
+      const session = await adapter.deleteSession(sessionToken);
+      await ((_events$signOut2 = events.signOut) === null || _events$signOut2 === void 0 ? void 0 : _events$signOut2.call(events, {
+        session
+      }));
+    } catch (error) {
+      logger.error("SIGNOUT_ERROR", error);
+    }
+  }
+  const sessionCookies = sessionStore.clean();
+  return {
+    redirect: callbackUrl,
+    cookies: sessionCookies
+  };
+}