@codelionapps/unharness 0.0.0-stage → 0.1.1

package/dashboard/.next/standalone/node_modules/next/dist/server/lib/experimental/create-env-definitions.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createEnvDefinitions", {
+    enumerable: true,
+    get: function() {
+        return createEnvDefinitions;
+    }
+});
+const _nodepath = require("node:path");
+const _promises = require("node:fs/promises");
+async function createEnvDefinitions({ distDir, loadedEnvFiles }) {
+    const envLines = [];
+    const seenKeys = new Set();
+    // env files are in order of priority
+    for (const { path, env } of loadedEnvFiles){
+        for(const key in env){
+            if (!seenKeys.has(key)) {
+                envLines.push(`      /** Loaded from \`${path}\` */`);
+                envLines.push(`      ${key}?: string`);
+                seenKeys.add(key);
+            }
+        }
+    }
+    const envStr = envLines.join('\n');
+    const definitionStr = `// Type definitions for Next.js environment variables
+declare global {
+  namespace NodeJS {
+    interface ProcessEnv {
+${envStr}
+    }
+  }
+}
+export {}`;
+    if (process.env.NODE_ENV === 'test') {
+        return definitionStr;
+    }
+    try {
+        // we expect the types directory to already exist
+        const envDtsPath = (0, _nodepath.join)(distDir, 'types', 'env.d.ts');
+        await (0, _promises.writeFile)(envDtsPath, definitionStr, 'utf-8');
+    } catch (e) {
+        console.error('Failed to write env.d.ts:', e);
+    }
+}
+
+//# sourceMappingURL=create-env-definitions.js.map

