lkd-web-kit 0.7.9 → 0.7.10

package/dist/node_modules/next/dist/shared/lib/router/utils/parse-loader-tree.js

@@ -0,0 +1,42 @@
+import { __exports as parseLoaderTree } from '../../../../../../../_virtual/parse-loader-tree.js';
+import { __require as requireSegment } from '../../segment.js';
+
+var hasRequiredParseLoaderTree;
+
+function requireParseLoaderTree () {
+	if (hasRequiredParseLoaderTree) return parseLoaderTree;
+	hasRequiredParseLoaderTree = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", {
+		    value: true
+		});
+		Object.defineProperty(exports, "parseLoaderTree", {
+		    enumerable: true,
+		    get: function() {
+		        return parseLoaderTree;
+		    }
+		});
+		const _segment = requireSegment();
+		function parseLoaderTree(tree) {
+		    const [segment, parallelRoutes, modules] = tree;
+		    const { layout, template } = modules;
+		    let { page } = modules;
+		    // a __DEFAULT__ segment means that this route didn't match any of the
+		    // segments in the route, so we should use the default page
+		    page = segment === _segment.DEFAULT_SEGMENT_KEY ? modules.defaultPage : page;
+		    const conventionPath = layout?.[1] || template?.[1] || page?.[1];
+		    return {
+		        page,
+		        segment,
+		        modules,
+		        /* it can be either layout / template / page */ conventionPath,
+		        parallelRoutes
+		    };
+		}
+
+		
+	} (parseLoaderTree));
+	return parseLoaderTree;
+}
+
+export { requireParseLoaderTree as __require };

package/dist/node_modules/next/dist/shared/lib/router/utils/parse-path.cjs

@@ -0,0 +1,51 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const parsePath = require('../../../../../../../_virtual/parse-path.cjs');
+
+/**
+ * Given a path this function will find the pathname, query and hash and return
+ * them. This is useful to parse full paths on the client side.
+ * @param path A path to parse e.g. /foo/bar?id=1#hash
+ */
+
+var hasRequiredParsePath;
+
+function requireParsePath () {
+	if (hasRequiredParsePath) return parsePath.__exports;
+	hasRequiredParsePath = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", {
+		    value: true
+		});
+		Object.defineProperty(exports, "parsePath", {
+		    enumerable: true,
+		    get: function() {
+		        return parsePath;
+		    }
+		});
+		function parsePath(path) {
+		    const hashIndex = path.indexOf('#');
+		    const queryIndex = path.indexOf('?');
+		    const hasQuery = queryIndex > -1 && (hashIndex < 0 || queryIndex < hashIndex);
+		    if (hasQuery || hashIndex > -1) {
+		        return {
+		            pathname: path.substring(0, hasQuery ? queryIndex : hashIndex),
+		            query: hasQuery ? path.substring(queryIndex, hashIndex > -1 ? hashIndex : undefined) : '',
+		            hash: hashIndex > -1 ? path.slice(hashIndex) : ''
+		        };
+		    }
+		    return {
+		        pathname: path,
+		        query: '',
+		        hash: ''
+		    };
+		}
+
+		
+	} (parsePath.__exports));
+	return parsePath.__exports;
+}
+
+exports.__require = requireParsePath;

package/dist/node_modules/next/dist/shared/lib/router/utils/parse-path.js

