npm - @nilsr0711/drydock - Versions diffs - 0.1.0 → 0.1.1 - Mend

@nilsr0711/drydock 0.1.0 → 0.1.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (933) hide show

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/shared/lib/router/utils/compare-states.js ADDED Viewed

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "compareRouterStates", {
+    enumerable: true,
+    get: function() {
+        return compareRouterStates;
+    }
+});
+function compareRouterStates(a, b) {
+    const stateKeys = Object.keys(a);
+    if (stateKeys.length !== Object.keys(b).length) return false;
+    for(let i = stateKeys.length; i--;){
+        const key = stateKeys[i];
+        if (key === 'query') {
+            const queryKeys = Object.keys(a.query);
+            if (queryKeys.length !== Object.keys(b.query).length) {
+                return false;
+            }
+            for(let j = queryKeys.length; j--;){
+                const queryKey = queryKeys[j];
+                if (!b.query.hasOwnProperty(queryKey) || a.query[queryKey] !== b.query[queryKey]) {
+                    return false;
+                }
+            }
+        } else if (!b.hasOwnProperty(key) || a[key] !== b[key]) {
+            return false;
+        }
+    }
+    return true;
+}
+//# sourceMappingURL=compare-states.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/shared/lib/router/utils/disable-smooth-scroll.js ADDED Viewed

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "disableSmoothScrollDuringRouteTransition", {
+    enumerable: true,
+    get: function() {
+        return disableSmoothScrollDuringRouteTransition;
+    }
+});
+const _warnonce = require("../../utils/warn-once");
+function disableSmoothScrollDuringRouteTransition(fn, options = {}) {
+    // if only the hash is changed, we don't need to disable smooth scrolling
+    // we only care to prevent smooth scrolling when navigating to a new page to avoid jarring UX
+    if (options.onlyHashChange) {
+        fn();
+        return;
+    }
+    const htmlElement = document.documentElement;
+    const hasDataAttribute = htmlElement.dataset.scrollBehavior === 'smooth';
+    if (!hasDataAttribute) {
+        // Warn if smooth scrolling is detected but no data attribute is present
+        if (process.env.NODE_ENV === 'development' && getComputedStyle(htmlElement).scrollBehavior === 'smooth') {
+            (0, _warnonce.warnOnce)('Detected `scroll-behavior: smooth` on the `<html>` element. To disable smooth scrolling during route transitions, ' + 'add `data-scroll-behavior="smooth"` to your <html> element. ' + 'Learn more: https://nextjs.org/docs/messages/missing-data-scroll-behavior');
+        }
+        // No smooth scrolling configured, run directly without style manipulation
+        fn();
+        return;
+    }
+    // Proceed with temporarily disabling smooth scrolling
+    const existing = htmlElement.style.scrollBehavior;
+    htmlElement.style.scrollBehavior = 'auto';
+    if (!options.dontForceLayout) {
+        // In Chrome-based browsers we need to force reflow before calling `scrollTo`.
+        // Otherwise it will not pickup the change in scrollBehavior
+        // More info here: https://github.com/vercel/next.js/issues/40719#issuecomment-1336248042
+        htmlElement.getClientRects();
+    }
+    fn();
+    htmlElement.style.scrollBehavior = existing;
+}
+//# sourceMappingURL=disable-smooth-scroll.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/shared/lib/router/utils/get-asset-path-from-route.js ADDED Viewed