package/dashboard/.next/standalone/node_modules/next/dist/server/lib/find-page-file.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    createValidFileMatcher: null,
+    findPageFile: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    createValidFileMatcher: function() {
+        return createValidFileMatcher;
+    },
+    findPageFile: function() {
+        return findPageFile;
+    }
+});
+const _fileexists = require("../../lib/file-exists");
+const _getpagepaths = require("../../shared/lib/page-path/get-page-paths");
+const _nonnullable = require("../../lib/non-nullable");
+const _path = require("path");
+const _fs = require("fs");
+const _log = require("../../build/output/log");
+const _picocolors = require("../../lib/picocolors");
+const _ismetadataroute = require("../../lib/metadata/is-metadata-route");
+const _escaperegexp = require("../../shared/lib/escape-regexp");
+async function isTrueCasePagePath(pagePath, pagesDir) {
+    const pageSegments = (0, _path.normalize)(pagePath).split(_path.sep).filter(Boolean);
+    const segmentExistsPromises = pageSegments.map(async (segment, i)=>{
+        const segmentParentDir = (0, _path.join)(pagesDir, ...pageSegments.slice(0, i));
+        const parentDirEntries = await _fs.promises.readdir(segmentParentDir);
+        return parentDirEntries.includes(segment);
+    });
+    return (await Promise.all(segmentExistsPromises)).every(Boolean);
+}
+async function findPageFile(pagesDir, normalizedPagePath, pageExtensions, isAppDir) {
+    const pagePaths = (0, _getpagepaths.getPagePaths)(normalizedPagePath, pageExtensions, isAppDir);
+    const [existingPath, ...others] = (await Promise.all(pagePaths.map(async (path)=>{
+        const filePath = (0, _path.join)(pagesDir, path);
+        try {
+            return await (0, _fileexists.fileExists)(filePath) ? path : null;
+        } catch (err) {
+            var _err_code;
+            if (!(err == null ? void 0 : (_err_code = err.code) == null ? void 0 : _err_code.includes('ENOTDIR'))) throw err;
+        }
+        return null;
+    }))).filter(_nonnullable.nonNullable);
+    if (!existingPath) {
+        return null;
+    }
+    if (!await isTrueCasePagePath(existingPath, pagesDir)) {
+        return null;
+    }
+    if (others.length > 0) {
+        (0, _log.warn)(`Duplicate page detected. ${(0, _picocolors.cyan)((0, _path.join)('pages', existingPath))} and ${(0, _picocolors.cyan)((0, _path.join)('pages', others[0]))} both resolve to ${(0, _picocolors.cyan)(normalizedPagePath)}.`);
+    }
+    return existingPath;
+}
+function createValidFileMatcher(pageExtensions, appDirPath) {
+    // Helper to create extension regex pattern
+    const extPattern = `(?:${pageExtensions.map((extension)=>(0, _escaperegexp.escapeStringRegexp)(extension)).join('|')})`;
+    // Pattern factory for "leaf" files that can appear at start of path or after separator
+    // e.g., 'page.tsx', '/path/page.tsx', '\\path\\route.js'
+    const createLeafPattern = (fileNames)=>{
+        const names = fileNames.length === 1 ? fileNames[0] : `(${fileNames.join('|')})`;
+        return new RegExp(`(^${names}|[\\\\/]${names})\\.${extPattern}$`);
+    };
+    // Pattern factory for root-only files (no path separator allowed)
+    const createRootOnlyPattern = (fileName)=>new RegExp(`^${fileName}\\.${extPattern}$`);
+    // All file matching patterns
+    const validExtensionFileRegex = new RegExp(`\\.${extPattern}$`);
+    const leafOnlyPageFileRegex = createLeafPattern([
+        'page',
+        'route'
+    ]);
+    const leafOnlyRouteFileRegex = createLeafPattern([
+        'route'
+    ]);
+    const leafOnlyLayoutFileRegex = createLeafPattern([
+        'layout'
+    ]);
+    const leafOnlyDefaultFileRegex = createLeafPattern([
+        'default'
+    ]);
+    const rootNotFoundFileRegex = createRootOnlyPattern('not-found');
+    /** TODO-METADATA: support other metadata routes
+   *  regex for:
+   *
+   * /robots.txt|<ext>
+   * /sitemap.xml|<ext>
+   * /favicon.ico
+   * /manifest.json|<ext>
+   * <route>/icon.png|jpg|<ext>
+   * <route>/apple-touch-icon.png|jpg|<ext>
+   *
+   */ /**
+   * Match the file if it's a metadata route file, static: if the file is a static metadata file.
+   * It needs to be a file which doesn't match the custom metadata routes e.g. `app/robots.txt/route.js`
+   */ function isMetadataFile(filePath) {
+        const appDirRelativePath = appDirPath ? filePath.replace(appDirPath, '') : filePath;
+        return (0, _ismetadataroute.isMetadataRouteFile)(appDirRelativePath, pageExtensions, true);
+    }
+    // Determine if the file is leaf node page file or route file under layouts,
+    // 'page.<extension>' | 'route.<extension>'
+    function isAppRouterPage(filePath) {
+        return leafOnlyPageFileRegex.test(filePath) || isMetadataFile(filePath);
+    }
+    // Determine if the file is leaf node route file under app directory
+    function isAppRouterRoute(filePath) {
+        return leafOnlyRouteFileRegex.test(filePath);
+    }
+    function isAppLayoutPage(filePath) {
+        return leafOnlyLayoutFileRegex.test(filePath);
+    }
+    function isAppDefaultPage(filePath) {
+        return leafOnlyDefaultFileRegex.test(filePath);
+    }
+    function isPageFile(filePath) {
+        return validExtensionFileRegex.test(filePath) || isMetadataFile(filePath);
+    }
+    function isRootNotFound(filePath) {
+        if (!appDirPath) {
+            return false;
+        }
+        if (!filePath.startsWith(appDirPath + _path.sep)) {
+            return false;
+        }
+        const rest = filePath.slice(appDirPath.length + 1);
+        return rootNotFoundFileRegex.test(rest);
+    }
+    return {
+        isPageFile,
+        isAppRouterPage,
+        isAppRouterRoute,
+        isAppLayoutPage,
+        isAppDefaultPage,
+        isMetadataFile,
+        isRootNotFound
+    };
+}
+
+//# sourceMappingURL=find-page-file.js.map

package/dashboard/.next/standalone/node_modules/next/dist/server/lib/fix-mojibake.js

