Initial commit

frontend/webapp/node_modules/next/dist/client/app-dir/form.d.ts

@@ -0,0 +1,3 @@
+import { type FormProps } from '../form-shared';
+export type { FormProps };
+export default function Form({ replace, scroll, prefetch: prefetchProp, ref: externalRef, ...props }: FormProps): import("react/jsx-runtime").JSX.Element;

frontend/webapp/node_modules/next/dist/client/app-dir/form.js

@@ -0,0 +1,158 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return Form;
+    }
+});
+const _jsxruntime = require("react/jsx-runtime");
+const _react = require("react");
+const _addbasepath = require("../add-base-path");
+const _usemergedref = require("../use-merged-ref");
+const _approutercontextsharedruntime = require("../../shared/lib/app-router-context.shared-runtime");
+const _routerreducertypes = require("../components/router-reducer/router-reducer-types");
+const _formshared = require("../form-shared");
+const _links = require("../components/links");
+function Form(param) {
+    let { replace, scroll, prefetch: prefetchProp, ref: externalRef, ...props } = param;
+    const router = (0, _react.useContext)(_approutercontextsharedruntime.AppRouterContext);
+    const actionProp = props.action;
+    const isNavigatingForm = typeof actionProp === 'string';
+    // Validate `action`
+    if (process.env.NODE_ENV === 'development') {
+        if (isNavigatingForm) {
+            (0, _formshared.checkFormActionUrl)(actionProp, 'action');
+        }
+    }
+    // Validate `prefetch`
+    if (process.env.NODE_ENV === 'development') {
+        if (!(prefetchProp === undefined || prefetchProp === false || prefetchProp === null)) {
+            console.error('The `prefetch` prop of <Form> must be `false` or `null`');
+        }
+        if (prefetchProp !== undefined && !isNavigatingForm) {
+            console.error('Passing `prefetch` to a <Form> whose `action` is a function has no effect.');
+        }
+    }
+    const prefetch = prefetchProp === false || prefetchProp === null ? prefetchProp : null;
+    // Validate `scroll` and `replace`
+    if (process.env.NODE_ENV === 'development') {
+        if (!isNavigatingForm && (replace !== undefined || scroll !== undefined)) {
+            console.error('Passing `replace` or `scroll` to a <Form> whose `action` is a function has no effect.\n' + 'See the relevant docs to learn how to control this behavior for navigations triggered from actions:\n' + '  `redirect()`       - https://nextjs.org/docs/app/api-reference/functions/redirect#parameters\n' + '  `router.replace()` - https://nextjs.org/docs/app/api-reference/functions/use-router#userouter\n');
+        }
+    }
+    // Clean up any unsupported form props (and warn if present)
+    for (const key of _formshared.DISALLOWED_FORM_PROPS){
+        if (key in props) {
+            if (process.env.NODE_ENV === 'development') {
+                console.error("<Form> does not support changing `" + key + "`. " + (isNavigatingForm ? "If you'd like to use it to perform a mutation, consider making `action` a function instead.\n" + "Learn more: https://nextjs.org/docs/app/building-your-application/data-fetching/server-actions-and-mutations" : ''));
+            }
+            delete props[key];
+        }
+    }
+    const isPrefetchEnabled = // if we don't have an action path, we can't prefetch anything.
+    !!router && isNavigatingForm && prefetch === null;
+    const observeFormVisibilityOnMount = (0, _react.useCallback)((element)=>{
+        if (isPrefetchEnabled && router !== null) {
+            (0, _links.mountFormInstance)(element, actionProp, router, _routerreducertypes.PrefetchKind.AUTO);
+        }
+        return ()=>{
+            (0, _links.unmountPrefetchableInstance)(element);
+        };
+    }, [
+        isPrefetchEnabled,
+        actionProp,
+        router
+    ]);
+    const mergedRef = (0, _usemergedref.useMergedRef)(observeFormVisibilityOnMount, externalRef != null ? externalRef : null);
+    if (!isNavigatingForm) {
+        return /*#__PURE__*/ (0, _jsxruntime.jsx)("form", {
+            ...props,
+            ref: mergedRef
+        });
+    }
+    const actionHref = (0, _addbasepath.addBasePath)(actionProp);
+    return /*#__PURE__*/ (0, _jsxruntime.jsx)("form", {
+        ...props,
+        ref: mergedRef,
+        action: actionHref,
+        onSubmit: (event)=>onFormSubmit(event, {
+                router,
+                actionHref,
+                replace,
+                scroll,
+                onSubmit: props.onSubmit
+            })
+    });
+}
+function onFormSubmit(event, param) {
+    let { actionHref, onSubmit, replace, scroll, router } = param;
+    if (typeof onSubmit === 'function') {
+        onSubmit(event);
+        // if the user called event.preventDefault(), do nothing.
+        // (this matches what Link does for `onClick`)
+        if (event.defaultPrevented) {
+            return;
+        }
+    }
+    if (!router) {
+        // Form was somehow used outside of the router (but not in pages, the implementation is forked!).
+        // We can't perform a soft navigation, so let the native submit handling do its thing.
+        return;
+    }
+    const formElement = event.currentTarget;
+    const submitter = event.nativeEvent.submitter;
+    let action = actionHref;
+    if (submitter) {
+        if (process.env.NODE_ENV === 'development') {
+            // the way server actions are encoded (e.g. `formMethod="post")
+            // causes some unnecessary dev-mode warnings from `hasUnsupportedSubmitterAttributes`.
+            // we'd bail out anyway, but we just do it silently.
+            if (hasReactServerActionAttributes(submitter)) {
+                return;
+            }
+        }
+        if ((0, _formshared.hasUnsupportedSubmitterAttributes)(submitter)) {
+            return;
+        }
+        // client actions have `formAction="javascript:..."`. We obviously can't prefetch/navigate to that.
+        if ((0, _formshared.hasReactClientActionAttributes)(submitter)) {
+            return;
+        }
+        // If the submitter specified an alternate formAction,
+        // use that URL instead -- this is what a native form would do.
+        // NOTE: `submitter.formAction` is unreliable, because it will give us `location.href` if it *wasn't* set
+        // NOTE: this should not have `basePath` added, because we can't add it before hydration
+        const submitterFormAction = submitter.getAttribute('formAction');
+        if (submitterFormAction !== null) {
+            if (process.env.NODE_ENV === 'development') {
+                (0, _formshared.checkFormActionUrl)(submitterFormAction, 'formAction');
+            }
+            action = submitterFormAction;
+        }
+    }
+    const targetUrl = (0, _formshared.createFormSubmitDestinationUrl)(action, formElement);
+    // Finally, no more reasons for bailing out.
+    event.preventDefault();
+    const method = replace ? 'replace' : 'push';
+    const targetHref = targetUrl.href;
+    router[method](targetHref, {
+        scroll
+    });
+}
+function hasReactServerActionAttributes(submitter) {
+    // https://github.com/facebook/react/blob/942eb80381b96f8410eab1bef1c539bed1ab0eb1/packages/react-client/src/ReactFlightReplyClient.js#L931-L934
+    const name = submitter.getAttribute('name');
+    return name && (name.startsWith('$ACTION_ID_') || name.startsWith('$ACTION_REF_'));
+}
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=form.js.map

