@nogataka/cc-search 0.1.0

package/dist/standalone/node_modules/next/dist/client/components/navigation.react-server.js

@@ -0,0 +1,79 @@
+/** @internal */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    ReadonlyURLSearchParams: null,
+    RedirectType: null,
+    forbidden: null,
+    notFound: null,
+    permanentRedirect: null,
+    redirect: null,
+    unauthorized: null,
+    unstable_rethrow: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ReadonlyURLSearchParams: function() {
+        return ReadonlyURLSearchParams;
+    },
+    RedirectType: function() {
+        return _redirecterror.RedirectType;
+    },
+    forbidden: function() {
+        return _forbidden.forbidden;
+    },
+    notFound: function() {
+        return _notfound.notFound;
+    },
+    permanentRedirect: function() {
+        return _redirect.permanentRedirect;
+    },
+    redirect: function() {
+        return _redirect.redirect;
+    },
+    unauthorized: function() {
+        return _unauthorized.unauthorized;
+    },
+    unstable_rethrow: function() {
+        return _unstablerethrow.unstable_rethrow;
+    }
+});
+const _redirect = require("./redirect");
+const _redirecterror = require("./redirect-error");
+const _notfound = require("./not-found");
+const _forbidden = require("./forbidden");
+const _unauthorized = require("./unauthorized");
+const _unstablerethrow = require("./unstable-rethrow");
+class ReadonlyURLSearchParamsError extends Error {
+    constructor(){
+        super('Method unavailable on `ReadonlyURLSearchParams`. Read more: https://nextjs.org/docs/app/api-reference/functions/use-search-params#updating-searchparams');
+    }
+}
+class ReadonlyURLSearchParams extends URLSearchParams {
+    /** @deprecated Method unavailable on `ReadonlyURLSearchParams`. Read more: https://nextjs.org/docs/app/api-reference/functions/use-search-params#updating-searchparams */ append() {
+        throw new ReadonlyURLSearchParamsError();
+    }
+    /** @deprecated Method unavailable on `ReadonlyURLSearchParams`. Read more: https://nextjs.org/docs/app/api-reference/functions/use-search-params#updating-searchparams */ delete() {
+        throw new ReadonlyURLSearchParamsError();
+    }
+    /** @deprecated Method unavailable on `ReadonlyURLSearchParams`. Read more: https://nextjs.org/docs/app/api-reference/functions/use-search-params#updating-searchparams */ set() {
+        throw new ReadonlyURLSearchParamsError();
+    }
+    /** @deprecated Method unavailable on `ReadonlyURLSearchParams`. Read more: https://nextjs.org/docs/app/api-reference/functions/use-search-params#updating-searchparams */ sort() {
+        throw new ReadonlyURLSearchParamsError();
+    }
+}
+
+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=navigation.react-server.js.map

package/dist/standalone/node_modules/next/dist/client/components/noop-head.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return NoopHead;
+    }
+});
+function NoopHead() {
+    return null;
+}
+
+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=noop-head.js.map

package/dist/standalone/node_modules/next/dist/client/components/not-found-error.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return NotFound;
+    }
+});
+const _jsxruntime = require("react/jsx-runtime");
+const _errorfallback = require("./http-access-fallback/error-fallback");
+function NotFound() {
+    return /*#__PURE__*/ (0, _jsxruntime.jsx)(_errorfallback.HTTPAccessErrorFallback, {
+        status: 404,
+        message: "This page could not be found."
+    });
+}
+
+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=not-found-error.js.map