@@ -0,0 +1,47 @@
+import { __exports as parsePath } from '../../../../../../../_virtual/parse-path.js';
+
+/**
+ * Given a path this function will find the pathname, query and hash and return
+ * them. This is useful to parse full paths on the client side.
+ * @param path A path to parse e.g. /foo/bar?id=1#hash
+ */
+
+var hasRequiredParsePath;
+
+function requireParsePath () {
+	if (hasRequiredParsePath) return parsePath;
+	hasRequiredParsePath = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", {
+		    value: true
+		});
+		Object.defineProperty(exports, "parsePath", {
+		    enumerable: true,
+		    get: function() {
+		        return parsePath;
+		    }
+		});
+		function parsePath(path) {
+		    const hashIndex = path.indexOf('#');
+		    const queryIndex = path.indexOf('?');
+		    const hasQuery = queryIndex > -1 && (hashIndex < 0 || queryIndex < hashIndex);
+		    if (hasQuery || hashIndex > -1) {
+		        return {
+		            pathname: path.substring(0, hasQuery ? queryIndex : hashIndex),
+		            query: hasQuery ? path.substring(queryIndex, hashIndex > -1 ? hashIndex : undefined) : '',
+		            hash: hashIndex > -1 ? path.slice(hashIndex) : ''
+		        };
+		    }
+		    return {
+		        pathname: path,
+		        query: '',
+		        hash: ''
+		    };
+		}
+
+		
+	} (parsePath));
+	return parsePath;
+}
+
+export { requireParsePath as __require };

package/dist/node_modules/next/dist/shared/lib/router/utils/parse-relative-url.cjs

@@ -0,0 +1,54 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const parseRelativeUrl = require('../../../../../../../_virtual/parse-relative-url.cjs');
+const utils = require('../../utils.cjs');
+const querystring = require('./querystring.cjs');
+
+var hasRequiredParseRelativeUrl;
+
+function requireParseRelativeUrl () {
+	if (hasRequiredParseRelativeUrl) return parseRelativeUrl.__exports;
+	hasRequiredParseRelativeUrl = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", {
+		    value: true
+		});
+		Object.defineProperty(exports, "parseRelativeUrl", {
+		    enumerable: true,
+		    get: function() {
+		        return parseRelativeUrl;
+		    }
+		});
+		const _utils = utils.__require();
+		const _querystring = querystring.__require();
+		function parseRelativeUrl(url, base, parseQuery = true) {
+		    const globalBase = new URL(typeof window === 'undefined' ? 'http://n' : (0, _utils.getLocationOrigin)());
+		    const resolvedBase = base ? new URL(base, globalBase) : url.startsWith('.') ? new URL(typeof window === 'undefined' ? 'http://n' : window.location.href) : globalBase;
+		    const { pathname, searchParams, search, hash, href, origin } = new URL(url, resolvedBase);
+		    if (origin !== globalBase.origin) {
+		        throw Object.defineProperty(new Error(`invariant: invalid relative URL, router received ${url}`), "__NEXT_ERROR_CODE", {
+		            value: "E159",
+		            enumerable: false,
+		            configurable: true
+		        });
+		    }
+		    return {
+		        pathname,
+		        query: parseQuery ? (0, _querystring.searchParamsToUrlQuery)(searchParams) : undefined,
+		        search,
+		        hash,
+		        href: href.slice(origin.length),
+		        // We don't know for relative URLs at this point since we set a custom, internal
+		        // base that isn't surfaced to users.
+		        slashes: undefined
+		    };
+		}
+
+		
+	} (parseRelativeUrl.__exports));
+	return parseRelativeUrl.__exports;
+}
+
+exports.__require = requireParseRelativeUrl;

package/dist/node_modules/next/dist/shared/lib/router/utils/parse-relative-url.js

