onvif-dashboard 0.1.0

package/.next/standalone/node_modules/next/dist/server/lib/etag.js

@@ -0,0 +1,56 @@
+/**
+ * FNV-1a Hash implementation
+ * @author Travis Webb (tjwebb) <me@traviswebb.com>
+ *
+ * Ported from https://github.com/tjwebb/fnv-plus/blob/master/index.js
+ *
+ * Simplified, optimized and add modified for 52 bit, which provides a larger hash space
+ * and still making use of Javascript's 53-bit integer space.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    fnv1a52: null,
+    generateETag: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    fnv1a52: function() {
+        return fnv1a52;
+    },
+    generateETag: function() {
+        return generateETag;
+    }
+});
+const fnv1a52 = (str)=>{
+    const len = str.length;
+    let i = 0, t0 = 0, v0 = 0x2325, t1 = 0, v1 = 0x8422, t2 = 0, v2 = 0x9ce4, t3 = 0, v3 = 0xcbf2;
+    while(i < len){
+        v0 ^= str.charCodeAt(i++);
+        t0 = v0 * 435;
+        t1 = v1 * 435;
+        t2 = v2 * 435;
+        t3 = v3 * 435;
+        t2 += v0 << 8;
+        t3 += v1 << 8;
+        t1 += t0 >>> 16;
+        v0 = t0 & 65535;
+        t2 += t1 >>> 16;
+        v1 = t1 & 65535;
+        v3 = t3 + (t2 >>> 16) & 65535;
+        v2 = t2 & 65535;
+    }
+    return (v3 & 15) * 281474976710656 + v2 * 4294967296 + v1 * 65536 + (v0 ^ v3 >> 4);
+};
+const generateETag = (payload, weak = false)=>{
+    const prefix = weak ? 'W/"' : '"';
+    return prefix + fnv1a52(payload).toString(36) + payload.length.toString(36) + '"';
+};
+
+//# sourceMappingURL=etag.js.map

package/.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/.next/standalone/node_modules/next/dist/server/lib/experimental/ppr.js

@@ -0,0 +1,47 @@
+/**
+ * If set to `incremental`, only those leaf pages that export
+ * `experimental_ppr = true` will have partial prerendering enabled. If any
+ * page exports this value as `false` or does not export it at all will not
+ * have partial prerendering enabled. If set to a boolean, the options for
+ * `experimental_ppr` will be ignored.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    checkIsAppPPREnabled: null,
+    checkIsRoutePPREnabled: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    checkIsAppPPREnabled: function() {
+        return checkIsAppPPREnabled;
+    },
+    checkIsRoutePPREnabled: function() {
+        return checkIsRoutePPREnabled;
+    }
+});
+function checkIsAppPPREnabled(config) {
+    // If the config is undefined, partial prerendering is disabled.
+    if (typeof config === 'undefined') return false;
+    // If the config is a boolean, use it directly.
+    if (typeof config === 'boolean') return config;
+    // If the config is a string, it must be 'incremental' to enable partial
+    // prerendering.
+    if (config === 'incremental') return true;
+    return false;
+}
+function checkIsRoutePPREnabled(config) {
+    // If the config is undefined, partial prerendering is disabled.
+    if (typeof config === 'undefined') return false;
+    // If the config is a boolean, use it directly.
+    if (typeof config === 'boolean') return config;
+    return false;
+}
+
+//# sourceMappingURL=ppr.js.map

package/.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/.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/.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/.next/standalone/node_modules/next/dist/server/lib/generate-agent-files.js

@@ -0,0 +1,180 @@
+/**
+ * Auto-generate AGENTS.md / CLAUDE.md with the managed Next.js agent-rules
+ * block when `next dev` detects an AI coding agent but the block is missing.
+ *
+ * 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_RULES_END_MARKER: null,
+    AGENT_RULES_START_MARKER: null,
+    hasCurrentAgentRules: null,
+    writeAgentFiles: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    AGENT_RULES_END_MARKER: function() {
+        return AGENT_RULES_END_MARKER;
+    },
+    AGENT_RULES_START_MARKER: function() {
+        return AGENT_RULES_START_MARKER;
+    },
+    hasCurrentAgentRules: function() {
+        return hasCurrentAgentRules;
+    },
+    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 -->';
+/**
+ * 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}`;
+}
+const CLAUDE_MD_CONTENT = `@AGENTS.md\n`;
+/**
+ * Returns the managed block (markers included) found in `content`, or
+ * `null` when the markers are absent or malformed.
+ */ function extractAgentRulesBlock(content) {
+    const start = content.indexOf(AGENT_RULES_START_MARKER);
+    if (start === -1) return null;
+    const end = content.indexOf(AGENT_RULES_END_MARKER, start);
+    if (end === -1) return null;
+    return content.slice(start, end + AGENT_RULES_END_MARKER.length);
+}
+function hasCurrentAgentRules(dir) {
+    const block = buildAgentRulesBlock();
+    for (const file of [
+        'AGENTS.md',
+        'CLAUDE.md'
+    ]){
+        const content = tryReadFile(_path.default.join(dir, file));
+        if (!content) continue;
+        const installed = extractAgentRulesBlock(content);
+        if (installed !== null && normalizeEol(installed, '\n') === block) {
+            return true;
+        }
+    }
+    return false;
+}
+function writeAgentFiles(projectDir) {
+    var _tryReadFile, _tryReadFile1;
+    const agentsMdPath = _path.default.join(projectDir, 'AGENTS.md');
+    const claudeMdPath = _path.default.join(projectDir, 'CLAUDE.md');
+    const block = buildAgentRulesBlock();
+    const agentsMdExists = _fs.default.existsSync(agentsMdPath);
+    const claudeMdExists = _fs.default.existsSync(claudeMdPath);
+    const claudeMdHostsBlock = claudeMdExists && (((_tryReadFile = tryReadFile(claudeMdPath)) == null ? void 0 : _tryReadFile.includes(AGENT_RULES_START_MARKER)) ?? false);
+    const agentsMdHostsBlock = agentsMdExists && (((_tryReadFile1 = tryReadFile(agentsMdPath)) == null ? void 0 : _tryReadFile1.includes(AGENT_RULES_START_MARKER)) ?? false);
+    if (agentsMdExists && (agentsMdHostsBlock || !claudeMdHostsBlock)) {
+        return {
+            agentsMd: upsertFile(agentsMdPath, block),
+            claudeMd: 'skipped'
+        };
+    }
+    if (claudeMdExists) {
+        return {
+            agentsMd: 'skipped',
+            claudeMd: upsertFile(claudeMdPath, block)
+        };
+    }
+    // Neither file exists — scaffold both, matching create-next-app.
+    _fs.default.writeFileSync(agentsMdPath, block + '\n', 'utf-8');
+    _fs.default.writeFileSync(claudeMdPath, CLAUDE_MD_CONTENT, 'utf-8');
+    return {
+        agentsMd: 'created',
+        claudeMd: 'created'
+    };
+}
+// ---------------------------------------------------------------------------
+// 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';
+}
+/**
+ * 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 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/.next/standalone/node_modules/next/dist/server/lib/i18n-provider.js

@@ -0,0 +1,129 @@
+"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 Object.defineProperty(new Error('Invariant: No locales provided'), "__NEXT_ERROR_CODE", {
+                value: "E510",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        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