qalita 2.3.2__py3-none-any.whl → 2.5.3__py3-none-any.whl

qalita/_frontend/node_modules/next/dist/lib/picocolors.js

@@ -0,0 +1,177 @@
+// ISC License
+// Copyright (c) 2021 Alexey Raspopov, Kostiantyn Denysov, Anton Verinov
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+//
+// https://github.com/alexeyraspopov/picocolors/blob/b6261487e7b81aaab2440e397a356732cad9e342/picocolors.js#L1
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    bgBlack: null,
+    bgBlue: null,
+    bgCyan: null,
+    bgGreen: null,
+    bgMagenta: null,
+    bgRed: null,
+    bgWhite: null,
+    bgYellow: null,
+    black: null,
+    blue: null,
+    bold: null,
+    cyan: null,
+    dim: null,
+    gray: null,
+    green: null,
+    hidden: null,
+    inverse: null,
+    italic: null,
+    magenta: null,
+    purple: null,
+    red: null,
+    reset: null,
+    strikethrough: null,
+    underline: null,
+    white: null,
+    yellow: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    bgBlack: function() {
+        return bgBlack;
+    },
+    bgBlue: function() {
+        return bgBlue;
+    },
+    bgCyan: function() {
+        return bgCyan;
+    },
+    bgGreen: function() {
+        return bgGreen;
+    },
+    bgMagenta: function() {
+        return bgMagenta;
+    },
+    bgRed: function() {
+        return bgRed;
+    },
+    bgWhite: function() {
+        return bgWhite;
+    },
+    bgYellow: function() {
+        return bgYellow;
+    },
+    black: function() {
+        return black;
+    },
+    blue: function() {
+        return blue;
+    },
+    bold: function() {
+        return bold;
+    },
+    cyan: function() {
+        return cyan;
+    },
+    dim: function() {
+        return dim;
+    },
+    gray: function() {
+        return gray;
+    },
+    green: function() {
+        return green;
+    },
+    hidden: function() {
+        return hidden;
+    },
+    inverse: function() {
+        return inverse;
+    },
+    italic: function() {
+        return italic;
+    },
+    magenta: function() {
+        return magenta;
+    },
+    purple: function() {
+        return purple;
+    },
+    red: function() {
+        return red;
+    },
+    reset: function() {
+        return reset;
+    },
+    strikethrough: function() {
+        return strikethrough;
+    },
+    underline: function() {
+        return underline;
+    },
+    white: function() {
+        return white;
+    },
+    yellow: function() {
+        return yellow;
+    }
+});
+var _globalThis;
+const { env, stdout } = ((_globalThis = globalThis) == null ? void 0 : _globalThis.process) ?? {};
+const enabled = env && !env.NO_COLOR && (env.FORCE_COLOR || (stdout == null ? void 0 : stdout.isTTY) && !env.CI && env.TERM !== 'dumb');
+const replaceClose = (str, close, replace, index)=>{
+    const start = str.substring(0, index) + replace;
+    const end = str.substring(index + close.length);
+    const nextIndex = end.indexOf(close);
+    return ~nextIndex ? start + replaceClose(end, close, replace, nextIndex) : start + end;
+};
+const formatter = (open, close, replace = open)=>{
+    if (!enabled) return String;
+    return (input)=>{
+        const string = '' + input;
+        const index = string.indexOf(close, open.length);
+        return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+    };
+};
+const reset = enabled ? (s)=>`\x1b[0m${s}\x1b[0m` : String;
+const bold = formatter('\x1b[1m', '\x1b[22m', '\x1b[22m\x1b[1m');
+const dim = formatter('\x1b[2m', '\x1b[22m', '\x1b[22m\x1b[2m');
+const italic = formatter('\x1b[3m', '\x1b[23m');
+const underline = formatter('\x1b[4m', '\x1b[24m');
+const inverse = formatter('\x1b[7m', '\x1b[27m');
+const hidden = formatter('\x1b[8m', '\x1b[28m');
+const strikethrough = formatter('\x1b[9m', '\x1b[29m');
+const black = formatter('\x1b[30m', '\x1b[39m');
+const red = formatter('\x1b[31m', '\x1b[39m');
+const green = formatter('\x1b[32m', '\x1b[39m');
+const yellow = formatter('\x1b[33m', '\x1b[39m');
+const blue = formatter('\x1b[34m', '\x1b[39m');
+const magenta = formatter('\x1b[35m', '\x1b[39m');
+const purple = formatter('\x1b[38;2;173;127;168m', '\x1b[39m');
+const cyan = formatter('\x1b[36m', '\x1b[39m');
+const white = formatter('\x1b[37m', '\x1b[39m');
+const gray = formatter('\x1b[90m', '\x1b[39m');
+const bgBlack = formatter('\x1b[40m', '\x1b[49m');
+const bgRed = formatter('\x1b[41m', '\x1b[49m');
+const bgGreen = formatter('\x1b[42m', '\x1b[49m');
+const bgYellow = formatter('\x1b[43m', '\x1b[49m');
+const bgBlue = formatter('\x1b[44m', '\x1b[49m');
+const bgMagenta = formatter('\x1b[45m', '\x1b[49m');
+const bgCyan = formatter('\x1b[46m', '\x1b[49m');
+const bgWhite = formatter('\x1b[47m', '\x1b[49m');
+
+//# sourceMappingURL=picocolors.js.map