package/dist/standalone/node_modules/next/dist/client/components/not-found.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "notFound", {
+    enumerable: true,
+    get: function() {
+        return notFound;
+    }
+});
+const _httpaccessfallback = require("./http-access-fallback/http-access-fallback");
+/**
+ * This function allows you to render the [not-found.js file](https://nextjs.org/docs/app/api-reference/file-conventions/not-found)
+ * within a route segment as well as inject a tag.
+ *
+ * `notFound()` can be used in
+ * [Server Components](https://nextjs.org/docs/app/building-your-application/rendering/server-components),
+ * [Route Handlers](https://nextjs.org/docs/app/building-your-application/routing/route-handlers), and
+ * [Server Actions](https://nextjs.org/docs/app/building-your-application/data-fetching/server-actions-and-mutations).
+ *
+ * - In a Server Component, this will insert a `<meta name="robots" content="noindex" />` meta tag and set the status code to 404.
+ * - In a Route Handler or Server Action, it will serve a 404 to the caller.
+ *
+ * Read more: [Next.js Docs: `notFound`](https://nextjs.org/docs/app/api-reference/functions/not-found)
+ */ const DIGEST = "" + _httpaccessfallback.HTTP_ERROR_FALLBACK_ERROR_CODE + ";404";
+function notFound() {
+    // eslint-disable-next-line no-throw-literal
+    const error = Object.defineProperty(new Error(DIGEST), "__NEXT_ERROR_CODE", {
+        value: "E394",
+        enumerable: false,
+        configurable: true
+    });
+    error.digest = DIGEST;
+    throw 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=not-found.js.map

package/dist/standalone/node_modules/next/dist/client/components/parallel-route-default.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    PARALLEL_ROUTE_DEFAULT_PATH: null,
+    default: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    PARALLEL_ROUTE_DEFAULT_PATH: function() {
+        return PARALLEL_ROUTE_DEFAULT_PATH;
+    },
+    default: function() {
+        return ParallelRouteDefault;
+    }
+});
+const _notfound = require("./not-found");
+const PARALLEL_ROUTE_DEFAULT_PATH = 'next/dist/client/components/parallel-route-default.js';
+function ParallelRouteDefault() {
+    (0, _notfound.notFound)();
+}
+
+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=parallel-route-default.js.map

package/dist/standalone/node_modules/next/dist/client/components/promise-queue.js

