@nilsr0711/drydock 0.1.0 → 0.1.1

package/.next/standalone/node_modules/.pnpm/next@16.2.6_react-dom@19.2.6_react@19.2.6__react@19.2.6/node_modules/next/dist/client/dev/hot-reloader/turbopack-hot-reloader-common.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "TurbopackHmr", {
+    enumerable: true,
+    get: function() {
+        return TurbopackHmr;
+    }
+});
+// How long to wait before reporting the HMR start, used to suppress irrelevant
+// `BUILDING` events. Does not impact reported latency.
+const TURBOPACK_HMR_START_DELAY_MS = 100;
+class TurbopackHmr {
+    #updatedModules;
+    #startMsSinceEpoch;
+    #lastUpdateMsSinceEpoch;
+    #deferredReportHmrStartId;
+    #reportedHmrStart;
+    constructor(){
+        this.#updatedModules = new Set();
+        this.#reportedHmrStart = false;
+    }
+    // HACK: Turbopack tends to generate a lot of irrelevant "BUILDING" actions,
+    // as it reports *any* compilation, including fully no-op/cached compilations
+    // and those unrelated to HMR. Fixing this would require significant
+    // architectural changes.
+    //
+    // Work around this by deferring any "rebuilding" message by 100ms. If we get
+    // a BUILT event within that threshold and nothing has changed, just suppress
+    // the message entirely.
+    #runDeferredReportHmrStart() {
+        if (this.#deferredReportHmrStartId != null) {
+            console.log('[Fast Refresh] rebuilding');
+            this.#reportedHmrStart = true;
+            this.#cancelDeferredReportHmrStart();
+        }
+    }
+    #cancelDeferredReportHmrStart() {
+        clearTimeout(this.#deferredReportHmrStartId);
+        this.#deferredReportHmrStartId = undefined;
+    }
+    onBuilding() {
+        this.#lastUpdateMsSinceEpoch = undefined;
+        this.#cancelDeferredReportHmrStart();
+        this.#startMsSinceEpoch = Date.now();
+        // report the HMR start after a short delay
+        this.#deferredReportHmrStartId = setTimeout(()=>this.#runDeferredReportHmrStart(), // debugging feature: don't defer/suppress noisy no-op HMR update messages
+        self.__NEXT_HMR_TURBOPACK_REPORT_NOISY_NOOP_EVENTS ? 0 : TURBOPACK_HMR_START_DELAY_MS);
+    }
+    /** Helper for other `onEvent` methods. */ #onUpdate() {
+        this.#runDeferredReportHmrStart();
+        this.#lastUpdateMsSinceEpoch = Date.now();
+    }
+    onTurbopackMessage(msg) {
+        this.#onUpdate();
+        const updatedModules = extractModulesFromTurbopackMessage(msg.data);
+        for (const module of updatedModules){
+            this.#updatedModules.add(module);
+        }
+    }
+    onServerComponentChanges() {
+        this.#onUpdate();
+    }
+    onReloadPage() {
+        this.#onUpdate();
+    }
+    onPageAddRemove() {
+        this.#onUpdate();
+    }
+    /**
+   * @returns `null` if the caller should ignore the update entirely. Returns an
+   *   object with `hasUpdates: false` if the caller should report the end of
+   *   the HMR in the browser console, but the HMR was a no-op.
+   */ onBuilt() {
+        // Check that we got *any* `TurbopackMessage`, even if
+        // `updatedModules` is empty (not everything gets recorded there).
+        //
+        // There's also a case where `onBuilt` gets called before `onBuilding`,
+        // which can happen during initial page load. Ignore that too!
+        const hasUpdates = this.#lastUpdateMsSinceEpoch != null && this.#startMsSinceEpoch != null;
+        if (!hasUpdates && !this.#reportedHmrStart) {
+            // suppress the update entirely
+            this.#cancelDeferredReportHmrStart();
+            return null;
+        }
+        this.#runDeferredReportHmrStart();
+        const result = {
+            hasUpdates,
+            updatedModules: this.#updatedModules,
+            startMsSinceEpoch: this.#startMsSinceEpoch,
+            endMsSinceEpoch: this.#lastUpdateMsSinceEpoch ?? Date.now()
+        };
+        this.#updatedModules = new Set();
+        this.#reportedHmrStart = false;
+        return result;
+    }
+}
+function extractModulesFromTurbopackMessage(data) {
+    const updatedModules = new Set();
+    const updates = Array.isArray(data) ? data : [
+        data
+    ];
+    for (const update of updates){
+        // TODO this won't capture changes to CSS since they don't result in a "merged" update
+        if (update.type !== 'partial' || update.instruction.type !== 'ChunkListUpdate' || update.instruction.merged === undefined) {
+            continue;
+        }
+        for (const mergedUpdate of update.instruction.merged){
+            for (const name of Object.keys(mergedUpdate.entries)){
+                const res = /(.*)\s+[([].*/.exec(name);
+                if (res === null) {
+                    continue;
+                }
+                updatedModules.add(res[1]);
+            }
+        }
+    }
+    return updatedModules;
+}
+
+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=turbopack-hot-reloader-common.js.map

package/.next/standalone/node_modules/.pnpm/next@16.2.6_react-dom@19.2.6_react@19.2.6__react@19.2.6/node_modules/next/dist/client/dev/report-hmr-latency.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, /**
+ * Logs information about a completed HMR to the console, the server (via a
+ * `client-hmr-latency` event), and to `self.__NEXT_HMR_LATENCY_CB` (a debugging
+ * hook).
+ *
+ * @param hasUpdate Set this to `false` to avoid reporting the HMR event via a
+ *   `client-hmr-latency` event or to `self.__NEXT_HMR_LATENCY_CB`. Used by
+ *   turbopack when we must report a message to the browser console (because we
+ *   already logged a "rebuilding" message), but it's not a real HMR, so we
+ *   don't want to impact our telemetry.
+ */ "default", {
+    enumerable: true,
+    get: function() {
+        return reportHmrLatency;
+    }
+});
+function reportHmrLatency(sendMessage, updatedModules, startMsSinceEpoch, endMsSinceEpoch, hasUpdate = true) {
+    const latencyMs = endMsSinceEpoch - startMsSinceEpoch;
+    console.log(`[Fast Refresh] done in ${latencyMs}ms`);
+    if (!hasUpdate) {
+        return;
+    }
+    sendMessage(JSON.stringify({
+        event: 'client-hmr-latency',
+        id: window.__nextDevClientId,
+        startTime: startMsSinceEpoch,
+        endTime: endMsSinceEpoch,
+        page: window.location.pathname,
+        updatedModules,
+        // Whether the page (tab) was hidden at the time the event occurred.
+        // This can impact the accuracy of the event's timing.
+        isPageHidden: document.visibilityState === 'hidden'
+    }));
+    if (self.__NEXT_HMR_LATENCY_CB) {
+        self.__NEXT_HMR_LATENCY_CB(latencyMs);
+    }
+}
+
+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=report-hmr-latency.js.map

package/.next/standalone/node_modules/.pnpm/next@16.2.6_react-dom@19.2.6_react@19.2.6__react@19.2.6/node_modules/next/dist/client/dev/runtime-error-handler.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "RuntimeErrorHandler", {
+    enumerable: true,
+    get: function() {
+        return RuntimeErrorHandler;
+    }
+});
+const RuntimeErrorHandler = {
+    hadRuntimeError: false
+};
+
+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=runtime-error-handler.js.map

