@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/shared/lib/bloom-filter.js

@@ -0,0 +1,85 @@
+// minimal implementation MurmurHash2 hash function
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "BloomFilter", {
+    enumerable: true,
+    get: function() {
+        return BloomFilter;
+    }
+});
+function murmurhash2(str) {
+    let h = 0;
+    for(let i = 0; i < str.length; i++){
+        const c = str.charCodeAt(i);
+        h = Math.imul(h ^ c, 0x5bd1e995);
+        h ^= h >>> 13;
+        h = Math.imul(h, 0x5bd1e995);
+    }
+    return h >>> 0;
+}
+// default to 0.01% error rate as the filter compresses very well
+const DEFAULT_ERROR_RATE = 0.0001;
+class BloomFilter {
+    constructor(numItems, errorRate = DEFAULT_ERROR_RATE){
+        this.numItems = numItems;
+        this.errorRate = errorRate;
+        this.numBits = Math.ceil(-(numItems * Math.log(errorRate)) / (Math.log(2) * Math.log(2)));
+        this.numHashes = Math.ceil(this.numBits / numItems * Math.log(2));
+        this.bitArray = new Array(this.numBits).fill(0);
+    }
+    static from(items, errorRate = DEFAULT_ERROR_RATE) {
+        const filter = new BloomFilter(items.length, errorRate);
+        for (const item of items){
+            filter.add(item);
+        }
+        return filter;
+    }
+    export() {
+        const data = {
+            numItems: this.numItems,
+            errorRate: this.errorRate,
+            numBits: this.numBits,
+            numHashes: this.numHashes,
+            bitArray: this.bitArray
+        };
+        if (process.env.NEXT_RUNTIME === 'nodejs') {
+            if (this.errorRate < DEFAULT_ERROR_RATE) {
+                const filterData = JSON.stringify(data);
+                const gzipSize = require('next/dist/compiled/gzip-size').sync(filterData);
+                if (gzipSize > 1024) {
+                    console.warn(`Creating filter with error rate less than 0.1% (0.001) can increase the size dramatically proceed with caution. Received error rate ${this.errorRate} resulted in size ${filterData.length} bytes, ${gzipSize} bytes (gzip)`);
+                }
+            }
+        }
+        return data;
+    }
+    import(data) {
+        this.numItems = data.numItems;
+        this.errorRate = data.errorRate;
+        this.numBits = data.numBits;
+        this.numHashes = data.numHashes;
+        this.bitArray = data.bitArray;
+    }
+    add(item) {
+        const hashValues = this.getHashValues(item);
+        hashValues.forEach((hash)=>{
+            this.bitArray[hash] = 1;
+        });
+    }
+    contains(item) {
+        const hashValues = this.getHashValues(item);
+        return hashValues.every((hash)=>this.bitArray[hash]);
+    }
+    getHashValues(item) {
+        const hashValues = [];
+        for(let i = 1; i <= this.numHashes; i++){
+            const hash = murmurhash2(`${item}${i}`) % this.numBits;
+            hashValues.push(hash);
+        }
+        return hashValues;
+    }
+}
+
+//# sourceMappingURL=bloom-filter.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/format-webpack-messages.js

