onvif-dashboard 0.1.0

package/.next/standalone/node_modules/next/dist/server/instrumentation/types.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=types.js.map

package/.next/standalone/node_modules/next/dist/server/instrumentation/utils.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getRevalidateReason", {
+    enumerable: true,
+    get: function() {
+        return getRevalidateReason;
+    }
+});
+function getRevalidateReason(params) {
+    if (params.isOnDemandRevalidate) {
+        return 'on-demand';
+    }
+    if (params.isStaticGeneration) {
+        return 'stale';
+    }
+    return undefined;
+}
+
+//# sourceMappingURL=utils.js.map

package/.next/standalone/node_modules/next/dist/server/internal-utils.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    stripInternalQueries: null,
+    stripInternalSearchParams: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    stripInternalQueries: function() {
+        return stripInternalQueries;
+    },
+    stripInternalSearchParams: function() {
+        return stripInternalSearchParams;
+    }
+});
+const _approuterheaders = require("../client/components/app-router-headers");
+const INTERNAL_QUERY_NAMES = [
+    _approuterheaders.NEXT_RSC_UNION_QUERY
+];
+function stripInternalQueries(query) {
+    for (const name of INTERNAL_QUERY_NAMES){
+        delete query[name];
+    }
+}
+function stripInternalSearchParams(url) {
+    const isStringUrl = typeof url === 'string';
+    const instance = isStringUrl ? new URL(url) : url;
+    instance.searchParams.delete(_approuterheaders.NEXT_RSC_UNION_QUERY);
+    return isStringUrl ? instance.toString() : instance;
+}
+
+//# sourceMappingURL=internal-utils.js.map

package/.next/standalone/node_modules/next/dist/server/is-private-ip.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "isPrivateIp", {
+    enumerable: true,
+    get: function() {
+        return isPrivateIp;
+    }
+});
+const _ipaddr = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/ipaddr.js"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function isPrivateIp(ip) {
+    if (ip.startsWith('[') && ip.endsWith(']')) {
+        ip = ip.slice(1, -1);
+    }
+    if (!_ipaddr.default.isValid(ip)) {
+        return false;
+    }
+    try {
+        let addr = _ipaddr.default.parse(ip);
+        if (addr.kind() === 'ipv6' && addr.isIPv4MappedAddress()) {
+            addr = addr.toIPv4Address();
+        }
+        const range = addr.range();
+        return range !== 'unicast';
+    } catch (e) {
+        return false;
+    }
+}
+
+//# sourceMappingURL=is-private-ip.js.map

package/.next/standalone/node_modules/next/dist/server/lib/app-dir-module.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    getComponentTypeModule: null,
+    getLayoutOrPageModule: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getComponentTypeModule: function() {
+        return getComponentTypeModule;
+    },
+    getLayoutOrPageModule: function() {
+        return getLayoutOrPageModule;
+    }
+});
+const _segment = require("../../shared/lib/segment");
+async function getLayoutOrPageModule(loaderTree) {
+    const { layout, page, defaultPage } = loaderTree[2];
+    const isLayout = typeof layout !== 'undefined';
+    const isPage = typeof page !== 'undefined';
+    const isDefaultPage = typeof defaultPage !== 'undefined' && loaderTree[0] === _segment.DEFAULT_SEGMENT_KEY;
+    let mod = undefined;
+    let modType = undefined;
+    let filePath = undefined;
+    if (isLayout) {
+        mod = await layout[0]();
+        modType = 'layout';
+        filePath = layout[1];
+    } else if (isPage) {
+        mod = await page[0]();
+        modType = 'page';
+        filePath = page[1];
+    } else if (isDefaultPage) {
+        mod = await defaultPage[0]();
+        modType = 'page';
+        filePath = defaultPage[1];
+    }
+    return {
+        mod,
+        modType,
+        filePath
+    };
+}
+async function getComponentTypeModule(loaderTree, moduleType) {
+    const { [moduleType]: module1 } = loaderTree[2];
+    if (typeof module1 !== 'undefined') {
+        return await module1[0]();
+    }
+    return undefined;
+}
+
+//# sourceMappingURL=app-dir-module.js.map