package/.next/standalone/node_modules/.pnpm/next@16.2.6_react-dom@19.2.6_react@19.2.6__react@19.2.6/node_modules/next/dist/client/lib/promise.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "resolvePromiseWithTimeout", {
+    enumerable: true,
+    get: function() {
+        return resolvePromiseWithTimeout;
+    }
+});
+const _requestidlecallback = require("../request-idle-callback");
+// 3.8s was arbitrarily chosen as it's what https://web.dev/interactive
+// considers as "Good" time-to-interactive. We must assume something went
+// wrong beyond this point, and then fall-back to a full page transition to
+// show the user something of value.
+const MS_MAX_IDLE_DELAY = 3800;
+function resolvePromiseWithTimeout(p, err, devPromise) {
+    return new Promise((resolve, reject)=>{
+        let cancelled = false;
+        p.then((r)=>{
+            // Resolved, cancel the timeout
+            cancelled = true;
+            resolve(r);
+        }).catch(reject);
+        // We wrap these checks separately for better dead-code elimination in
+        // production bundles.
+        if (process.env.NODE_ENV === 'development') {
+            ;
+            (devPromise || Promise.resolve()).then(()=>{
+                (0, _requestidlecallback.requestIdleCallback)(()=>setTimeout(()=>{
+                        if (!cancelled) {
+                            reject(err);
+                        }
+                    }, MS_MAX_IDLE_DELAY));
+            });
+        }
+        if (process.env.NODE_ENV !== 'development') {
+            (0, _requestidlecallback.requestIdleCallback)(()=>setTimeout(()=>{
+                    if (!cancelled) {
+                        reject(err);
+                    }
+                }, MS_MAX_IDLE_DELAY));
+        }
+    });
+}
+
+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=promise.js.map