@@ -0,0 +1,25 @@
+// x-matched-path header can be decoded incorrectly
+// and should only be utf8 characters so this fixes
+// incorrectly encoded values
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "fixMojibake", {
+    enumerable: true,
+    get: function() {
+        return fixMojibake;
+    }
+});
+function fixMojibake(input) {
+    // Convert each character's char code to a byte
+    const bytes = new Uint8Array(input.length);
+    for(let i = 0; i < input.length; i++){
+        bytes[i] = input.charCodeAt(i);
+    }
+    // Decode the bytes as proper UTF-8
+    const decoder = new TextDecoder('utf-8');
+    return decoder.decode(bytes);
+}
+
+//# sourceMappingURL=fix-mojibake.js.map

package/dashboard/.next/standalone/node_modules/next/dist/server/lib/format-hostname.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "formatHostname", {
+    enumerable: true,
+    get: function() {
+        return formatHostname;
+    }
+});
+const _isipv6 = require("./is-ipv6");
+function formatHostname(hostname) {
+    return (0, _isipv6.isIPv6)(hostname) ? `[${hostname}]` : hostname;
+}
+
+//# sourceMappingURL=format-hostname.js.map

package/dashboard/.next/standalone/node_modules/next/dist/server/lib/generate-agent-files.js

@@ -0,0 +1,303 @@
+/**
+ * Create or update AGENTS.md with managed Next.js instructions when `next dev`
+ * detects an AI coding agent.
+ *
+ * Keep the marker and block content in sync with:
+ *   - packages/create-next-app/helpers/generate-agent-files.ts
+ *   - packages/next-codemod/lib/agents-md.ts
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    AGENT_FEEDBACK_END_MARKER: null,
+    AGENT_FEEDBACK_START_MARKER: null,
+    AGENT_RULES_END_MARKER: null,
+    AGENT_RULES_START_MARKER: null,
+    hasCurrentAgentFeedback: null,
+    hasCurrentAgentRules: null,
+    removeAgentFeedbackFiles: null,
+    removeAgentRulesFiles: null,
+    writeAgentFeedbackFiles: null,
+    writeAgentFiles: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    AGENT_FEEDBACK_END_MARKER: function() {
+        return AGENT_FEEDBACK_END_MARKER;
+    },
+    AGENT_FEEDBACK_START_MARKER: function() {
+        return AGENT_FEEDBACK_START_MARKER;
+    },
+    AGENT_RULES_END_MARKER: function() {
+        return AGENT_RULES_END_MARKER;
+    },
+    AGENT_RULES_START_MARKER: function() {
+        return AGENT_RULES_START_MARKER;
+    },
+    hasCurrentAgentFeedback: function() {
+        return hasCurrentAgentFeedback;
+    },
+    hasCurrentAgentRules: function() {
+        return hasCurrentAgentRules;
+    },
+    removeAgentFeedbackFiles: function() {
+        return removeAgentFeedbackFiles;
+    },
+    removeAgentRulesFiles: function() {
+        return removeAgentRulesFiles;
+    },
+    writeAgentFeedbackFiles: function() {
+        return writeAgentFeedbackFiles;
+    },
+    writeAgentFiles: function() {
+        return writeAgentFiles;
+    }
+});
+const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const AGENT_RULES_START_MARKER = '<!-- BEGIN:nextjs-agent-rules -->';
+const AGENT_RULES_END_MARKER = '<!-- END:nextjs-agent-rules -->';
+const AGENT_FEEDBACK_START_MARKER = '<!-- BEGIN:nextjs-agent-feedback -->';
+const AGENT_FEEDBACK_END_MARKER = '<!-- END:nextjs-agent-feedback -->';
+/**
+ * Markers written by the pre-bundled-docs version of `agents-md`.
+ * Stripped on upsert so projects that ran the old codemod end up with
+ * a single current block instead of two stale-and-current blocks.
+ */ const LEGACY_AGENT_RULES_START_MARKER = '<!-- NEXT-AGENTS-MD-START -->';
+const LEGACY_AGENT_RULES_END_MARKER = '<!-- NEXT-AGENTS-MD-END -->';
+function buildAgentRulesBlock() {
+    return `${AGENT_RULES_START_MARKER}
+
+## This is NOT the Next.js you know
+
+This version has breaking changes — APIs, conventions, and file structure may all differ from your training data. Read the relevant guide in \`node_modules/next/dist/docs/\` (resolved from this file's directory; in monorepos the \`next\` package may not be visible from the repo root) before writing any code. Heed deprecation notices.
+
+This block is written and re-added by \`next dev\` — verify at \`node_modules/next/dist/server/lib/generate-agent-files.js\`. Removing it from a diff only re-creates the uncommitted change; committing it with your work keeps the tree clean.
+
+${AGENT_RULES_END_MARKER}`;
+}
+/**
+ * The block points agents at `next internal agent-feedback-instructions`.
+ * That command is not covered by semver, which is acceptable here because
+ * `next dev` rewrites this block whenever the installed version changes it,
+ * so a project never keeps an instruction that its own `next` can't serve.
+ */ function buildAgentFeedbackBlock() {
+    return `${AGENT_FEEDBACK_START_MARKER}
+
+## Report Next.js feedback
+
+The project owner enabled \`experimental.agentFeedback\`, authorizing this feedback pass. When enabled, \`next dev\` writes this block and restores it if removed. Commit \`AGENTS.md\` with your work to keep the tree clean.
+
+During the current user request, retain anonymized facts as feedback candidates for meaningful or recurring Next.js issues:
+
+- Crashes, hangs, OOMs, or unexpected slowness
+- Incorrect behavior, output, errors, or diagnostics
+- Missing, unclear, or conflicting documentation
+- Unexpected CLI, codemod, Skill, or upgrade behavior and non-obvious workarounds
+
+Continue the current user request without reporting immediately. Routine debugging is not feedback. Verify changes before retaining them as feedback candidates. Never retain code, logs, paths, URLs, secrets, personal information, or project-specific data.
+
+Retain qualifying friction even if it is later fixed or worked around; record the final outcome during the reporting pass.
+
+Before the final response, run one reporting pass. If candidates remain, from this file's directory run \`npx --no-install next internal agent-feedback-instructions\` once without piping or truncating its output. Follow its output or error guidance. If a network sandbox blocks it, retry with network access; if it still returns no output, continue normally.
+
+${AGENT_FEEDBACK_END_MARKER}`;
+}
+/**
+ * Returns the managed block (markers included) found in `content`, or
+ * `null` when the markers are absent or malformed.
+ */ function extractAgentRulesBlock(content) {
+    return extractManagedBlock(content, AGENT_RULES_START_MARKER, AGENT_RULES_END_MARKER);
+}
+function extractManagedBlock(content, startMarker, endMarker) {
+    const start = content.indexOf(startMarker);
+    if (start === -1) return null;
+    const end = content.indexOf(endMarker, start);
+    if (end === -1) return null;
+    return content.slice(start, end + endMarker.length);
+}
+function hasCurrentAgentRules(dir) {
+    const block = buildAgentRulesBlock();
+    const content = tryReadFile(_path.default.join(dir, 'AGENTS.md'));
+    if (!content) return false;
+    const installed = extractAgentRulesBlock(content);
+    return installed !== null && normalizeEol(installed, '\n') === block;
+}
+function hasCurrentAgentFeedback(dir) {
+    const block = buildAgentFeedbackBlock();
+    const content = tryReadFile(_path.default.join(dir, 'AGENTS.md'));
+    if (!content) return false;
+    const installed = extractManagedBlock(content, AGENT_FEEDBACK_START_MARKER, AGENT_FEEDBACK_END_MARKER);
+    return installed !== null && normalizeEol(installed, '\n') === block;
+}
+function writeAgentFiles(projectDir) {
+    const agentsMdPath = _path.default.join(projectDir, 'AGENTS.md');
+    const block = buildAgentRulesBlock();
+    if (_fs.default.existsSync(agentsMdPath)) {
+        return {
+            agentsMd: upsertFile(agentsMdPath, block)
+        };
+    }
+    _fs.default.writeFileSync(agentsMdPath, block + '\n', 'utf-8');
+    return {
+        agentsMd: 'created'
+    };
+}
+function writeAgentFeedbackFiles(projectDir) {
+    const agentsMdPath = _path.default.join(projectDir, 'AGENTS.md');
+    const block = buildAgentFeedbackBlock();
+    if (_fs.default.existsSync(agentsMdPath)) {
+        return {
+            agentsMd: upsertFeedbackFile(agentsMdPath, block)
+        };
+    }
+    _fs.default.writeFileSync(agentsMdPath, block + '\n', 'utf-8');
+    return {
+        agentsMd: 'created'
+    };
+}
+function removeAgentFeedbackFiles(projectDir) {
+    return {
+        agentsMd: removeManagedBlockFromFile(_path.default.join(projectDir, 'AGENTS.md'), AGENT_FEEDBACK_START_MARKER, AGENT_FEEDBACK_END_MARKER)
+    };
+}
+function removeAgentRulesFiles(projectDir) {
+    return {
+        agentsMd: removeManagedBlockFromFile(_path.default.join(projectDir, 'AGENTS.md'), AGENT_RULES_START_MARKER, AGENT_RULES_END_MARKER)
+    };
+}
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+function tryReadFile(filePath) {
+    try {
+        return _fs.default.readFileSync(filePath, 'utf-8');
+    } catch  {
+        return null;
+    }
+}
+function upsertFile(filePath, block) {
+    const existing = _fs.default.readFileSync(filePath, 'utf-8');
+    const updated = upsertAgentRulesBlock(existing, block);
+    if (updated === existing) return 'unchanged';
+    _fs.default.writeFileSync(filePath, updated, 'utf-8');
+    return 'updated';
+}
+function upsertFeedbackFile(filePath, block) {
+    const existing = _fs.default.readFileSync(filePath, 'utf-8');
+    const updated = upsertManagedBlock(existing, block, AGENT_FEEDBACK_START_MARKER, AGENT_FEEDBACK_END_MARKER);
+    if (updated === existing) return 'unchanged';
+    _fs.default.writeFileSync(filePath, updated, 'utf-8');
+    return 'updated';
+}
+function removeManagedBlockFromFile(filePath, startMarker, endMarker) {
+    const existing = tryReadFile(filePath);
+    if (existing === null) return 'skipped';
+    const updated = removeManagedBlock(existing, startMarker, endMarker);
+    if (updated === existing) return 'unchanged';
+    if (updated.trim() === '') {
+        // Nothing but the managed block lived here, so Next.js effectively owned
+        // the file. Leaving a zero-byte AGENTS.md behind is more confusing than
+        // removing it.
+        _fs.default.unlinkSync(filePath);
+    } else {
+        _fs.default.writeFileSync(filePath, updated, 'utf-8');
+    }
+    return 'removed';
+}
+/**
+ * Detect the predominant line-ending style. Returns `'\r\n'` if any
+ * CRLF is present, `'\n'` otherwise — avoids mixed EOLs on Windows.
+ */ function detectEol(content) {
+    return /\r\n/.test(content) ? '\r\n' : '\n';
+}
+function normalizeEol(s, eol) {
+    return s.replace(/\r?\n/g, eol);
+}
+function upsertAgentRulesBlock(existing, block) {
+    const eol = detectEol(existing);
+    const normalizedBlock = normalizeEol(block, eol);
+    existing = stripLegacyAgentRulesBlock(existing, eol);
+    const startIdx = existing.indexOf(AGENT_RULES_START_MARKER);
+    const endIdx = existing.indexOf(AGENT_RULES_END_MARKER);
+    if (startIdx !== -1 && endIdx !== -1 && endIdx > startIdx) {
+        const before = existing.slice(0, startIdx);
+        const after = existing.slice(endIdx + AGENT_RULES_END_MARKER.length);
+        const replaced = before + normalizedBlock + after;
+        return replaced === existing ? existing : replaced;
+    }
+    const separator = existing.length === 0 || /\r?\n$/.test(existing) ? eol : eol + eol;
+    return existing + separator + normalizedBlock + eol;
+}
+function upsertManagedBlock(existing, block, startMarker, endMarker) {
+    const eol = detectEol(existing);
+    const normalizedBlock = normalizeEol(block, eol);
+    const startIdx = existing.indexOf(startMarker);
+    const endIdx = existing.indexOf(endMarker, startIdx);
+    if (startIdx !== -1 && endIdx !== -1 && endIdx > startIdx) {
+        const before = existing.slice(0, startIdx);
+        const after = existing.slice(endIdx + endMarker.length);
+        return before + normalizedBlock + after;
+    }
+    const separator = existing.length === 0 || /\r?\n$/.test(existing) ? eol : eol + eol;
+    return existing + separator + normalizedBlock + eol;
+}
+function removeManagedBlock(existing, startMarker, endMarker) {
+    const startIdx = existing.indexOf(startMarker);
+    if (startIdx === -1) return existing;
+    const endIdx = existing.indexOf(endMarker, startIdx);
+    if (endIdx === -1) return existing;
+    let cutStart = startIdx;
+    while(cutStart > 0 && /[\t ]/.test(existing[cutStart - 1]))cutStart--;
+    if (cutStart > 0 && existing[cutStart - 1] === '\n') {
+        cutStart--;
+        if (cutStart > 0 && existing[cutStart - 1] === '\r') cutStart--;
+    }
+    let cutEnd = endIdx + endMarker.length;
+    while(cutEnd < existing.length && /[\t ]/.test(existing[cutEnd]))cutEnd++;
+    if (existing[cutEnd] === '\r') cutEnd++;
+    if (existing[cutEnd] === '\n') cutEnd++;
+    // A block at the very top has no preceding newline to absorb, so also drop
+    // the blank line that separated it from the content below. Otherwise the
+    // file would start with an empty line.
+    if (cutStart === 0) {
+        if (existing[cutEnd] === '\r') cutEnd++;
+        if (existing[cutEnd] === '\n') cutEnd++;
+    }
+    const before = existing.slice(0, cutStart);
+    const after = existing.slice(cutEnd);
+    const separator = before.length > 0 && after.length > 0 && !before.endsWith('\n') && !after.startsWith('\r') && !after.startsWith('\n') ? detectEol(existing) : '';
+    return before + separator + after;
+}
+function stripLegacyAgentRulesBlock(existing, eol = '\n') {
+    while(true){
+        const startIdx = existing.indexOf(LEGACY_AGENT_RULES_START_MARKER);
+        if (startIdx === -1) return existing;
+        const endIdx = existing.indexOf(LEGACY_AGENT_RULES_END_MARKER, startIdx);
+        if (endIdx === -1) return existing;
+        let cutStart = startIdx;
+        while(cutStart > 0 && /\s/.test(existing[cutStart - 1])){
+            cutStart--;
+        }
+        let cutEnd = endIdx + LEGACY_AGENT_RULES_END_MARKER.length;
+        while(cutEnd < existing.length && /\s/.test(existing[cutEnd])){
+            cutEnd++;
+        }
+        const before = existing.slice(0, cutStart);
+        const after = existing.slice(cutEnd);
+        existing = before.length > 0 && after.length > 0 ? before + eol + eol + after : before + after;
+    }
+}
+
+//# sourceMappingURL=generate-agent-files.js.map