@@ -0,0 +1,50 @@
+import { __exports as parseRelativeUrl } from '../../../../../../../_virtual/parse-relative-url.js';
+import { __require as requireUtils } from '../../utils.js';
+import { __require as requireQuerystring } from './querystring.js';
+
+var hasRequiredParseRelativeUrl;
+
+function requireParseRelativeUrl () {
+	if (hasRequiredParseRelativeUrl) return parseRelativeUrl;
+	hasRequiredParseRelativeUrl = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", {
+		    value: true
+		});
+		Object.defineProperty(exports, "parseRelativeUrl", {
+		    enumerable: true,
+		    get: function() {
+		        return parseRelativeUrl;
+		    }
+		});
+		const _utils = requireUtils();
+		const _querystring = requireQuerystring();
+		function parseRelativeUrl(url, base, parseQuery = true) {
+		    const globalBase = new URL(typeof window === 'undefined' ? 'http://n' : (0, _utils.getLocationOrigin)());
+		    const resolvedBase = base ? new URL(base, globalBase) : url.startsWith('.') ? new URL(typeof window === 'undefined' ? 'http://n' : window.location.href) : globalBase;
+		    const { pathname, searchParams, search, hash, href, origin } = new URL(url, resolvedBase);
+		    if (origin !== globalBase.origin) {
+		        throw Object.defineProperty(new Error(`invariant: invalid relative URL, router received ${url}`), "__NEXT_ERROR_CODE", {
+		            value: "E159",
+		            enumerable: false,
+		            configurable: true
+		        });
+		    }
+		    return {
+		        pathname,
+		        query: parseQuery ? (0, _querystring.searchParamsToUrlQuery)(searchParams) : undefined,
+		        search,
+		        hash,
+		        href: href.slice(origin.length),
+		        // We don't know for relative URLs at this point since we set a custom, internal
+		        // base that isn't surfaced to users.
+		        slashes: undefined
+		    };
+		}
+
+		
+	} (parseRelativeUrl));
+	return parseRelativeUrl;
+}
+
+export { requireParseRelativeUrl as __require };

package/dist/node_modules/next/dist/shared/lib/router/utils/parse-url.cjs

@@ -0,0 +1,50 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const parseUrl = require('../../../../../../../_virtual/parse-url.cjs');
+const querystring = require('./querystring.cjs');
+const parseRelativeUrl = require('./parse-relative-url.cjs');
+
+var hasRequiredParseUrl;
+
+function requireParseUrl () {
+	if (hasRequiredParseUrl) return parseUrl.__exports;
+	hasRequiredParseUrl = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", {
+		    value: true
+		});
+		Object.defineProperty(exports, "parseUrl", {
+		    enumerable: true,
+		    get: function() {
+		        return parseUrl;
+		    }
+		});
+		const _querystring = querystring.__require();
+		const _parserelativeurl = parseRelativeUrl.__require();
+		function parseUrl(url) {
+		    if (url.startsWith('/')) {
+		        return (0, _parserelativeurl.parseRelativeUrl)(url);
+		    }
+		    const parsedURL = new URL(url);
+		    return {
+		        hash: parsedURL.hash,
+		        hostname: parsedURL.hostname,
+		        href: parsedURL.href,
+		        pathname: parsedURL.pathname,
+		        port: parsedURL.port,
+		        protocol: parsedURL.protocol,
+		        query: (0, _querystring.searchParamsToUrlQuery)(parsedURL.searchParams),
+		        search: parsedURL.search,
+		        origin: parsedURL.origin,
+		        slashes: parsedURL.href.slice(parsedURL.protocol.length, parsedURL.protocol.length + 2) === '//'
+		    };
+		}
+
+		
+	} (parseUrl.__exports));
+	return parseUrl.__exports;
+}
+
+exports.__require = requireParseUrl;

package/dist/node_modules/next/dist/shared/lib/router/utils/parse-url.js