frontend/webapp/node_modules/next/dist/client/app-dir/link.d.ts

@@ -0,0 +1,193 @@
+import React from 'react';
+import type { UrlObject } from 'url';
+type Url = string | UrlObject;
+type OnNavigateEventHandler = (event: {
+    preventDefault: () => void;
+}) => void;
+type InternalLinkProps = {
+    /**
+     * **Required**. The path or URL to navigate to. It can also be an object (similar to `URL`).
+     *
+     * @example
+     * ```tsx
+     * // Navigate to /dashboard:
+     * <Link href="/dashboard">Dashboard</Link>
+     *
+     * // Navigate to /about?name=test:
+     * <Link href={{ pathname: '/about', query: { name: 'test' } }}>
+     *   About
+     * </Link>
+     * ```
+     *
+     * @remarks
+     * - For external URLs, use a fully qualified URL such as `https://...`.
+     * - In the App Router, dynamic routes must not include bracketed segments in `href`.
+     */
+    href: Url;
+    /**
+     * @deprecated v10.0.0: `href` props pointing to a dynamic route are
+     * automatically resolved and no longer require the `as` prop.
+     */
+    as?: Url;
+    /**
+     * Replace the current `history` state instead of adding a new URL into the stack.
+     *
+     * @defaultValue `false`
+     *
+     * @example
+     * ```tsx
+     * <Link href="/about" replace>
+     *   About (replaces the history state)
+     * </Link>
+     * ```
+     */
+    replace?: boolean;
+    /**
+     * Whether to override the default scroll behavior. If `true`, Next.js attempts to maintain
+     * the scroll position if the newly navigated page is still visible. If not, it scrolls to the top.
+     *
+     * If `false`, Next.js will not modify the scroll behavior at all.
+     *
+     * @defaultValue `true`
+     *
+     * @example
+     * ```tsx
+     * <Link href="/dashboard" scroll={false}>
+     *   No auto scroll
+     * </Link>
+     * ```
+     */
+    scroll?: boolean;
+    /**
+     * Update the path of the current page without rerunning data fetching methods
+     * like `getStaticProps`, `getServerSideProps`, or `getInitialProps`.
+     *
+     * @remarks
+     * `shallow` only applies to the Pages Router. For the App Router, see the
+     * [following documentation](https://nextjs.org/docs/app/building-your-application/routing/linking-and-navigating#using-the-native-history-api).
+     *
+     * @defaultValue `false`
+     *
+     * @example
+     * ```tsx
+     * <Link href="/blog" shallow>
+     *   Shallow navigation
+     * </Link>
+     * ```
+     */
+    shallow?: boolean;
+    /**
+     * Forces `Link` to pass its `href` to the child component. Useful if the child is a custom
+     * component that wraps an `<a>` tag, or if you're using certain styling libraries.
+     *
+     * @defaultValue `false`
+     *
+     * @example
+     * ```tsx
+     * <Link href="/dashboard" passHref>
+     *   <MyStyledAnchor>Dashboard</MyStyledAnchor>
+     * </Link>
+     * ```
+     */
+    passHref?: boolean;
+    /**
+     * Prefetch the page in the background.
+     * Any `<Link />` that is in the viewport (initially or through scroll) will be prefetched.
+     * Prefetch can be disabled by passing `prefetch={false}`.
+     *
+     * @remarks
+     * Prefetching is only enabled in production.
+     *
+     * - In the **App Router**:
+     *   - `null` (default): Prefetch behavior depends on static vs dynamic routes:
+     *     - Static routes: fully prefetched
+     *     - Dynamic routes: partial prefetch to the nearest segment with a `loading.js`
+     *   - `true`: Always prefetch the full route and data.
+     *   - `false`: Disable prefetching on both viewport and hover.
+     * - In the **Pages Router**:
+     *   - `true` (default): Prefetches the route and data in the background on viewport or hover.
+     *   - `false`: Prefetch only on hover, not on viewport.
+     *
+     * @defaultValue `true` (Pages Router) or `null` (App Router)
+     *
+     * @example
+     * ```tsx
+     * <Link href="/dashboard" prefetch={false}>
+     *   Dashboard
+     * </Link>
+     * ```
+     */
+    prefetch?: boolean | null;
+    /**
+     * (unstable) Switch to a dynamic prefetch on hover. Effectively the same as
+     * updating the prefetch prop to `true` in a mouse event.
+     */
+    unstable_dynamicOnHover?: boolean;
+    /**
+     * The active locale is automatically prepended in the Pages Router. `locale` allows for providing
+     * a different locale, or can be set to `false` to opt out of automatic locale behavior.
+     *
+     * @remarks
+     * Note: locale only applies in the Pages Router and is ignored in the App Router.
+     *
+     * @example
+     * ```tsx
+     * // Use the 'fr' locale:
+     * <Link href="/about" locale="fr">
+     *   About (French)
+     * </Link>
+     *
+     * // Disable locale prefix:
+     * <Link href="/about" locale={false}>
+     *   About (no locale prefix)
+     * </Link>
+     * ```
+     */
+    locale?: string | false;
+    /**
+     * Enable legacy link behavior, requiring an `<a>` tag to wrap the child content
+     * if the child is a string or number.
+     *
+     * @deprecated This will be removed in v16
+     * @defaultValue `false`
+     * @see https://github.com/vercel/next.js/commit/489e65ed98544e69b0afd7e0cfc3f9f6c2b803b7
+     */
+    legacyBehavior?: boolean;
+    /**
+     * Optional event handler for when the mouse pointer is moved onto the `<Link>`.
+     */
+    onMouseEnter?: React.MouseEventHandler<HTMLAnchorElement>;
+    /**
+     * Optional event handler for when the `<Link>` is touched.
+     */
+    onTouchStart?: React.TouchEventHandler<HTMLAnchorElement>;
+    /**
+     * Optional event handler for when the `<Link>` is clicked.
+     */
+    onClick?: React.MouseEventHandler<HTMLAnchorElement>;
+    /**
+     * Optional event handler for when the `<Link>` is navigated.
+     */
+    onNavigate?: OnNavigateEventHandler;
+};
+export type LinkProps<RouteInferType = any> = InternalLinkProps;
+/**
+ * A React component that extends the HTML `<a>` element to provide
+ * [prefetching](https://nextjs.org/docs/app/building-your-application/routing/linking-and-navigating#2-prefetching)
+ * and client-side navigation. This is the primary way to navigate between routes in Next.js.
+ *
+ * @remarks
+ * - Prefetching is only enabled in production.
+ *
+ * @see https://nextjs.org/docs/app/api-reference/components/link
+ */
+export default function LinkComponent(props: LinkProps & {
+    children: React.ReactNode;
+    ref: React.Ref<HTMLAnchorElement>;
+}): import("react/jsx-runtime").JSX.Element;
+export declare const useLinkStatus: () => {
+    pending: boolean;
+} | {
+    pending: boolean;
+};
+export {};