@@ -0,0 +1,91 @@
+/*
+    This is a simple promise queue that allows you to limit the number of concurrent promises
+    that are running at any given time. It's used to limit the number of concurrent
+    prefetch requests that are being made to the server but could be used for other
+    things as well.
+*/ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "PromiseQueue", {
+    enumerable: true,
+    get: function() {
+        return PromiseQueue;
+    }
+});
+const _class_private_field_loose_base = require("@swc/helpers/_/_class_private_field_loose_base");
+const _class_private_field_loose_key = require("@swc/helpers/_/_class_private_field_loose_key");
+var _maxConcurrency = /*#__PURE__*/ _class_private_field_loose_key._("_maxConcurrency"), _runningCount = /*#__PURE__*/ _class_private_field_loose_key._("_runningCount"), _queue = /*#__PURE__*/ _class_private_field_loose_key._("_queue"), _processNext = /*#__PURE__*/ _class_private_field_loose_key._("_processNext");
+class PromiseQueue {
+    enqueue(promiseFn) {
+        let taskResolve;
+        let taskReject;
+        const taskPromise = new Promise((resolve, reject)=>{
+            taskResolve = resolve;
+            taskReject = reject;
+        });
+        const task = async ()=>{
+            try {
+                _class_private_field_loose_base._(this, _runningCount)[_runningCount]++;
+                const result = await promiseFn();
+                taskResolve(result);
+            } catch (error) {
+                taskReject(error);
+            } finally{
+                _class_private_field_loose_base._(this, _runningCount)[_runningCount]--;
+                _class_private_field_loose_base._(this, _processNext)[_processNext]();
+            }
+        };
+        const enqueueResult = {
+            promiseFn: taskPromise,
+            task
+        };
+        // wonder if we should take a LIFO approach here
+        _class_private_field_loose_base._(this, _queue)[_queue].push(enqueueResult);
+        _class_private_field_loose_base._(this, _processNext)[_processNext]();
+        return taskPromise;
+    }
+    bump(promiseFn) {
+        const index = _class_private_field_loose_base._(this, _queue)[_queue].findIndex((item)=>item.promiseFn === promiseFn);
+        if (index > -1) {
+            const bumpedItem = _class_private_field_loose_base._(this, _queue)[_queue].splice(index, 1)[0];
+            _class_private_field_loose_base._(this, _queue)[_queue].unshift(bumpedItem);
+            _class_private_field_loose_base._(this, _processNext)[_processNext](true);
+        }
+    }
+    constructor(maxConcurrency = 5){
+        Object.defineProperty(this, _processNext, {
+            value: processNext
+        });
+        Object.defineProperty(this, _maxConcurrency, {
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, _runningCount, {
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, _queue, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_loose_base._(this, _maxConcurrency)[_maxConcurrency] = maxConcurrency;
+        _class_private_field_loose_base._(this, _runningCount)[_runningCount] = 0;
+        _class_private_field_loose_base._(this, _queue)[_queue] = [];
+    }
+}
+function processNext(forced) {
+    if (forced === void 0) forced = false;
+    if ((_class_private_field_loose_base._(this, _runningCount)[_runningCount] < _class_private_field_loose_base._(this, _maxConcurrency)[_maxConcurrency] || forced) && _class_private_field_loose_base._(this, _queue)[_queue].length > 0) {
+        var _class_private_field_loose_base__queue_shift;
+        (_class_private_field_loose_base__queue_shift = _class_private_field_loose_base._(this, _queue)[_queue].shift()) == null ? void 0 : _class_private_field_loose_base__queue_shift.task();
+    }
+}
+
+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-queue.js.map

package/dist/standalone/node_modules/next/dist/client/components/react-dev-overlay/app/app-dev-overlay-error-boundary.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "AppDevOverlayErrorBoundary", {
+    enumerable: true,
+    get: function() {
+        return AppDevOverlayErrorBoundary;
+    }
+});
+const _jsxruntime = require("react/jsx-runtime");
+const _react = require("react");
+const _runtimeerrorhandler = require("../../errors/runtime-error-handler");
+const _errorboundary = require("../../error-boundary");
+function ErroredHtml(param) {
+    let { globalError: [GlobalError, globalErrorStyles], error } = param;
+    if (!error) {
+        return /*#__PURE__*/ (0, _jsxruntime.jsxs)("html", {
+            children: [
+                /*#__PURE__*/ (0, _jsxruntime.jsx)("head", {}),
+                /*#__PURE__*/ (0, _jsxruntime.jsx)("body", {})
+            ]
+        });
+    }
+    return /*#__PURE__*/ (0, _jsxruntime.jsxs)(_errorboundary.ErrorBoundary, {
+        errorComponent: _errorboundary.GlobalError,
+        children: [
+            globalErrorStyles,
+            /*#__PURE__*/ (0, _jsxruntime.jsx)(GlobalError, {
+                error: error
+            })
+        ]
+    });
+}
+class AppDevOverlayErrorBoundary extends _react.PureComponent {
+    static getDerivedStateFromError(error) {
+        if (!error.stack) {
+            return {
+                isReactError: false,
+                reactError: null
+            };
+        }
+        _runtimeerrorhandler.RuntimeErrorHandler.hadRuntimeError = true;
+        return {
+            isReactError: true,
+            reactError: error
+        };
+    }
+    componentDidCatch() {
+        this.props.onError(this.state.isReactError);
+    }
+    render() {
+        const { children, globalError } = this.props;
+        const { isReactError, reactError } = this.state;
+        const fallback = /*#__PURE__*/ (0, _jsxruntime.jsx)(ErroredHtml, {
+            globalError: globalError,
+            error: reactError
+        });
+        return isReactError ? fallback : children;
+    }
+    constructor(...args){
+        super(...args), this.state = {
+            isReactError: false,
+            reactError: null
+        };
+    }
+}
+
+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=app-dev-overlay-error-boundary.js.map

package/dist/standalone/node_modules/next/dist/client/components/react-dev-overlay/app/app-dev-overlay.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "AppDevOverlay", {
+    enumerable: true,
+    get: function() {
+        return AppDevOverlay;
+    }
+});
+const _jsxruntime = require("react/jsx-runtime");
+const _react = require("react");
+const _appdevoverlayerrorboundary = require("./app-dev-overlay-error-boundary");
+const _fontstyles = require("../font/font-styles");
+const _devoverlay = require("../ui/dev-overlay");
+const _useerrorhandler = require("../../errors/use-error-handler");
+const _isnextroutererror = require("../../is-next-router-error");
+const _constants = require("../../../../shared/lib/errors/constants");
+function readSsrError() {
+    if (typeof document === 'undefined') {
+        return null;
+    }
+    const ssrErrorTemplateTag = document.querySelector('template[data-next-error-message]');
+    if (ssrErrorTemplateTag) {
+        const message = ssrErrorTemplateTag.getAttribute('data-next-error-message');
+        const stack = ssrErrorTemplateTag.getAttribute('data-next-error-stack');
+        const digest = ssrErrorTemplateTag.getAttribute('data-next-error-digest');
+        const error = Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
+            value: "E394",
+            enumerable: false,
+            configurable: true
+        });
+        if (digest) {
+            ;
+            error.digest = digest;
+        }
+        // Skip Next.js SSR'd internal errors that which will be handled by the error boundaries.
+        if ((0, _isnextroutererror.isNextRouterError)(error)) {
+            return null;
+        }
+        error.stack = stack || '';
+        return error;
+    }
+    return null;
+}
+// Needs to be in the same error boundary as the shell.
+// If it commits, we know we recovered from an SSR error.
+// If it doesn't commit, we errored again and React will take care of error reporting.
+function ReplaySsrOnlyErrors(param) {
+    let { onBlockingError } = param;
+    if (process.env.NODE_ENV !== 'production') {
+        // Need to read during render. The attributes will be gone after commit.
+        const ssrError = readSsrError();
+        // eslint-disable-next-line react-hooks/rules-of-hooks
+        (0, _react.useEffect)(()=>{
+            if (ssrError !== null) {
+                // TODO(veil): Produces wrong Owner Stack
+                // TODO(veil): Mark as recoverable error
+                // TODO(veil): console.error
+                (0, _useerrorhandler.handleClientError)(ssrError);
+                // If it's missing root tags, we can't recover, make it blocking.
+                if (ssrError.digest === _constants.MISSING_ROOT_TAGS_ERROR) {
+                    onBlockingError();
+                }
+            }
+        }, [
+            ssrError,
+            onBlockingError
+        ]);
+    }
+    return null;
+}
+function AppDevOverlay(param) {
+    let { state, globalError, children } = param;
+    const [isErrorOverlayOpen, setIsErrorOverlayOpen] = (0, _react.useState)(false);
+    const openOverlay = (0, _react.useCallback)(()=>{
+        setIsErrorOverlayOpen(true);
+    }, []);
+    return /*#__PURE__*/ (0, _jsxruntime.jsxs)(_jsxruntime.Fragment, {
+        children: [
+            /*#__PURE__*/ (0, _jsxruntime.jsxs)(_appdevoverlayerrorboundary.AppDevOverlayErrorBoundary, {
+                globalError: globalError,
+                onError: setIsErrorOverlayOpen,
+                children: [
+                    /*#__PURE__*/ (0, _jsxruntime.jsx)(ReplaySsrOnlyErrors, {
+                        onBlockingError: openOverlay
+                    }),
+                    children
+                ]
+            }),
+            /*#__PURE__*/ (0, _jsxruntime.jsxs)(_jsxruntime.Fragment, {
+                children: [
+                    /*#__PURE__*/ (0, _jsxruntime.jsx)(_fontstyles.FontStyles, {}),
+                    /*#__PURE__*/ (0, _jsxruntime.jsx)(_devoverlay.DevOverlay, {
+                        state: state,
+                        isErrorOverlayOpen: isErrorOverlayOpen,
+                        setIsErrorOverlayOpen: setIsErrorOverlayOpen
+                    })
+                ]
+            })
+        ]
+    });
+}
+
+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=app-dev-overlay.js.map