package/.next/standalone/node_modules/.pnpm/next@16.2.6_react-dom@19.2.6_react@19.2.6__react@19.2.6/node_modules/next/dist/client/react-client-callbacks/on-recoverable-error.js

@@ -0,0 +1,66 @@
+// This module can be shared between both pages router and app router
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    isRecoverableError: null,
+    onRecoverableError: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    isRecoverableError: function() {
+        return isRecoverableError;
+    },
+    onRecoverableError: function() {
+        return onRecoverableError;
+    }
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _bailouttocsr = require("../../shared/lib/lazy-dynamic/bailout-to-csr");
+const _iserror = /*#__PURE__*/ _interop_require_default._(require("../../lib/is-error"));
+const _reportglobalerror = require("./report-global-error");
+const recoverableErrors = new WeakSet();
+const isInstantTest = process.env.__NEXT_EXPOSE_TESTING_API && typeof self !== 'undefined' && !!self.__next_instant_test;
+function isRecoverableError(error) {
+    return recoverableErrors.has(error);
+}
+const onRecoverableError = (error)=>{
+    // x-ref: https://github.com/facebook/react/pull/28736
+    let cause = (0, _iserror.default)(error) && 'cause' in error ? error.cause : error;
+    // Skip certain custom errors which are not expected to be reported on client
+    if ((0, _bailouttocsr.isBailoutToCSRError)(cause)) return;
+    // Instant Navigation Testing API: suppress "server could not finish this
+    // Suspense boundary" errors (React error #419) during instant test mode.
+    // The static shell intentionally has incomplete Suspense boundaries — React
+    // correctly falls back to client rendering, which is expected.
+    if (isInstantTest) {
+        if ((0, _iserror.default)(cause)) {
+            if (process.env.NODE_ENV === 'production') {
+                if (cause.message.includes('#419')) return;
+            } else {
+                if (cause.message.includes('could not finish this Suspense boundary')) return;
+            }
+        }
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        const { decorateDevError } = require('../../next-devtools/userspace/app/errors/stitched-error');
+        const causeError = decorateDevError(cause);
+        recoverableErrors.add(causeError);
+        cause = causeError;
+    }
+    (0, _reportglobalerror.reportGlobalError)(cause);
+};
+
+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=on-recoverable-error.js.map