@@ -0,0 +1,46 @@
+import { __exports as parseUrl } from '../../../../../../../_virtual/parse-url.js';
+import { __require as requireQuerystring } from './querystring.js';
+import { __require as requireParseRelativeUrl } from './parse-relative-url.js';
+
+var hasRequiredParseUrl;
+
+function requireParseUrl () {
+	if (hasRequiredParseUrl) return parseUrl;
+	hasRequiredParseUrl = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", {
+		    value: true
+		});
+		Object.defineProperty(exports, "parseUrl", {
+		    enumerable: true,
+		    get: function() {
+		        return parseUrl;
+		    }
+		});
+		const _querystring = requireQuerystring();
+		const _parserelativeurl = requireParseRelativeUrl();
+		function parseUrl(url) {
+		    if (url.startsWith('/')) {
+		        return (0, _parserelativeurl.parseRelativeUrl)(url);
+		    }
+		    const parsedURL = new URL(url);
+		    return {
+		        hash: parsedURL.hash,
+		        hostname: parsedURL.hostname,
+		        href: parsedURL.href,
+		        pathname: parsedURL.pathname,
+		        port: parsedURL.port,
+		        protocol: parsedURL.protocol,
+		        query: (0, _querystring.searchParamsToUrlQuery)(parsedURL.searchParams),
+		        search: parsedURL.search,
+		        origin: parsedURL.origin,
+		        slashes: parsedURL.href.slice(parsedURL.protocol.length, parsedURL.protocol.length + 2) === '//'
+		    };
+		}
+
+		
+	} (parseUrl));
+	return parseUrl;
+}
+
+export { requireParseUrl as __require };

package/dist/node_modules/next/dist/shared/lib/router/utils/path-has-prefix.cjs

@@ -0,0 +1,37 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const pathHasPrefix = require('../../../../../../../_virtual/path-has-prefix.cjs');
+const parsePath = require('./parse-path.cjs');
+
+var hasRequiredPathHasPrefix;
+
+function requirePathHasPrefix () {
+	if (hasRequiredPathHasPrefix) return pathHasPrefix.__exports;
+	hasRequiredPathHasPrefix = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", {
+		    value: true
+		});
+		Object.defineProperty(exports, "pathHasPrefix", {
+		    enumerable: true,
+		    get: function() {
+		        return pathHasPrefix;
+		    }
+		});
+		const _parsepath = parsePath.__require();
+		function pathHasPrefix(path, prefix) {
+		    if (typeof path !== 'string') {
+		        return false;
+		    }
+		    const { pathname } = (0, _parsepath.parsePath)(path);
+		    return pathname === prefix || pathname.startsWith(prefix + '/');
+		}
+
+		
+	} (pathHasPrefix.__exports));
+	return pathHasPrefix.__exports;
+}
+
+exports.__require = requirePathHasPrefix;

package/dist/node_modules/next/dist/shared/lib/router/utils/path-has-prefix.js

@@ -0,0 +1,33 @@
+import { __exports as pathHasPrefix } from '../../../../../../../_virtual/path-has-prefix.js';
+import { __require as requireParsePath } from './parse-path.js';
+
+var hasRequiredPathHasPrefix;
+
+function requirePathHasPrefix () {
+	if (hasRequiredPathHasPrefix) return pathHasPrefix;
+	hasRequiredPathHasPrefix = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", {
+		    value: true
+		});
+		Object.defineProperty(exports, "pathHasPrefix", {
+		    enumerable: true,
+		    get: function() {
+		        return pathHasPrefix;
+		    }
+		});
+		const _parsepath = requireParsePath();
+		function pathHasPrefix(path, prefix) {
+		    if (typeof path !== 'string') {
+		        return false;
+		    }
+		    const { pathname } = (0, _parsepath.parsePath)(path);
+		    return pathname === prefix || pathname.startsWith(prefix + '/');
+		}
+
+		
+	} (pathHasPrefix));
+	return pathHasPrefix;
+}
+
+export { requirePathHasPrefix as __require };

package/dist/node_modules/next/dist/shared/lib/router/utils/path-match.cjs