package/.next/standalone/node_modules/next/dist/server/lib/app-info-log.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    ensureAgentRulesForDev: null,
+    getEnvInfo: null,
+    logExperimentalInfo: null,
+    logStartInfo: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ensureAgentRulesForDev: function() {
+        return ensureAgentRulesForDev;
+    },
+    getEnvInfo: function() {
+        return getEnvInfo;
+    },
+    logExperimentalInfo: function() {
+        return logExperimentalInfo;
+    },
+    logStartInfo: function() {
+        return logStartInfo;
+    }
+});
+const _env = require("@next/env");
+const _inspector = /*#__PURE__*/ _interop_require_wildcard(require("inspector"));
+const _log = /*#__PURE__*/ _interop_require_wildcard(require("../../build/output/log"));
+const _picocolors = require("../../lib/picocolors");
+const _configschema = require("../config-schema");
+const _agentname = require("../../telemetry/agent-name");
+const _bundler = require("../../lib/bundler");
+const _generateagentfiles = require("./generate-agent-files");
+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;
+}
+function logStartInfo({ networkUrl, appUrl, envInfo, logBundler }) {
+    const versionSuffix = logBundler ? ` (${(0, _bundler.bundlerName)((0, _bundler.getBundlerFromEnv)())})` : '';
+    _log.bootstrap(`${(0, _picocolors.bold)((0, _picocolors.purple)(`${_log.prefixes.ready} Next.js ${"16.3.5"}`))}${versionSuffix}`);
+    if (appUrl) {
+        _log.bootstrap(`- Local:         ${appUrl}`);
+    }
+    if (networkUrl) {
+        _log.bootstrap(`- Network:       ${networkUrl}`);
+    }
+    const inspectorUrl = _inspector.url();
+    if (inspectorUrl) {
+        // Could also parse this port from the inspector URL.
+        // process.debugPort will always be defined even if the process is not being inspected.
+        // The full URL seems noisy as far as I can tell.
+        // Node.js will print the full URL anyway.
+        const debugPort = process.debugPort;
+        _log.bootstrap(`- Debugger port: ${debugPort}`);
+    }
+    if (envInfo == null ? void 0 : envInfo.length) _log.bootstrap(`- Environments: ${envInfo.join(', ')}`);
+}
+function logExperimentalInfo({ experimentalFeatures, cacheComponents, partialPrefetching }) {
+    if (cacheComponents) {
+        _log.bootstrap(`- Cache Components enabled`);
+    }
+    if (partialPrefetching) {
+        const mode = partialPrefetching === 'unstable_eager' ? ' (unstable_eager)' : '';
+        _log.bootstrap(`- Partial Prefetching enabled${mode}`);
+    }
+    if (experimentalFeatures == null ? void 0 : experimentalFeatures.length) {
+        _log.bootstrap(`- Experiments (use with caution):`);
+        for (const exp of experimentalFeatures){
+            const isValid = Object.prototype.hasOwnProperty.call(_configschema.experimentalSchema, exp.key);
+            if (isValid) {
+                const symbol = typeof exp.value === 'boolean' ? exp.value === true ? (0, _picocolors.bold)('✓') : (0, _picocolors.bold)('⨯') : '·';
+                const suffix = typeof exp.value === 'number' || typeof exp.value === 'string' ? `: ${JSON.stringify(exp.value)}` : '';
+                const reason = exp.reason ? ` (${exp.reason})` : '';
+                _log.bootstrap(`  ${symbol} ${exp.key}${suffix}${reason}`);
+            } else {
+                _log.bootstrap(`  ? ${(0, _picocolors.strikethrough)(exp.key)} (invalid experimental key)`);
+            }
+        }
+    }
+    // New line after the bootstrap info
+    _log.info('');
+}
+async function ensureAgentRulesForDev(dir) {
+    if (await (0, _agentname.getAgentName)() === null) return null;
+    if ((0, _generateagentfiles.hasCurrentAgentRules)(dir)) return null;
+    return (0, _generateagentfiles.writeAgentFiles)(dir);
+}
+function getEnvInfo(dir) {
+    const { loadedEnvFiles } = (0, _env.loadEnvConfig)(dir, true, console, false);
+    return loadedEnvFiles.map((f)=>f.path);
+}
+
+//# sourceMappingURL=app-info-log.js.map

package/.next/standalone/node_modules/next/dist/server/lib/async-callback-set.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "AsyncCallbackSet", {
+    enumerable: true,
+    get: function() {
+        return AsyncCallbackSet;
+    }
+});
+class AsyncCallbackSet {
+    add(callback) {
+        this.callbacks.push(callback);
+    }
+    async runAll() {
+        if (!this.callbacks.length) {
+            return;
+        }
+        const callbacks = this.callbacks;
+        this.callbacks = [];
+        await Promise.allSettled(callbacks.map(// NOTE: wrapped in an async function to protect against synchronous exceptions
+        async (f)=>f()));
+    }
+    constructor(){
+        this.callbacks = [];
+    }
+}
+
+//# sourceMappingURL=async-callback-set.js.map