package/.next/standalone/node_modules/.pnpm/next@16.2.6_react-dom@19.2.6_react@19.2.6__react@19.2.6/node_modules/next/dist/client/react-client-callbacks/report-global-error.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "reportGlobalError", {
+    enumerable: true,
+    get: function() {
+        return reportGlobalError;
+    }
+});
+const reportGlobalError = typeof reportError === 'function' ? // emulating an uncaught JavaScript error.
+reportError : (error)=>{
+    // TODO: Dispatch error event
+    globalThis.console.error(error);
+};
+
+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=report-global-error.js.map

package/.next/standalone/node_modules/.pnpm/next@16.2.6_react-dom@19.2.6_react@19.2.6__react@19.2.6/node_modules/next/dist/client/remove-locale.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "removeLocale", {
+    enumerable: true,
+    get: function() {
+        return removeLocale;
+    }
+});
+const _parsepath = require("../shared/lib/router/utils/parse-path");
+function removeLocale(path, locale) {
+    if (process.env.__NEXT_I18N_SUPPORT) {
+        const { pathname } = (0, _parsepath.parsePath)(path);
+        const pathLower = pathname.toLowerCase();
+        const localeLower = locale?.toLowerCase();
+        return locale && (pathLower.startsWith(`/${localeLower}/`) || pathLower === `/${localeLower}`) ? `${pathname.length === locale.length + 1 ? `/` : ``}${path.slice(locale.length + 1)}` : path;
+    }
+    return path;
+}
+
+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=remove-locale.js.map

package/.next/standalone/node_modules/.pnpm/next@16.2.6_react-dom@19.2.6_react@19.2.6__react@19.2.6/node_modules/next/dist/client/request-idle-callback.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    cancelIdleCallback: null,
+    requestIdleCallback: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    cancelIdleCallback: function() {
+        return cancelIdleCallback;
+    },
+    requestIdleCallback: function() {
+        return requestIdleCallback;
+    }
+});
+const requestIdleCallback = typeof self !== 'undefined' && self.requestIdleCallback && self.requestIdleCallback.bind(window) || function(cb) {
+    let start = Date.now();
+    return self.setTimeout(function() {
+        cb({
+            didTimeout: false,
+            timeRemaining: function() {
+                return Math.max(0, 50 - (Date.now() - start));
+            }
+        });
+    }, 1);
+};
+const cancelIdleCallback = typeof self !== 'undefined' && self.cancelIdleCallback && self.cancelIdleCallback.bind(window) || function(id) {
+    return clearTimeout(id);
+};
+
+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=request-idle-callback.js.map