@@ -0,0 +1,184 @@
+/**
+MIT License
+
+Copyright (c) 2015-present, Facebook, Inc.
+
+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 formatWebpackMessages;
+    }
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _stripansi = /*#__PURE__*/ _interop_require_default._(require("next/dist/compiled/strip-ansi"));
+// This file is based on https://github.com/facebook/create-react-app/blob/7b1a32be6ec9f99a6c9a3c66813f3ac09c4736b9/packages/react-dev-utils/formatWebpackMessages.js
+// It's been edited to remove chalk and CRA-specific logic
+const friendlySyntaxErrorLabel = 'Syntax error:';
+const WEBPACK_BREAKING_CHANGE_POLYFILLS = '\n\nBREAKING CHANGE: webpack < 5 used to include polyfills for node.js core modules by default.';
+function isLikelyASyntaxError(message) {
+    return (0, _stripansi.default)(message).includes(friendlySyntaxErrorLabel);
+}
+let hadMissingSassError = false;
+// Cleans up webpack error messages.
+function formatMessage(message, verbose, importTraceNote) {
+    // TODO: Replace this once webpack 5 is stable
+    if (typeof message === 'object' && message.message) {
+        const filteredModuleTrace = message.moduleTrace && message.moduleTrace.filter((trace)=>!/next-(middleware|client-pages|route|edge-function)-loader\.js/.test(trace.originName));
+        let body = message.message;
+        const breakingChangeIndex = body.indexOf(WEBPACK_BREAKING_CHANGE_POLYFILLS);
+        if (breakingChangeIndex >= 0) {
+            body = body.slice(0, breakingChangeIndex);
+        }
+        // TODO: Rspack currently doesn't populate moduleName correctly in some cases,
+        // fall back to moduleIdentifier as a workaround
+        if (process.env.NEXT_RSPACK && !message.moduleName && !message.file && message.moduleIdentifier) {
+            const parts = message.moduleIdentifier.split('!');
+            message.moduleName = parts[parts.length - 1];
+        }
+        message = (message.moduleName ? (0, _stripansi.default)(message.moduleName) + '\n' : '') + (message.file ? (0, _stripansi.default)(message.file) + '\n' : '') + body + (message.details && verbose ? '\n' + message.details : '') + (filteredModuleTrace && filteredModuleTrace.length ? (importTraceNote || '\n\nImport trace for requested module:') + filteredModuleTrace.map((trace)=>`\n${trace.moduleName}`).join('') : '') + (message.stack && verbose ? '\n' + message.stack : '');
+    }
+    let lines = message.split('\n');
+    // Extract loader paths from Webpack-added headers and move them to end.
+    // Original format: "Module build failed (from ./loaders/foo-loader.js):"
+    // The header line is removed and the path is appended at the end as:
+    //   "  (from ./loaders/foo-loader.js)"
+    // https://github.com/webpack/webpack/blob/master/lib/ModuleError.js
+    const loaderPaths = [];
+    lines = lines.filter((line)=>{
+        const match = /Module [A-z ]+\(from (.+)\):?\s*$/.exec(line);
+        if (match) {
+            loaderPaths.push(match[1]);
+            return false;
+        }
+        return true;
+    });
+    // Transform parsing error into syntax error
+    // TODO: move this to our ESLint formatter?
+    lines = lines.map((line)=>{
+        const parsingError = /Line (\d+):(?:(\d+):)?\s*Parsing error: (.+)$/.exec(line);
+        if (!parsingError) {
+            return line;
+        }
+        const [, errorLine, errorColumn, errorMessage] = parsingError;
+        return `${friendlySyntaxErrorLabel} ${errorMessage} (${errorLine}:${errorColumn})`;
+    });
+    message = lines.join('\n');
+    // Smoosh syntax errors (commonly found in CSS)
+    message = message.replace(/SyntaxError\s+\((\d+):(\d+)\)\s*(.+?)\n/g, `${friendlySyntaxErrorLabel} $3 ($1:$2)\n`);
+    // Clean up export errors
+    message = message.replace(/^.*export '(.+?)' was not found in '(.+?)'.*$/gm, `Attempted import error: '$1' is not exported from '$2'.`);
+    message = message.replace(/^.*export 'default' \(imported as '(.+?)'\) was not found in '(.+?)'.*$/gm, `Attempted import error: '$2' does not contain a default export (imported as '$1').`);
+    message = message.replace(/^.*export '(.+?)' \(imported as '(.+?)'\) was not found in '(.+?)'.*$/gm, `Attempted import error: '$1' is not exported from '$3' (imported as '$2').`);
+    lines = message.split('\n');
+    // Remove leading newline
+    if (lines.length > 2 && lines[1].trim() === '') {
+        lines.splice(1, 1);
+    }
+    // Cleans up verbose "module not found" messages for files and packages.
+    if (lines[1] && lines[1].startsWith('Module not found: ')) {
+        lines = [
+            lines[0],
+            lines[1].replace('Error: ', '').replace('Module not found: Cannot find file:', 'Cannot find file:'),
+            ...lines.slice(2)
+        ];
+    }
+    // Add helpful message for users trying to use Sass for the first time
+    if (lines[1] && lines[1].match(/Cannot find module.+sass/)) {
+        // ./file.module.scss (<<loader info>>) => ./file.module.scss
+        const firstLine = lines[0].split('!');
+        lines[0] = firstLine[firstLine.length - 1];
+        lines[1] = "To use Next.js' built-in Sass support, you first need to install `sass`.\n";
+        lines[1] += 'Run `npm i sass` or `yarn add sass` inside your workspace.\n';
+        lines[1] += '\nLearn more: https://nextjs.org/docs/messages/install-sass';
+        // dispose of unhelpful stack trace
+        lines = lines.slice(0, 2);
+        hadMissingSassError = true;
+    } else if (hadMissingSassError && message.match(/(sass-loader|resolve-url-loader: CSS error)/)) {
+        // dispose of unhelpful stack trace following missing sass module
+        lines = [];
+    }
+    if (!verbose) {
+        message = lines.join('\n');
+        // Internal stacks are generally useless so we strip them... with the
+        // exception of stacks containing `webpack:` because they're normally
+        // from user code generated by Webpack. For more information see
+        // https://github.com/facebook/create-react-app/pull/1050
+        message = message.replace(/^\s*at\s((?!webpack:).)*:\d+:\d+[\s)]*(\n|$)/gm, '') // at ... ...:x:y
+        ;
+        message = message.replace(/^\s*at\s<anonymous>(\n|$)/gm, '') // at <anonymous>
+        ;
+        message = message.replace(/File was processed with these loaders:\n(.+[\\/](next[\\/]dist[\\/].+|@next[\\/]react-refresh-utils[\\/]loader)\.js\n)*You may need an additional loader to handle the result of these loaders.\n/g, '');
+        lines = message.split('\n');
+    }
+    // Append loader paths at the end (before any remaining stack trace)
+    if (loaderPaths.length > 0) {
+        for (const loaderPath of loaderPaths){
+            // Don't show internal Next.js loader paths — they're noise for users
+            if (!/[/\\]next[/\\]dist[/\\]/.test(loaderPath)) {
+                lines.push(`  (from ${loaderPath})`);
+            }
+        }
+    }
+    // Remove duplicated newlines
+    lines = lines.filter((line, index, arr)=>index === 0 || line.trim() !== '' || line.trim() !== arr[index - 1].trim());
+    // Reassemble the message
+    message = lines.join('\n');
+    return message.trim();
+}
+function formatWebpackMessages(json, verbose) {
+    const formattedErrors = json.errors.map((message)=>{
+        const isUnknownNextFontError = message.message.includes('An error occurred in `next/font`.');
+        return formatMessage(message, isUnknownNextFontError || verbose);
+    });
+    const formattedWarnings = json.warnings.map((message)=>{
+        return formatMessage(message, verbose);
+    });
+    // Reorder errors to put the most relevant ones first.
+    let reactServerComponentsError = -1;
+    for(let i = 0; i < formattedErrors.length; i++){
+        const error = formattedErrors[i];
+        if (error.includes('ReactServerComponentsError')) {
+            reactServerComponentsError = i;
+            break;
+        }
+    }
+    // Move the reactServerComponentsError to the top if it exists
+    if (reactServerComponentsError !== -1) {
+        const error = formattedErrors.splice(reactServerComponentsError, 1);
+        formattedErrors.unshift(error[0]);
+    }
+    const result = {
+        ...json,
+        errors: formattedErrors,
+        warnings: formattedWarnings
+    };
+    if (!verbose && result.errors.some(isLikelyASyntaxError)) {
+        // If there are any syntax errors, show just them.
+        result.errors = result.errors.filter(isLikelyASyntaxError);
+        result.warnings = [];
+    }
+    return result;
+}
+
+//# sourceMappingURL=format-webpack-messages.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/get-rspack.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getRspackCore", {
+    enumerable: true,
+    get: function() {
+        return getRspackCore;
+    }
+});
+const _log = require("../../build/output/log");
+function getRspackCore() {
+    warnRspack();
+    try {
+        // eslint-disable-next-line @next/internal/typechecked-require
+        return require('next-rspack/rspack-core');
+    } catch (e) {
+        if (e instanceof Error && 'code' in e && e.code === 'MODULE_NOT_FOUND') {
+            throw Object.defineProperty(new Error('@rspack/core is not available. Please make sure `next-rspack` is correctly installed.'), "__NEXT_ERROR_CODE", {
+                value: "E647",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        throw e;
+    }
+}
+function warnRspack() {
+    if (process.env.__NEXT_TEST_MODE) {
+        return;
+    }
+    (0, _log.warnOnce)(`\`next-rspack\` is currently experimental. It's not an official Next.js plugin, and is supported by the Rspack team in partnership with Next.js. Help improve Next.js and Rspack by providing feedback at https://github.com/vercel/next.js/discussions/77800`);
+}
+
+//# sourceMappingURL=get-rspack.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/get-webpack-bundler.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, /**
+ * Depending on if Rspack is active or not, returns the appropriate set of
+ * webpack-compatible api.
+ *
+ * @returns webpack bundler
+ */ "default", {
+    enumerable: true,
+    get: function() {
+        return getWebpackBundler;
+    }
+});
+const _webpack = require("next/dist/compiled/webpack/webpack");
+const _getrspack = require("./get-rspack");
+function getWebpackBundler() {
+    return process.env.NEXT_RSPACK ? (0, _getrspack.getRspackCore)() : _webpack.webpack;
+}
+
+//# sourceMappingURL=get-webpack-bundler.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/is-internal.js

@@ -0,0 +1,41 @@
+/** React that's compiled with `next`. Used by App Router. */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    default: null,
+    nextInternalsRe: null,
+    reactNodeModulesRe: null,
+    reactVendoredRe: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    default: function() {
+        return isInternal;
+    },
+    nextInternalsRe: function() {
+        return nextInternalsRe;
+    },
+    reactNodeModulesRe: function() {
+        return reactNodeModulesRe;
+    },
+    reactVendoredRe: function() {
+        return reactVendoredRe;
+    }
+});
+const reactVendoredRe = /[\\/]next[\\/]dist[\\/]compiled[\\/](react|react-dom|react-server-dom-(webpack|turbopack)|scheduler)[\\/]/;
+const reactNodeModulesRe = /node_modules[\\/](react|react-dom|scheduler)[\\/]/;
+const nextInternalsRe = /(node_modules[\\/]next[\\/]|[\\/].next[\\/]static[\\/]chunks[\\/]webpack\.js$|(edge-runtime-webpack|webpack-runtime)\.js$)/;
+function isInternal(file) {
+    if (!file) return false;
+    // NOTE: native code has a version of the same logic in crates/next-napi-bindings/src/next_api/utils.rs
+    // keep them in sync.
+    return nextInternalsRe.test(file) || reactVendoredRe.test(file) || reactNodeModulesRe.test(file);
+}
+
+//# sourceMappingURL=is-internal.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/magic-identifier.js