qalita/_frontend/node_modules/next/dist/lib/pretty-bytes.js

@@ -0,0 +1,74 @@
+/*
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return prettyBytes;
+    }
+});
+const UNITS = [
+    'B',
+    'kB',
+    'MB',
+    'GB',
+    'TB',
+    'PB',
+    'EB',
+    'ZB',
+    'YB'
+];
+/*
+Formats the given number using `Number#toLocaleString`.
+- If locale is a string, the value is expected to be a locale-key (for example: `de`).
+- If locale is true, the system default locale is used for translation.
+- If no value for locale is specified, the number is returned unmodified.
+*/ const toLocaleString = (number, locale)=>{
+    let result = number;
+    if (typeof locale === 'string') {
+        result = number.toLocaleString(locale);
+    } else if (locale === true) {
+        result = number.toLocaleString();
+    }
+    return result;
+};
+function prettyBytes(number, options) {
+    if (!Number.isFinite(number)) {
+        throw Object.defineProperty(new TypeError(`Expected a finite number, got ${typeof number}: ${number}`), "__NEXT_ERROR_CODE", {
+            value: "E572",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    options = Object.assign({}, options);
+    if (options.signed && number === 0) {
+        return ' 0 B';
+    }
+    const isNegative = number < 0;
+    const prefix = isNegative ? '-' : options.signed ? '+' : '';
+    if (isNegative) {
+        number = -number;
+    }
+    if (number < 1) {
+        const numberString = toLocaleString(number, options.locale);
+        return prefix + numberString + ' B';
+    }
+    const exponent = Math.min(Math.floor(Math.log10(number) / 3), UNITS.length - 1);
+    number = Number((number / Math.pow(1000, exponent)).toPrecision(3));
+    const numberString = toLocaleString(number, options.locale);
+    const unit = UNITS[exponent];
+    return prefix + numberString + ' ' + unit;
+}
+
+//# sourceMappingURL=pretty-bytes.js.map

qalita/_frontend/node_modules/next/dist/lib/realpath.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "realpathSync", {
+    enumerable: true,
+    get: function() {
+        return realpathSync;
+    }
+});
+const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const isWindows = process.platform === 'win32';
+const realpathSync = isWindows ? _fs.default.realpathSync : _fs.default.realpathSync.native;
+
+//# sourceMappingURL=realpath.js.map

qalita/_frontend/node_modules/next/dist/lib/recursive-copy.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "recursiveCopy", {
+    enumerable: true,
+    get: function() {
+        return recursiveCopy;
+    }
+});
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _fs = require("fs");
+const _asyncsema = require("next/dist/compiled/async-sema");
+const _iserror = /*#__PURE__*/ _interop_require_default(require("./is-error"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const COPYFILE_EXCL = _fs.constants.COPYFILE_EXCL;
+async function recursiveCopy(source, dest, { concurrency = 32, overwrite = false, filter = ()=>true } = {}) {
+    const cwdPath = process.cwd();
+    const from = _path.default.resolve(cwdPath, source);
+    const to = _path.default.resolve(cwdPath, dest);
+    const sema = new _asyncsema.Sema(concurrency);
+    // deep copy the file/directory
+    async function _copy(item, lstats) {
+        const target = item.replace(from, to);
+        await sema.acquire();
+        if (!lstats) {
+            // after lock on first run
+            lstats = await _fs.promises.lstat(from);
+        }
+        // readdir & lstat do not follow symbolic links
+        // if part is a symbolic link, follow it with stat
+        let isFile = lstats.isFile();
+        let isDirectory = lstats.isDirectory();
+        if (lstats.isSymbolicLink()) {
+            const stats = await _fs.promises.stat(item);
+            isFile = stats.isFile();
+            isDirectory = stats.isDirectory();
+        }
+        if (isDirectory) {
+            try {
+                await _fs.promises.mkdir(target, {
+                    recursive: true
+                });
+            } catch (err) {
+                // do not throw `folder already exists` errors
+                if ((0, _iserror.default)(err) && err.code !== 'EEXIST') {
+                    throw err;
+                }
+            }
+            sema.release();
+            const files = await _fs.promises.readdir(item, {
+                withFileTypes: true
+            });
+            await Promise.all(files.map((file)=>_copy(_path.default.join(item, file.name), file)));
+        } else if (isFile && // before we send the path to filter
+        // we remove the base path (from) and replace \ by / (windows)
+        filter(item.replace(from, '').replace(/\\/g, '/'))) {
+            await _fs.promises.copyFile(item, target, overwrite ? undefined : COPYFILE_EXCL).catch((err)=>{
+                // if overwrite is false we shouldn't fail on EEXIST
+                if (err.code !== 'EEXIST') {
+                    throw err;
+                }
+            });
+            sema.release();
+        } else {
+            sema.release();
+        }
+    }
+    await _copy(from);
+}
+
+//# sourceMappingURL=recursive-copy.js.map

qalita/_frontend/node_modules/next/dist/lib/recursive-delete.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    calcBackoffMs: null,
+    recursiveDeleteSyncWithAsyncRetries: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    calcBackoffMs: function() {
+        return calcBackoffMs;
+    },
+    recursiveDeleteSyncWithAsyncRetries: function() {
+        return recursiveDeleteSyncWithAsyncRetries;
+    }
+});
+const _nodefs = /*#__PURE__*/ _interop_require_wildcard(require("node:fs"));
+const _nodepath = require("node:path");
+const _iserror = /*#__PURE__*/ _interop_require_default(require("./is-error"));
+const _wait = require("./wait");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+// We use an exponential backoff. See the unit test for example values.
+//
+// - Node's `fs` module uses a linear backoff, starting with 100ms.
+// - Rust tries 64 times with only a `thread::yield_now` in between.
+//
+// We want something more aggressive, as `recursiveDelete` is in the critical
+// path of `next dev` and `next build` startup.
+const INITIAL_RETRY_MS = 8;
+const MAX_RETRY_MS = 64;
+const MAX_RETRIES = 6;
+function calcBackoffMs(attempt) {
+    return Math.min(INITIAL_RETRY_MS * Math.pow(2, attempt), MAX_RETRY_MS);
+}
+function unlinkPath(p, isDir = false, attempt = 0) {
+    try {
+        if (isDir) {
+            _nodefs.rmdirSync(p);
+        } else {
+            _nodefs.unlinkSync(p);
+        }
+    } catch (e) {
+        const code = (0, _iserror.default)(e) && e.code;
+        if ((code === 'EBUSY' || code === 'ENOTEMPTY' || code === 'EPERM' || code === 'EMFILE') && attempt < MAX_RETRIES) {
+            // retrying is unlikely to succeed on POSIX platforms, but Windows can
+            // fail due to temporarily-open files
+            return (async ()=>{
+                await (0, _wait.wait)(calcBackoffMs(attempt));
+                return unlinkPath(p, isDir, attempt + 1);
+            })();
+        }
+        if (code === 'ENOENT') {
+            return;
+        }
+        throw e;
+    }
+}
+async function recursiveDeleteSyncWithAsyncRetries(/** Directory to delete the contents of */ dir, /** Exclude based on relative file path */ exclude, /** Relative path to the directory being deleted, used for exclude */ previousPath = '') {
+    let result;
+    try {
+        result = _nodefs.readdirSync(dir, {
+            withFileTypes: true
+        });
+    } catch (e) {
+        if ((0, _iserror.default)(e) && e.code === 'ENOENT') {
+            return;
+        }
+        throw e;
+    }
+    await Promise.all(result.map(async (part)=>{
+        const absolutePath = (0, _nodepath.join)(dir, part.name);
+        const pp = (0, _nodepath.join)(previousPath, part.name);
+        const isNotExcluded = !exclude || !exclude.test(pp);
+        if (isNotExcluded) {
+            // Note: readdir does not follow symbolic links, that's good: we want to
+            // delete the links and not the destination.
+            let isDirectory = part.isDirectory();
+            if (isDirectory) {
+                await recursiveDeleteSyncWithAsyncRetries(absolutePath, exclude, pp);
+            }
+            return unlinkPath(absolutePath, isDirectory);
+        }
+    }));
+}
+
+//# sourceMappingURL=recursive-delete.js.map

qalita/_frontend/node_modules/next/dist/lib/recursive-readdir.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "recursiveReadDir", {
+    enumerable: true,
+    get: function() {
+        return recursiveReadDir;
+    }
+});
+const _promises = /*#__PURE__*/ _interop_require_default(require("fs/promises"));
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+async function recursiveReadDir(rootDirectory, options = {}) {
+    // Grab our options.
+    const { pathnameFilter, ignoreFilter, ignorePartFilter, sortPathnames = true, relativePathnames = true } = options;
+    // The list of pathnames to return.
+    const pathnames = [];
+    /**
+   * Coerces the pathname to be relative if requested.
+   */ const coerce = relativePathnames ? (pathname)=>pathname.replace(rootDirectory, '') : (pathname)=>pathname;
+    // The queue of directories to scan.
+    let directories = [
+        rootDirectory
+    ];
+    while(directories.length > 0){
+        // Load all the files in each directory at the same time.
+        const results = await Promise.all(directories.map(async (directory)=>{
+            const result = {
+                directories: [],
+                pathnames: [],
+                links: []
+            };
+            try {
+                const dir = await _promises.default.readdir(directory, {
+                    withFileTypes: true
+                });
+                for (const file of dir){
+                    // If enabled, ignore the file if it matches the ignore filter.
+                    if (ignorePartFilter && ignorePartFilter(file.name)) {
+                        continue;
+                    }
+                    // Handle each file.
+                    const absolutePathname = _path.default.join(directory, file.name);
+                    // If enabled, ignore the file if it matches the ignore filter.
+                    if (ignoreFilter && ignoreFilter(absolutePathname)) {
+                        continue;
+                    }
+                    // If the file is a directory, then add it to the list of directories,
+                    // they'll be scanned on a later pass.
+                    if (file.isDirectory()) {
+                        result.directories.push(absolutePathname);
+                    } else if (file.isSymbolicLink()) {
+                        result.links.push(absolutePathname);
+                    } else if (!pathnameFilter || pathnameFilter(absolutePathname)) {
+                        result.pathnames.push(coerce(absolutePathname));
+                    }
+                }
+            } catch (err) {
+                // This can only happen when the underlying directory was removed. If
+                // anything other than this error occurs, re-throw it.
+                // if (err.code !== 'ENOENT') throw err
+                if (err.code !== 'ENOENT' || directory === rootDirectory) throw err;
+                // The error occurred, so abandon reading this directory.
+                return null;
+            }
+            return result;
+        }));
+        // Empty the directories, we'll fill it later if some of the files are
+        // directories.
+        directories = [];
+        // Keep track of any symbolic links we find, we'll resolve them later.
+        const links = [];
+        // For each result of directory scans...
+        for (const result of results){
+            // If the directory was removed, then skip it.
+            if (!result) continue;
+            // Add any directories to the list of directories to scan.
+            directories.push(...result.directories);
+            // Add any symbolic links to the list of symbolic links to resolve.
+            links.push(...result.links);
+            // Add any file pathnames to the list of pathnames.
+            pathnames.push(...result.pathnames);
+        }
+        // Resolve all the symbolic links we found if any.
+        if (links.length > 0) {
+            const resolved = await Promise.all(links.map(async (absolutePathname)=>{
+                try {
+                    return await _promises.default.stat(absolutePathname);
+                } catch (err) {
+                    // This can only happen when the underlying link was removed. If
+                    // anything other than this error occurs, re-throw it.
+                    if (err.code !== 'ENOENT') throw err;
+                    // The error occurred, so abandon reading this directory.
+                    return null;
+                }
+            }));
+            for(let i = 0; i < links.length; i++){
+                const stats = resolved[i];
+                // If the link was removed, then skip it.
+                if (!stats) continue;
+                // We would have already ignored the file if it matched the ignore
+                // filter, so we don't need to check it again.
+                const absolutePathname = links[i];
+                if (stats.isDirectory()) {
+                    directories.push(absolutePathname);
+                } else if (!pathnameFilter || pathnameFilter(absolutePathname)) {
+                    pathnames.push(coerce(absolutePathname));
+                }
+            }
+        }
+    }
+    // Sort the pathnames in place if requested.
+    if (sortPathnames) {
+        pathnames.sort();
+    }
+    return pathnames;
+}
+
+//# sourceMappingURL=recursive-readdir.js.map