package/.next/standalone/node_modules/.pnpm/next@16.2.6_react-dom@19.2.6_react@19.2.6__react@19.2.6/node_modules/next/dist/client/resolve-href.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "resolveHref", {
+    enumerable: true,
+    get: function() {
+        return resolveHref;
+    }
+});
+const _querystring = require("../shared/lib/router/utils/querystring");
+const _formaturl = require("../shared/lib/router/utils/format-url");
+const _omit = require("../shared/lib/router/utils/omit");
+const _utils = require("../shared/lib/utils");
+const _normalizetrailingslash = require("./normalize-trailing-slash");
+const _islocalurl = require("../shared/lib/router/utils/is-local-url");
+const _utils1 = require("../shared/lib/router/utils");
+const _interpolateas = require("../shared/lib/router/utils/interpolate-as");
+const _routeregex = require("../shared/lib/router/utils/route-regex");
+const _routematcher = require("../shared/lib/router/utils/route-matcher");
+function resolveHref(router, href, resolveAs) {
+    // we use a dummy base url for relative urls
+    let base;
+    let urlAsString = typeof href === 'string' ? href : (0, _formaturl.formatWithValidation)(href);
+    // repeated slashes and backslashes in the URL are considered
+    // invalid and will never match a Next.js page/file
+    // https://www.rfc-editor.org/rfc/rfc3986.html#section-3.1
+    const urlProtoMatch = urlAsString.match(/^[a-z][a-z0-9+.-]*:\/\//i);
+    const urlAsStringNoProto = urlProtoMatch ? urlAsString.slice(urlProtoMatch[0].length) : urlAsString;
+    const urlParts = urlAsStringNoProto.split('?', 1);
+    if ((urlParts[0] || '').match(/(\/\/|\\)/)) {
+        console.error(`Invalid href '${urlAsString}' passed to next/router in page: '${router.pathname}'. Repeated forward-slashes (//) or backslashes \\ are not valid in the href.`);
+        const normalizedUrl = (0, _utils.normalizeRepeatedSlashes)(urlAsStringNoProto);
+        urlAsString = (urlProtoMatch ? urlProtoMatch[0] : '') + normalizedUrl;
+    }
+    // Return because it cannot be routed by the Next.js router
+    if (!(0, _islocalurl.isLocalURL)(urlAsString)) {
+        return resolveAs ? [
+            urlAsString
+        ] : urlAsString;
+    }
+    try {
+        let baseBase = urlAsString.startsWith('#') ? router.asPath : router.pathname;
+        // If the provided href is only a query string, it is safer to use the asPath
+        // considering rewrites.
+        if (urlAsString.startsWith('?')) {
+            baseBase = router.asPath;
+            // However, if is a dynamic route, we need to use the pathname to preserve the
+            // query interpolation and rewrites (router.pathname will look like "/[slug]").
+            if ((0, _utils1.isDynamicRoute)(router.pathname)) {
+                baseBase = router.pathname;
+                const routeRegex = (0, _routeregex.getRouteRegex)(router.pathname);
+                const match = (0, _routematcher.getRouteMatcher)(routeRegex)(router.asPath);
+                // For dynamic routes, if asPath doesn't match the pathname regex, it is a rewritten path.
+                // In this case, should use asPath to preserve the current URL.
+                if (!match) {
+                    baseBase = router.asPath;
+                }
+            // Note: There is an edge case where the pathname is dynamic, and also a rewrite path to the same segment.
+            // E.g. in "/[slug]" path, rewrite "/foo" -> "/bar"
+            // In this case, it will be treated as a non-rewritten path and possibly interpolate the query string.
+            // E.g., "/any?slug=foo" will become the content of "/foo", not rewritten as "/bar"
+            // This is currently a trade-off of not resolving rewrite paths on every Router/Link call,
+            // but using a lighter route regex pattern check.
+            }
+        }
+        base = new URL(baseBase, 'http://n');
+    } catch (_) {
+        // fallback to / for invalid asPath values e.g. //
+        base = new URL('/', 'http://n');
+    }
+    try {
+        const finalUrl = new URL(urlAsString, base);
+        finalUrl.pathname = (0, _normalizetrailingslash.normalizePathTrailingSlash)(finalUrl.pathname);
+        let interpolatedAs = '';
+        if ((0, _utils1.isDynamicRoute)(finalUrl.pathname) && finalUrl.searchParams && resolveAs) {
+            const query = (0, _querystring.searchParamsToUrlQuery)(finalUrl.searchParams);
+            const { result, params } = (0, _interpolateas.interpolateAs)(finalUrl.pathname, finalUrl.pathname, query);
+            if (result) {
+                interpolatedAs = (0, _formaturl.formatWithValidation)({
+                    pathname: result,
+                    hash: finalUrl.hash,
+                    query: (0, _omit.omit)(query, params)
+                });
+            }
+        }
+        // if the origin didn't change, it means we received a relative href
+        const resolvedHref = finalUrl.origin === base.origin ? finalUrl.href.slice(finalUrl.origin.length) : finalUrl.href;
+        return resolveAs ? [
+            resolvedHref,
+            interpolatedAs || resolvedHref
+        ] : resolvedHref;
+    } catch (_) {
+        return resolveAs ? [
+            urlAsString
+        ] : urlAsString;
+    }
+}
+
+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=resolve-href.js.map