frontend/webapp/node_modules/next/dist/client/app-dir/link.js

@@ -0,0 +1,384 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    default: null,
+    useLinkStatus: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    /**
+ * A React component that extends the HTML `<a>` element to provide
+ * [prefetching](https://nextjs.org/docs/app/building-your-application/routing/linking-and-navigating#2-prefetching)
+ * and client-side navigation. This is the primary way to navigate between routes in Next.js.
+ *
+ * @remarks
+ * - Prefetching is only enabled in production.
+ *
+ * @see https://nextjs.org/docs/app/api-reference/components/link
+ */ default: function() {
+        return LinkComponent;
+    },
+    useLinkStatus: function() {
+        return useLinkStatus;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _jsxruntime = require("react/jsx-runtime");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _formaturl = require("../../shared/lib/router/utils/format-url");
+const _approutercontextsharedruntime = require("../../shared/lib/app-router-context.shared-runtime");
+const _routerreducertypes = require("../components/router-reducer/router-reducer-types");
+const _usemergedref = require("../use-merged-ref");
+const _utils = require("../../shared/lib/utils");
+const _addbasepath = require("../add-base-path");
+const _warnonce = require("../../shared/lib/utils/warn-once");
+const _links = require("../components/links");
+const _islocalurl = require("../../shared/lib/router/utils/is-local-url");
+const _approuterinstance = require("../components/app-router-instance");
+const _erroronce = require("../../shared/lib/utils/error-once");
+function isModifiedEvent(event) {
+    const eventTarget = event.currentTarget;
+    const target = eventTarget.getAttribute('target');
+    return target && target !== '_self' || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey || // triggers resource download
+    event.nativeEvent && event.nativeEvent.which === 2;
+}
+function linkClicked(e, href, as, linkInstanceRef, replace, scroll, onNavigate) {
+    const { nodeName } = e.currentTarget;
+    // anchors inside an svg have a lowercase nodeName
+    const isAnchorNodeName = nodeName.toUpperCase() === 'A';
+    if (isAnchorNodeName && isModifiedEvent(e) || e.currentTarget.hasAttribute('download')) {
+        // ignore click for browser’s default behavior
+        return;
+    }
+    if (!(0, _islocalurl.isLocalURL)(href)) {
+        if (replace) {
+            // browser default behavior does not replace the history state
+            // so we need to do it manually
+            e.preventDefault();
+            location.replace(href);
+        }
+        // ignore click for browser’s default behavior
+        return;
+    }
+    e.preventDefault();
+    const navigate = ()=>{
+        if (onNavigate) {
+            let isDefaultPrevented = false;
+            onNavigate({
+                preventDefault: ()=>{
+                    isDefaultPrevented = true;
+                }
+            });
+            if (isDefaultPrevented) {
+                return;
+            }
+        }
+        (0, _approuterinstance.dispatchNavigateAction)(as || href, replace ? 'replace' : 'push', scroll != null ? scroll : true, linkInstanceRef.current);
+    };
+    _react.default.startTransition(navigate);
+}
+function formatStringOrUrl(urlObjOrString) {
+    if (typeof urlObjOrString === 'string') {
+        return urlObjOrString;
+    }
+    return (0, _formaturl.formatUrl)(urlObjOrString);
+}
+function LinkComponent(props) {
+    const [linkStatus, setOptimisticLinkStatus] = (0, _react.useOptimistic)(_links.IDLE_LINK_STATUS);
+    let children;
+    const linkInstanceRef = (0, _react.useRef)(null);
+    const { href: hrefProp, as: asProp, children: childrenProp, prefetch: prefetchProp = null, passHref, replace, shallow, scroll, onClick, onMouseEnter: onMouseEnterProp, onTouchStart: onTouchStartProp, legacyBehavior = false, onNavigate, ref: forwardedRef, unstable_dynamicOnHover, ...restProps } = props;
+    children = childrenProp;
+    if (legacyBehavior && (typeof children === 'string' || typeof children === 'number')) {
+        children = /*#__PURE__*/ (0, _jsxruntime.jsx)("a", {
+            children: children
+        });
+    }
+    const router = _react.default.useContext(_approutercontextsharedruntime.AppRouterContext);
+    const prefetchEnabled = prefetchProp !== false;
+    /**
+   * The possible states for prefetch are:
+   * - null: this is the default "auto" mode, where we will prefetch partially if the link is in the viewport
+   * - true: we will prefetch if the link is visible and prefetch the full page, not just partially
+   * - false: we will not prefetch if in the viewport at all
+   * - 'unstable_dynamicOnHover': this starts in "auto" mode, but switches to "full" when the link is hovered
+   */ const appPrefetchKind = prefetchProp === null ? _routerreducertypes.PrefetchKind.AUTO : _routerreducertypes.PrefetchKind.FULL;
+    if (process.env.NODE_ENV !== 'production') {
+        function createPropError(args) {
+            return Object.defineProperty(new Error("Failed prop type: The prop `" + args.key + "` expects a " + args.expected + " in `<Link>`, but got `" + args.actual + "` instead." + (typeof window !== 'undefined' ? "\nOpen your browser's console to view the Component stack trace." : '')), "__NEXT_ERROR_CODE", {
+                value: "E319",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        // TypeScript trick for type-guarding:
+        const requiredPropsGuard = {
+            href: true
+        };
+        const requiredProps = Object.keys(requiredPropsGuard);
+        requiredProps.forEach((key)=>{
+            if (key === 'href') {
+                if (props[key] == null || typeof props[key] !== 'string' && typeof props[key] !== 'object') {
+                    throw createPropError({
+                        key,
+                        expected: '`string` or `object`',
+                        actual: props[key] === null ? 'null' : typeof props[key]
+                    });
+                }
+            } else {
+                // TypeScript trick for type-guarding:
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                const _ = key;
+            }
+        });
+        // TypeScript trick for type-guarding:
+        const optionalPropsGuard = {
+            as: true,
+            replace: true,
+            scroll: true,
+            shallow: true,
+            passHref: true,
+            prefetch: true,
+            unstable_dynamicOnHover: true,
+            onClick: true,
+            onMouseEnter: true,
+            onTouchStart: true,
+            legacyBehavior: true,
+            onNavigate: true
+        };
+        const optionalProps = Object.keys(optionalPropsGuard);
+        optionalProps.forEach((key)=>{
+            const valType = typeof props[key];
+            if (key === 'as') {
+                if (props[key] && valType !== 'string' && valType !== 'object') {
+                    throw createPropError({
+                        key,
+                        expected: '`string` or `object`',
+                        actual: valType
+                    });
+                }
+            } else if (key === 'onClick' || key === 'onMouseEnter' || key === 'onTouchStart' || key === 'onNavigate') {
+                if (props[key] && valType !== 'function') {
+                    throw createPropError({
+                        key,
+                        expected: '`function`',
+                        actual: valType
+                    });
+                }
+            } else if (key === 'replace' || key === 'scroll' || key === 'shallow' || key === 'passHref' || key === 'prefetch' || key === 'legacyBehavior' || key === 'unstable_dynamicOnHover') {
+                if (props[key] != null && valType !== 'boolean') {
+                    throw createPropError({
+                        key,
+                        expected: '`boolean`',
+                        actual: valType
+                    });
+                }
+            } else {
+                // TypeScript trick for type-guarding:
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                const _ = key;
+            }
+        });
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        if (props.locale) {
+            (0, _warnonce.warnOnce)('The `locale` prop is not supported in `next/link` while using the `app` router. Read more about app router internalization: https://nextjs.org/docs/app/building-your-application/routing/internationalization');
+        }
+        if (!asProp) {
+            let href;
+            if (typeof hrefProp === 'string') {
+                href = hrefProp;
+            } else if (typeof hrefProp === 'object' && typeof hrefProp.pathname === 'string') {
+                href = hrefProp.pathname;
+            }
+            if (href) {
+                const hasDynamicSegment = href.split('/').some((segment)=>segment.startsWith('[') && segment.endsWith(']'));
+                if (hasDynamicSegment) {
+                    throw Object.defineProperty(new Error("Dynamic href `" + href + "` found in <Link> while using the `/app` router, this is not supported. Read more: https://nextjs.org/docs/messages/app-dir-dynamic-href"), "__NEXT_ERROR_CODE", {
+                        value: "E267",
+                        enumerable: false,
+                        configurable: true
+                    });
+                }
+            }
+        }
+    }
+    const { href, as } = _react.default.useMemo(()=>{
+        const resolvedHref = formatStringOrUrl(hrefProp);
+        return {
+            href: resolvedHref,
+            as: asProp ? formatStringOrUrl(asProp) : resolvedHref
+        };
+    }, [
+        hrefProp,
+        asProp
+    ]);
+    // This will return the first child, if multiple are provided it will throw an error
+    let child;
+    if (legacyBehavior) {
+        if (process.env.NODE_ENV === 'development') {
+            if (onClick) {
+                console.warn('"onClick" was passed to <Link> with `href` of `' + hrefProp + '` but "legacyBehavior" was set. The legacy behavior requires onClick be set on the child of next/link');
+            }
+            if (onMouseEnterProp) {
+                console.warn('"onMouseEnter" was passed to <Link> with `href` of `' + hrefProp + '` but "legacyBehavior" was set. The legacy behavior requires onMouseEnter be set on the child of next/link');
+            }
+            try {
+                child = _react.default.Children.only(children);
+            } catch (err) {
+                if (!children) {
+                    throw Object.defineProperty(new Error("No children were passed to <Link> with `href` of `" + hrefProp + "` but one child is required https://nextjs.org/docs/messages/link-no-children"), "__NEXT_ERROR_CODE", {
+                        value: "E320",
+                        enumerable: false,
+                        configurable: true
+                    });
+                }
+                throw Object.defineProperty(new Error("Multiple children were passed to <Link> with `href` of `" + hrefProp + "` but only one child is supported https://nextjs.org/docs/messages/link-multiple-children" + (typeof window !== 'undefined' ? " \nOpen your browser's console to view the Component stack trace." : '')), "__NEXT_ERROR_CODE", {
+                    value: "E266",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+        } else {
+            child = _react.default.Children.only(children);
+        }
+    } else {
+        if (process.env.NODE_ENV === 'development') {
+            if ((children == null ? void 0 : children.type) === 'a') {
+                throw Object.defineProperty(new Error('Invalid <Link> with <a> child. Please remove <a> or use <Link legacyBehavior>.\nLearn more: https://nextjs.org/docs/messages/invalid-new-link-with-extra-anchor'), "__NEXT_ERROR_CODE", {
+                    value: "E209",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+        }
+    }
+    const childRef = legacyBehavior ? child && typeof child === 'object' && child.ref : forwardedRef;
+    // Use a callback ref to attach an IntersectionObserver to the anchor tag on
+    // mount. In the future we will also use this to keep track of all the
+    // currently mounted <Link> instances, e.g. so we can re-prefetch them after
+    // a revalidation or refresh.
+    const observeLinkVisibilityOnMount = _react.default.useCallback((element)=>{
+        if (router !== null) {
+            linkInstanceRef.current = (0, _links.mountLinkInstance)(element, href, router, appPrefetchKind, prefetchEnabled, setOptimisticLinkStatus);
+        }
+        return ()=>{
+            if (linkInstanceRef.current) {
+                (0, _links.unmountLinkForCurrentNavigation)(linkInstanceRef.current);
+                linkInstanceRef.current = null;
+            }
+            (0, _links.unmountPrefetchableInstance)(element);
+        };
+    }, [
+        prefetchEnabled,
+        href,
+        router,
+        appPrefetchKind,
+        setOptimisticLinkStatus
+    ]);
+    const mergedRef = (0, _usemergedref.useMergedRef)(observeLinkVisibilityOnMount, childRef);
+    const childProps = {
+        ref: mergedRef,
+        onClick (e) {
+            if (process.env.NODE_ENV !== 'production') {
+                if (!e) {
+                    throw Object.defineProperty(new Error('Component rendered inside next/link has to pass click event to "onClick" prop.'), "__NEXT_ERROR_CODE", {
+                        value: "E312",
+                        enumerable: false,
+                        configurable: true
+                    });
+                }
+            }
+            if (!legacyBehavior && typeof onClick === 'function') {
+                onClick(e);
+            }
+            if (legacyBehavior && child.props && typeof child.props.onClick === 'function') {
+                child.props.onClick(e);
+            }
+            if (!router) {
+                return;
+            }
+            if (e.defaultPrevented) {
+                return;
+            }
+            linkClicked(e, href, as, linkInstanceRef, replace, scroll, onNavigate);
+        },
+        onMouseEnter (e) {
+            if (!legacyBehavior && typeof onMouseEnterProp === 'function') {
+                onMouseEnterProp(e);
+            }
+            if (legacyBehavior && child.props && typeof child.props.onMouseEnter === 'function') {
+                child.props.onMouseEnter(e);
+            }
+            if (!router) {
+                return;
+            }
+            if (!prefetchEnabled || process.env.NODE_ENV === 'development') {
+                return;
+            }
+            const upgradeToDynamicPrefetch = unstable_dynamicOnHover === true;
+            (0, _links.onNavigationIntent)(e.currentTarget, upgradeToDynamicPrefetch);
+        },
+        onTouchStart: process.env.__NEXT_LINK_NO_TOUCH_START ? undefined : function onTouchStart(e) {
+            if (!legacyBehavior && typeof onTouchStartProp === 'function') {
+                onTouchStartProp(e);
+            }
+            if (legacyBehavior && child.props && typeof child.props.onTouchStart === 'function') {
+                child.props.onTouchStart(e);
+            }
+            if (!router) {
+                return;
+            }
+            if (!prefetchEnabled) {
+                return;
+            }
+            const upgradeToDynamicPrefetch = unstable_dynamicOnHover === true;
+            (0, _links.onNavigationIntent)(e.currentTarget, upgradeToDynamicPrefetch);
+        }
+    };
+    // If child is an <a> tag and doesn't have a href attribute, or if the 'passHref' property is
+    // defined, we specify the current 'href', so that repetition is not needed by the user.
+    // If the url is absolute, we can bypass the logic to prepend the basePath.
+    if ((0, _utils.isAbsoluteUrl)(as)) {
+        childProps.href = as;
+    } else if (!legacyBehavior || passHref || child.type === 'a' && !('href' in child.props)) {
+        childProps.href = (0, _addbasepath.addBasePath)(as);
+    }
+    let link;
+    if (legacyBehavior) {
+        if (process.env.NODE_ENV === 'development') {
+            (0, _erroronce.errorOnce)('`legacyBehavior` is deprecated and will be removed in a future ' + 'release. A codemod is available to upgrade your components:\n\n' + 'npx @next/codemod@latest new-link .\n\n' + 'Learn more: https://nextjs.org/docs/app/building-your-application/upgrading/codemods#remove-a-tags-from-link-components');
+        }
+        link = /*#__PURE__*/ _react.default.cloneElement(child, childProps);
+    } else {
+        link = /*#__PURE__*/ (0, _jsxruntime.jsx)("a", {
+            ...restProps,
+            ...childProps,
+            children: children
+        });
+    }
+    return /*#__PURE__*/ (0, _jsxruntime.jsx)(LinkStatusContext.Provider, {
+        value: linkStatus,
+        children: link
+    });
+}
+const LinkStatusContext = /*#__PURE__*/ (0, _react.createContext)(_links.IDLE_LINK_STATUS);
+const useLinkStatus = ()=>{
+    return (0, _react.useContext)(LinkStatusContext);
+};
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=link.js.map