@@ -0,0 +1,18 @@
+// Translates a logical route into its pages asset path (relative from a common prefix)
+// "asset path" being its javascript file, data file, prerendered html,...
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return getAssetPathFromRoute;
+    }
+});
+function getAssetPathFromRoute(route, ext = '') {
+    const path = route === '/' ? '/index' : /^\/index(\/|$)/.test(route) ? `/index${route}` : route;
+    return path + ext;
+}
+//# sourceMappingURL=get-asset-path-from-route.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/shared/lib/router/utils/interpolate-as.js ADDED Viewed

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "interpolateAs", {
+    enumerable: true,
+    get: function() {
+        return interpolateAs;
+    }
+});
+const _routematcher = require("./route-matcher");
+const _routeregex = require("./route-regex");
+function interpolateAs(route, asPathname, query) {
+    let interpolatedRoute = '';
+    const dynamicRegex = (0, _routeregex.getRouteRegex)(route);
+    const dynamicGroups = dynamicRegex.groups;
+    const dynamicMatches = // Try to match the dynamic route against the asPath
+    (asPathname !== route ? (0, _routematcher.getRouteMatcher)(dynamicRegex)(asPathname) : '') || // Fall back to reading the values from the href
+    // TODO: should this take priority; also need to change in the router.
+    query;
+    interpolatedRoute = route;
+    const params = Object.keys(dynamicGroups);
+    if (!params.every((param)=>{
+        let value = dynamicMatches[param] || '';
+        const { repeat, optional } = dynamicGroups[param];
+        // support single-level catch-all
+        // TODO: more robust handling for user-error (passing `/`)
+        let replaced = `[${repeat ? '...' : ''}${param}]`;
+        if (optional) {
+            replaced = `${!value ? '/' : ''}[${replaced}]`;
+        }
+        if (repeat && !Array.isArray(value)) value = [
+            value
+        ];
+        return (optional || param in dynamicMatches) && // Interpolate group into data URL if present
+        (interpolatedRoute = interpolatedRoute.replace(replaced, repeat ? value.map(// these values should be fully encoded instead of just
+        // path delimiter escaped since they are being inserted
+        // into the URL and we expect URL encoded segments
+        // when parsing dynamic route params
+        (segment)=>encodeURIComponent(segment)).join('/') : encodeURIComponent(value)) || '/');
+    })) {
+        interpolatedRoute = '' // did not satisfy all requirements
+        ;
+    // n.b. We ignore this error because we handle warning for this case in
+    // development in the `<Link>` component directly.
+    }
+    return {
+        params,
+        result: interpolatedRoute
+    };
+}
+//# sourceMappingURL=interpolate-as.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/shared/lib/router/utils/is-local-url.js ADDED Viewed

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "isLocalURL", {
+    enumerable: true,
+    get: function() {
+        return isLocalURL;
+    }
+});
+const _utils = require("../../utils");
+const _hasbasepath = require("../../../../client/has-base-path");
+function isLocalURL(url) {
+    // prevent a hydration mismatch on href for url with anchor refs
+    if (!(0, _utils.isAbsoluteUrl)(url)) return true;
+    try {
+        // absolute urls can be local if they are on the same origin
+        const locationOrigin = (0, _utils.getLocationOrigin)();
+        const resolved = new URL(url, locationOrigin);
+        return resolved.origin === locationOrigin && (0, _hasbasepath.hasBasePath)(resolved.pathname);
+    } catch (_) {
+        return false;
+    }
+}
+//# sourceMappingURL=is-local-url.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/shared/lib/router/utils/omit.js ADDED Viewed

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "omit", {
+    enumerable: true,
+    get: function() {
+        return omit;
+    }
+});
+function omit(object, keys) {
+    const omitted = {};
+    Object.keys(object).forEach((key)=>{
+        if (!keys.includes(key)) {
+            omitted[key] = object[key];
+        }
+    });
+    return omitted;
+}
+//# sourceMappingURL=omit.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/shared/lib/router/utils/resolve-rewrites.js ADDED Viewed

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return resolveRewrites;
+    }
+});
+const _pathmatch = require("./path-match");
+const _preparedestination = require("./prepare-destination");
+const _removetrailingslash = require("./remove-trailing-slash");
+const _normalizelocalepath = require("../../i18n/normalize-locale-path");
+const _removebasepath = require("../../../../client/remove-base-path");
+const _parserelativeurl = require("./parse-relative-url");
+function resolveRewrites(asPath, pages, rewrites, query, resolveHref, locales) {
+    let matchedPage = false;
+    let externalDest = false;
+    let parsedAs = (0, _parserelativeurl.parseRelativeUrl)(asPath);
+    let fsPathname = (0, _removetrailingslash.removeTrailingSlash)((0, _normalizelocalepath.normalizeLocalePath)((0, _removebasepath.removeBasePath)(parsedAs.pathname), locales).pathname);
+    let resolvedHref;
+    const handleRewrite = (rewrite)=>{
+        const matcher = (0, _pathmatch.getPathMatch)(rewrite.source + (process.env.__NEXT_TRAILING_SLASH ? '(/)?' : ''), {
+            removeUnnamedParams: true,
+            strict: true
+        });
+        let params = matcher(parsedAs.pathname);
+        if ((rewrite.has || rewrite.missing) && params) {
+            const hasParams = (0, _preparedestination.matchHas)({
+                headers: {
+                    host: document.location.hostname,
+                    'user-agent': navigator.userAgent
+                },
+                cookies: document.cookie.split('; ').reduce((acc, item)=>{
+                    const [key, ...value] = item.split('=');
+                    acc[key] = value.join('=');
+                    return acc;
+                }, {})
+            }, parsedAs.query, rewrite.has, rewrite.missing);
+            if (hasParams) {
+                Object.assign(params, hasParams);
+            } else {
+                params = false;
+            }
+        }
+        if (params) {
+            if (!rewrite.destination) {
+                // this is a proxied rewrite which isn't handled on the client
+                externalDest = true;
+                return true;
+            }
+            const destRes = (0, _preparedestination.prepareDestination)({
+                appendParamsToQuery: true,
+                destination: rewrite.destination,
+                params: params,
+                query: query
+            });
+            parsedAs = destRes.parsedDestination;
+            asPath = destRes.newUrl;
+            Object.assign(query, destRes.parsedDestination.query);
+            fsPathname = (0, _removetrailingslash.removeTrailingSlash)((0, _normalizelocalepath.normalizeLocalePath)((0, _removebasepath.removeBasePath)(asPath), locales).pathname);
+            if (pages.includes(fsPathname)) {
+                // check if we now match a page as this means we are done
+                // resolving the rewrites
+                matchedPage = true;
+                resolvedHref = fsPathname;
+                return true;
+            }
+            // check if we match a dynamic-route, if so we break the rewrites chain
+            resolvedHref = resolveHref(fsPathname);
+            if (resolvedHref !== asPath && pages.includes(resolvedHref)) {
+                matchedPage = true;
+                return true;
+            }
+        }
+    };
+    let finished = false;
+    for(let i = 0; i < rewrites.beforeFiles.length; i++){
+        // we don't end after match in beforeFiles to allow
+        // continuing through all beforeFiles rewrites
+        handleRewrite(rewrites.beforeFiles[i]);
+    }
+    matchedPage = pages.includes(fsPathname);
+    if (!matchedPage) {
+        if (!finished) {
+            for(let i = 0; i < rewrites.afterFiles.length; i++){
+                if (handleRewrite(rewrites.afterFiles[i])) {
+                    finished = true;
+                    break;
+                }
+            }
+        }
+        // check dynamic route before processing fallback rewrites
+        if (!finished) {
+            resolvedHref = resolveHref(fsPathname);
+            matchedPage = pages.includes(resolvedHref);
+            finished = matchedPage;
+        }
+        if (!finished) {
+            for(let i = 0; i < rewrites.fallback.length; i++){
+                if (handleRewrite(rewrites.fallback[i])) {
+                    finished = true;
+                    break;
+                }
+            }
+        }
+    }
+    return {
+        asPath,
+        parsedAs,
+        matchedPage,
+        resolvedHref,
+        externalDest
+    };
+}
+//# sourceMappingURL=resolve-rewrites.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/shared/lib/turbopack/compilation-events.js ADDED Viewed

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    backgroundLogCompilationEvents: null,
+    msToNs: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    backgroundLogCompilationEvents: function() {
+        return backgroundLogCompilationEvents;
+    },
+    msToNs: function() {
+        return msToNs;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _log = /*#__PURE__*/ _interop_require_wildcard._(require("../../../build/output/log"));
+const _trace = require("../../../trace");
+const _trace1 = require("../../../lib/memory/trace");
+const MILLISECONDS_IN_NANOSECOND = BigInt(1000000);
+function msToNs(ms) {
+    return BigInt(Math.floor(ms)) * MILLISECONDS_IN_NANOSECOND;
+}
+function backgroundLogCompilationEvents(project, { eventTypes, signal, parentSpan } = {}) {
+    const iterator = project.compilationEventsSubscribe(eventTypes);
+    // Close the iterator as soon as the signal fires so the for-await loop
+    // exits without waiting for the next compilation event.
+    signal?.addEventListener('abort', ()=>iterator.return?.(undefined), {
+        once: true
+    });
+    const promise = async function() {
+        for await (const event of iterator){
+            // Record TraceEvent compilation events as trace spans in .next/trace.
+            if (parentSpan && event.typeName === 'TraceEvent' && event.eventJson) {
+                try {
+                    const data = JSON.parse(event.eventJson);
+                    parentSpan.manualTraceChild(data.name, msToNs(data.startTimeMs), msToNs(data.endTimeMs), Object.fromEntries(data.attributes ?? []));
+                    (0, _trace1.traceMemoryUsage)(data.name, parentSpan);
+                    // We flush after each event to make sure it makes it to disk.  These events are rare and
+                    // tend to happen at the very end of a build so to make sure they are logged we need to
+                    // flush.
+                    // NOTE: in a `next build` environment where we are reporting events to the parent thread, this is a no-op.
+                    await (0, _trace.flushAllTraces)();
+                } catch  {}
+                continue; // don't log these events, they just go to the trace file
+            }
+            switch(event.severity){
+                case 'EVENT':
+                    _log.event(event.message);
+                    break;
+                case 'TRACE':
+                    _log.trace(event.message);
+                    break;
+                case 'INFO':
+                    _log.info(event.message);
+                    break;
+                case 'WARNING':
+                    _log.warn(event.message);
+                    break;
+                case 'ERROR':
+                    _log.error(event.message);
+                    break;
+                case 'FATAL':
+                    _log.error(event.message);
+                    break;
+                default:
+                    break;
+            }
+        }
+    }();
+    // Prevent unhandled rejection if the subscription errors after the project shuts down.
+    promise.catch(()=>{});
+    return promise;
+}
+//# sourceMappingURL=compilation-events.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/shared/lib/turbopack/entry-key.js ADDED Viewed

@@ -0,0 +1,39 @@
+/**
+ * `app` -> app dir
+ * `pages` -> pages dir
+ * `root` -> middleware / instrumentation
+ * `assets` -> assets
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    getEntryKey: null,
+    splitEntryKey: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getEntryKey: function() {
+        return getEntryKey;
+    },
+    splitEntryKey: function() {
+        return splitEntryKey;
+    }
+});
+function getEntryKey(type, side, page) {
+    return JSON.stringify({
+        type,
+        side,
+        page
+    });
+}
+function splitEntryKey(key) {
+    return JSON.parse(key);
+}
+//# sourceMappingURL=entry-key.js.map