qalita/_frontend/node_modules/next/dist/lib/redirect-status.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    allowedStatusCodes: null,
+    getRedirectStatus: null,
+    modifyRouteRegex: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    allowedStatusCodes: function() {
+        return allowedStatusCodes;
+    },
+    getRedirectStatus: function() {
+        return getRedirectStatus;
+    },
+    modifyRouteRegex: function() {
+        return modifyRouteRegex;
+    }
+});
+const _redirectstatuscode = require("../client/components/redirect-status-code");
+const allowedStatusCodes = new Set([
+    301,
+    302,
+    303,
+    307,
+    308
+]);
+function getRedirectStatus(route) {
+    return route.statusCode || (route.permanent ? _redirectstatuscode.RedirectStatusCode.PermanentRedirect : _redirectstatuscode.RedirectStatusCode.TemporaryRedirect);
+}
+function modifyRouteRegex(regex, restrictedPaths) {
+    if (restrictedPaths) {
+        regex = regex.replace(/\^/, `^(?!${restrictedPaths.map((path)=>path.replace(/\//g, '\\/')).join('|')})`);
+    }
+    regex = regex.replace(/\$$/, '(?:\\/)?$');
+    return regex;
+}
+
+//# sourceMappingURL=redirect-status.js.map

qalita/_frontend/node_modules/next/dist/lib/require-instrumentation-client.js

@@ -0,0 +1,26 @@
+/**
+ * This module imports the client instrumentation hook from the project root.
+ *
+ * The `private-next-instrumentation-client` module is automatically aliased to
+ * the `instrumentation-client.ts` file in the project root by webpack or turbopack.
+ */ "use strict";
+if (process.env.NODE_ENV === 'development') {
+    const measureName = 'Client Instrumentation Hook';
+    const startTime = performance.now();
+    // eslint-disable-next-line @next/internal/typechecked-require -- Not a module.
+    module.exports = require('private-next-instrumentation-client');
+    const endTime = performance.now();
+    const duration = endTime - startTime;
+    // Using 16ms threshold as it represents one frame (1000ms/60fps)
+    // This helps identify if the instrumentation hook initialization
+    // could potentially cause frame drops during development.
+    const THRESHOLD = 16;
+    if (duration > THRESHOLD) {
+        console.log(`[${measureName}] Slow execution detected: ${duration.toFixed(0)}ms (Note: Code download overhead is not included in this measurement)`);
+    }
+} else {
+    // eslint-disable-next-line @next/internal/typechecked-require -- Not a module.
+    module.exports = require('private-next-instrumentation-client');
+}
+
+//# sourceMappingURL=require-instrumentation-client.js.map