@@ -0,0 +1,66 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const pathMatch = require('../../../../../../../_virtual/path-match.cjs');
+const index = require('../../../../compiled/path-to-regexp/index.cjs');
+
+var hasRequiredPathMatch;
+
+function requirePathMatch () {
+	if (hasRequiredPathMatch) return pathMatch.__exports;
+	hasRequiredPathMatch = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", {
+		    value: true
+		});
+		Object.defineProperty(exports, "getPathMatch", {
+		    enumerable: true,
+		    get: function() {
+		        return getPathMatch;
+		    }
+		});
+		const _pathtoregexp = index.__require();
+		function getPathMatch(path, options) {
+		    const keys = [];
+		    const regexp = (0, _pathtoregexp.pathToRegexp)(path, keys, {
+		        delimiter: '/',
+		        sensitive: typeof options?.sensitive === 'boolean' ? options.sensitive : false,
+		        strict: options?.strict
+		    });
+		    const matcher = (0, _pathtoregexp.regexpToFunction)(options?.regexModifier ? new RegExp(options.regexModifier(regexp.source), regexp.flags) : regexp, keys);
+		    /**
+		   * A matcher function that will check if a given pathname matches the path
+		   * given in the builder function. When the path does not match it will return
+		   * `false` but if it does it will return an object with the matched params
+		   * merged with the params provided in the second argument.
+		   */ return (pathname, params)=>{
+		        // If no pathname is provided it's not a match.
+		        if (typeof pathname !== 'string') return false;
+		        const match = matcher(pathname);
+		        // If the path did not match `false` will be returned.
+		        if (!match) return false;
+		        /**
+		     * If unnamed params are not allowed they must be removed from
+		     * the matched parameters. path-to-regexp uses "string" for named and
+		     * "number" for unnamed parameters.
+		     */ if (options?.removeUnnamedParams) {
+		            for (const key of keys){
+		                if (typeof key.name === 'number') {
+		                    delete match.params[key.name];
+		                }
+		            }
+		        }
+		        return {
+		            ...params,
+		            ...match.params
+		        };
+		    };
+		}
+
+		
+	} (pathMatch.__exports));
+	return pathMatch.__exports;
+}
+
+exports.__require = requirePathMatch;

package/dist/node_modules/next/dist/shared/lib/router/utils/path-match.js

@@ -0,0 +1,62 @@
+import { __exports as pathMatch } from '../../../../../../../_virtual/path-match.js';
+import { __require as requirePathToRegexp } from '../../../../compiled/path-to-regexp/index.js';
+
+var hasRequiredPathMatch;
+
+function requirePathMatch () {
+	if (hasRequiredPathMatch) return pathMatch;
+	hasRequiredPathMatch = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", {
+		    value: true
+		});
+		Object.defineProperty(exports, "getPathMatch", {
+		    enumerable: true,
+		    get: function() {
+		        return getPathMatch;
+		    }
+		});
+		const _pathtoregexp = requirePathToRegexp();
+		function getPathMatch(path, options) {
+		    const keys = [];
+		    const regexp = (0, _pathtoregexp.pathToRegexp)(path, keys, {
+		        delimiter: '/',
+		        sensitive: typeof options?.sensitive === 'boolean' ? options.sensitive : false,
+		        strict: options?.strict
+		    });
+		    const matcher = (0, _pathtoregexp.regexpToFunction)(options?.regexModifier ? new RegExp(options.regexModifier(regexp.source), regexp.flags) : regexp, keys);
+		    /**
+		   * A matcher function that will check if a given pathname matches the path
+		   * given in the builder function. When the path does not match it will return
+		   * `false` but if it does it will return an object with the matched params
+		   * merged with the params provided in the second argument.
+		   */ return (pathname, params)=>{
+		        // If no pathname is provided it's not a match.
+		        if (typeof pathname !== 'string') return false;
+		        const match = matcher(pathname);
+		        // If the path did not match `false` will be returned.
+		        if (!match) return false;
+		        /**
+		     * If unnamed params are not allowed they must be removed from
+		     * the matched parameters. path-to-regexp uses "string" for named and
+		     * "number" for unnamed parameters.
+		     */ if (options?.removeUnnamedParams) {
+		            for (const key of keys){
+		                if (typeof key.name === 'number') {
+		                    delete match.params[key.name];
+		                }
+		            }
+		        }
+		        return {
+		            ...params,
+		            ...match.params
+		        };
+		    };
+		}
+
+		
+	} (pathMatch));
+	return pathMatch;
+}
+
+export { requirePathMatch as __require };