@@ -0,0 +1,218 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    MAGIC_IDENTIFIER_REGEX: null,
+    decodeMagicIdentifier: null,
+    deobfuscateModuleId: null,
+    deobfuscateText: null,
+    deobfuscateTextParts: null,
+    removeFreeCallWrapper: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    MAGIC_IDENTIFIER_REGEX: function() {
+        return MAGIC_IDENTIFIER_REGEX;
+    },
+    decodeMagicIdentifier: function() {
+        return decodeMagicIdentifier;
+    },
+    deobfuscateModuleId: function() {
+        return deobfuscateModuleId;
+    },
+    deobfuscateText: function() {
+        return deobfuscateText;
+    },
+    deobfuscateTextParts: function() {
+        return deobfuscateTextParts;
+    },
+    removeFreeCallWrapper: function() {
+        return removeFreeCallWrapper;
+    }
+});
+function decodeHex(hexStr) {
+    if (hexStr.trim() === '') {
+        throw Object.defineProperty(new Error("can't decode empty hex"), "__NEXT_ERROR_CODE", {
+            value: "E19",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    const num = parseInt(hexStr, 16);
+    if (isNaN(num)) {
+        throw Object.defineProperty(new Error(`invalid hex: \`${hexStr}\``), "__NEXT_ERROR_CODE", {
+            value: "E293",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    return String.fromCodePoint(num);
+}
+const DECODE_REGEX = /^__TURBOPACK__([a-zA-Z0-9_$]+)__$/;
+function decodeMagicIdentifier(identifier) {
+    const matches = identifier.match(DECODE_REGEX);
+    if (!matches) {
+        return identifier;
+    }
+    const inner = matches[1];
+    let output = '';
+    let mode = 0;
+    let buffer = '';
+    for(let i = 0; i < inner.length; i++){
+        const char = inner[i];
+        if (mode === 0) {
+            if (char === '_') {
+                mode = 1;
+            } else if (char === '$') {
+                mode = 2;
+            } else {
+                output += char;
+            }
+        } else if (mode === 1) {
+            if (char === '_') {
+                output += ' ';
+                mode = 0;
+            } else if (char === '$') {
+                output += '_';
+                mode = 2;
+            } else {
+                output += char;
+                mode = 0;
+            }
+        } else if (mode === 2) {
+            if (buffer.length === 2) {
+                output += decodeHex(buffer);
+                buffer = '';
+            }
+            if (char === '_') {
+                if (buffer !== '') {
+                    throw Object.defineProperty(new Error(`invalid hex: \`${buffer}\``), "__NEXT_ERROR_CODE", {
+                        value: "E1022",
+                        enumerable: false,
+                        configurable: true
+                    });
+                }
+                mode = 3;
+            } else if (char === '$') {
+                if (buffer !== '') {
+                    throw Object.defineProperty(new Error(`invalid hex: \`${buffer}\``), "__NEXT_ERROR_CODE", {
+                        value: "E1022",
+                        enumerable: false,
+                        configurable: true
+                    });
+                }
+                mode = 0;
+            } else {
+                buffer += char;
+            }
+        } else if (mode === 3) {
+            if (char === '_') {
+                throw Object.defineProperty(new Error(`invalid hex: \`${buffer + char}\``), "__NEXT_ERROR_CODE", {
+                    value: "E293",
+                    enumerable: false,
+                    configurable: true
+                });
+            } else if (char === '$') {
+                output += decodeHex(buffer);
+                buffer = '';
+                mode = 0;
+            } else {
+                buffer += char;
+            }
+        }
+    }
+    return output;
+}
+const MAGIC_IDENTIFIER_REGEX = /__TURBOPACK__[a-zA-Z0-9_$]+__/g;
+function deobfuscateModuleId(moduleId) {
+    return moduleId// Replace [project] with .
+    .replace(/\[project\]/g, '.')// Remove content in square brackets (e.g. [app-rsc])
+    .replace(/\s\[([^\]]*)\]/g, '')// Remove content in parentheses (e.g. (ecmascript))
+    .replace(/\s\(([^)]*)\)/g, '')// Remove content in angle brackets (e.g. <locals>)
+    .replace(/\s<([^>]*)>/g, '')// Clean up any extra whitespace
+    .trim();
+}
+function removeFreeCallWrapper(text) {
+    // Match (0, <ident>.<ident>) patterns anywhere in the text the beginning
+    // Overzealous: accept any non-whitespace member expression after the dot.
+    // TODO: Fix https://linear.app/vercel/issue/NEXT-4875 to allow using unicode property escapes
+    return text.replace(/\(0\s*,\s*(__TURBOPACK__[a-zA-Z0-9_$]+__\.[^\s)]+)\)/g, '$1');
+}
+function deobfuscateTextParts(text) {
+    // First, remove free call wrappers
+    const withoutFreeCall = removeFreeCallWrapper(text);
+    const parts = [];
+    let lastIndex = 0;
+    // Create a new regex instance for global matching
+    const regex = new RegExp(MAGIC_IDENTIFIER_REGEX.source, 'g');
+    for(let match = regex.exec(withoutFreeCall); match !== null; match = regex.exec(withoutFreeCall)){
+        const matchStart = match.index;
+        const matchEnd = regex.lastIndex;
+        const ident = match[0];
+        // Add raw text before this match (if any)
+        if (matchStart > lastIndex) {
+            const rawText = withoutFreeCall.substring(lastIndex, matchStart);
+            parts.push([
+                'raw',
+                rawText
+            ]);
+        }
+        // Process and add the deobfuscated part
+        try {
+            const decoded = decodeMagicIdentifier(ident);
+            // If it was a magic identifier, clean up the module ID
+            if (decoded !== ident) {
+                // Check if this is an "imported module" reference
+                const importedModuleMatch = decoded.match(/^imported module (.+)$/);
+                if (importedModuleMatch) {
+                    // Clean the entire module path (which includes [app-rsc], etc.)
+                    const modulePathWithMetadata = importedModuleMatch[1];
+                    const cleaned = deobfuscateModuleId(modulePathWithMetadata);
+                    parts.push([
+                        'deobfuscated',
+                        `{imported module ${cleaned}}`
+                    ]);
+                } else {
+                    const cleaned = deobfuscateModuleId(decoded);
+                    parts.push([
+                        'deobfuscated',
+                        `{${cleaned}}`
+                    ]);
+                }
+            } else {
+                // Not actually a magic identifier, treat as raw
+                parts.push([
+                    'raw',
+                    ident
+                ]);
+            }
+        } catch (e) {
+            parts.push([
+                'deobfuscated',
+                `{${ident} (decoding failed: ${e})}`
+            ]);
+        }
+        lastIndex = matchEnd;
+    }
+    // Add any remaining raw text after the last match
+    if (lastIndex < withoutFreeCall.length) {
+        const rawText = withoutFreeCall.substring(lastIndex);
+        parts.push([
+            'raw',
+            rawText
+        ]);
+    }
+    return parts;
+}
+function deobfuscateText(text) {
+    const parts = deobfuscateTextParts(text);
+    return parts.map((part)=>part[1]).join('');
+}
+
+//# sourceMappingURL=magic-identifier.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/mitt.js

@@ -0,0 +1,46 @@
+/*
+MIT License
+
+Copyright (c) Jason Miller (https://jasonformat.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.
+*/ // This file is based on https://github.com/developit/mitt/blob/v1.1.3/src/index.js
+// It's been edited for the needs of this script
+// See the LICENSE at the top of the file
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return mitt;
+    }
+});
+function mitt() {
+    const all = Object.create(null);
+    return {
+        on (type, handler) {
+            ;
+            (all[type] || (all[type] = [])).push(handler);
+        },
+        off (type, handler) {
+            if (all[type]) {
+                all[type].splice(all[type].indexOf(handler) >>> 0, 1);
+            }
+        },
+        emit (type, ...evts) {
+            // eslint-disable-next-line array-callback-return
+            ;
+            (all[type] || []).slice().map((handler)=>{
+                handler(...evts);
+            });
+        }
+    };
+}
+
+//# sourceMappingURL=mitt.js.map