package/.next/standalone/node_modules/next/dist/server/lib/cache-control.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getCacheControlHeader", {
+    enumerable: true,
+    get: function() {
+        return getCacheControlHeader;
+    }
+});
+const _constants = require("../../lib/constants");
+function getCacheControlHeader({ revalidate, expire }) {
+    const swrHeader = typeof revalidate === 'number' && expire !== undefined && revalidate < expire ? `, stale-while-revalidate=${expire - revalidate}` : '';
+    if (revalidate === 0) {
+        return 'private, no-cache, no-store, max-age=0, must-revalidate';
+    } else if (typeof revalidate === 'number') {
+        return `s-maxage=${revalidate}${swrHeader}`;
+    }
+    return `s-maxage=${_constants.CACHE_ONE_YEAR_SECONDS}${swrHeader}`;
+}
+
+//# sourceMappingURL=cache-control.js.map

package/.next/standalone/node_modules/next/dist/server/lib/cache-handlers/default.external.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, /**
+ * Used for edge runtime compatibility.
+ *
+ * @deprecated Use createDefaultCacheHandler instead.
+ */ "default", {
+    enumerable: true,
+    get: function() {
+        return _default1;
+    }
+});
+const _default = require("./default");
+const _default1 = (0, _default.createDefaultCacheHandler)(50 * 1024 * 1024);
+
+//# sourceMappingURL=default.external.js.map

package/.next/standalone/node_modules/next/dist/server/lib/cache-handlers/default.js