package/dashboard/.next/standalone/node_modules/next/dist/server/lib/i18n-provider.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "I18NProvider", {
+    enumerable: true,
+    get: function() {
+        return I18NProvider;
+    }
+});
+const _requestmeta = require("../request-meta");
+class I18NProvider {
+    constructor(config){
+        var _config_domains;
+        this.config = config;
+        if (!config.locales.length) {
+            throw new Error('Invariant: No locales provided');
+        }
+        this.lowerCaseLocales = config.locales.map((locale)=>locale.toLowerCase());
+        this.lowerCaseDomains = (_config_domains = config.domains) == null ? void 0 : _config_domains.map((domainLocale)=>{
+            var _domainLocale_locales;
+            const domain = domainLocale.domain.toLowerCase();
+            return {
+                defaultLocale: domainLocale.defaultLocale.toLowerCase(),
+                hostname: domain.split(':', 1)[0],
+                domain,
+                locales: (_domainLocale_locales = domainLocale.locales) == null ? void 0 : _domainLocale_locales.map((locale)=>locale.toLowerCase()),
+                http: domainLocale.http
+            };
+        });
+    }
+    /**
+   * Detects the domain locale from the hostname and the detected locale if
+   * provided.
+   *
+   * @param hostname The hostname to detect the domain locale from, this must be lowercased.
+   * @param detectedLocale The detected locale to use if the hostname does not match.
+   * @returns The domain locale if found, `undefined` otherwise.
+   */ detectDomainLocale(hostname, detectedLocale) {
+        if (!hostname || !this.lowerCaseDomains || !this.config.domains) return;
+        if (detectedLocale) detectedLocale = detectedLocale.toLowerCase();
+        for(let i = 0; i < this.lowerCaseDomains.length; i++){
+            var // Configuration validation ensures that the locale is not repeated in
+            // other domains locales.
+            _domainLocale_locales;
+            const domainLocale = this.lowerCaseDomains[i];
+            if (// We assume that the hostname is already lowercased.
+            domainLocale.hostname === hostname || ((_domainLocale_locales = domainLocale.locales) == null ? void 0 : _domainLocale_locales.some((locale)=>locale === detectedLocale))) {
+                return this.config.domains[i];
+            }
+        }
+        return;
+    }
+    /**
+   * Pulls the pre-computed locale and inference results from the query
+   * object.
+   *
+   * @param req the request object
+   * @param pathname the pathname that could contain a locale prefix
+   * @returns the locale analysis result
+   */ fromRequest(req, pathname) {
+        const detectedLocale = (0, _requestmeta.getRequestMeta)(req, 'locale');
+        // If a locale was detected on the query, analyze the pathname to ensure
+        // that the locale matches.
+        if (detectedLocale) {
+            const analysis = this.analyze(pathname);
+            // If the analysis contained a locale we should validate it against the
+            // query and strip it from the pathname.
+            if (analysis.detectedLocale) {
+                if (analysis.detectedLocale !== detectedLocale) {
+                    console.warn(`The detected locale does not match the locale in the query. Expected to find '${detectedLocale}' in '${pathname}' but found '${analysis.detectedLocale}'}`);
+                }
+                pathname = analysis.pathname;
+            }
+        }
+        return {
+            pathname,
+            detectedLocale,
+            inferredFromDefault: (0, _requestmeta.getRequestMeta)(req, 'localeInferredFromDefault') ?? false
+        };
+    }
+    /**
+   * Analyzes the pathname for a locale and returns the pathname without it.
+   *
+   * @param pathname The pathname that could contain a locale prefix.
+   * @param options The options to use when matching the locale.
+   * @returns The matched locale and the pathname without the locale prefix
+   *          (if any).
+   */ analyze(pathname, options = {}) {
+        let detectedLocale = options.defaultLocale;
+        // By default, we assume that the default locale was inferred if there was
+        // no detected locale.
+        let inferredFromDefault = typeof detectedLocale === 'string';
+        // The first segment will be empty, because it has a leading `/`. If
+        // there is no further segment, there is no locale (or it's the default).
+        const segments = pathname.split('/', 2);
+        if (!segments[1]) return {
+            detectedLocale,
+            pathname,
+            inferredFromDefault
+        };
+        // The second segment will contain the locale part if any.
+        const segment = segments[1].toLowerCase();
+        // See if the segment matches one of the locales. If it doesn't, there is
+        // no locale (or it's the default).
+        const index = this.lowerCaseLocales.indexOf(segment);
+        if (index < 0) return {
+            detectedLocale,
+            pathname,
+            inferredFromDefault
+        };
+        // Return the case-sensitive locale.
+        detectedLocale = this.config.locales[index];
+        inferredFromDefault = false;
+        // Remove the `/${locale}` part of the pathname.
+        pathname = pathname.slice(detectedLocale.length + 1) || '/';
+        return {
+            detectedLocale,
+            pathname,
+            inferredFromDefault
+        };
+    }
+}
+
+//# sourceMappingURL=i18n-provider.js.map