@@ -0,0 +1,196 @@
+/**
+ * This is the default "use cache" handler it defaults to an in-memory store.
+ * In-memory caches are fragile and should not use stale-while-revalidate
+ * semantics on the caches because it's not worth warming up an entry that's
+ * likely going to get evicted before we get to use it anyway. However, we also
+ * don't want to reuse a stale entry for too long so stale entries should be
+ * considered expired/missing in such cache handlers.
+ *
+ * The dev server (`next dev`) is the exception: to keep reloads fast it serves
+ * stale entries until they expire, relying on the wrapper's
+ * stale-while-revalidate path to warm a fresh entry in the background. See
+ * `get` for where this branches.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createDefaultCacheHandler", {
+    enumerable: true,
+    get: function() {
+        return createDefaultCacheHandler;
+    }
+});
+const _lrucache = require("../lru-cache");
+const _tagsmanifestexternal = require("../incremental-cache/tags-manifest.external");
+const _constants = require("../../use-cache/constants");
+function createDefaultCacheHandler(maxSize) {
+    // If the max size is 0, return a cache handler that doesn't cache anything,
+    // this avoids an unnecessary LRUCache instance and potential memory
+    // allocation.
+    if (maxSize === 0) {
+        return {
+            get: ()=>Promise.resolve(undefined),
+            set: ()=>Promise.resolve(),
+            refreshTags: ()=>Promise.resolve(),
+            getExpiration: ()=>Promise.resolve(0),
+            updateTags: ()=>Promise.resolve()
+        };
+    }
+    const memoryCache = new _lrucache.LRUCache(maxSize, (entry, cacheKey)=>entry.size + cacheKey.length);
+    const pendingSets = new Map();
+    const debug = process.env.NEXT_PRIVATE_DEBUG_CACHE ? console.debug.bind(console, 'DefaultCacheHandler:') : undefined;
+    return {
+        async get (cacheKey) {
+            const pendingPromise = pendingSets.get(cacheKey);
+            if (pendingPromise) {
+                debug == null ? void 0 : debug('get', cacheKey, 'pending');
+                await pendingPromise;
+            }
+            const privateEntry = memoryCache.get(cacheKey);
+            if (!privateEntry) {
+                debug == null ? void 0 : debug('get', cacheKey, 'not found');
+                return undefined;
+            }
+            const entry = privateEntry.entry;
+            // A negative `expire` is an eviction sentinel: the tiered cache handler
+            // (dev-only) marks a front entry for deletion by overwriting it with a
+            // negative `expire`, since the cache-handler interface has no per-key
+            // delete. Treat it as missing here, independently of the minimum
+            // retention below (which would otherwise keep it alive). This is distinct
+            // from `revalidate = -1` below, which keeps serving the entry but forces
+            // a revalidation.
+            if (entry.expire < 0) {
+                debug == null ? void 0 : debug('get', cacheKey, 'evicted');
+                return undefined;
+            }
+            // The dev server serves stale entries until they expire (see the file
+            // overview); production drops them once past the revalidate time. In dev,
+            // an entry is retained for at least `MIN_PRERENDERABLE_EXPIRE` so that
+            // entries with a short `expire` (for example a `cacheLife({ expire: 0 })`
+            // client-only cache) still linger long enough that a reload hits the
+            // cache. That minimum is the same threshold below which the "use cache"
+            // wrapper treats an entry as dynamic, so it only extends the retention of
+            // entries that are dynamic anyway. It affects retention only; the
+            // returned entry keeps its real `expire`, so staging decisions are
+            // unchanged.
+            const maxAgeSeconds = process.env.__NEXT_DEV_SERVER ? Math.max(entry.expire, _constants.MIN_PRERENDERABLE_EXPIRE) : entry.revalidate;
+            if (performance.timeOrigin + performance.now() > entry.timestamp + maxAgeSeconds * 1000) {
+                debug == null ? void 0 : debug('get', cacheKey, 'expired');
+                return undefined;
+            }
+            let revalidate = entry.revalidate;
+            if ((0, _tagsmanifestexternal.areTagsExpired)(entry.tags, entry.timestamp)) {
+                debug == null ? void 0 : debug('get', cacheKey, 'had expired tag');
+                return undefined;
+            }
+            if ((0, _tagsmanifestexternal.areTagsStale)(entry.tags, entry.timestamp)) {
+                debug == null ? void 0 : debug('get', cacheKey, 'had stale tag');
+                revalidate = -1;
+            }
+            const [returnStream, newSaved] = entry.value.tee();
+            entry.value = newSaved;
+            debug == null ? void 0 : debug('get', cacheKey, 'found', {
+                tags: entry.tags,
+                timestamp: entry.timestamp,
+                expire: entry.expire,
+                revalidate
+            });
+            return {
+                ...entry,
+                revalidate,
+                value: returnStream
+            };
+        },
+        async set (cacheKey, pendingEntry) {
+            debug == null ? void 0 : debug('set', cacheKey, 'start');
+            let resolvePending = ()=>{};
+            const pendingPromise = new Promise((resolve)=>{
+                resolvePending = resolve;
+            });
+            pendingSets.set(cacheKey, pendingPromise);
+            const entry = await pendingEntry;
+            let size = 0;
+            try {
+                // In production an `expire: 0` entry is dynamic: the "use cache"
+                // wrapper regenerates it on every read instead of serving the stored
+                // copy, so persisting it would be a wasted write of a value that is
+                // never served back. Skip storing it so the next read is a plain miss.
+                // The dev server keeps it, because its minimum retention serves the
+                // previously cached value across reloads. The `finally` below still
+                // resolves the pending set.
+                if (!process.env.__NEXT_DEV_SERVER && entry.expire === 0) {
+                    debug == null ? void 0 : debug('set', cacheKey, 'skipped dynamic entry');
+                    return;
+                }
+                const [value, clonedValue] = entry.value.tee();
+                entry.value = value;
+                const reader = clonedValue.getReader();
+                for(let chunk; !(chunk = await reader.read()).done;){
+                    size += Buffer.from(chunk.value).byteLength;
+                }
+                memoryCache.set(cacheKey, {
+                    entry,
+                    isErrored: false,
+                    errorRetryCount: 0,
+                    size
+                });
+                debug == null ? void 0 : debug('set', cacheKey, 'done');
+            } catch (err) {
+                // TODO: store partial buffer with error after we retry 3 times
+                debug == null ? void 0 : debug('set', cacheKey, 'failed', err);
+            } finally{
+                resolvePending();
+                pendingSets.delete(cacheKey);
+            }
+        },
+        async refreshTags () {
+        // Nothing to do for an in-memory cache handler.
+        },
+        async getExpiration (tags) {
+            const expirations = tags.map((tag)=>{
+                const entry = _tagsmanifestexternal.tagsManifest.get(tag);
+                if (!entry) return 0;
+                // Return the most recent timestamp (either expired or stale)
+                return entry.expired || 0;
+            });
+            const expiration = Math.max(...expirations, 0);
+            debug == null ? void 0 : debug('getExpiration', {
+                tags,
+                expiration
+            });
+            return expiration;
+        },
+        async updateTags (tags, durations) {
+            const now = Math.round(performance.timeOrigin + performance.now());
+            debug == null ? void 0 : debug('updateTags', {
+                tags,
+                timestamp: now
+            });
+            for (const tag of tags){
+                // TODO: update file-system-cache?
+                const existingEntry = _tagsmanifestexternal.tagsManifest.get(tag) || {};
+                if (durations) {
+                    // Use provided durations directly
+                    const updates = {
+                        ...existingEntry
+                    };
+                    // mark as stale immediately
+                    updates.stale = now;
+                    if (durations.expire !== undefined) {
+                        updates.expired = now + durations.expire * 1000 // Convert seconds to ms
+                        ;
+                    }
+                    _tagsmanifestexternal.tagsManifest.set(tag, updates);
+                } else {
+                    // Update expired field for immediate expiration (default behavior when no durations provided)
+                    _tagsmanifestexternal.tagsManifest.set(tag, {
+                        ...existingEntry,
+                        expired: now
+                    });
+                }
+            }
+        }
+    };
+}
+
+//# sourceMappingURL=default.js.map

package/.next/standalone/node_modules/next/dist/server/lib/cache-handlers/types.js

@@ -0,0 +1,8 @@
+/**
+ * A timestamp in milliseconds elapsed since the epoch
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=types.js.map