freedakgmail
5681 lines
245 KiB
JavaScript
5681 lines
245 KiB
JavaScript
(globalThis.TURBOPACK || (globalThis.TURBOPACK = [])).push([typeof document === "object" ? document.currentScript : undefined,
|
||
"[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/shared/lib/router/utils/querystring.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
"use strict";
|
||
|
||
Object.defineProperty(exports, "__esModule", {
|
||
value: true
|
||
});
|
||
0 && (module.exports = {
|
||
assign: null,
|
||
searchParamsToUrlQuery: null,
|
||
urlQueryToSearchParams: null
|
||
});
|
||
function _export(target, all) {
|
||
for(var name in all)Object.defineProperty(target, name, {
|
||
enumerable: true,
|
||
get: all[name]
|
||
});
|
||
}
|
||
_export(exports, {
|
||
assign: function() {
|
||
return assign;
|
||
},
|
||
searchParamsToUrlQuery: function() {
|
||
return searchParamsToUrlQuery;
|
||
},
|
||
urlQueryToSearchParams: function() {
|
||
return urlQueryToSearchParams;
|
||
}
|
||
});
|
||
function searchParamsToUrlQuery(searchParams) {
|
||
const query = {};
|
||
for (const [key, value] of searchParams.entries()){
|
||
const existing = query[key];
|
||
if (typeof existing === 'undefined') {
|
||
query[key] = value;
|
||
} else if (Array.isArray(existing)) {
|
||
existing.push(value);
|
||
} else {
|
||
query[key] = [
|
||
existing,
|
||
value
|
||
];
|
||
}
|
||
}
|
||
return query;
|
||
}
|
||
function stringifyUrlQueryParam(param) {
|
||
if (typeof param === 'string') {
|
||
return param;
|
||
}
|
||
if (typeof param === 'number' && !isNaN(param) || typeof param === 'boolean') {
|
||
return String(param);
|
||
} else {
|
||
return '';
|
||
}
|
||
}
|
||
function urlQueryToSearchParams(query) {
|
||
const searchParams = new URLSearchParams();
|
||
for (const [key, value] of Object.entries(query)){
|
||
if (Array.isArray(value)) {
|
||
for (const item of value){
|
||
searchParams.append(key, stringifyUrlQueryParam(item));
|
||
}
|
||
} else {
|
||
searchParams.set(key, stringifyUrlQueryParam(value));
|
||
}
|
||
}
|
||
return searchParams;
|
||
}
|
||
function assign(target, ...searchParamsList) {
|
||
for (const searchParams of searchParamsList){
|
||
for (const key of searchParams.keys()){
|
||
target.delete(key);
|
||
}
|
||
for (const [key, value] of searchParams.entries()){
|
||
target.append(key, value);
|
||
}
|
||
}
|
||
return target;
|
||
} //# sourceMappingURL=querystring.js.map
|
||
}),
|
||
"[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/shared/lib/router/utils/format-url.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
"use strict";
|
||
|
||
// Format function modified from nodejs
|
||
// Copyright Joyent, Inc. and other Node contributors.
|
||
//
|
||
// Permission is hereby granted, free of charge, to any person obtaining a
|
||
// copy of this software and associated documentation files (the
|
||
// "Software"), to deal in the Software without restriction, including
|
||
// without limitation the rights to use, copy, modify, merge, publish,
|
||
// distribute, sublicense, and/or sell copies of the Software, and to permit
|
||
// persons to whom the Software is furnished to do so, subject to the
|
||
// following conditions:
|
||
//
|
||
// The above copyright notice and this permission notice shall be included
|
||
// in all copies or substantial portions of the Software.
|
||
//
|
||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
||
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
|
||
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
||
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
||
// USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||
var __TURBOPACK__imported__module__$5b$project$5d2f$Documents$2f$go$2d$new$2f$chinese$2d$family$2d$tree$2f$node_modules$2f2e$pnpm$2f$next$40$16$2e$0$2e$3_react$2d$dom$40$19$2e$2$2e$0_react$40$19$2e$2$2e$0_$5f$react$40$19$2e$2$2e$0$2f$node_modules$2f$next$2f$dist$2f$build$2f$polyfills$2f$process$2e$js__$5b$app$2d$client$5d$__$28$ecmascript$29$__ = /*#__PURE__*/ __turbopack_context__.i("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/build/polyfills/process.js [app-client] (ecmascript)");
|
||
"use strict";
|
||
Object.defineProperty(exports, "__esModule", {
|
||
value: true
|
||
});
|
||
0 && (module.exports = {
|
||
formatUrl: null,
|
||
formatWithValidation: null,
|
||
urlObjectKeys: null
|
||
});
|
||
function _export(target, all) {
|
||
for(var name in all)Object.defineProperty(target, name, {
|
||
enumerable: true,
|
||
get: all[name]
|
||
});
|
||
}
|
||
_export(exports, {
|
||
formatUrl: function() {
|
||
return formatUrl;
|
||
},
|
||
formatWithValidation: function() {
|
||
return formatWithValidation;
|
||
},
|
||
urlObjectKeys: function() {
|
||
return urlObjectKeys;
|
||
}
|
||
});
|
||
const _interop_require_wildcard = __turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/@swc+helpers@0.5.15/node_modules/@swc/helpers/cjs/_interop_require_wildcard.cjs [app-client] (ecmascript)");
|
||
const _querystring = /*#__PURE__*/ _interop_require_wildcard._(__turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/shared/lib/router/utils/querystring.js [app-client] (ecmascript)"));
|
||
const slashedProtocols = /https?|ftp|gopher|file/;
|
||
function formatUrl(urlObj) {
|
||
let { auth, hostname } = urlObj;
|
||
let protocol = urlObj.protocol || '';
|
||
let pathname = urlObj.pathname || '';
|
||
let hash = urlObj.hash || '';
|
||
let query = urlObj.query || '';
|
||
let host = false;
|
||
auth = auth ? encodeURIComponent(auth).replace(/%3A/i, ':') + '@' : '';
|
||
if (urlObj.host) {
|
||
host = auth + urlObj.host;
|
||
} else if (hostname) {
|
||
host = auth + (~hostname.indexOf(':') ? `[${hostname}]` : hostname);
|
||
if (urlObj.port) {
|
||
host += ':' + urlObj.port;
|
||
}
|
||
}
|
||
if (query && typeof query === 'object') {
|
||
query = String(_querystring.urlQueryToSearchParams(query));
|
||
}
|
||
let search = urlObj.search || query && `?${query}` || '';
|
||
if (protocol && !protocol.endsWith(':')) protocol += ':';
|
||
if (urlObj.slashes || (!protocol || slashedProtocols.test(protocol)) && host !== false) {
|
||
host = '//' + (host || '');
|
||
if (pathname && pathname[0] !== '/') pathname = '/' + pathname;
|
||
} else if (!host) {
|
||
host = '';
|
||
}
|
||
if (hash && hash[0] !== '#') hash = '#' + hash;
|
||
if (search && search[0] !== '?') search = '?' + search;
|
||
pathname = pathname.replace(/[?#]/g, encodeURIComponent);
|
||
search = search.replace('#', '%23');
|
||
return `${protocol}${host}${pathname}${search}${hash}`;
|
||
}
|
||
const urlObjectKeys = [
|
||
'auth',
|
||
'hash',
|
||
'host',
|
||
'hostname',
|
||
'href',
|
||
'path',
|
||
'pathname',
|
||
'port',
|
||
'protocol',
|
||
'query',
|
||
'search',
|
||
'slashes'
|
||
];
|
||
function formatWithValidation(url) {
|
||
if ("TURBOPACK compile-time truthy", 1) {
|
||
if (url !== null && typeof url === 'object') {
|
||
Object.keys(url).forEach((key)=>{
|
||
if (!urlObjectKeys.includes(key)) {
|
||
console.warn(`Unknown key passed via urlObject into url.format: ${key}`);
|
||
}
|
||
});
|
||
}
|
||
}
|
||
return formatUrl(url);
|
||
} //# sourceMappingURL=format-url.js.map
|
||
}),
|
||
"[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/client/use-merged-ref.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
"use strict";
|
||
|
||
Object.defineProperty(exports, "__esModule", {
|
||
value: true
|
||
});
|
||
Object.defineProperty(exports, "useMergedRef", {
|
||
enumerable: true,
|
||
get: function() {
|
||
return useMergedRef;
|
||
}
|
||
});
|
||
const _react = __turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/compiled/react/index.js [app-client] (ecmascript)");
|
||
function useMergedRef(refA, refB) {
|
||
const cleanupA = (0, _react.useRef)(null);
|
||
const cleanupB = (0, _react.useRef)(null);
|
||
// NOTE: In theory, we could skip the wrapping if only one of the refs is non-null.
|
||
// (this happens often if the user doesn't pass a ref to Link/Form/Image)
|
||
// But this can cause us to leak a cleanup-ref into user code (previously via `<Link legacyBehavior>`),
|
||
// and the user might pass that ref into ref-merging library that doesn't support cleanup refs
|
||
// (because it hasn't been updated for React 19)
|
||
// which can then cause things to blow up, because a cleanup-returning ref gets called with `null`.
|
||
// So in practice, it's safer to be defensive and always wrap the ref, even on React 19.
|
||
return (0, _react.useCallback)((current)=>{
|
||
if (current === null) {
|
||
const cleanupFnA = cleanupA.current;
|
||
if (cleanupFnA) {
|
||
cleanupA.current = null;
|
||
cleanupFnA();
|
||
}
|
||
const cleanupFnB = cleanupB.current;
|
||
if (cleanupFnB) {
|
||
cleanupB.current = null;
|
||
cleanupFnB();
|
||
}
|
||
} else {
|
||
if (refA) {
|
||
cleanupA.current = applyRef(refA, current);
|
||
}
|
||
if (refB) {
|
||
cleanupB.current = applyRef(refB, current);
|
||
}
|
||
}
|
||
}, [
|
||
refA,
|
||
refB
|
||
]);
|
||
}
|
||
function applyRef(refA, current) {
|
||
if (typeof refA === 'function') {
|
||
const cleanup = refA(current);
|
||
if (typeof cleanup === 'function') {
|
||
return cleanup;
|
||
} else {
|
||
return ()=>refA(null);
|
||
}
|
||
} else {
|
||
refA.current = current;
|
||
return ()=>{
|
||
refA.current = null;
|
||
};
|
||
}
|
||
}
|
||
if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
|
||
Object.defineProperty(exports.default, '__esModule', {
|
||
value: true
|
||
});
|
||
Object.assign(exports.default, exports);
|
||
module.exports = exports.default;
|
||
} //# sourceMappingURL=use-merged-ref.js.map
|
||
}),
|
||
"[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/shared/lib/utils.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
"use strict";
|
||
|
||
var __TURBOPACK__imported__module__$5b$project$5d2f$Documents$2f$go$2d$new$2f$chinese$2d$family$2d$tree$2f$node_modules$2f2e$pnpm$2f$next$40$16$2e$0$2e$3_react$2d$dom$40$19$2e$2$2e$0_react$40$19$2e$2$2e$0_$5f$react$40$19$2e$2$2e$0$2f$node_modules$2f$next$2f$dist$2f$build$2f$polyfills$2f$process$2e$js__$5b$app$2d$client$5d$__$28$ecmascript$29$__ = /*#__PURE__*/ __turbopack_context__.i("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/build/polyfills/process.js [app-client] (ecmascript)");
|
||
"use strict";
|
||
Object.defineProperty(exports, "__esModule", {
|
||
value: true
|
||
});
|
||
0 && (module.exports = {
|
||
DecodeError: null,
|
||
MiddlewareNotFoundError: null,
|
||
MissingStaticPage: null,
|
||
NormalizeError: null,
|
||
PageNotFoundError: null,
|
||
SP: null,
|
||
ST: null,
|
||
WEB_VITALS: null,
|
||
execOnce: null,
|
||
getDisplayName: null,
|
||
getLocationOrigin: null,
|
||
getURL: null,
|
||
isAbsoluteUrl: null,
|
||
isResSent: null,
|
||
loadGetInitialProps: null,
|
||
normalizeRepeatedSlashes: null,
|
||
stringifyError: null
|
||
});
|
||
function _export(target, all) {
|
||
for(var name in all)Object.defineProperty(target, name, {
|
||
enumerable: true,
|
||
get: all[name]
|
||
});
|
||
}
|
||
_export(exports, {
|
||
DecodeError: function() {
|
||
return DecodeError;
|
||
},
|
||
MiddlewareNotFoundError: function() {
|
||
return MiddlewareNotFoundError;
|
||
},
|
||
MissingStaticPage: function() {
|
||
return MissingStaticPage;
|
||
},
|
||
NormalizeError: function() {
|
||
return NormalizeError;
|
||
},
|
||
PageNotFoundError: function() {
|
||
return PageNotFoundError;
|
||
},
|
||
SP: function() {
|
||
return SP;
|
||
},
|
||
ST: function() {
|
||
return ST;
|
||
},
|
||
WEB_VITALS: function() {
|
||
return WEB_VITALS;
|
||
},
|
||
execOnce: function() {
|
||
return execOnce;
|
||
},
|
||
getDisplayName: function() {
|
||
return getDisplayName;
|
||
},
|
||
getLocationOrigin: function() {
|
||
return getLocationOrigin;
|
||
},
|
||
getURL: function() {
|
||
return getURL;
|
||
},
|
||
isAbsoluteUrl: function() {
|
||
return isAbsoluteUrl;
|
||
},
|
||
isResSent: function() {
|
||
return isResSent;
|
||
},
|
||
loadGetInitialProps: function() {
|
||
return loadGetInitialProps;
|
||
},
|
||
normalizeRepeatedSlashes: function() {
|
||
return normalizeRepeatedSlashes;
|
||
},
|
||
stringifyError: function() {
|
||
return stringifyError;
|
||
}
|
||
});
|
||
const WEB_VITALS = [
|
||
'CLS',
|
||
'FCP',
|
||
'FID',
|
||
'INP',
|
||
'LCP',
|
||
'TTFB'
|
||
];
|
||
function execOnce(fn) {
|
||
let used = false;
|
||
let result;
|
||
return (...args)=>{
|
||
if (!used) {
|
||
used = true;
|
||
result = fn(...args);
|
||
}
|
||
return result;
|
||
};
|
||
}
|
||
// Scheme: https://tools.ietf.org/html/rfc3986#section-3.1
|
||
// Absolute URL: https://tools.ietf.org/html/rfc3986#section-4.3
|
||
const ABSOLUTE_URL_REGEX = /^[a-zA-Z][a-zA-Z\d+\-.]*?:/;
|
||
const isAbsoluteUrl = (url)=>ABSOLUTE_URL_REGEX.test(url);
|
||
function getLocationOrigin() {
|
||
const { protocol, hostname, port } = window.location;
|
||
return `${protocol}//${hostname}${port ? ':' + port : ''}`;
|
||
}
|
||
function getURL() {
|
||
const { href } = window.location;
|
||
const origin = getLocationOrigin();
|
||
return href.substring(origin.length);
|
||
}
|
||
function getDisplayName(Component) {
|
||
return typeof Component === 'string' ? Component : Component.displayName || Component.name || 'Unknown';
|
||
}
|
||
function isResSent(res) {
|
||
return res.finished || res.headersSent;
|
||
}
|
||
function normalizeRepeatedSlashes(url) {
|
||
const urlParts = url.split('?');
|
||
const urlNoQuery = urlParts[0];
|
||
return urlNoQuery // first we replace any non-encoded backslashes with forward
|
||
// then normalize repeated forward slashes
|
||
.replace(/\\/g, '/').replace(/\/\/+/g, '/') + (urlParts[1] ? `?${urlParts.slice(1).join('?')}` : '');
|
||
}
|
||
async function loadGetInitialProps(App, ctx) {
|
||
if ("TURBOPACK compile-time truthy", 1) {
|
||
if (App.prototype?.getInitialProps) {
|
||
const message = `"${getDisplayName(App)}.getInitialProps()" is defined as an instance method - visit https://nextjs.org/docs/messages/get-initial-props-as-an-instance-method for more information.`;
|
||
throw Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
|
||
value: "E394",
|
||
enumerable: false,
|
||
configurable: true
|
||
});
|
||
}
|
||
}
|
||
// when called from _app `ctx` is nested in `ctx`
|
||
const res = ctx.res || ctx.ctx && ctx.ctx.res;
|
||
if (!App.getInitialProps) {
|
||
if (ctx.ctx && ctx.Component) {
|
||
// @ts-ignore pageProps default
|
||
return {
|
||
pageProps: await loadGetInitialProps(ctx.Component, ctx.ctx)
|
||
};
|
||
}
|
||
return {};
|
||
}
|
||
const props = await App.getInitialProps(ctx);
|
||
if (res && isResSent(res)) {
|
||
return props;
|
||
}
|
||
if (!props) {
|
||
const message = `"${getDisplayName(App)}.getInitialProps()" should resolve to an object. But found "${props}" instead.`;
|
||
throw Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
|
||
value: "E394",
|
||
enumerable: false,
|
||
configurable: true
|
||
});
|
||
}
|
||
if ("TURBOPACK compile-time truthy", 1) {
|
||
if (Object.keys(props).length === 0 && !ctx.ctx) {
|
||
console.warn(`${getDisplayName(App)} returned an empty object from \`getInitialProps\`. This de-optimizes and prevents automatic static optimization. https://nextjs.org/docs/messages/empty-object-getInitialProps`);
|
||
}
|
||
}
|
||
return props;
|
||
}
|
||
const SP = typeof performance !== 'undefined';
|
||
const ST = SP && [
|
||
'mark',
|
||
'measure',
|
||
'getEntriesByName'
|
||
].every((method)=>typeof performance[method] === 'function');
|
||
class DecodeError extends Error {
|
||
}
|
||
class NormalizeError extends Error {
|
||
}
|
||
class PageNotFoundError extends Error {
|
||
constructor(page){
|
||
super();
|
||
this.code = 'ENOENT';
|
||
this.name = 'PageNotFoundError';
|
||
this.message = `Cannot find module for page: ${page}`;
|
||
}
|
||
}
|
||
class MissingStaticPage extends Error {
|
||
constructor(page, message){
|
||
super();
|
||
this.message = `Failed to load static file for page: ${page} ${message}`;
|
||
}
|
||
}
|
||
class MiddlewareNotFoundError extends Error {
|
||
constructor(){
|
||
super();
|
||
this.code = 'ENOENT';
|
||
this.message = `Cannot find the middleware module`;
|
||
}
|
||
}
|
||
function stringifyError(error) {
|
||
return JSON.stringify({
|
||
message: error.message,
|
||
stack: error.stack
|
||
});
|
||
} //# sourceMappingURL=utils.js.map
|
||
}),
|
||
"[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/shared/lib/router/utils/is-local-url.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
"use strict";
|
||
|
||
Object.defineProperty(exports, "__esModule", {
|
||
value: true
|
||
});
|
||
Object.defineProperty(exports, "isLocalURL", {
|
||
enumerable: true,
|
||
get: function() {
|
||
return isLocalURL;
|
||
}
|
||
});
|
||
const _utils = __turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/shared/lib/utils.js [app-client] (ecmascript)");
|
||
const _hasbasepath = __turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/client/has-base-path.js [app-client] (ecmascript)");
|
||
function isLocalURL(url) {
|
||
// prevent a hydration mismatch on href for url with anchor refs
|
||
if (!(0, _utils.isAbsoluteUrl)(url)) return true;
|
||
try {
|
||
// absolute urls can be local if they are on the same origin
|
||
const locationOrigin = (0, _utils.getLocationOrigin)();
|
||
const resolved = new URL(url, locationOrigin);
|
||
return resolved.origin === locationOrigin && (0, _hasbasepath.hasBasePath)(resolved.pathname);
|
||
} catch (_) {
|
||
return false;
|
||
}
|
||
} //# sourceMappingURL=is-local-url.js.map
|
||
}),
|
||
"[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/shared/lib/utils/error-once.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
"use strict";
|
||
|
||
var __TURBOPACK__imported__module__$5b$project$5d2f$Documents$2f$go$2d$new$2f$chinese$2d$family$2d$tree$2f$node_modules$2f2e$pnpm$2f$next$40$16$2e$0$2e$3_react$2d$dom$40$19$2e$2$2e$0_react$40$19$2e$2$2e$0_$5f$react$40$19$2e$2$2e$0$2f$node_modules$2f$next$2f$dist$2f$build$2f$polyfills$2f$process$2e$js__$5b$app$2d$client$5d$__$28$ecmascript$29$__ = /*#__PURE__*/ __turbopack_context__.i("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/build/polyfills/process.js [app-client] (ecmascript)");
|
||
"use strict";
|
||
Object.defineProperty(exports, "__esModule", {
|
||
value: true
|
||
});
|
||
Object.defineProperty(exports, "errorOnce", {
|
||
enumerable: true,
|
||
get: function() {
|
||
return errorOnce;
|
||
}
|
||
});
|
||
let errorOnce = (_)=>{};
|
||
if ("TURBOPACK compile-time truthy", 1) {
|
||
const errors = new Set();
|
||
errorOnce = (msg)=>{
|
||
if (!errors.has(msg)) {
|
||
console.error(msg);
|
||
}
|
||
errors.add(msg);
|
||
};
|
||
} //# sourceMappingURL=error-once.js.map
|
||
}),
|
||
"[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/client/app-dir/link.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
"use strict";
|
||
|
||
var __TURBOPACK__imported__module__$5b$project$5d2f$Documents$2f$go$2d$new$2f$chinese$2d$family$2d$tree$2f$node_modules$2f2e$pnpm$2f$next$40$16$2e$0$2e$3_react$2d$dom$40$19$2e$2$2e$0_react$40$19$2e$2$2e$0_$5f$react$40$19$2e$2$2e$0$2f$node_modules$2f$next$2f$dist$2f$build$2f$polyfills$2f$process$2e$js__$5b$app$2d$client$5d$__$28$ecmascript$29$__ = /*#__PURE__*/ __turbopack_context__.i("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/build/polyfills/process.js [app-client] (ecmascript)");
|
||
'use client';
|
||
"use strict";
|
||
Object.defineProperty(exports, "__esModule", {
|
||
value: true
|
||
});
|
||
0 && (module.exports = {
|
||
default: null,
|
||
useLinkStatus: null
|
||
});
|
||
function _export(target, all) {
|
||
for(var name in all)Object.defineProperty(target, name, {
|
||
enumerable: true,
|
||
get: all[name]
|
||
});
|
||
}
|
||
_export(exports, {
|
||
/**
|
||
* A React component that extends the HTML `<a>` element to provide
|
||
* [prefetching](https://nextjs.org/docs/app/building-your-application/routing/linking-and-navigating#2-prefetching)
|
||
* and client-side navigation. This is the primary way to navigate between routes in Next.js.
|
||
*
|
||
* @remarks
|
||
* - Prefetching is only enabled in production.
|
||
*
|
||
* @see https://nextjs.org/docs/app/api-reference/components/link
|
||
*/ default: function() {
|
||
return LinkComponent;
|
||
},
|
||
useLinkStatus: function() {
|
||
return useLinkStatus;
|
||
}
|
||
});
|
||
const _interop_require_wildcard = __turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/@swc+helpers@0.5.15/node_modules/@swc/helpers/cjs/_interop_require_wildcard.cjs [app-client] (ecmascript)");
|
||
const _jsxruntime = __turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/compiled/react/jsx-runtime.js [app-client] (ecmascript)");
|
||
const _react = /*#__PURE__*/ _interop_require_wildcard._(__turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/compiled/react/index.js [app-client] (ecmascript)"));
|
||
const _formaturl = __turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/shared/lib/router/utils/format-url.js [app-client] (ecmascript)");
|
||
const _approutercontextsharedruntime = __turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/shared/lib/app-router-context.shared-runtime.js [app-client] (ecmascript)");
|
||
const _usemergedref = __turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/client/use-merged-ref.js [app-client] (ecmascript)");
|
||
const _utils = __turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/shared/lib/utils.js [app-client] (ecmascript)");
|
||
const _addbasepath = __turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/client/add-base-path.js [app-client] (ecmascript)");
|
||
const _warnonce = __turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/shared/lib/utils/warn-once.js [app-client] (ecmascript)");
|
||
const _links = __turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/client/components/links.js [app-client] (ecmascript)");
|
||
const _islocalurl = __turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/shared/lib/router/utils/is-local-url.js [app-client] (ecmascript)");
|
||
const _types = __turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/client/components/segment-cache/types.js [app-client] (ecmascript)");
|
||
const _erroronce = __turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/shared/lib/utils/error-once.js [app-client] (ecmascript)");
|
||
function isModifiedEvent(event) {
|
||
const eventTarget = event.currentTarget;
|
||
const target = eventTarget.getAttribute('target');
|
||
return target && target !== '_self' || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey || // triggers resource download
|
||
event.nativeEvent && event.nativeEvent.which === 2;
|
||
}
|
||
function linkClicked(e, href, as, linkInstanceRef, replace, scroll, onNavigate) {
|
||
if (typeof window !== 'undefined') {
|
||
const { nodeName } = e.currentTarget;
|
||
// anchors inside an svg have a lowercase nodeName
|
||
const isAnchorNodeName = nodeName.toUpperCase() === 'A';
|
||
if (isAnchorNodeName && isModifiedEvent(e) || e.currentTarget.hasAttribute('download')) {
|
||
// ignore click for browser’s default behavior
|
||
return;
|
||
}
|
||
if (!(0, _islocalurl.isLocalURL)(href)) {
|
||
if (replace) {
|
||
// browser default behavior does not replace the history state
|
||
// so we need to do it manually
|
||
e.preventDefault();
|
||
location.replace(href);
|
||
}
|
||
// ignore click for browser’s default behavior
|
||
return;
|
||
}
|
||
e.preventDefault();
|
||
if (onNavigate) {
|
||
let isDefaultPrevented = false;
|
||
onNavigate({
|
||
preventDefault: ()=>{
|
||
isDefaultPrevented = true;
|
||
}
|
||
});
|
||
if (isDefaultPrevented) {
|
||
return;
|
||
}
|
||
}
|
||
const { dispatchNavigateAction } = __turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/client/components/app-router-instance.js [app-client] (ecmascript)");
|
||
_react.default.startTransition(()=>{
|
||
dispatchNavigateAction(as || href, replace ? 'replace' : 'push', scroll ?? true, linkInstanceRef.current);
|
||
});
|
||
}
|
||
}
|
||
function formatStringOrUrl(urlObjOrString) {
|
||
if (typeof urlObjOrString === 'string') {
|
||
return urlObjOrString;
|
||
}
|
||
return (0, _formaturl.formatUrl)(urlObjOrString);
|
||
}
|
||
function LinkComponent(props) {
|
||
const [linkStatus, setOptimisticLinkStatus] = (0, _react.useOptimistic)(_links.IDLE_LINK_STATUS);
|
||
let children;
|
||
const linkInstanceRef = (0, _react.useRef)(null);
|
||
const { href: hrefProp, as: asProp, children: childrenProp, prefetch: prefetchProp = null, passHref, replace, shallow, scroll, onClick, onMouseEnter: onMouseEnterProp, onTouchStart: onTouchStartProp, legacyBehavior = false, onNavigate, ref: forwardedRef, unstable_dynamicOnHover, ...restProps } = props;
|
||
children = childrenProp;
|
||
if (legacyBehavior && (typeof children === 'string' || typeof children === 'number')) {
|
||
children = /*#__PURE__*/ (0, _jsxruntime.jsx)("a", {
|
||
children: children
|
||
});
|
||
}
|
||
const router = _react.default.useContext(_approutercontextsharedruntime.AppRouterContext);
|
||
const prefetchEnabled = prefetchProp !== false;
|
||
const fetchStrategy = prefetchProp !== false ? getFetchStrategyFromPrefetchProp(prefetchProp) : _types.FetchStrategy.PPR;
|
||
if ("TURBOPACK compile-time truthy", 1) {
|
||
function createPropError(args) {
|
||
return Object.defineProperty(new Error(`Failed prop type: The prop \`${args.key}\` expects a ${args.expected} in \`<Link>\`, but got \`${args.actual}\` instead.` + (typeof window !== 'undefined' ? "\nOpen your browser's console to view the Component stack trace." : '')), "__NEXT_ERROR_CODE", {
|
||
value: "E319",
|
||
enumerable: false,
|
||
configurable: true
|
||
});
|
||
}
|
||
// TypeScript trick for type-guarding:
|
||
const requiredPropsGuard = {
|
||
href: true
|
||
};
|
||
const requiredProps = Object.keys(requiredPropsGuard);
|
||
requiredProps.forEach((key)=>{
|
||
if (key === 'href') {
|
||
if (props[key] == null || typeof props[key] !== 'string' && typeof props[key] !== 'object') {
|
||
throw createPropError({
|
||
key,
|
||
expected: '`string` or `object`',
|
||
actual: props[key] === null ? 'null' : typeof props[key]
|
||
});
|
||
}
|
||
} else {
|
||
// TypeScript trick for type-guarding:
|
||
const _ = key;
|
||
}
|
||
});
|
||
// TypeScript trick for type-guarding:
|
||
const optionalPropsGuard = {
|
||
as: true,
|
||
replace: true,
|
||
scroll: true,
|
||
shallow: true,
|
||
passHref: true,
|
||
prefetch: true,
|
||
unstable_dynamicOnHover: true,
|
||
onClick: true,
|
||
onMouseEnter: true,
|
||
onTouchStart: true,
|
||
legacyBehavior: true,
|
||
onNavigate: true
|
||
};
|
||
const optionalProps = Object.keys(optionalPropsGuard);
|
||
optionalProps.forEach((key)=>{
|
||
const valType = typeof props[key];
|
||
if (key === 'as') {
|
||
if (props[key] && valType !== 'string' && valType !== 'object') {
|
||
throw createPropError({
|
||
key,
|
||
expected: '`string` or `object`',
|
||
actual: valType
|
||
});
|
||
}
|
||
} else if (key === 'onClick' || key === 'onMouseEnter' || key === 'onTouchStart' || key === 'onNavigate') {
|
||
if (props[key] && valType !== 'function') {
|
||
throw createPropError({
|
||
key,
|
||
expected: '`function`',
|
||
actual: valType
|
||
});
|
||
}
|
||
} else if (key === 'replace' || key === 'scroll' || key === 'shallow' || key === 'passHref' || key === 'legacyBehavior' || key === 'unstable_dynamicOnHover') {
|
||
if (props[key] != null && valType !== 'boolean') {
|
||
throw createPropError({
|
||
key,
|
||
expected: '`boolean`',
|
||
actual: valType
|
||
});
|
||
}
|
||
} else if (key === 'prefetch') {
|
||
if (props[key] != null && valType !== 'boolean' && props[key] !== 'auto') {
|
||
throw createPropError({
|
||
key,
|
||
expected: '`boolean | "auto"`',
|
||
actual: valType
|
||
});
|
||
}
|
||
} else {
|
||
// TypeScript trick for type-guarding:
|
||
const _ = key;
|
||
}
|
||
});
|
||
}
|
||
if ("TURBOPACK compile-time truthy", 1) {
|
||
if (props.locale) {
|
||
(0, _warnonce.warnOnce)('The `locale` prop is not supported in `next/link` while using the `app` router. Read more about app router internalization: https://nextjs.org/docs/app/building-your-application/routing/internationalization');
|
||
}
|
||
if (!asProp) {
|
||
let href;
|
||
if (typeof hrefProp === 'string') {
|
||
href = hrefProp;
|
||
} else if (typeof hrefProp === 'object' && typeof hrefProp.pathname === 'string') {
|
||
href = hrefProp.pathname;
|
||
}
|
||
if (href) {
|
||
const hasDynamicSegment = href.split('/').some((segment)=>segment.startsWith('[') && segment.endsWith(']'));
|
||
if (hasDynamicSegment) {
|
||
throw Object.defineProperty(new Error(`Dynamic href \`${href}\` found in <Link> while using the \`/app\` router, this is not supported. Read more: https://nextjs.org/docs/messages/app-dir-dynamic-href`), "__NEXT_ERROR_CODE", {
|
||
value: "E267",
|
||
enumerable: false,
|
||
configurable: true
|
||
});
|
||
}
|
||
}
|
||
}
|
||
}
|
||
const { href, as } = _react.default.useMemo({
|
||
"LinkComponent.useMemo": ()=>{
|
||
const resolvedHref = formatStringOrUrl(hrefProp);
|
||
return {
|
||
href: resolvedHref,
|
||
as: asProp ? formatStringOrUrl(asProp) : resolvedHref
|
||
};
|
||
}
|
||
}["LinkComponent.useMemo"], [
|
||
hrefProp,
|
||
asProp
|
||
]);
|
||
// This will return the first child, if multiple are provided it will throw an error
|
||
let child;
|
||
if (legacyBehavior) {
|
||
if (children?.$$typeof === Symbol.for('react.lazy')) {
|
||
throw Object.defineProperty(new Error(`\`<Link legacyBehavior>\` received a direct child that is either a Server Component, or JSX that was loaded with React.lazy(). This is not supported. Either remove legacyBehavior, or make the direct child a Client Component that renders the Link's \`<a>\` tag.`), "__NEXT_ERROR_CODE", {
|
||
value: "E863",
|
||
enumerable: false,
|
||
configurable: true
|
||
});
|
||
}
|
||
if ("TURBOPACK compile-time truthy", 1) {
|
||
if (onClick) {
|
||
console.warn(`"onClick" was passed to <Link> with \`href\` of \`${hrefProp}\` but "legacyBehavior" was set. The legacy behavior requires onClick be set on the child of next/link`);
|
||
}
|
||
if (onMouseEnterProp) {
|
||
console.warn(`"onMouseEnter" was passed to <Link> with \`href\` of \`${hrefProp}\` but "legacyBehavior" was set. The legacy behavior requires onMouseEnter be set on the child of next/link`);
|
||
}
|
||
try {
|
||
child = _react.default.Children.only(children);
|
||
} catch (err) {
|
||
if (!children) {
|
||
throw Object.defineProperty(new Error(`No children were passed to <Link> with \`href\` of \`${hrefProp}\` but one child is required https://nextjs.org/docs/messages/link-no-children`), "__NEXT_ERROR_CODE", {
|
||
value: "E320",
|
||
enumerable: false,
|
||
configurable: true
|
||
});
|
||
}
|
||
throw Object.defineProperty(new Error(`Multiple children were passed to <Link> with \`href\` of \`${hrefProp}\` but only one child is supported https://nextjs.org/docs/messages/link-multiple-children` + (typeof window !== 'undefined' ? " \nOpen your browser's console to view the Component stack trace." : '')), "__NEXT_ERROR_CODE", {
|
||
value: "E266",
|
||
enumerable: false,
|
||
configurable: true
|
||
});
|
||
}
|
||
} else //TURBOPACK unreachable
|
||
;
|
||
} else {
|
||
if ("TURBOPACK compile-time truthy", 1) {
|
||
if (children?.type === 'a') {
|
||
throw Object.defineProperty(new Error('Invalid <Link> with <a> child. Please remove <a> or use <Link legacyBehavior>.\nLearn more: https://nextjs.org/docs/messages/invalid-new-link-with-extra-anchor'), "__NEXT_ERROR_CODE", {
|
||
value: "E209",
|
||
enumerable: false,
|
||
configurable: true
|
||
});
|
||
}
|
||
}
|
||
}
|
||
const childRef = legacyBehavior ? child && typeof child === 'object' && child.ref : forwardedRef;
|
||
// Use a callback ref to attach an IntersectionObserver to the anchor tag on
|
||
// mount. In the future we will also use this to keep track of all the
|
||
// currently mounted <Link> instances, e.g. so we can re-prefetch them after
|
||
// a revalidation or refresh.
|
||
const observeLinkVisibilityOnMount = _react.default.useCallback({
|
||
"LinkComponent.useCallback[observeLinkVisibilityOnMount]": (element)=>{
|
||
if (router !== null) {
|
||
linkInstanceRef.current = (0, _links.mountLinkInstance)(element, href, router, fetchStrategy, prefetchEnabled, setOptimisticLinkStatus);
|
||
}
|
||
return ({
|
||
"LinkComponent.useCallback[observeLinkVisibilityOnMount]": ()=>{
|
||
if (linkInstanceRef.current) {
|
||
(0, _links.unmountLinkForCurrentNavigation)(linkInstanceRef.current);
|
||
linkInstanceRef.current = null;
|
||
}
|
||
(0, _links.unmountPrefetchableInstance)(element);
|
||
}
|
||
})["LinkComponent.useCallback[observeLinkVisibilityOnMount]"];
|
||
}
|
||
}["LinkComponent.useCallback[observeLinkVisibilityOnMount]"], [
|
||
prefetchEnabled,
|
||
href,
|
||
router,
|
||
fetchStrategy,
|
||
setOptimisticLinkStatus
|
||
]);
|
||
const mergedRef = (0, _usemergedref.useMergedRef)(observeLinkVisibilityOnMount, childRef);
|
||
const childProps = {
|
||
ref: mergedRef,
|
||
onClick (e) {
|
||
if ("TURBOPACK compile-time truthy", 1) {
|
||
if (!e) {
|
||
throw Object.defineProperty(new Error(`Component rendered inside next/link has to pass click event to "onClick" prop.`), "__NEXT_ERROR_CODE", {
|
||
value: "E312",
|
||
enumerable: false,
|
||
configurable: true
|
||
});
|
||
}
|
||
}
|
||
if (!legacyBehavior && typeof onClick === 'function') {
|
||
onClick(e);
|
||
}
|
||
if (legacyBehavior && child.props && typeof child.props.onClick === 'function') {
|
||
child.props.onClick(e);
|
||
}
|
||
if (!router) {
|
||
return;
|
||
}
|
||
if (e.defaultPrevented) {
|
||
return;
|
||
}
|
||
linkClicked(e, href, as, linkInstanceRef, replace, scroll, onNavigate);
|
||
},
|
||
onMouseEnter (e) {
|
||
if (!legacyBehavior && typeof onMouseEnterProp === 'function') {
|
||
onMouseEnterProp(e);
|
||
}
|
||
if (legacyBehavior && child.props && typeof child.props.onMouseEnter === 'function') {
|
||
child.props.onMouseEnter(e);
|
||
}
|
||
if (!router) {
|
||
return;
|
||
}
|
||
if ("TURBOPACK compile-time truthy", 1) {
|
||
return;
|
||
}
|
||
//TURBOPACK unreachable
|
||
;
|
||
const upgradeToDynamicPrefetch = undefined;
|
||
},
|
||
onTouchStart: ("TURBOPACK compile-time falsy", 0) ? "TURBOPACK unreachable" : function onTouchStart(e) {
|
||
if (!legacyBehavior && typeof onTouchStartProp === 'function') {
|
||
onTouchStartProp(e);
|
||
}
|
||
if (legacyBehavior && child.props && typeof child.props.onTouchStart === 'function') {
|
||
child.props.onTouchStart(e);
|
||
}
|
||
if (!router) {
|
||
return;
|
||
}
|
||
if (!prefetchEnabled) {
|
||
return;
|
||
}
|
||
const upgradeToDynamicPrefetch = unstable_dynamicOnHover === true;
|
||
(0, _links.onNavigationIntent)(e.currentTarget, upgradeToDynamicPrefetch);
|
||
}
|
||
};
|
||
// If the url is absolute, we can bypass the logic to prepend the basePath.
|
||
if ((0, _utils.isAbsoluteUrl)(as)) {
|
||
childProps.href = as;
|
||
} else if (!legacyBehavior || passHref || child.type === 'a' && !('href' in child.props)) {
|
||
childProps.href = (0, _addbasepath.addBasePath)(as);
|
||
}
|
||
let link;
|
||
if (legacyBehavior) {
|
||
if ("TURBOPACK compile-time truthy", 1) {
|
||
(0, _erroronce.errorOnce)('`legacyBehavior` is deprecated and will be removed in a future ' + 'release. A codemod is available to upgrade your components:\n\n' + 'npx @next/codemod@latest new-link .\n\n' + 'Learn more: https://nextjs.org/docs/app/building-your-application/upgrading/codemods#remove-a-tags-from-link-components');
|
||
}
|
||
link = /*#__PURE__*/ _react.default.cloneElement(child, childProps);
|
||
} else {
|
||
link = /*#__PURE__*/ (0, _jsxruntime.jsx)("a", {
|
||
...restProps,
|
||
...childProps,
|
||
children: children
|
||
});
|
||
}
|
||
return /*#__PURE__*/ (0, _jsxruntime.jsx)(LinkStatusContext.Provider, {
|
||
value: linkStatus,
|
||
children: link
|
||
});
|
||
}
|
||
const LinkStatusContext = /*#__PURE__*/ (0, _react.createContext)(_links.IDLE_LINK_STATUS);
|
||
const useLinkStatus = ()=>{
|
||
return (0, _react.useContext)(LinkStatusContext);
|
||
};
|
||
function getFetchStrategyFromPrefetchProp(prefetchProp) {
|
||
if ("TURBOPACK compile-time falsy", 0) //TURBOPACK unreachable
|
||
;
|
||
else {
|
||
return prefetchProp === null || prefetchProp === 'auto' ? _types.FetchStrategy.PPR : // (although invalid values should've been filtered out by prop validation in dev)
|
||
_types.FetchStrategy.Full;
|
||
}
|
||
}
|
||
if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
|
||
Object.defineProperty(exports.default, '__esModule', {
|
||
value: true
|
||
});
|
||
Object.assign(exports.default, exports);
|
||
module.exports = exports.default;
|
||
} //# sourceMappingURL=link.js.map
|
||
}),
|
||
"[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/shared/lib/image-blur-svg.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
"use strict";
|
||
|
||
/**
|
||
* A shared function, used on both client and server, to generate a SVG blur placeholder.
|
||
*/ Object.defineProperty(exports, "__esModule", {
|
||
value: true
|
||
});
|
||
Object.defineProperty(exports, "getImageBlurSvg", {
|
||
enumerable: true,
|
||
get: function() {
|
||
return getImageBlurSvg;
|
||
}
|
||
});
|
||
function getImageBlurSvg({ widthInt, heightInt, blurWidth, blurHeight, blurDataURL, objectFit }) {
|
||
const std = 20;
|
||
const svgWidth = blurWidth ? blurWidth * 40 : widthInt;
|
||
const svgHeight = blurHeight ? blurHeight * 40 : heightInt;
|
||
const viewBox = svgWidth && svgHeight ? `viewBox='0 0 ${svgWidth} ${svgHeight}'` : '';
|
||
const preserveAspectRatio = viewBox ? 'none' : objectFit === 'contain' ? 'xMidYMid' : objectFit === 'cover' ? 'xMidYMid slice' : 'none';
|
||
return `%3Csvg xmlns='http://www.w3.org/2000/svg' ${viewBox}%3E%3Cfilter id='b' color-interpolation-filters='sRGB'%3E%3CfeGaussianBlur stdDeviation='${std}'/%3E%3CfeColorMatrix values='1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 100 -1' result='s'/%3E%3CfeFlood x='0' y='0' width='100%25' height='100%25'/%3E%3CfeComposite operator='out' in='s'/%3E%3CfeComposite in2='SourceGraphic'/%3E%3CfeGaussianBlur stdDeviation='${std}'/%3E%3C/filter%3E%3Cimage width='100%25' height='100%25' x='0' y='0' preserveAspectRatio='${preserveAspectRatio}' style='filter: url(%23b);' href='${blurDataURL}'/%3E%3C/svg%3E`;
|
||
} //# sourceMappingURL=image-blur-svg.js.map
|
||
}),
|
||
"[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/shared/lib/image-config.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
"use strict";
|
||
|
||
Object.defineProperty(exports, "__esModule", {
|
||
value: true
|
||
});
|
||
0 && (module.exports = {
|
||
VALID_LOADERS: null,
|
||
imageConfigDefault: null
|
||
});
|
||
function _export(target, all) {
|
||
for(var name in all)Object.defineProperty(target, name, {
|
||
enumerable: true,
|
||
get: all[name]
|
||
});
|
||
}
|
||
_export(exports, {
|
||
VALID_LOADERS: function() {
|
||
return VALID_LOADERS;
|
||
},
|
||
imageConfigDefault: function() {
|
||
return imageConfigDefault;
|
||
}
|
||
});
|
||
const VALID_LOADERS = [
|
||
'default',
|
||
'imgix',
|
||
'cloudinary',
|
||
'akamai',
|
||
'custom'
|
||
];
|
||
const imageConfigDefault = {
|
||
deviceSizes: [
|
||
640,
|
||
750,
|
||
828,
|
||
1080,
|
||
1200,
|
||
1920,
|
||
2048,
|
||
3840
|
||
],
|
||
imageSizes: [
|
||
32,
|
||
48,
|
||
64,
|
||
96,
|
||
128,
|
||
256,
|
||
384
|
||
],
|
||
path: '/_next/image',
|
||
loader: 'default',
|
||
loaderFile: '',
|
||
/**
|
||
* @deprecated Use `remotePatterns` instead to protect your application from malicious users.
|
||
*/ domains: [],
|
||
disableStaticImages: false,
|
||
minimumCacheTTL: 14400,
|
||
formats: [
|
||
'image/webp'
|
||
],
|
||
maximumRedirects: 3,
|
||
dangerouslyAllowLocalIP: false,
|
||
dangerouslyAllowSVG: false,
|
||
contentSecurityPolicy: `script-src 'none'; frame-src 'none'; sandbox;`,
|
||
contentDispositionType: 'attachment',
|
||
localPatterns: undefined,
|
||
remotePatterns: [],
|
||
qualities: [
|
||
75
|
||
],
|
||
unoptimized: false
|
||
}; //# sourceMappingURL=image-config.js.map
|
||
}),
|
||
"[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/shared/lib/get-img-props.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
"use strict";
|
||
|
||
var __TURBOPACK__imported__module__$5b$project$5d2f$Documents$2f$go$2d$new$2f$chinese$2d$family$2d$tree$2f$node_modules$2f2e$pnpm$2f$next$40$16$2e$0$2e$3_react$2d$dom$40$19$2e$2$2e$0_react$40$19$2e$2$2e$0_$5f$react$40$19$2e$2$2e$0$2f$node_modules$2f$next$2f$dist$2f$build$2f$polyfills$2f$process$2e$js__$5b$app$2d$client$5d$__$28$ecmascript$29$__ = /*#__PURE__*/ __turbopack_context__.i("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/build/polyfills/process.js [app-client] (ecmascript)");
|
||
"use strict";
|
||
Object.defineProperty(exports, "__esModule", {
|
||
value: true
|
||
});
|
||
Object.defineProperty(exports, "getImgProps", {
|
||
enumerable: true,
|
||
get: function() {
|
||
return getImgProps;
|
||
}
|
||
});
|
||
const _warnonce = __turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/shared/lib/utils/warn-once.js [app-client] (ecmascript)");
|
||
const _imageblursvg = __turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/shared/lib/image-blur-svg.js [app-client] (ecmascript)");
|
||
const _imageconfig = __turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/shared/lib/image-config.js [app-client] (ecmascript)");
|
||
const VALID_LOADING_VALUES = [
|
||
'lazy',
|
||
'eager',
|
||
undefined
|
||
];
|
||
// Object-fit values that are not valid background-size values
|
||
const INVALID_BACKGROUND_SIZE_VALUES = [
|
||
'-moz-initial',
|
||
'fill',
|
||
'none',
|
||
'scale-down',
|
||
undefined
|
||
];
|
||
function isStaticRequire(src) {
|
||
return src.default !== undefined;
|
||
}
|
||
function isStaticImageData(src) {
|
||
return src.src !== undefined;
|
||
}
|
||
function isStaticImport(src) {
|
||
return !!src && typeof src === 'object' && (isStaticRequire(src) || isStaticImageData(src));
|
||
}
|
||
const allImgs = new Map();
|
||
let perfObserver;
|
||
function getInt(x) {
|
||
if (typeof x === 'undefined') {
|
||
return x;
|
||
}
|
||
if (typeof x === 'number') {
|
||
return Number.isFinite(x) ? x : NaN;
|
||
}
|
||
if (typeof x === 'string' && /^[0-9]+$/.test(x)) {
|
||
return parseInt(x, 10);
|
||
}
|
||
return NaN;
|
||
}
|
||
function getWidths({ deviceSizes, allSizes }, width, sizes) {
|
||
if (sizes) {
|
||
// Find all the "vw" percent sizes used in the sizes prop
|
||
const viewportWidthRe = /(^|\s)(1?\d?\d)vw/g;
|
||
const percentSizes = [];
|
||
for(let match; match = viewportWidthRe.exec(sizes); match){
|
||
percentSizes.push(parseInt(match[2]));
|
||
}
|
||
if (percentSizes.length) {
|
||
const smallestRatio = Math.min(...percentSizes) * 0.01;
|
||
return {
|
||
widths: allSizes.filter((s)=>s >= deviceSizes[0] * smallestRatio),
|
||
kind: 'w'
|
||
};
|
||
}
|
||
return {
|
||
widths: allSizes,
|
||
kind: 'w'
|
||
};
|
||
}
|
||
if (typeof width !== 'number') {
|
||
return {
|
||
widths: deviceSizes,
|
||
kind: 'w'
|
||
};
|
||
}
|
||
const widths = [
|
||
...new Set(// > are actually 3x in the green color, but only 1.5x in the red and
|
||
// > blue colors. Showing a 3x resolution image in the app vs a 2x
|
||
// > resolution image will be visually the same, though the 3x image
|
||
// > takes significantly more data. Even true 3x resolution screens are
|
||
// > wasteful as the human eye cannot see that level of detail without
|
||
// > something like a magnifying glass.
|
||
// https://blog.twitter.com/engineering/en_us/topics/infrastructure/2019/capping-image-fidelity-on-ultra-high-resolution-devices.html
|
||
[
|
||
width,
|
||
width * 2 /*, width * 3*/
|
||
].map((w)=>allSizes.find((p)=>p >= w) || allSizes[allSizes.length - 1]))
|
||
];
|
||
return {
|
||
widths,
|
||
kind: 'x'
|
||
};
|
||
}
|
||
function generateImgAttrs({ config, src, unoptimized, width, quality, sizes, loader }) {
|
||
if (unoptimized) {
|
||
return {
|
||
src,
|
||
srcSet: undefined,
|
||
sizes: undefined
|
||
};
|
||
}
|
||
const { widths, kind } = getWidths(config, width, sizes);
|
||
const last = widths.length - 1;
|
||
return {
|
||
sizes: !sizes && kind === 'w' ? '100vw' : sizes,
|
||
srcSet: widths.map((w, i)=>`${loader({
|
||
config,
|
||
src,
|
||
quality,
|
||
width: w
|
||
})} ${kind === 'w' ? w : i + 1}${kind}`).join(', '),
|
||
// It's intended to keep `src` the last attribute because React updates
|
||
// attributes in order. If we keep `src` the first one, Safari will
|
||
// immediately start to fetch `src`, before `sizes` and `srcSet` are even
|
||
// updated by React. That causes multiple unnecessary requests if `srcSet`
|
||
// and `sizes` are defined.
|
||
// This bug cannot be reproduced in Chrome or Firefox.
|
||
src: loader({
|
||
config,
|
||
src,
|
||
quality,
|
||
width: widths[last]
|
||
})
|
||
};
|
||
}
|
||
function getImgProps({ src, sizes, unoptimized = false, priority = false, preload = false, loading, className, quality, width, height, fill = false, style, overrideSrc, onLoad, onLoadingComplete, placeholder = 'empty', blurDataURL, fetchPriority, decoding = 'async', layout, objectFit, objectPosition, lazyBoundary, lazyRoot, ...rest }, _state) {
|
||
const { imgConf, showAltText, blurComplete, defaultLoader } = _state;
|
||
let config;
|
||
let c = imgConf || _imageconfig.imageConfigDefault;
|
||
if ('allSizes' in c) {
|
||
config = c;
|
||
} else {
|
||
const allSizes = [
|
||
...c.deviceSizes,
|
||
...c.imageSizes
|
||
].sort((a, b)=>a - b);
|
||
const deviceSizes = c.deviceSizes.sort((a, b)=>a - b);
|
||
const qualities = c.qualities?.sort((a, b)=>a - b);
|
||
config = {
|
||
...c,
|
||
allSizes,
|
||
deviceSizes,
|
||
qualities
|
||
};
|
||
}
|
||
if (typeof defaultLoader === 'undefined') {
|
||
throw Object.defineProperty(new Error('images.loaderFile detected but the file is missing default export.\nRead more: https://nextjs.org/docs/messages/invalid-images-config'), "__NEXT_ERROR_CODE", {
|
||
value: "E163",
|
||
enumerable: false,
|
||
configurable: true
|
||
});
|
||
}
|
||
let loader = rest.loader || defaultLoader;
|
||
// Remove property so it's not spread on <img> element
|
||
delete rest.loader;
|
||
delete rest.srcSet;
|
||
// This special value indicates that the user
|
||
// didn't define a "loader" prop or "loader" config.
|
||
const isDefaultLoader = '__next_img_default' in loader;
|
||
if (isDefaultLoader) {
|
||
if (config.loader === 'custom') {
|
||
throw Object.defineProperty(new Error(`Image with src "${src}" is missing "loader" prop.` + `\nRead more: https://nextjs.org/docs/messages/next-image-missing-loader`), "__NEXT_ERROR_CODE", {
|
||
value: "E252",
|
||
enumerable: false,
|
||
configurable: true
|
||
});
|
||
}
|
||
} else {
|
||
// The user defined a "loader" prop or config.
|
||
// Since the config object is internal only, we
|
||
// must not pass it to the user-defined "loader".
|
||
const customImageLoader = loader;
|
||
loader = (obj)=>{
|
||
const { config: _, ...opts } = obj;
|
||
return customImageLoader(opts);
|
||
};
|
||
}
|
||
if (layout) {
|
||
if (layout === 'fill') {
|
||
fill = true;
|
||
}
|
||
const layoutToStyle = {
|
||
intrinsic: {
|
||
maxWidth: '100%',
|
||
height: 'auto'
|
||
},
|
||
responsive: {
|
||
width: '100%',
|
||
height: 'auto'
|
||
}
|
||
};
|
||
const layoutToSizes = {
|
||
responsive: '100vw',
|
||
fill: '100vw'
|
||
};
|
||
const layoutStyle = layoutToStyle[layout];
|
||
if (layoutStyle) {
|
||
style = {
|
||
...style,
|
||
...layoutStyle
|
||
};
|
||
}
|
||
const layoutSizes = layoutToSizes[layout];
|
||
if (layoutSizes && !sizes) {
|
||
sizes = layoutSizes;
|
||
}
|
||
}
|
||
let staticSrc = '';
|
||
let widthInt = getInt(width);
|
||
let heightInt = getInt(height);
|
||
let blurWidth;
|
||
let blurHeight;
|
||
if (isStaticImport(src)) {
|
||
const staticImageData = isStaticRequire(src) ? src.default : src;
|
||
if (!staticImageData.src) {
|
||
throw Object.defineProperty(new Error(`An object should only be passed to the image component src parameter if it comes from a static image import. It must include src. Received ${JSON.stringify(staticImageData)}`), "__NEXT_ERROR_CODE", {
|
||
value: "E460",
|
||
enumerable: false,
|
||
configurable: true
|
||
});
|
||
}
|
||
if (!staticImageData.height || !staticImageData.width) {
|
||
throw Object.defineProperty(new Error(`An object should only be passed to the image component src parameter if it comes from a static image import. It must include height and width. Received ${JSON.stringify(staticImageData)}`), "__NEXT_ERROR_CODE", {
|
||
value: "E48",
|
||
enumerable: false,
|
||
configurable: true
|
||
});
|
||
}
|
||
blurWidth = staticImageData.blurWidth;
|
||
blurHeight = staticImageData.blurHeight;
|
||
blurDataURL = blurDataURL || staticImageData.blurDataURL;
|
||
staticSrc = staticImageData.src;
|
||
if (!fill) {
|
||
if (!widthInt && !heightInt) {
|
||
widthInt = staticImageData.width;
|
||
heightInt = staticImageData.height;
|
||
} else if (widthInt && !heightInt) {
|
||
const ratio = widthInt / staticImageData.width;
|
||
heightInt = Math.round(staticImageData.height * ratio);
|
||
} else if (!widthInt && heightInt) {
|
||
const ratio = heightInt / staticImageData.height;
|
||
widthInt = Math.round(staticImageData.width * ratio);
|
||
}
|
||
}
|
||
}
|
||
src = typeof src === 'string' ? src : staticSrc;
|
||
let isLazy = !priority && !preload && (loading === 'lazy' || typeof loading === 'undefined');
|
||
if (!src || src.startsWith('data:') || src.startsWith('blob:')) {
|
||
// https://developer.mozilla.org/docs/Web/HTTP/Basics_of_HTTP/Data_URIs
|
||
unoptimized = true;
|
||
isLazy = false;
|
||
}
|
||
if (config.unoptimized) {
|
||
unoptimized = true;
|
||
}
|
||
if (isDefaultLoader && !config.dangerouslyAllowSVG && src.split('?', 1)[0].endsWith('.svg')) {
|
||
// Special case to make svg serve as-is to avoid proxying
|
||
// through the built-in Image Optimization API.
|
||
unoptimized = true;
|
||
}
|
||
const qualityInt = getInt(quality);
|
||
if ("TURBOPACK compile-time truthy", 1) {
|
||
if (config.output === 'export' && isDefaultLoader && !unoptimized) {
|
||
throw Object.defineProperty(new Error(`Image Optimization using the default loader is not compatible with \`{ output: 'export' }\`.
|
||
Possible solutions:
|
||
- Remove \`{ output: 'export' }\` and run "next start" to run server mode including the Image Optimization API.
|
||
- Configure \`{ images: { unoptimized: true } }\` in \`next.config.js\` to disable the Image Optimization API.
|
||
Read more: https://nextjs.org/docs/messages/export-image-api`), "__NEXT_ERROR_CODE", {
|
||
value: "E500",
|
||
enumerable: false,
|
||
configurable: true
|
||
});
|
||
}
|
||
if (!src) {
|
||
// React doesn't show the stack trace and there's
|
||
// no `src` to help identify which image, so we
|
||
// instead console.error(ref) during mount.
|
||
unoptimized = true;
|
||
} else {
|
||
if (fill) {
|
||
if (width) {
|
||
throw Object.defineProperty(new Error(`Image with src "${src}" has both "width" and "fill" properties. Only one should be used.`), "__NEXT_ERROR_CODE", {
|
||
value: "E96",
|
||
enumerable: false,
|
||
configurable: true
|
||
});
|
||
}
|
||
if (height) {
|
||
throw Object.defineProperty(new Error(`Image with src "${src}" has both "height" and "fill" properties. Only one should be used.`), "__NEXT_ERROR_CODE", {
|
||
value: "E115",
|
||
enumerable: false,
|
||
configurable: true
|
||
});
|
||
}
|
||
if (style?.position && style.position !== 'absolute') {
|
||
throw Object.defineProperty(new Error(`Image with src "${src}" has both "fill" and "style.position" properties. Images with "fill" always use position absolute - it cannot be modified.`), "__NEXT_ERROR_CODE", {
|
||
value: "E216",
|
||
enumerable: false,
|
||
configurable: true
|
||
});
|
||
}
|
||
if (style?.width && style.width !== '100%') {
|
||
throw Object.defineProperty(new Error(`Image with src "${src}" has both "fill" and "style.width" properties. Images with "fill" always use width 100% - it cannot be modified.`), "__NEXT_ERROR_CODE", {
|
||
value: "E73",
|
||
enumerable: false,
|
||
configurable: true
|
||
});
|
||
}
|
||
if (style?.height && style.height !== '100%') {
|
||
throw Object.defineProperty(new Error(`Image with src "${src}" has both "fill" and "style.height" properties. Images with "fill" always use height 100% - it cannot be modified.`), "__NEXT_ERROR_CODE", {
|
||
value: "E404",
|
||
enumerable: false,
|
||
configurable: true
|
||
});
|
||
}
|
||
} else {
|
||
if (typeof widthInt === 'undefined') {
|
||
throw Object.defineProperty(new Error(`Image with src "${src}" is missing required "width" property.`), "__NEXT_ERROR_CODE", {
|
||
value: "E451",
|
||
enumerable: false,
|
||
configurable: true
|
||
});
|
||
} else if (isNaN(widthInt)) {
|
||
throw Object.defineProperty(new Error(`Image with src "${src}" has invalid "width" property. Expected a numeric value in pixels but received "${width}".`), "__NEXT_ERROR_CODE", {
|
||
value: "E66",
|
||
enumerable: false,
|
||
configurable: true
|
||
});
|
||
}
|
||
if (typeof heightInt === 'undefined') {
|
||
throw Object.defineProperty(new Error(`Image with src "${src}" is missing required "height" property.`), "__NEXT_ERROR_CODE", {
|
||
value: "E397",
|
||
enumerable: false,
|
||
configurable: true
|
||
});
|
||
} else if (isNaN(heightInt)) {
|
||
throw Object.defineProperty(new Error(`Image with src "${src}" has invalid "height" property. Expected a numeric value in pixels but received "${height}".`), "__NEXT_ERROR_CODE", {
|
||
value: "E444",
|
||
enumerable: false,
|
||
configurable: true
|
||
});
|
||
}
|
||
// eslint-disable-next-line no-control-regex
|
||
if (/^[\x00-\x20]/.test(src)) {
|
||
throw Object.defineProperty(new Error(`Image with src "${src}" cannot start with a space or control character. Use src.trimStart() to remove it or encodeURIComponent(src) to keep it.`), "__NEXT_ERROR_CODE", {
|
||
value: "E176",
|
||
enumerable: false,
|
||
configurable: true
|
||
});
|
||
}
|
||
// eslint-disable-next-line no-control-regex
|
||
if (/[\x00-\x20]$/.test(src)) {
|
||
throw Object.defineProperty(new Error(`Image with src "${src}" cannot end with a space or control character. Use src.trimEnd() to remove it or encodeURIComponent(src) to keep it.`), "__NEXT_ERROR_CODE", {
|
||
value: "E21",
|
||
enumerable: false,
|
||
configurable: true
|
||
});
|
||
}
|
||
}
|
||
}
|
||
if (!VALID_LOADING_VALUES.includes(loading)) {
|
||
throw Object.defineProperty(new Error(`Image with src "${src}" has invalid "loading" property. Provided "${loading}" should be one of ${VALID_LOADING_VALUES.map(String).join(',')}.`), "__NEXT_ERROR_CODE", {
|
||
value: "E357",
|
||
enumerable: false,
|
||
configurable: true
|
||
});
|
||
}
|
||
if (priority && loading === 'lazy') {
|
||
throw Object.defineProperty(new Error(`Image with src "${src}" has both "priority" and "loading='lazy'" properties. Only one should be used.`), "__NEXT_ERROR_CODE", {
|
||
value: "E218",
|
||
enumerable: false,
|
||
configurable: true
|
||
});
|
||
}
|
||
if (preload && loading === 'lazy') {
|
||
throw Object.defineProperty(new Error(`Image with src "${src}" has both "preload" and "loading='lazy'" properties. Only one should be used.`), "__NEXT_ERROR_CODE", {
|
||
value: "E803",
|
||
enumerable: false,
|
||
configurable: true
|
||
});
|
||
}
|
||
if (preload && priority) {
|
||
throw Object.defineProperty(new Error(`Image with src "${src}" has both "preload" and "priority" properties. Only "preload" should be used.`), "__NEXT_ERROR_CODE", {
|
||
value: "E802",
|
||
enumerable: false,
|
||
configurable: true
|
||
});
|
||
}
|
||
if (placeholder !== 'empty' && placeholder !== 'blur' && !placeholder.startsWith('data:image/')) {
|
||
throw Object.defineProperty(new Error(`Image with src "${src}" has invalid "placeholder" property "${placeholder}".`), "__NEXT_ERROR_CODE", {
|
||
value: "E431",
|
||
enumerable: false,
|
||
configurable: true
|
||
});
|
||
}
|
||
if (placeholder !== 'empty') {
|
||
if (widthInt && heightInt && widthInt * heightInt < 1600) {
|
||
(0, _warnonce.warnOnce)(`Image with src "${src}" is smaller than 40x40. Consider removing the "placeholder" property to improve performance.`);
|
||
}
|
||
}
|
||
if (qualityInt && config.qualities && !config.qualities.includes(qualityInt)) {
|
||
(0, _warnonce.warnOnce)(`Image with src "${src}" is using quality "${qualityInt}" which is not configured in images.qualities [${config.qualities.join(', ')}]. Please update your config to [${[
|
||
...config.qualities,
|
||
qualityInt
|
||
].sort().join(', ')}].` + `\nRead more: https://nextjs.org/docs/messages/next-image-unconfigured-qualities`);
|
||
}
|
||
if (placeholder === 'blur' && !blurDataURL) {
|
||
const VALID_BLUR_EXT = [
|
||
'jpeg',
|
||
'png',
|
||
'webp',
|
||
'avif'
|
||
] // should match next-image-loader
|
||
;
|
||
throw Object.defineProperty(new Error(`Image with src "${src}" has "placeholder='blur'" property but is missing the "blurDataURL" property.
|
||
Possible solutions:
|
||
- Add a "blurDataURL" property, the contents should be a small Data URL to represent the image
|
||
- Change the "src" property to a static import with one of the supported file types: ${VALID_BLUR_EXT.join(',')} (animated images not supported)
|
||
- Remove the "placeholder" property, effectively no blur effect
|
||
Read more: https://nextjs.org/docs/messages/placeholder-blur-data-url`), "__NEXT_ERROR_CODE", {
|
||
value: "E371",
|
||
enumerable: false,
|
||
configurable: true
|
||
});
|
||
}
|
||
if ('ref' in rest) {
|
||
(0, _warnonce.warnOnce)(`Image with src "${src}" is using unsupported "ref" property. Consider using the "onLoad" property instead.`);
|
||
}
|
||
if (!unoptimized && !isDefaultLoader) {
|
||
const urlStr = loader({
|
||
config,
|
||
src,
|
||
width: widthInt || 400,
|
||
quality: qualityInt || 75
|
||
});
|
||
let url;
|
||
try {
|
||
url = new URL(urlStr);
|
||
} catch (err) {}
|
||
if (urlStr === src || url && url.pathname === src && !url.search) {
|
||
(0, _warnonce.warnOnce)(`Image with src "${src}" has a "loader" property that does not implement width. Please implement it or use the "unoptimized" property instead.` + `\nRead more: https://nextjs.org/docs/messages/next-image-missing-loader-width`);
|
||
}
|
||
}
|
||
if (onLoadingComplete) {
|
||
(0, _warnonce.warnOnce)(`Image with src "${src}" is using deprecated "onLoadingComplete" property. Please use the "onLoad" property instead.`);
|
||
}
|
||
for (const [legacyKey, legacyValue] of Object.entries({
|
||
layout,
|
||
objectFit,
|
||
objectPosition,
|
||
lazyBoundary,
|
||
lazyRoot
|
||
})){
|
||
if (legacyValue) {
|
||
(0, _warnonce.warnOnce)(`Image with src "${src}" has legacy prop "${legacyKey}". Did you forget to run the codemod?` + `\nRead more: https://nextjs.org/docs/messages/next-image-upgrade-to-13`);
|
||
}
|
||
}
|
||
if (typeof window !== 'undefined' && !perfObserver && window.PerformanceObserver) {
|
||
perfObserver = new PerformanceObserver((entryList)=>{
|
||
for (const entry of entryList.getEntries()){
|
||
// @ts-ignore - missing "LargestContentfulPaint" class with "element" prop
|
||
const imgSrc = entry?.element?.src || '';
|
||
const lcpImage = allImgs.get(imgSrc);
|
||
if (lcpImage && lcpImage.loading === 'lazy' && lcpImage.placeholder === 'empty' && !lcpImage.src.startsWith('data:') && !lcpImage.src.startsWith('blob:')) {
|
||
// https://web.dev/lcp/#measure-lcp-in-javascript
|
||
(0, _warnonce.warnOnce)(`Image with src "${lcpImage.src}" was detected as the Largest Contentful Paint (LCP). Please add the \`loading="eager"\` property if this image is above the fold.` + `\nRead more: https://nextjs.org/docs/app/api-reference/components/image#loading`);
|
||
}
|
||
}
|
||
});
|
||
try {
|
||
perfObserver.observe({
|
||
type: 'largest-contentful-paint',
|
||
buffered: true
|
||
});
|
||
} catch (err) {
|
||
// Log error but don't crash the app
|
||
console.error(err);
|
||
}
|
||
}
|
||
}
|
||
const imgStyle = Object.assign(fill ? {
|
||
position: 'absolute',
|
||
height: '100%',
|
||
width: '100%',
|
||
left: 0,
|
||
top: 0,
|
||
right: 0,
|
||
bottom: 0,
|
||
objectFit,
|
||
objectPosition
|
||
} : {}, showAltText ? {} : {
|
||
color: 'transparent'
|
||
}, style);
|
||
const backgroundImage = !blurComplete && placeholder !== 'empty' ? placeholder === 'blur' ? `url("data:image/svg+xml;charset=utf-8,${(0, _imageblursvg.getImageBlurSvg)({
|
||
widthInt,
|
||
heightInt,
|
||
blurWidth,
|
||
blurHeight,
|
||
blurDataURL: blurDataURL || '',
|
||
objectFit: imgStyle.objectFit
|
||
})}")` : `url("${placeholder}")` // assume `data:image/`
|
||
: null;
|
||
const backgroundSize = !INVALID_BACKGROUND_SIZE_VALUES.includes(imgStyle.objectFit) ? imgStyle.objectFit : imgStyle.objectFit === 'fill' ? '100% 100%' // the background-size equivalent of `fill`
|
||
: 'cover';
|
||
let placeholderStyle = backgroundImage ? {
|
||
backgroundSize,
|
||
backgroundPosition: imgStyle.objectPosition || '50% 50%',
|
||
backgroundRepeat: 'no-repeat',
|
||
backgroundImage
|
||
} : {};
|
||
if ("TURBOPACK compile-time truthy", 1) {
|
||
if (placeholderStyle.backgroundImage && placeholder === 'blur' && blurDataURL?.startsWith('/')) {
|
||
// During `next dev`, we don't want to generate blur placeholders with webpack
|
||
// because it can delay starting the dev server. Instead, `next-image-loader.js`
|
||
// will inline a special url to lazily generate the blur placeholder at request time.
|
||
placeholderStyle.backgroundImage = `url("${blurDataURL}")`;
|
||
}
|
||
}
|
||
const imgAttributes = generateImgAttrs({
|
||
config,
|
||
src,
|
||
unoptimized,
|
||
width: widthInt,
|
||
quality: qualityInt,
|
||
sizes,
|
||
loader
|
||
});
|
||
const loadingFinal = isLazy ? 'lazy' : loading;
|
||
if ("TURBOPACK compile-time truthy", 1) {
|
||
if (typeof window !== 'undefined') {
|
||
let fullUrl;
|
||
try {
|
||
fullUrl = new URL(imgAttributes.src);
|
||
} catch (e) {
|
||
fullUrl = new URL(imgAttributes.src, window.location.href);
|
||
}
|
||
allImgs.set(fullUrl.href, {
|
||
src,
|
||
loading: loadingFinal,
|
||
placeholder
|
||
});
|
||
}
|
||
}
|
||
const props = {
|
||
...rest,
|
||
loading: loadingFinal,
|
||
fetchPriority,
|
||
width: widthInt,
|
||
height: heightInt,
|
||
decoding,
|
||
className,
|
||
style: {
|
||
...imgStyle,
|
||
...placeholderStyle
|
||
},
|
||
sizes: imgAttributes.sizes,
|
||
srcSet: imgAttributes.srcSet,
|
||
src: overrideSrc || imgAttributes.src
|
||
};
|
||
const meta = {
|
||
unoptimized,
|
||
preload: preload || priority,
|
||
placeholder,
|
||
fill
|
||
};
|
||
return {
|
||
props,
|
||
meta
|
||
};
|
||
} //# sourceMappingURL=get-img-props.js.map
|
||
}),
|
||
"[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/shared/lib/side-effect.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
"use strict";
|
||
|
||
Object.defineProperty(exports, "__esModule", {
|
||
value: true
|
||
});
|
||
Object.defineProperty(exports, "default", {
|
||
enumerable: true,
|
||
get: function() {
|
||
return SideEffect;
|
||
}
|
||
});
|
||
const _react = __turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/compiled/react/index.js [app-client] (ecmascript)");
|
||
const isServer = typeof window === 'undefined';
|
||
const useClientOnlyLayoutEffect = isServer ? ()=>{} : _react.useLayoutEffect;
|
||
const useClientOnlyEffect = isServer ? ()=>{} : _react.useEffect;
|
||
function SideEffect(props) {
|
||
const { headManager, reduceComponentsToState } = props;
|
||
function emitChange() {
|
||
if (headManager && headManager.mountedInstances) {
|
||
const headElements = _react.Children.toArray(Array.from(headManager.mountedInstances).filter(Boolean));
|
||
headManager.updateHead(reduceComponentsToState(headElements));
|
||
}
|
||
}
|
||
if (isServer) {
|
||
headManager?.mountedInstances?.add(props.children);
|
||
emitChange();
|
||
}
|
||
useClientOnlyLayoutEffect({
|
||
"SideEffect.useClientOnlyLayoutEffect": ()=>{
|
||
headManager?.mountedInstances?.add(props.children);
|
||
return ({
|
||
"SideEffect.useClientOnlyLayoutEffect": ()=>{
|
||
headManager?.mountedInstances?.delete(props.children);
|
||
}
|
||
})["SideEffect.useClientOnlyLayoutEffect"];
|
||
}
|
||
}["SideEffect.useClientOnlyLayoutEffect"]);
|
||
// We need to call `updateHead` method whenever the `SideEffect` is trigger in all
|
||
// life-cycles: mount, update, unmount. However, if there are multiple `SideEffect`s
|
||
// being rendered, we only trigger the method from the last one.
|
||
// This is ensured by keeping the last unflushed `updateHead` in the `_pendingUpdate`
|
||
// singleton in the layout effect pass, and actually trigger it in the effect pass.
|
||
useClientOnlyLayoutEffect({
|
||
"SideEffect.useClientOnlyLayoutEffect": ()=>{
|
||
if (headManager) {
|
||
headManager._pendingUpdate = emitChange;
|
||
}
|
||
return ({
|
||
"SideEffect.useClientOnlyLayoutEffect": ()=>{
|
||
if (headManager) {
|
||
headManager._pendingUpdate = emitChange;
|
||
}
|
||
}
|
||
})["SideEffect.useClientOnlyLayoutEffect"];
|
||
}
|
||
}["SideEffect.useClientOnlyLayoutEffect"]);
|
||
useClientOnlyEffect({
|
||
"SideEffect.useClientOnlyEffect": ()=>{
|
||
if (headManager && headManager._pendingUpdate) {
|
||
headManager._pendingUpdate();
|
||
headManager._pendingUpdate = null;
|
||
}
|
||
return ({
|
||
"SideEffect.useClientOnlyEffect": ()=>{
|
||
if (headManager && headManager._pendingUpdate) {
|
||
headManager._pendingUpdate();
|
||
headManager._pendingUpdate = null;
|
||
}
|
||
}
|
||
})["SideEffect.useClientOnlyEffect"];
|
||
}
|
||
}["SideEffect.useClientOnlyEffect"]);
|
||
return null;
|
||
} //# sourceMappingURL=side-effect.js.map
|
||
}),
|
||
"[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/shared/lib/head.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
"use strict";
|
||
|
||
var __TURBOPACK__imported__module__$5b$project$5d2f$Documents$2f$go$2d$new$2f$chinese$2d$family$2d$tree$2f$node_modules$2f2e$pnpm$2f$next$40$16$2e$0$2e$3_react$2d$dom$40$19$2e$2$2e$0_react$40$19$2e$2$2e$0_$5f$react$40$19$2e$2$2e$0$2f$node_modules$2f$next$2f$dist$2f$build$2f$polyfills$2f$process$2e$js__$5b$app$2d$client$5d$__$28$ecmascript$29$__ = /*#__PURE__*/ __turbopack_context__.i("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/build/polyfills/process.js [app-client] (ecmascript)");
|
||
'use client';
|
||
"use strict";
|
||
Object.defineProperty(exports, "__esModule", {
|
||
value: true
|
||
});
|
||
0 && (module.exports = {
|
||
default: null,
|
||
defaultHead: null
|
||
});
|
||
function _export(target, all) {
|
||
for(var name in all)Object.defineProperty(target, name, {
|
||
enumerable: true,
|
||
get: all[name]
|
||
});
|
||
}
|
||
_export(exports, {
|
||
default: function() {
|
||
return _default;
|
||
},
|
||
defaultHead: function() {
|
||
return defaultHead;
|
||
}
|
||
});
|
||
const _interop_require_default = __turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/@swc+helpers@0.5.15/node_modules/@swc/helpers/cjs/_interop_require_default.cjs [app-client] (ecmascript)");
|
||
const _interop_require_wildcard = __turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/@swc+helpers@0.5.15/node_modules/@swc/helpers/cjs/_interop_require_wildcard.cjs [app-client] (ecmascript)");
|
||
const _jsxruntime = __turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/compiled/react/jsx-runtime.js [app-client] (ecmascript)");
|
||
const _react = /*#__PURE__*/ _interop_require_wildcard._(__turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/compiled/react/index.js [app-client] (ecmascript)"));
|
||
const _sideeffect = /*#__PURE__*/ _interop_require_default._(__turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/shared/lib/side-effect.js [app-client] (ecmascript)"));
|
||
const _headmanagercontextsharedruntime = __turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/shared/lib/head-manager-context.shared-runtime.js [app-client] (ecmascript)");
|
||
const _warnonce = __turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/shared/lib/utils/warn-once.js [app-client] (ecmascript)");
|
||
function defaultHead() {
|
||
const head = [
|
||
/*#__PURE__*/ (0, _jsxruntime.jsx)("meta", {
|
||
charSet: "utf-8"
|
||
}, "charset"),
|
||
/*#__PURE__*/ (0, _jsxruntime.jsx)("meta", {
|
||
name: "viewport",
|
||
content: "width=device-width"
|
||
}, "viewport")
|
||
];
|
||
return head;
|
||
}
|
||
function onlyReactElement(list, child) {
|
||
// React children can be "string" or "number" in this case we ignore them for backwards compat
|
||
if (typeof child === 'string' || typeof child === 'number') {
|
||
return list;
|
||
}
|
||
// Adds support for React.Fragment
|
||
if (child.type === _react.default.Fragment) {
|
||
return list.concat(_react.default.Children.toArray(child.props.children).reduce((fragmentList, fragmentChild)=>{
|
||
if (typeof fragmentChild === 'string' || typeof fragmentChild === 'number') {
|
||
return fragmentList;
|
||
}
|
||
return fragmentList.concat(fragmentChild);
|
||
}, []));
|
||
}
|
||
return list.concat(child);
|
||
}
|
||
const METATYPES = [
|
||
'name',
|
||
'httpEquiv',
|
||
'charSet',
|
||
'itemProp'
|
||
];
|
||
/*
|
||
returns a function for filtering head child elements
|
||
which shouldn't be duplicated, like <title/>
|
||
Also adds support for deduplicated `key` properties
|
||
*/ function unique() {
|
||
const keys = new Set();
|
||
const tags = new Set();
|
||
const metaTypes = new Set();
|
||
const metaCategories = {};
|
||
return (h)=>{
|
||
let isUnique = true;
|
||
let hasKey = false;
|
||
if (h.key && typeof h.key !== 'number' && h.key.indexOf('$') > 0) {
|
||
hasKey = true;
|
||
const key = h.key.slice(h.key.indexOf('$') + 1);
|
||
if (keys.has(key)) {
|
||
isUnique = false;
|
||
} else {
|
||
keys.add(key);
|
||
}
|
||
}
|
||
// eslint-disable-next-line default-case
|
||
switch(h.type){
|
||
case 'title':
|
||
case 'base':
|
||
if (tags.has(h.type)) {
|
||
isUnique = false;
|
||
} else {
|
||
tags.add(h.type);
|
||
}
|
||
break;
|
||
case 'meta':
|
||
for(let i = 0, len = METATYPES.length; i < len; i++){
|
||
const metatype = METATYPES[i];
|
||
if (!h.props.hasOwnProperty(metatype)) continue;
|
||
if (metatype === 'charSet') {
|
||
if (metaTypes.has(metatype)) {
|
||
isUnique = false;
|
||
} else {
|
||
metaTypes.add(metatype);
|
||
}
|
||
} else {
|
||
const category = h.props[metatype];
|
||
const categories = metaCategories[metatype] || new Set();
|
||
if ((metatype !== 'name' || !hasKey) && categories.has(category)) {
|
||
isUnique = false;
|
||
} else {
|
||
categories.add(category);
|
||
metaCategories[metatype] = categories;
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
return isUnique;
|
||
};
|
||
}
|
||
/**
|
||
*
|
||
* @param headChildrenElements List of children of <Head>
|
||
*/ function reduceComponents(headChildrenElements) {
|
||
return headChildrenElements.reduce(onlyReactElement, []).reverse().concat(defaultHead().reverse()).filter(unique()).reverse().map((c, i)=>{
|
||
const key = c.key || i;
|
||
if ("TURBOPACK compile-time truthy", 1) {
|
||
// omit JSON-LD structured data snippets from the warning
|
||
if (c.type === 'script' && c.props['type'] !== 'application/ld+json') {
|
||
const srcMessage = c.props['src'] ? `<script> tag with src="${c.props['src']}"` : `inline <script>`;
|
||
(0, _warnonce.warnOnce)(`Do not add <script> tags using next/head (see ${srcMessage}). Use next/script instead. \nSee more info here: https://nextjs.org/docs/messages/no-script-tags-in-head-component`);
|
||
} else if (c.type === 'link' && c.props['rel'] === 'stylesheet') {
|
||
(0, _warnonce.warnOnce)(`Do not add stylesheets using next/head (see <link rel="stylesheet"> tag with href="${c.props['href']}"). Use Document instead. \nSee more info here: https://nextjs.org/docs/messages/no-stylesheets-in-head-component`);
|
||
}
|
||
}
|
||
return /*#__PURE__*/ _react.default.cloneElement(c, {
|
||
key
|
||
});
|
||
});
|
||
}
|
||
/**
|
||
* This component injects elements to `<head>` of your page.
|
||
* To avoid duplicated `tags` in `<head>` you can use the `key` property, which will make sure every tag is only rendered once.
|
||
*/ function Head({ children }) {
|
||
const headManager = (0, _react.useContext)(_headmanagercontextsharedruntime.HeadManagerContext);
|
||
return /*#__PURE__*/ (0, _jsxruntime.jsx)(_sideeffect.default, {
|
||
reduceComponentsToState: reduceComponents,
|
||
headManager: headManager,
|
||
children: children
|
||
});
|
||
}
|
||
const _default = Head;
|
||
if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
|
||
Object.defineProperty(exports.default, '__esModule', {
|
||
value: true
|
||
});
|
||
Object.assign(exports.default, exports);
|
||
module.exports = exports.default;
|
||
} //# sourceMappingURL=head.js.map
|
||
}),
|
||
"[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/shared/lib/image-config-context.shared-runtime.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
"use strict";
|
||
|
||
var __TURBOPACK__imported__module__$5b$project$5d2f$Documents$2f$go$2d$new$2f$chinese$2d$family$2d$tree$2f$node_modules$2f2e$pnpm$2f$next$40$16$2e$0$2e$3_react$2d$dom$40$19$2e$2$2e$0_react$40$19$2e$2$2e$0_$5f$react$40$19$2e$2$2e$0$2f$node_modules$2f$next$2f$dist$2f$build$2f$polyfills$2f$process$2e$js__$5b$app$2d$client$5d$__$28$ecmascript$29$__ = /*#__PURE__*/ __turbopack_context__.i("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/build/polyfills/process.js [app-client] (ecmascript)");
|
||
"use strict";
|
||
Object.defineProperty(exports, "__esModule", {
|
||
value: true
|
||
});
|
||
Object.defineProperty(exports, "ImageConfigContext", {
|
||
enumerable: true,
|
||
get: function() {
|
||
return ImageConfigContext;
|
||
}
|
||
});
|
||
const _interop_require_default = __turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/@swc+helpers@0.5.15/node_modules/@swc/helpers/cjs/_interop_require_default.cjs [app-client] (ecmascript)");
|
||
const _react = /*#__PURE__*/ _interop_require_default._(__turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/compiled/react/index.js [app-client] (ecmascript)"));
|
||
const _imageconfig = __turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/shared/lib/image-config.js [app-client] (ecmascript)");
|
||
const ImageConfigContext = _react.default.createContext(_imageconfig.imageConfigDefault);
|
||
if ("TURBOPACK compile-time truthy", 1) {
|
||
ImageConfigContext.displayName = 'ImageConfigContext';
|
||
} //# sourceMappingURL=image-config-context.shared-runtime.js.map
|
||
}),
|
||
"[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/shared/lib/router-context.shared-runtime.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
"use strict";
|
||
|
||
var __TURBOPACK__imported__module__$5b$project$5d2f$Documents$2f$go$2d$new$2f$chinese$2d$family$2d$tree$2f$node_modules$2f2e$pnpm$2f$next$40$16$2e$0$2e$3_react$2d$dom$40$19$2e$2$2e$0_react$40$19$2e$2$2e$0_$5f$react$40$19$2e$2$2e$0$2f$node_modules$2f$next$2f$dist$2f$build$2f$polyfills$2f$process$2e$js__$5b$app$2d$client$5d$__$28$ecmascript$29$__ = /*#__PURE__*/ __turbopack_context__.i("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/build/polyfills/process.js [app-client] (ecmascript)");
|
||
"use strict";
|
||
Object.defineProperty(exports, "__esModule", {
|
||
value: true
|
||
});
|
||
Object.defineProperty(exports, "RouterContext", {
|
||
enumerable: true,
|
||
get: function() {
|
||
return RouterContext;
|
||
}
|
||
});
|
||
const _interop_require_default = __turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/@swc+helpers@0.5.15/node_modules/@swc/helpers/cjs/_interop_require_default.cjs [app-client] (ecmascript)");
|
||
const _react = /*#__PURE__*/ _interop_require_default._(__turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/compiled/react/index.js [app-client] (ecmascript)"));
|
||
const RouterContext = _react.default.createContext(null);
|
||
if ("TURBOPACK compile-time truthy", 1) {
|
||
RouterContext.displayName = 'RouterContext';
|
||
} //# sourceMappingURL=router-context.shared-runtime.js.map
|
||
}),
|
||
"[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/shared/lib/find-closest-quality.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
"use strict";
|
||
|
||
Object.defineProperty(exports, "__esModule", {
|
||
value: true
|
||
});
|
||
Object.defineProperty(exports, "findClosestQuality", {
|
||
enumerable: true,
|
||
get: function() {
|
||
return findClosestQuality;
|
||
}
|
||
});
|
||
function findClosestQuality(quality, config) {
|
||
const q = quality || 75;
|
||
if (!config?.qualities?.length) {
|
||
return q;
|
||
}
|
||
return config.qualities.reduce((prev, cur)=>Math.abs(cur - q) < Math.abs(prev - q) ? cur : prev, 0);
|
||
} //# sourceMappingURL=find-closest-quality.js.map
|
||
}),
|
||
"[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/compiled/picomatch/index.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
|
||
var __TURBOPACK__imported__module__$5b$project$5d2f$Documents$2f$go$2d$new$2f$chinese$2d$family$2d$tree$2f$node_modules$2f2e$pnpm$2f$next$40$16$2e$0$2e$3_react$2d$dom$40$19$2e$2$2e$0_react$40$19$2e$2$2e$0_$5f$react$40$19$2e$2$2e$0$2f$node_modules$2f$next$2f$dist$2f$build$2f$polyfills$2f$process$2e$js__$5b$app$2d$client$5d$__$28$ecmascript$29$__ = /*#__PURE__*/ __turbopack_context__.i("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/build/polyfills/process.js [app-client] (ecmascript)");
|
||
(()=>{
|
||
"use strict";
|
||
var t = {
|
||
170: (t, e, u)=>{
|
||
const n = u(510);
|
||
const isWindows = ()=>{
|
||
if (typeof navigator !== "undefined" && navigator.platform) {
|
||
const t = navigator.platform.toLowerCase();
|
||
return t === "win32" || t === "windows";
|
||
}
|
||
if (typeof __TURBOPACK__imported__module__$5b$project$5d2f$Documents$2f$go$2d$new$2f$chinese$2d$family$2d$tree$2f$node_modules$2f2e$pnpm$2f$next$40$16$2e$0$2e$3_react$2d$dom$40$19$2e$2$2e$0_react$40$19$2e$2$2e$0_$5f$react$40$19$2e$2$2e$0$2f$node_modules$2f$next$2f$dist$2f$build$2f$polyfills$2f$process$2e$js__$5b$app$2d$client$5d$__$28$ecmascript$29$__["default"] !== "undefined" && __TURBOPACK__imported__module__$5b$project$5d2f$Documents$2f$go$2d$new$2f$chinese$2d$family$2d$tree$2f$node_modules$2f2e$pnpm$2f$next$40$16$2e$0$2e$3_react$2d$dom$40$19$2e$2$2e$0_react$40$19$2e$2$2e$0_$5f$react$40$19$2e$2$2e$0$2f$node_modules$2f$next$2f$dist$2f$build$2f$polyfills$2f$process$2e$js__$5b$app$2d$client$5d$__$28$ecmascript$29$__["default"].platform) {
|
||
return __TURBOPACK__imported__module__$5b$project$5d2f$Documents$2f$go$2d$new$2f$chinese$2d$family$2d$tree$2f$node_modules$2f2e$pnpm$2f$next$40$16$2e$0$2e$3_react$2d$dom$40$19$2e$2$2e$0_react$40$19$2e$2$2e$0_$5f$react$40$19$2e$2$2e$0$2f$node_modules$2f$next$2f$dist$2f$build$2f$polyfills$2f$process$2e$js__$5b$app$2d$client$5d$__$28$ecmascript$29$__["default"].platform === "win32";
|
||
}
|
||
return false;
|
||
};
|
||
function picomatch(t, e, u = false) {
|
||
if (e && (e.windows === null || e.windows === undefined)) {
|
||
e = {
|
||
...e,
|
||
windows: isWindows()
|
||
};
|
||
}
|
||
return n(t, e, u);
|
||
}
|
||
Object.assign(picomatch, n);
|
||
t.exports = picomatch;
|
||
},
|
||
154: (t)=>{
|
||
const e = "\\\\/";
|
||
const u = `[^${e}]`;
|
||
const n = "\\.";
|
||
const o = "\\+";
|
||
const s = "\\?";
|
||
const r = "\\/";
|
||
const a = "(?=.)";
|
||
const i = "[^/]";
|
||
const c = `(?:${r}|$)`;
|
||
const p = `(?:^|${r})`;
|
||
const l = `${n}{1,2}${c}`;
|
||
const f = `(?!${n})`;
|
||
const A = `(?!${p}${l})`;
|
||
const _ = `(?!${n}{0,1}${c})`;
|
||
const R = `(?!${l})`;
|
||
const E = `[^.${r}]`;
|
||
const h = `${i}*?`;
|
||
const g = "/";
|
||
const b = {
|
||
DOT_LITERAL: n,
|
||
PLUS_LITERAL: o,
|
||
QMARK_LITERAL: s,
|
||
SLASH_LITERAL: r,
|
||
ONE_CHAR: a,
|
||
QMARK: i,
|
||
END_ANCHOR: c,
|
||
DOTS_SLASH: l,
|
||
NO_DOT: f,
|
||
NO_DOTS: A,
|
||
NO_DOT_SLASH: _,
|
||
NO_DOTS_SLASH: R,
|
||
QMARK_NO_DOT: E,
|
||
STAR: h,
|
||
START_ANCHOR: p,
|
||
SEP: g
|
||
};
|
||
const C = {
|
||
...b,
|
||
SLASH_LITERAL: `[${e}]`,
|
||
QMARK: u,
|
||
STAR: `${u}*?`,
|
||
DOTS_SLASH: `${n}{1,2}(?:[${e}]|$)`,
|
||
NO_DOT: `(?!${n})`,
|
||
NO_DOTS: `(?!(?:^|[${e}])${n}{1,2}(?:[${e}]|$))`,
|
||
NO_DOT_SLASH: `(?!${n}{0,1}(?:[${e}]|$))`,
|
||
NO_DOTS_SLASH: `(?!${n}{1,2}(?:[${e}]|$))`,
|
||
QMARK_NO_DOT: `[^.${e}]`,
|
||
START_ANCHOR: `(?:^|[${e}])`,
|
||
END_ANCHOR: `(?:[${e}]|$)`,
|
||
SEP: "\\"
|
||
};
|
||
const y = {
|
||
alnum: "a-zA-Z0-9",
|
||
alpha: "a-zA-Z",
|
||
ascii: "\\x00-\\x7F",
|
||
blank: " \\t",
|
||
cntrl: "\\x00-\\x1F\\x7F",
|
||
digit: "0-9",
|
||
graph: "\\x21-\\x7E",
|
||
lower: "a-z",
|
||
print: "\\x20-\\x7E ",
|
||
punct: "\\-!\"#$%&'()\\*+,./:;<=>?@[\\]^_`{|}~",
|
||
space: " \\t\\r\\n\\v\\f",
|
||
upper: "A-Z",
|
||
word: "A-Za-z0-9_",
|
||
xdigit: "A-Fa-f0-9"
|
||
};
|
||
t.exports = {
|
||
MAX_LENGTH: 1024 * 64,
|
||
POSIX_REGEX_SOURCE: y,
|
||
REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
|
||
REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/,
|
||
REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/,
|
||
REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
|
||
REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
|
||
REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
|
||
REPLACEMENTS: {
|
||
"***": "*",
|
||
"**/**": "**",
|
||
"**/**/**": "**"
|
||
},
|
||
CHAR_0: 48,
|
||
CHAR_9: 57,
|
||
CHAR_UPPERCASE_A: 65,
|
||
CHAR_LOWERCASE_A: 97,
|
||
CHAR_UPPERCASE_Z: 90,
|
||
CHAR_LOWERCASE_Z: 122,
|
||
CHAR_LEFT_PARENTHESES: 40,
|
||
CHAR_RIGHT_PARENTHESES: 41,
|
||
CHAR_ASTERISK: 42,
|
||
CHAR_AMPERSAND: 38,
|
||
CHAR_AT: 64,
|
||
CHAR_BACKWARD_SLASH: 92,
|
||
CHAR_CARRIAGE_RETURN: 13,
|
||
CHAR_CIRCUMFLEX_ACCENT: 94,
|
||
CHAR_COLON: 58,
|
||
CHAR_COMMA: 44,
|
||
CHAR_DOT: 46,
|
||
CHAR_DOUBLE_QUOTE: 34,
|
||
CHAR_EQUAL: 61,
|
||
CHAR_EXCLAMATION_MARK: 33,
|
||
CHAR_FORM_FEED: 12,
|
||
CHAR_FORWARD_SLASH: 47,
|
||
CHAR_GRAVE_ACCENT: 96,
|
||
CHAR_HASH: 35,
|
||
CHAR_HYPHEN_MINUS: 45,
|
||
CHAR_LEFT_ANGLE_BRACKET: 60,
|
||
CHAR_LEFT_CURLY_BRACE: 123,
|
||
CHAR_LEFT_SQUARE_BRACKET: 91,
|
||
CHAR_LINE_FEED: 10,
|
||
CHAR_NO_BREAK_SPACE: 160,
|
||
CHAR_PERCENT: 37,
|
||
CHAR_PLUS: 43,
|
||
CHAR_QUESTION_MARK: 63,
|
||
CHAR_RIGHT_ANGLE_BRACKET: 62,
|
||
CHAR_RIGHT_CURLY_BRACE: 125,
|
||
CHAR_RIGHT_SQUARE_BRACKET: 93,
|
||
CHAR_SEMICOLON: 59,
|
||
CHAR_SINGLE_QUOTE: 39,
|
||
CHAR_SPACE: 32,
|
||
CHAR_TAB: 9,
|
||
CHAR_UNDERSCORE: 95,
|
||
CHAR_VERTICAL_LINE: 124,
|
||
CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279,
|
||
extglobChars (t) {
|
||
return {
|
||
"!": {
|
||
type: "negate",
|
||
open: "(?:(?!(?:",
|
||
close: `))${t.STAR})`
|
||
},
|
||
"?": {
|
||
type: "qmark",
|
||
open: "(?:",
|
||
close: ")?"
|
||
},
|
||
"+": {
|
||
type: "plus",
|
||
open: "(?:",
|
||
close: ")+"
|
||
},
|
||
"*": {
|
||
type: "star",
|
||
open: "(?:",
|
||
close: ")*"
|
||
},
|
||
"@": {
|
||
type: "at",
|
||
open: "(?:",
|
||
close: ")"
|
||
}
|
||
};
|
||
},
|
||
globChars (t) {
|
||
return t === true ? C : b;
|
||
}
|
||
};
|
||
},
|
||
697: (t, e, u)=>{
|
||
const n = u(154);
|
||
const o = u(96);
|
||
const { MAX_LENGTH: s, POSIX_REGEX_SOURCE: r, REGEX_NON_SPECIAL_CHARS: a, REGEX_SPECIAL_CHARS_BACKREF: i, REPLACEMENTS: c } = n;
|
||
const expandRange = (t, e)=>{
|
||
if (typeof e.expandRange === "function") {
|
||
return e.expandRange(...t, e);
|
||
}
|
||
t.sort();
|
||
const u = `[${t.join("-")}]`;
|
||
try {
|
||
new RegExp(u);
|
||
} catch (e) {
|
||
return t.map((t)=>o.escapeRegex(t)).join("..");
|
||
}
|
||
return u;
|
||
};
|
||
const syntaxError = (t, e)=>`Missing ${t}: "${e}" - use "\\\\${e}" to match literal characters`;
|
||
const parse = (t, e)=>{
|
||
if (typeof t !== "string") {
|
||
throw new TypeError("Expected a string");
|
||
}
|
||
t = c[t] || t;
|
||
const u = {
|
||
...e
|
||
};
|
||
const p = typeof u.maxLength === "number" ? Math.min(s, u.maxLength) : s;
|
||
let l = t.length;
|
||
if (l > p) {
|
||
throw new SyntaxError(`Input length: ${l}, exceeds maximum allowed length: ${p}`);
|
||
}
|
||
const f = {
|
||
type: "bos",
|
||
value: "",
|
||
output: u.prepend || ""
|
||
};
|
||
const A = [
|
||
f
|
||
];
|
||
const _ = u.capture ? "" : "?:";
|
||
const R = n.globChars(u.windows);
|
||
const E = n.extglobChars(R);
|
||
const { DOT_LITERAL: h, PLUS_LITERAL: g, SLASH_LITERAL: b, ONE_CHAR: C, DOTS_SLASH: y, NO_DOT: $, NO_DOT_SLASH: x, NO_DOTS_SLASH: S, QMARK: H, QMARK_NO_DOT: v, STAR: d, START_ANCHOR: L } = R;
|
||
const globstar = (t)=>`(${_}(?:(?!${L}${t.dot ? y : h}).)*?)`;
|
||
const T = u.dot ? "" : $;
|
||
const O = u.dot ? H : v;
|
||
let k = u.bash === true ? globstar(u) : d;
|
||
if (u.capture) {
|
||
k = `(${k})`;
|
||
}
|
||
if (typeof u.noext === "boolean") {
|
||
u.noextglob = u.noext;
|
||
}
|
||
const m = {
|
||
input: t,
|
||
index: -1,
|
||
start: 0,
|
||
dot: u.dot === true,
|
||
consumed: "",
|
||
output: "",
|
||
prefix: "",
|
||
backtrack: false,
|
||
negated: false,
|
||
brackets: 0,
|
||
braces: 0,
|
||
parens: 0,
|
||
quotes: 0,
|
||
globstar: false,
|
||
tokens: A
|
||
};
|
||
t = o.removePrefix(t, m);
|
||
l = t.length;
|
||
const w = [];
|
||
const N = [];
|
||
const I = [];
|
||
let B = f;
|
||
let G;
|
||
const eos = ()=>m.index === l - 1;
|
||
const D = m.peek = (e = 1)=>t[m.index + e];
|
||
const M = m.advance = ()=>t[++m.index] || "";
|
||
const remaining = ()=>t.slice(m.index + 1);
|
||
const consume = (t = "", e = 0)=>{
|
||
m.consumed += t;
|
||
m.index += e;
|
||
};
|
||
const append = (t)=>{
|
||
m.output += t.output != null ? t.output : t.value;
|
||
consume(t.value);
|
||
};
|
||
const negate = ()=>{
|
||
let t = 1;
|
||
while(D() === "!" && (D(2) !== "(" || D(3) === "?")){
|
||
M();
|
||
m.start++;
|
||
t++;
|
||
}
|
||
if (t % 2 === 0) {
|
||
return false;
|
||
}
|
||
m.negated = true;
|
||
m.start++;
|
||
return true;
|
||
};
|
||
const increment = (t)=>{
|
||
m[t]++;
|
||
I.push(t);
|
||
};
|
||
const decrement = (t)=>{
|
||
m[t]--;
|
||
I.pop();
|
||
};
|
||
const push = (t)=>{
|
||
if (B.type === "globstar") {
|
||
const e = m.braces > 0 && (t.type === "comma" || t.type === "brace");
|
||
const u = t.extglob === true || w.length && (t.type === "pipe" || t.type === "paren");
|
||
if (t.type !== "slash" && t.type !== "paren" && !e && !u) {
|
||
m.output = m.output.slice(0, -B.output.length);
|
||
B.type = "star";
|
||
B.value = "*";
|
||
B.output = k;
|
||
m.output += B.output;
|
||
}
|
||
}
|
||
if (w.length && t.type !== "paren") {
|
||
w[w.length - 1].inner += t.value;
|
||
}
|
||
if (t.value || t.output) append(t);
|
||
if (B && B.type === "text" && t.type === "text") {
|
||
B.output = (B.output || B.value) + t.value;
|
||
B.value += t.value;
|
||
return;
|
||
}
|
||
t.prev = B;
|
||
A.push(t);
|
||
B = t;
|
||
};
|
||
const extglobOpen = (t, e)=>{
|
||
const n = {
|
||
...E[e],
|
||
conditions: 1,
|
||
inner: ""
|
||
};
|
||
n.prev = B;
|
||
n.parens = m.parens;
|
||
n.output = m.output;
|
||
const o = (u.capture ? "(" : "") + n.open;
|
||
increment("parens");
|
||
push({
|
||
type: t,
|
||
value: e,
|
||
output: m.output ? "" : C
|
||
});
|
||
push({
|
||
type: "paren",
|
||
extglob: true,
|
||
value: M(),
|
||
output: o
|
||
});
|
||
w.push(n);
|
||
};
|
||
const extglobClose = (t)=>{
|
||
let n = t.close + (u.capture ? ")" : "");
|
||
let o;
|
||
if (t.type === "negate") {
|
||
let s = k;
|
||
if (t.inner && t.inner.length > 1 && t.inner.includes("/")) {
|
||
s = globstar(u);
|
||
}
|
||
if (s !== k || eos() || /^\)+$/.test(remaining())) {
|
||
n = t.close = `)$))${s}`;
|
||
}
|
||
if (t.inner.includes("*") && (o = remaining()) && /^\.[^\\/.]+$/.test(o)) {
|
||
const u = parse(o, {
|
||
...e,
|
||
fastpaths: false
|
||
}).output;
|
||
n = t.close = `)${u})${s})`;
|
||
}
|
||
if (t.prev.type === "bos") {
|
||
m.negatedExtglob = true;
|
||
}
|
||
}
|
||
push({
|
||
type: "paren",
|
||
extglob: true,
|
||
value: G,
|
||
output: n
|
||
});
|
||
decrement("parens");
|
||
};
|
||
if (u.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(t)) {
|
||
let n = false;
|
||
let s = t.replace(i, (t, e, u, o, s, r)=>{
|
||
if (o === "\\") {
|
||
n = true;
|
||
return t;
|
||
}
|
||
if (o === "?") {
|
||
if (e) {
|
||
return e + o + (s ? H.repeat(s.length) : "");
|
||
}
|
||
if (r === 0) {
|
||
return O + (s ? H.repeat(s.length) : "");
|
||
}
|
||
return H.repeat(u.length);
|
||
}
|
||
if (o === ".") {
|
||
return h.repeat(u.length);
|
||
}
|
||
if (o === "*") {
|
||
if (e) {
|
||
return e + o + (s ? k : "");
|
||
}
|
||
return k;
|
||
}
|
||
return e ? t : `\\${t}`;
|
||
});
|
||
if (n === true) {
|
||
if (u.unescape === true) {
|
||
s = s.replace(/\\/g, "");
|
||
} else {
|
||
s = s.replace(/\\+/g, (t)=>t.length % 2 === 0 ? "\\\\" : t ? "\\" : "");
|
||
}
|
||
}
|
||
if (s === t && u.contains === true) {
|
||
m.output = t;
|
||
return m;
|
||
}
|
||
m.output = o.wrapOutput(s, m, e);
|
||
return m;
|
||
}
|
||
while(!eos()){
|
||
G = M();
|
||
if (G === "\0") {
|
||
continue;
|
||
}
|
||
if (G === "\\") {
|
||
const t = D();
|
||
if (t === "/" && u.bash !== true) {
|
||
continue;
|
||
}
|
||
if (t === "." || t === ";") {
|
||
continue;
|
||
}
|
||
if (!t) {
|
||
G += "\\";
|
||
push({
|
||
type: "text",
|
||
value: G
|
||
});
|
||
continue;
|
||
}
|
||
const e = /^\\+/.exec(remaining());
|
||
let n = 0;
|
||
if (e && e[0].length > 2) {
|
||
n = e[0].length;
|
||
m.index += n;
|
||
if (n % 2 !== 0) {
|
||
G += "\\";
|
||
}
|
||
}
|
||
if (u.unescape === true) {
|
||
G = M();
|
||
} else {
|
||
G += M();
|
||
}
|
||
if (m.brackets === 0) {
|
||
push({
|
||
type: "text",
|
||
value: G
|
||
});
|
||
continue;
|
||
}
|
||
}
|
||
if (m.brackets > 0 && (G !== "]" || B.value === "[" || B.value === "[^")) {
|
||
if (u.posix !== false && G === ":") {
|
||
const t = B.value.slice(1);
|
||
if (t.includes("[")) {
|
||
B.posix = true;
|
||
if (t.includes(":")) {
|
||
const t = B.value.lastIndexOf("[");
|
||
const e = B.value.slice(0, t);
|
||
const u = B.value.slice(t + 2);
|
||
const n = r[u];
|
||
if (n) {
|
||
B.value = e + n;
|
||
m.backtrack = true;
|
||
M();
|
||
if (!f.output && A.indexOf(B) === 1) {
|
||
f.output = C;
|
||
}
|
||
continue;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if (G === "[" && D() !== ":" || G === "-" && D() === "]") {
|
||
G = `\\${G}`;
|
||
}
|
||
if (G === "]" && (B.value === "[" || B.value === "[^")) {
|
||
G = `\\${G}`;
|
||
}
|
||
if (u.posix === true && G === "!" && B.value === "[") {
|
||
G = "^";
|
||
}
|
||
B.value += G;
|
||
append({
|
||
value: G
|
||
});
|
||
continue;
|
||
}
|
||
if (m.quotes === 1 && G !== '"') {
|
||
G = o.escapeRegex(G);
|
||
B.value += G;
|
||
append({
|
||
value: G
|
||
});
|
||
continue;
|
||
}
|
||
if (G === '"') {
|
||
m.quotes = m.quotes === 1 ? 0 : 1;
|
||
if (u.keepQuotes === true) {
|
||
push({
|
||
type: "text",
|
||
value: G
|
||
});
|
||
}
|
||
continue;
|
||
}
|
||
if (G === "(") {
|
||
increment("parens");
|
||
push({
|
||
type: "paren",
|
||
value: G
|
||
});
|
||
continue;
|
||
}
|
||
if (G === ")") {
|
||
if (m.parens === 0 && u.strictBrackets === true) {
|
||
throw new SyntaxError(syntaxError("opening", "("));
|
||
}
|
||
const t = w[w.length - 1];
|
||
if (t && m.parens === t.parens + 1) {
|
||
extglobClose(w.pop());
|
||
continue;
|
||
}
|
||
push({
|
||
type: "paren",
|
||
value: G,
|
||
output: m.parens ? ")" : "\\)"
|
||
});
|
||
decrement("parens");
|
||
continue;
|
||
}
|
||
if (G === "[") {
|
||
if (u.nobracket === true || !remaining().includes("]")) {
|
||
if (u.nobracket !== true && u.strictBrackets === true) {
|
||
throw new SyntaxError(syntaxError("closing", "]"));
|
||
}
|
||
G = `\\${G}`;
|
||
} else {
|
||
increment("brackets");
|
||
}
|
||
push({
|
||
type: "bracket",
|
||
value: G
|
||
});
|
||
continue;
|
||
}
|
||
if (G === "]") {
|
||
if (u.nobracket === true || B && B.type === "bracket" && B.value.length === 1) {
|
||
push({
|
||
type: "text",
|
||
value: G,
|
||
output: `\\${G}`
|
||
});
|
||
continue;
|
||
}
|
||
if (m.brackets === 0) {
|
||
if (u.strictBrackets === true) {
|
||
throw new SyntaxError(syntaxError("opening", "["));
|
||
}
|
||
push({
|
||
type: "text",
|
||
value: G,
|
||
output: `\\${G}`
|
||
});
|
||
continue;
|
||
}
|
||
decrement("brackets");
|
||
const t = B.value.slice(1);
|
||
if (B.posix !== true && t[0] === "^" && !t.includes("/")) {
|
||
G = `/${G}`;
|
||
}
|
||
B.value += G;
|
||
append({
|
||
value: G
|
||
});
|
||
if (u.literalBrackets === false || o.hasRegexChars(t)) {
|
||
continue;
|
||
}
|
||
const e = o.escapeRegex(B.value);
|
||
m.output = m.output.slice(0, -B.value.length);
|
||
if (u.literalBrackets === true) {
|
||
m.output += e;
|
||
B.value = e;
|
||
continue;
|
||
}
|
||
B.value = `(${_}${e}|${B.value})`;
|
||
m.output += B.value;
|
||
continue;
|
||
}
|
||
if (G === "{" && u.nobrace !== true) {
|
||
increment("braces");
|
||
const t = {
|
||
type: "brace",
|
||
value: G,
|
||
output: "(",
|
||
outputIndex: m.output.length,
|
||
tokensIndex: m.tokens.length
|
||
};
|
||
N.push(t);
|
||
push(t);
|
||
continue;
|
||
}
|
||
if (G === "}") {
|
||
const t = N[N.length - 1];
|
||
if (u.nobrace === true || !t) {
|
||
push({
|
||
type: "text",
|
||
value: G,
|
||
output: G
|
||
});
|
||
continue;
|
||
}
|
||
let e = ")";
|
||
if (t.dots === true) {
|
||
const t = A.slice();
|
||
const n = [];
|
||
for(let e = t.length - 1; e >= 0; e--){
|
||
A.pop();
|
||
if (t[e].type === "brace") {
|
||
break;
|
||
}
|
||
if (t[e].type !== "dots") {
|
||
n.unshift(t[e].value);
|
||
}
|
||
}
|
||
e = expandRange(n, u);
|
||
m.backtrack = true;
|
||
}
|
||
if (t.comma !== true && t.dots !== true) {
|
||
const u = m.output.slice(0, t.outputIndex);
|
||
const n = m.tokens.slice(t.tokensIndex);
|
||
t.value = t.output = "\\{";
|
||
G = e = "\\}";
|
||
m.output = u;
|
||
for (const t of n){
|
||
m.output += t.output || t.value;
|
||
}
|
||
}
|
||
push({
|
||
type: "brace",
|
||
value: G,
|
||
output: e
|
||
});
|
||
decrement("braces");
|
||
N.pop();
|
||
continue;
|
||
}
|
||
if (G === "|") {
|
||
if (w.length > 0) {
|
||
w[w.length - 1].conditions++;
|
||
}
|
||
push({
|
||
type: "text",
|
||
value: G
|
||
});
|
||
continue;
|
||
}
|
||
if (G === ",") {
|
||
let t = G;
|
||
const e = N[N.length - 1];
|
||
if (e && I[I.length - 1] === "braces") {
|
||
e.comma = true;
|
||
t = "|";
|
||
}
|
||
push({
|
||
type: "comma",
|
||
value: G,
|
||
output: t
|
||
});
|
||
continue;
|
||
}
|
||
if (G === "/") {
|
||
if (B.type === "dot" && m.index === m.start + 1) {
|
||
m.start = m.index + 1;
|
||
m.consumed = "";
|
||
m.output = "";
|
||
A.pop();
|
||
B = f;
|
||
continue;
|
||
}
|
||
push({
|
||
type: "slash",
|
||
value: G,
|
||
output: b
|
||
});
|
||
continue;
|
||
}
|
||
if (G === ".") {
|
||
if (m.braces > 0 && B.type === "dot") {
|
||
if (B.value === ".") B.output = h;
|
||
const t = N[N.length - 1];
|
||
B.type = "dots";
|
||
B.output += G;
|
||
B.value += G;
|
||
t.dots = true;
|
||
continue;
|
||
}
|
||
if (m.braces + m.parens === 0 && B.type !== "bos" && B.type !== "slash") {
|
||
push({
|
||
type: "text",
|
||
value: G,
|
||
output: h
|
||
});
|
||
continue;
|
||
}
|
||
push({
|
||
type: "dot",
|
||
value: G,
|
||
output: h
|
||
});
|
||
continue;
|
||
}
|
||
if (G === "?") {
|
||
const t = B && B.value === "(";
|
||
if (!t && u.noextglob !== true && D() === "(" && D(2) !== "?") {
|
||
extglobOpen("qmark", G);
|
||
continue;
|
||
}
|
||
if (B && B.type === "paren") {
|
||
const t = D();
|
||
let e = G;
|
||
if (B.value === "(" && !/[!=<:]/.test(t) || t === "<" && !/<([!=]|\w+>)/.test(remaining())) {
|
||
e = `\\${G}`;
|
||
}
|
||
push({
|
||
type: "text",
|
||
value: G,
|
||
output: e
|
||
});
|
||
continue;
|
||
}
|
||
if (u.dot !== true && (B.type === "slash" || B.type === "bos")) {
|
||
push({
|
||
type: "qmark",
|
||
value: G,
|
||
output: v
|
||
});
|
||
continue;
|
||
}
|
||
push({
|
||
type: "qmark",
|
||
value: G,
|
||
output: H
|
||
});
|
||
continue;
|
||
}
|
||
if (G === "!") {
|
||
if (u.noextglob !== true && D() === "(") {
|
||
if (D(2) !== "?" || !/[!=<:]/.test(D(3))) {
|
||
extglobOpen("negate", G);
|
||
continue;
|
||
}
|
||
}
|
||
if (u.nonegate !== true && m.index === 0) {
|
||
negate();
|
||
continue;
|
||
}
|
||
}
|
||
if (G === "+") {
|
||
if (u.noextglob !== true && D() === "(" && D(2) !== "?") {
|
||
extglobOpen("plus", G);
|
||
continue;
|
||
}
|
||
if (B && B.value === "(" || u.regex === false) {
|
||
push({
|
||
type: "plus",
|
||
value: G,
|
||
output: g
|
||
});
|
||
continue;
|
||
}
|
||
if (B && (B.type === "bracket" || B.type === "paren" || B.type === "brace") || m.parens > 0) {
|
||
push({
|
||
type: "plus",
|
||
value: G
|
||
});
|
||
continue;
|
||
}
|
||
push({
|
||
type: "plus",
|
||
value: g
|
||
});
|
||
continue;
|
||
}
|
||
if (G === "@") {
|
||
if (u.noextglob !== true && D() === "(" && D(2) !== "?") {
|
||
push({
|
||
type: "at",
|
||
extglob: true,
|
||
value: G,
|
||
output: ""
|
||
});
|
||
continue;
|
||
}
|
||
push({
|
||
type: "text",
|
||
value: G
|
||
});
|
||
continue;
|
||
}
|
||
if (G !== "*") {
|
||
if (G === "$" || G === "^") {
|
||
G = `\\${G}`;
|
||
}
|
||
const t = a.exec(remaining());
|
||
if (t) {
|
||
G += t[0];
|
||
m.index += t[0].length;
|
||
}
|
||
push({
|
||
type: "text",
|
||
value: G
|
||
});
|
||
continue;
|
||
}
|
||
if (B && (B.type === "globstar" || B.star === true)) {
|
||
B.type = "star";
|
||
B.star = true;
|
||
B.value += G;
|
||
B.output = k;
|
||
m.backtrack = true;
|
||
m.globstar = true;
|
||
consume(G);
|
||
continue;
|
||
}
|
||
let e = remaining();
|
||
if (u.noextglob !== true && /^\([^?]/.test(e)) {
|
||
extglobOpen("star", G);
|
||
continue;
|
||
}
|
||
if (B.type === "star") {
|
||
if (u.noglobstar === true) {
|
||
consume(G);
|
||
continue;
|
||
}
|
||
const n = B.prev;
|
||
const o = n.prev;
|
||
const s = n.type === "slash" || n.type === "bos";
|
||
const r = o && (o.type === "star" || o.type === "globstar");
|
||
if (u.bash === true && (!s || e[0] && e[0] !== "/")) {
|
||
push({
|
||
type: "star",
|
||
value: G,
|
||
output: ""
|
||
});
|
||
continue;
|
||
}
|
||
const a = m.braces > 0 && (n.type === "comma" || n.type === "brace");
|
||
const i = w.length && (n.type === "pipe" || n.type === "paren");
|
||
if (!s && n.type !== "paren" && !a && !i) {
|
||
push({
|
||
type: "star",
|
||
value: G,
|
||
output: ""
|
||
});
|
||
continue;
|
||
}
|
||
while(e.slice(0, 3) === "/**"){
|
||
const u = t[m.index + 4];
|
||
if (u && u !== "/") {
|
||
break;
|
||
}
|
||
e = e.slice(3);
|
||
consume("/**", 3);
|
||
}
|
||
if (n.type === "bos" && eos()) {
|
||
B.type = "globstar";
|
||
B.value += G;
|
||
B.output = globstar(u);
|
||
m.output = B.output;
|
||
m.globstar = true;
|
||
consume(G);
|
||
continue;
|
||
}
|
||
if (n.type === "slash" && n.prev.type !== "bos" && !r && eos()) {
|
||
m.output = m.output.slice(0, -(n.output + B.output).length);
|
||
n.output = `(?:${n.output}`;
|
||
B.type = "globstar";
|
||
B.output = globstar(u) + (u.strictSlashes ? ")" : "|$)");
|
||
B.value += G;
|
||
m.globstar = true;
|
||
m.output += n.output + B.output;
|
||
consume(G);
|
||
continue;
|
||
}
|
||
if (n.type === "slash" && n.prev.type !== "bos" && e[0] === "/") {
|
||
const t = e[1] !== void 0 ? "|$" : "";
|
||
m.output = m.output.slice(0, -(n.output + B.output).length);
|
||
n.output = `(?:${n.output}`;
|
||
B.type = "globstar";
|
||
B.output = `${globstar(u)}${b}|${b}${t})`;
|
||
B.value += G;
|
||
m.output += n.output + B.output;
|
||
m.globstar = true;
|
||
consume(G + M());
|
||
push({
|
||
type: "slash",
|
||
value: "/",
|
||
output: ""
|
||
});
|
||
continue;
|
||
}
|
||
if (n.type === "bos" && e[0] === "/") {
|
||
B.type = "globstar";
|
||
B.value += G;
|
||
B.output = `(?:^|${b}|${globstar(u)}${b})`;
|
||
m.output = B.output;
|
||
m.globstar = true;
|
||
consume(G + M());
|
||
push({
|
||
type: "slash",
|
||
value: "/",
|
||
output: ""
|
||
});
|
||
continue;
|
||
}
|
||
m.output = m.output.slice(0, -B.output.length);
|
||
B.type = "globstar";
|
||
B.output = globstar(u);
|
||
B.value += G;
|
||
m.output += B.output;
|
||
m.globstar = true;
|
||
consume(G);
|
||
continue;
|
||
}
|
||
const n = {
|
||
type: "star",
|
||
value: G,
|
||
output: k
|
||
};
|
||
if (u.bash === true) {
|
||
n.output = ".*?";
|
||
if (B.type === "bos" || B.type === "slash") {
|
||
n.output = T + n.output;
|
||
}
|
||
push(n);
|
||
continue;
|
||
}
|
||
if (B && (B.type === "bracket" || B.type === "paren") && u.regex === true) {
|
||
n.output = G;
|
||
push(n);
|
||
continue;
|
||
}
|
||
if (m.index === m.start || B.type === "slash" || B.type === "dot") {
|
||
if (B.type === "dot") {
|
||
m.output += x;
|
||
B.output += x;
|
||
} else if (u.dot === true) {
|
||
m.output += S;
|
||
B.output += S;
|
||
} else {
|
||
m.output += T;
|
||
B.output += T;
|
||
}
|
||
if (D() !== "*") {
|
||
m.output += C;
|
||
B.output += C;
|
||
}
|
||
}
|
||
push(n);
|
||
}
|
||
while(m.brackets > 0){
|
||
if (u.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "]"));
|
||
m.output = o.escapeLast(m.output, "[");
|
||
decrement("brackets");
|
||
}
|
||
while(m.parens > 0){
|
||
if (u.strictBrackets === true) throw new SyntaxError(syntaxError("closing", ")"));
|
||
m.output = o.escapeLast(m.output, "(");
|
||
decrement("parens");
|
||
}
|
||
while(m.braces > 0){
|
||
if (u.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "}"));
|
||
m.output = o.escapeLast(m.output, "{");
|
||
decrement("braces");
|
||
}
|
||
if (u.strictSlashes !== true && (B.type === "star" || B.type === "bracket")) {
|
||
push({
|
||
type: "maybe_slash",
|
||
value: "",
|
||
output: `${b}?`
|
||
});
|
||
}
|
||
if (m.backtrack === true) {
|
||
m.output = "";
|
||
for (const t of m.tokens){
|
||
m.output += t.output != null ? t.output : t.value;
|
||
if (t.suffix) {
|
||
m.output += t.suffix;
|
||
}
|
||
}
|
||
}
|
||
return m;
|
||
};
|
||
parse.fastpaths = (t, e)=>{
|
||
const u = {
|
||
...e
|
||
};
|
||
const r = typeof u.maxLength === "number" ? Math.min(s, u.maxLength) : s;
|
||
const a = t.length;
|
||
if (a > r) {
|
||
throw new SyntaxError(`Input length: ${a}, exceeds maximum allowed length: ${r}`);
|
||
}
|
||
t = c[t] || t;
|
||
const { DOT_LITERAL: i, SLASH_LITERAL: p, ONE_CHAR: l, DOTS_SLASH: f, NO_DOT: A, NO_DOTS: _, NO_DOTS_SLASH: R, STAR: E, START_ANCHOR: h } = n.globChars(u.windows);
|
||
const g = u.dot ? _ : A;
|
||
const b = u.dot ? R : A;
|
||
const C = u.capture ? "" : "?:";
|
||
const y = {
|
||
negated: false,
|
||
prefix: ""
|
||
};
|
||
let $ = u.bash === true ? ".*?" : E;
|
||
if (u.capture) {
|
||
$ = `(${$})`;
|
||
}
|
||
const globstar = (t)=>{
|
||
if (t.noglobstar === true) return $;
|
||
return `(${C}(?:(?!${h}${t.dot ? f : i}).)*?)`;
|
||
};
|
||
const create = (t)=>{
|
||
switch(t){
|
||
case "*":
|
||
return `${g}${l}${$}`;
|
||
case ".*":
|
||
return `${i}${l}${$}`;
|
||
case "*.*":
|
||
return `${g}${$}${i}${l}${$}`;
|
||
case "*/*":
|
||
return `${g}${$}${p}${l}${b}${$}`;
|
||
case "**":
|
||
return g + globstar(u);
|
||
case "**/*":
|
||
return `(?:${g}${globstar(u)}${p})?${b}${l}${$}`;
|
||
case "**/*.*":
|
||
return `(?:${g}${globstar(u)}${p})?${b}${$}${i}${l}${$}`;
|
||
case "**/.*":
|
||
return `(?:${g}${globstar(u)}${p})?${i}${l}${$}`;
|
||
default:
|
||
{
|
||
const e = /^(.*?)\.(\w+)$/.exec(t);
|
||
if (!e) return;
|
||
const u = create(e[1]);
|
||
if (!u) return;
|
||
return u + i + e[2];
|
||
}
|
||
}
|
||
};
|
||
const x = o.removePrefix(t, y);
|
||
let S = create(x);
|
||
if (S && u.strictSlashes !== true) {
|
||
S += `${p}?`;
|
||
}
|
||
return S;
|
||
};
|
||
t.exports = parse;
|
||
},
|
||
510: (t, e, u)=>{
|
||
const n = u(716);
|
||
const o = u(697);
|
||
const s = u(96);
|
||
const r = u(154);
|
||
const isObject = (t)=>t && typeof t === "object" && !Array.isArray(t);
|
||
const picomatch = (t, e, u = false)=>{
|
||
if (Array.isArray(t)) {
|
||
const n = t.map((t)=>picomatch(t, e, u));
|
||
const arrayMatcher = (t)=>{
|
||
for (const e of n){
|
||
const u = e(t);
|
||
if (u) return u;
|
||
}
|
||
return false;
|
||
};
|
||
return arrayMatcher;
|
||
}
|
||
const n = isObject(t) && t.tokens && t.input;
|
||
if (t === "" || typeof t !== "string" && !n) {
|
||
throw new TypeError("Expected pattern to be a non-empty string");
|
||
}
|
||
const o = e || {};
|
||
const s = o.windows;
|
||
const r = n ? picomatch.compileRe(t, e) : picomatch.makeRe(t, e, false, true);
|
||
const a = r.state;
|
||
delete r.state;
|
||
let isIgnored = ()=>false;
|
||
if (o.ignore) {
|
||
const t = {
|
||
...e,
|
||
ignore: null,
|
||
onMatch: null,
|
||
onResult: null
|
||
};
|
||
isIgnored = picomatch(o.ignore, t, u);
|
||
}
|
||
const matcher = (u, n = false)=>{
|
||
const { isMatch: i, match: c, output: p } = picomatch.test(u, r, e, {
|
||
glob: t,
|
||
posix: s
|
||
});
|
||
const l = {
|
||
glob: t,
|
||
state: a,
|
||
regex: r,
|
||
posix: s,
|
||
input: u,
|
||
output: p,
|
||
match: c,
|
||
isMatch: i
|
||
};
|
||
if (typeof o.onResult === "function") {
|
||
o.onResult(l);
|
||
}
|
||
if (i === false) {
|
||
l.isMatch = false;
|
||
return n ? l : false;
|
||
}
|
||
if (isIgnored(u)) {
|
||
if (typeof o.onIgnore === "function") {
|
||
o.onIgnore(l);
|
||
}
|
||
l.isMatch = false;
|
||
return n ? l : false;
|
||
}
|
||
if (typeof o.onMatch === "function") {
|
||
o.onMatch(l);
|
||
}
|
||
return n ? l : true;
|
||
};
|
||
if (u) {
|
||
matcher.state = a;
|
||
}
|
||
return matcher;
|
||
};
|
||
picomatch.test = (t, e, u, { glob: n, posix: o } = {})=>{
|
||
if (typeof t !== "string") {
|
||
throw new TypeError("Expected input to be a string");
|
||
}
|
||
if (t === "") {
|
||
return {
|
||
isMatch: false,
|
||
output: ""
|
||
};
|
||
}
|
||
const r = u || {};
|
||
const a = r.format || (o ? s.toPosixSlashes : null);
|
||
let i = t === n;
|
||
let c = i && a ? a(t) : t;
|
||
if (i === false) {
|
||
c = a ? a(t) : t;
|
||
i = c === n;
|
||
}
|
||
if (i === false || r.capture === true) {
|
||
if (r.matchBase === true || r.basename === true) {
|
||
i = picomatch.matchBase(t, e, u, o);
|
||
} else {
|
||
i = e.exec(c);
|
||
}
|
||
}
|
||
return {
|
||
isMatch: Boolean(i),
|
||
match: i,
|
||
output: c
|
||
};
|
||
};
|
||
picomatch.matchBase = (t, e, u)=>{
|
||
const n = e instanceof RegExp ? e : picomatch.makeRe(e, u);
|
||
return n.test(s.basename(t));
|
||
};
|
||
picomatch.isMatch = (t, e, u)=>picomatch(e, u)(t);
|
||
picomatch.parse = (t, e)=>{
|
||
if (Array.isArray(t)) return t.map((t)=>picomatch.parse(t, e));
|
||
return o(t, {
|
||
...e,
|
||
fastpaths: false
|
||
});
|
||
};
|
||
picomatch.scan = (t, e)=>n(t, e);
|
||
picomatch.compileRe = (t, e, u = false, n = false)=>{
|
||
if (u === true) {
|
||
return t.output;
|
||
}
|
||
const o = e || {};
|
||
const s = o.contains ? "" : "^";
|
||
const r = o.contains ? "" : "$";
|
||
let a = `${s}(?:${t.output})${r}`;
|
||
if (t && t.negated === true) {
|
||
a = `^(?!${a}).*$`;
|
||
}
|
||
const i = picomatch.toRegex(a, e);
|
||
if (n === true) {
|
||
i.state = t;
|
||
}
|
||
return i;
|
||
};
|
||
picomatch.makeRe = (t, e = {}, u = false, n = false)=>{
|
||
if (!t || typeof t !== "string") {
|
||
throw new TypeError("Expected a non-empty string");
|
||
}
|
||
let s = {
|
||
negated: false,
|
||
fastpaths: true
|
||
};
|
||
if (e.fastpaths !== false && (t[0] === "." || t[0] === "*")) {
|
||
s.output = o.fastpaths(t, e);
|
||
}
|
||
if (!s.output) {
|
||
s = o(t, e);
|
||
}
|
||
return picomatch.compileRe(s, e, u, n);
|
||
};
|
||
picomatch.toRegex = (t, e)=>{
|
||
try {
|
||
const u = e || {};
|
||
return new RegExp(t, u.flags || (u.nocase ? "i" : ""));
|
||
} catch (t) {
|
||
if (e && e.debug === true) throw t;
|
||
return /$^/;
|
||
}
|
||
};
|
||
picomatch.constants = r;
|
||
t.exports = picomatch;
|
||
},
|
||
716: (t, e, u)=>{
|
||
const n = u(96);
|
||
const { CHAR_ASTERISK: o, CHAR_AT: s, CHAR_BACKWARD_SLASH: r, CHAR_COMMA: a, CHAR_DOT: i, CHAR_EXCLAMATION_MARK: c, CHAR_FORWARD_SLASH: p, CHAR_LEFT_CURLY_BRACE: l, CHAR_LEFT_PARENTHESES: f, CHAR_LEFT_SQUARE_BRACKET: A, CHAR_PLUS: _, CHAR_QUESTION_MARK: R, CHAR_RIGHT_CURLY_BRACE: E, CHAR_RIGHT_PARENTHESES: h, CHAR_RIGHT_SQUARE_BRACKET: g } = u(154);
|
||
const isPathSeparator = (t)=>t === p || t === r;
|
||
const depth = (t)=>{
|
||
if (t.isPrefix !== true) {
|
||
t.depth = t.isGlobstar ? Infinity : 1;
|
||
}
|
||
};
|
||
const scan = (t, e)=>{
|
||
const u = e || {};
|
||
const b = t.length - 1;
|
||
const C = u.parts === true || u.scanToEnd === true;
|
||
const y = [];
|
||
const $ = [];
|
||
const x = [];
|
||
let S = t;
|
||
let H = -1;
|
||
let v = 0;
|
||
let d = 0;
|
||
let L = false;
|
||
let T = false;
|
||
let O = false;
|
||
let k = false;
|
||
let m = false;
|
||
let w = false;
|
||
let N = false;
|
||
let I = false;
|
||
let B = false;
|
||
let G = false;
|
||
let D = 0;
|
||
let M;
|
||
let P;
|
||
let K = {
|
||
value: "",
|
||
depth: 0,
|
||
isGlob: false
|
||
};
|
||
const eos = ()=>H >= b;
|
||
const peek = ()=>S.charCodeAt(H + 1);
|
||
const advance = ()=>{
|
||
M = P;
|
||
return S.charCodeAt(++H);
|
||
};
|
||
while(H < b){
|
||
P = advance();
|
||
let t;
|
||
if (P === r) {
|
||
N = K.backslashes = true;
|
||
P = advance();
|
||
if (P === l) {
|
||
w = true;
|
||
}
|
||
continue;
|
||
}
|
||
if (w === true || P === l) {
|
||
D++;
|
||
while(eos() !== true && (P = advance())){
|
||
if (P === r) {
|
||
N = K.backslashes = true;
|
||
advance();
|
||
continue;
|
||
}
|
||
if (P === l) {
|
||
D++;
|
||
continue;
|
||
}
|
||
if (w !== true && P === i && (P = advance()) === i) {
|
||
L = K.isBrace = true;
|
||
O = K.isGlob = true;
|
||
G = true;
|
||
if (C === true) {
|
||
continue;
|
||
}
|
||
break;
|
||
}
|
||
if (w !== true && P === a) {
|
||
L = K.isBrace = true;
|
||
O = K.isGlob = true;
|
||
G = true;
|
||
if (C === true) {
|
||
continue;
|
||
}
|
||
break;
|
||
}
|
||
if (P === E) {
|
||
D--;
|
||
if (D === 0) {
|
||
w = false;
|
||
L = K.isBrace = true;
|
||
G = true;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if (C === true) {
|
||
continue;
|
||
}
|
||
break;
|
||
}
|
||
if (P === p) {
|
||
y.push(H);
|
||
$.push(K);
|
||
K = {
|
||
value: "",
|
||
depth: 0,
|
||
isGlob: false
|
||
};
|
||
if (G === true) continue;
|
||
if (M === i && H === v + 1) {
|
||
v += 2;
|
||
continue;
|
||
}
|
||
d = H + 1;
|
||
continue;
|
||
}
|
||
if (u.noext !== true) {
|
||
const t = P === _ || P === s || P === o || P === R || P === c;
|
||
if (t === true && peek() === f) {
|
||
O = K.isGlob = true;
|
||
k = K.isExtglob = true;
|
||
G = true;
|
||
if (P === c && H === v) {
|
||
B = true;
|
||
}
|
||
if (C === true) {
|
||
while(eos() !== true && (P = advance())){
|
||
if (P === r) {
|
||
N = K.backslashes = true;
|
||
P = advance();
|
||
continue;
|
||
}
|
||
if (P === h) {
|
||
O = K.isGlob = true;
|
||
G = true;
|
||
break;
|
||
}
|
||
}
|
||
continue;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
if (P === o) {
|
||
if (M === o) m = K.isGlobstar = true;
|
||
O = K.isGlob = true;
|
||
G = true;
|
||
if (C === true) {
|
||
continue;
|
||
}
|
||
break;
|
||
}
|
||
if (P === R) {
|
||
O = K.isGlob = true;
|
||
G = true;
|
||
if (C === true) {
|
||
continue;
|
||
}
|
||
break;
|
||
}
|
||
if (P === A) {
|
||
while(eos() !== true && (t = advance())){
|
||
if (t === r) {
|
||
N = K.backslashes = true;
|
||
advance();
|
||
continue;
|
||
}
|
||
if (t === g) {
|
||
T = K.isBracket = true;
|
||
O = K.isGlob = true;
|
||
G = true;
|
||
break;
|
||
}
|
||
}
|
||
if (C === true) {
|
||
continue;
|
||
}
|
||
break;
|
||
}
|
||
if (u.nonegate !== true && P === c && H === v) {
|
||
I = K.negated = true;
|
||
v++;
|
||
continue;
|
||
}
|
||
if (u.noparen !== true && P === f) {
|
||
O = K.isGlob = true;
|
||
if (C === true) {
|
||
while(eos() !== true && (P = advance())){
|
||
if (P === f) {
|
||
N = K.backslashes = true;
|
||
P = advance();
|
||
continue;
|
||
}
|
||
if (P === h) {
|
||
G = true;
|
||
break;
|
||
}
|
||
}
|
||
continue;
|
||
}
|
||
break;
|
||
}
|
||
if (O === true) {
|
||
G = true;
|
||
if (C === true) {
|
||
continue;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
if (u.noext === true) {
|
||
k = false;
|
||
O = false;
|
||
}
|
||
let U = S;
|
||
let X = "";
|
||
let F = "";
|
||
if (v > 0) {
|
||
X = S.slice(0, v);
|
||
S = S.slice(v);
|
||
d -= v;
|
||
}
|
||
if (U && O === true && d > 0) {
|
||
U = S.slice(0, d);
|
||
F = S.slice(d);
|
||
} else if (O === true) {
|
||
U = "";
|
||
F = S;
|
||
} else {
|
||
U = S;
|
||
}
|
||
if (U && U !== "" && U !== "/" && U !== S) {
|
||
if (isPathSeparator(U.charCodeAt(U.length - 1))) {
|
||
U = U.slice(0, -1);
|
||
}
|
||
}
|
||
if (u.unescape === true) {
|
||
if (F) F = n.removeBackslashes(F);
|
||
if (U && N === true) {
|
||
U = n.removeBackslashes(U);
|
||
}
|
||
}
|
||
const Q = {
|
||
prefix: X,
|
||
input: t,
|
||
start: v,
|
||
base: U,
|
||
glob: F,
|
||
isBrace: L,
|
||
isBracket: T,
|
||
isGlob: O,
|
||
isExtglob: k,
|
||
isGlobstar: m,
|
||
negated: I,
|
||
negatedExtglob: B
|
||
};
|
||
if (u.tokens === true) {
|
||
Q.maxDepth = 0;
|
||
if (!isPathSeparator(P)) {
|
||
$.push(K);
|
||
}
|
||
Q.tokens = $;
|
||
}
|
||
if (u.parts === true || u.tokens === true) {
|
||
let e;
|
||
for(let n = 0; n < y.length; n++){
|
||
const o = e ? e + 1 : v;
|
||
const s = y[n];
|
||
const r = t.slice(o, s);
|
||
if (u.tokens) {
|
||
if (n === 0 && v !== 0) {
|
||
$[n].isPrefix = true;
|
||
$[n].value = X;
|
||
} else {
|
||
$[n].value = r;
|
||
}
|
||
depth($[n]);
|
||
Q.maxDepth += $[n].depth;
|
||
}
|
||
if (n !== 0 || r !== "") {
|
||
x.push(r);
|
||
}
|
||
e = s;
|
||
}
|
||
if (e && e + 1 < t.length) {
|
||
const n = t.slice(e + 1);
|
||
x.push(n);
|
||
if (u.tokens) {
|
||
$[$.length - 1].value = n;
|
||
depth($[$.length - 1]);
|
||
Q.maxDepth += $[$.length - 1].depth;
|
||
}
|
||
}
|
||
Q.slashes = y;
|
||
Q.parts = x;
|
||
}
|
||
return Q;
|
||
};
|
||
t.exports = scan;
|
||
},
|
||
96: (t, e, u)=>{
|
||
const { REGEX_BACKSLASH: n, REGEX_REMOVE_BACKSLASH: o, REGEX_SPECIAL_CHARS: s, REGEX_SPECIAL_CHARS_GLOBAL: r } = u(154);
|
||
e.isObject = (t)=>t !== null && typeof t === "object" && !Array.isArray(t);
|
||
e.hasRegexChars = (t)=>s.test(t);
|
||
e.isRegexChar = (t)=>t.length === 1 && e.hasRegexChars(t);
|
||
e.escapeRegex = (t)=>t.replace(r, "\\$1");
|
||
e.toPosixSlashes = (t)=>t.replace(n, "/");
|
||
e.removeBackslashes = (t)=>t.replace(o, (t)=>t === "\\" ? "" : t);
|
||
e.escapeLast = (t, u, n)=>{
|
||
const o = t.lastIndexOf(u, n);
|
||
if (o === -1) return t;
|
||
if (t[o - 1] === "\\") return e.escapeLast(t, u, o - 1);
|
||
return `${t.slice(0, o)}\\${t.slice(o)}`;
|
||
};
|
||
e.removePrefix = (t, e = {})=>{
|
||
let u = t;
|
||
if (u.startsWith("./")) {
|
||
u = u.slice(2);
|
||
e.prefix = "./";
|
||
}
|
||
return u;
|
||
};
|
||
e.wrapOutput = (t, e = {}, u = {})=>{
|
||
const n = u.contains ? "" : "^";
|
||
const o = u.contains ? "" : "$";
|
||
let s = `${n}(?:${t})${o}`;
|
||
if (e.negated === true) {
|
||
s = `(?:^(?!${s}).*$)`;
|
||
}
|
||
return s;
|
||
};
|
||
e.basename = (t, { windows: e } = {})=>{
|
||
const u = t.split(e ? /[\\/]/ : "/");
|
||
const n = u[u.length - 1];
|
||
if (n === "") {
|
||
return u[u.length - 2];
|
||
}
|
||
return n;
|
||
};
|
||
}
|
||
};
|
||
var e = {};
|
||
function __nccwpck_require__(u) {
|
||
var n = e[u];
|
||
if (n !== undefined) {
|
||
return n.exports;
|
||
}
|
||
var o = e[u] = {
|
||
exports: {}
|
||
};
|
||
var s = true;
|
||
try {
|
||
t[u](o, o.exports, __nccwpck_require__);
|
||
s = false;
|
||
} finally{
|
||
if (s) delete e[u];
|
||
}
|
||
return o.exports;
|
||
}
|
||
if (typeof __nccwpck_require__ !== "undefined") __nccwpck_require__.ab = ("TURBOPACK compile-time value", "/ROOT/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/compiled/picomatch") + "/";
|
||
var u = __nccwpck_require__(170);
|
||
module.exports = u;
|
||
})();
|
||
}),
|
||
"[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/shared/lib/match-local-pattern.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
"use strict";
|
||
|
||
Object.defineProperty(exports, "__esModule", {
|
||
value: true
|
||
});
|
||
0 && (module.exports = {
|
||
hasLocalMatch: null,
|
||
matchLocalPattern: null
|
||
});
|
||
function _export(target, all) {
|
||
for(var name in all)Object.defineProperty(target, name, {
|
||
enumerable: true,
|
||
get: all[name]
|
||
});
|
||
}
|
||
_export(exports, {
|
||
hasLocalMatch: function() {
|
||
return hasLocalMatch;
|
||
},
|
||
matchLocalPattern: function() {
|
||
return matchLocalPattern;
|
||
}
|
||
});
|
||
const _picomatch = __turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/compiled/picomatch/index.js [app-client] (ecmascript)");
|
||
function matchLocalPattern(pattern, url) {
|
||
if (pattern.search !== undefined) {
|
||
if (pattern.search !== url.search) {
|
||
return false;
|
||
}
|
||
}
|
||
if (!(0, _picomatch.makeRe)(pattern.pathname ?? '**', {
|
||
dot: true
|
||
}).test(url.pathname)) {
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
function hasLocalMatch(localPatterns, urlPathAndQuery) {
|
||
if (!localPatterns) {
|
||
// if the user didn't define "localPatterns", we allow all local images
|
||
return true;
|
||
}
|
||
const url = new URL(urlPathAndQuery, 'http://n');
|
||
return localPatterns.some((p)=>matchLocalPattern(p, url));
|
||
} //# sourceMappingURL=match-local-pattern.js.map
|
||
}),
|
||
"[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/shared/lib/match-remote-pattern.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
"use strict";
|
||
|
||
Object.defineProperty(exports, "__esModule", {
|
||
value: true
|
||
});
|
||
0 && (module.exports = {
|
||
hasRemoteMatch: null,
|
||
matchRemotePattern: null
|
||
});
|
||
function _export(target, all) {
|
||
for(var name in all)Object.defineProperty(target, name, {
|
||
enumerable: true,
|
||
get: all[name]
|
||
});
|
||
}
|
||
_export(exports, {
|
||
hasRemoteMatch: function() {
|
||
return hasRemoteMatch;
|
||
},
|
||
matchRemotePattern: function() {
|
||
return matchRemotePattern;
|
||
}
|
||
});
|
||
const _picomatch = __turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/compiled/picomatch/index.js [app-client] (ecmascript)");
|
||
function matchRemotePattern(pattern, url) {
|
||
if (pattern.protocol !== undefined) {
|
||
if (pattern.protocol.replace(/:$/, '') !== url.protocol.replace(/:$/, '')) {
|
||
return false;
|
||
}
|
||
}
|
||
if (pattern.port !== undefined) {
|
||
if (pattern.port !== url.port) {
|
||
return false;
|
||
}
|
||
}
|
||
if (pattern.hostname === undefined) {
|
||
throw Object.defineProperty(new Error(`Pattern should define hostname but found\n${JSON.stringify(pattern)}`), "__NEXT_ERROR_CODE", {
|
||
value: "E410",
|
||
enumerable: false,
|
||
configurable: true
|
||
});
|
||
} else {
|
||
if (!(0, _picomatch.makeRe)(pattern.hostname).test(url.hostname)) {
|
||
return false;
|
||
}
|
||
}
|
||
if (pattern.search !== undefined) {
|
||
if (pattern.search !== url.search) {
|
||
return false;
|
||
}
|
||
}
|
||
// Should be the same as writeImagesManifest()
|
||
if (!(0, _picomatch.makeRe)(pattern.pathname ?? '**', {
|
||
dot: true
|
||
}).test(url.pathname)) {
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
function hasRemoteMatch(domains, remotePatterns, url) {
|
||
return domains.some((domain)=>url.hostname === domain) || remotePatterns.some((p)=>matchRemotePattern(p, url));
|
||
} //# sourceMappingURL=match-remote-pattern.js.map
|
||
}),
|
||
"[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/shared/lib/image-loader.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
"use strict";
|
||
|
||
var __TURBOPACK__imported__module__$5b$project$5d2f$Documents$2f$go$2d$new$2f$chinese$2d$family$2d$tree$2f$node_modules$2f2e$pnpm$2f$next$40$16$2e$0$2e$3_react$2d$dom$40$19$2e$2$2e$0_react$40$19$2e$2$2e$0_$5f$react$40$19$2e$2$2e$0$2f$node_modules$2f$next$2f$dist$2f$build$2f$polyfills$2f$process$2e$js__$5b$app$2d$client$5d$__$28$ecmascript$29$__ = /*#__PURE__*/ __turbopack_context__.i("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/build/polyfills/process.js [app-client] (ecmascript)");
|
||
"use strict";
|
||
Object.defineProperty(exports, "__esModule", {
|
||
value: true
|
||
});
|
||
Object.defineProperty(exports, "default", {
|
||
enumerable: true,
|
||
get: function() {
|
||
return _default;
|
||
}
|
||
});
|
||
const _findclosestquality = __turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/shared/lib/find-closest-quality.js [app-client] (ecmascript)");
|
||
function defaultLoader({ config, src, width, quality }) {
|
||
if (src.startsWith('/') && src.includes('?') && config.localPatterns?.length === 1 && config.localPatterns[0].pathname === '**' && config.localPatterns[0].search === '') {
|
||
throw Object.defineProperty(new Error(`Image with src "${src}" is using a query string which is not configured in images.localPatterns.` + `\nRead more: https://nextjs.org/docs/messages/next-image-unconfigured-localpatterns`), "__NEXT_ERROR_CODE", {
|
||
value: "E871",
|
||
enumerable: false,
|
||
configurable: true
|
||
});
|
||
}
|
||
if ("TURBOPACK compile-time truthy", 1) {
|
||
const missingValues = [];
|
||
// these should always be provided but make sure they are
|
||
if (!src) missingValues.push('src');
|
||
if (!width) missingValues.push('width');
|
||
if (missingValues.length > 0) {
|
||
throw Object.defineProperty(new Error(`Next Image Optimization requires ${missingValues.join(', ')} to be provided. Make sure you pass them as props to the \`next/image\` component. Received: ${JSON.stringify({
|
||
src,
|
||
width,
|
||
quality
|
||
})}`), "__NEXT_ERROR_CODE", {
|
||
value: "E188",
|
||
enumerable: false,
|
||
configurable: true
|
||
});
|
||
}
|
||
if (src.startsWith('//')) {
|
||
throw Object.defineProperty(new Error(`Failed to parse src "${src}" on \`next/image\`, protocol-relative URL (//) must be changed to an absolute URL (http:// or https://)`), "__NEXT_ERROR_CODE", {
|
||
value: "E360",
|
||
enumerable: false,
|
||
configurable: true
|
||
});
|
||
}
|
||
if (src.startsWith('/') && config.localPatterns) {
|
||
if ("TURBOPACK compile-time truthy", 1) {
|
||
// We use dynamic require because this should only error in development
|
||
const { hasLocalMatch } = __turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/shared/lib/match-local-pattern.js [app-client] (ecmascript)");
|
||
if (!hasLocalMatch(config.localPatterns, src)) {
|
||
throw Object.defineProperty(new Error(`Invalid src prop (${src}) on \`next/image\` does not match \`images.localPatterns\` configured in your \`next.config.js\`\n` + `See more info: https://nextjs.org/docs/messages/next-image-unconfigured-localpatterns`), "__NEXT_ERROR_CODE", {
|
||
value: "E426",
|
||
enumerable: false,
|
||
configurable: true
|
||
});
|
||
}
|
||
}
|
||
}
|
||
if (!src.startsWith('/') && (config.domains || config.remotePatterns)) {
|
||
let parsedSrc;
|
||
try {
|
||
parsedSrc = new URL(src);
|
||
} catch (err) {
|
||
console.error(err);
|
||
throw Object.defineProperty(new Error(`Failed to parse src "${src}" on \`next/image\`, if using relative image it must start with a leading slash "/" or be an absolute URL (http:// or https://)`), "__NEXT_ERROR_CODE", {
|
||
value: "E63",
|
||
enumerable: false,
|
||
configurable: true
|
||
});
|
||
}
|
||
if ("TURBOPACK compile-time truthy", 1) {
|
||
// We use dynamic require because this should only error in development
|
||
const { hasRemoteMatch } = __turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/shared/lib/match-remote-pattern.js [app-client] (ecmascript)");
|
||
if (!hasRemoteMatch(config.domains, config.remotePatterns, parsedSrc)) {
|
||
throw Object.defineProperty(new Error(`Invalid src prop (${src}) on \`next/image\`, hostname "${parsedSrc.hostname}" is not configured under images in your \`next.config.js\`\n` + `See more info: https://nextjs.org/docs/messages/next-image-unconfigured-host`), "__NEXT_ERROR_CODE", {
|
||
value: "E231",
|
||
enumerable: false,
|
||
configurable: true
|
||
});
|
||
}
|
||
}
|
||
}
|
||
}
|
||
const q = (0, _findclosestquality.findClosestQuality)(quality, config);
|
||
return `${config.path}?url=${encodeURIComponent(src)}&w=${width}&q=${q}${src.startsWith('/_next/static/media/') && ("TURBOPACK compile-time value", false) ? "TURBOPACK unreachable" : ''}`;
|
||
}
|
||
// We use this to determine if the import is the default loader
|
||
// or a custom loader defined by the user in next.config.js
|
||
defaultLoader.__next_img_default = true;
|
||
const _default = defaultLoader; //# sourceMappingURL=image-loader.js.map
|
||
}),
|
||
"[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/client/image-component.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
"use strict";
|
||
|
||
var __TURBOPACK__imported__module__$5b$project$5d2f$Documents$2f$go$2d$new$2f$chinese$2d$family$2d$tree$2f$node_modules$2f2e$pnpm$2f$next$40$16$2e$0$2e$3_react$2d$dom$40$19$2e$2$2e$0_react$40$19$2e$2$2e$0_$5f$react$40$19$2e$2$2e$0$2f$node_modules$2f$next$2f$dist$2f$build$2f$polyfills$2f$process$2e$js__$5b$app$2d$client$5d$__$28$ecmascript$29$__ = /*#__PURE__*/ __turbopack_context__.i("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/build/polyfills/process.js [app-client] (ecmascript)");
|
||
'use client';
|
||
"use strict";
|
||
Object.defineProperty(exports, "__esModule", {
|
||
value: true
|
||
});
|
||
Object.defineProperty(exports, "Image", {
|
||
enumerable: true,
|
||
get: function() {
|
||
return Image;
|
||
}
|
||
});
|
||
const _interop_require_default = __turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/@swc+helpers@0.5.15/node_modules/@swc/helpers/cjs/_interop_require_default.cjs [app-client] (ecmascript)");
|
||
const _interop_require_wildcard = __turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/@swc+helpers@0.5.15/node_modules/@swc/helpers/cjs/_interop_require_wildcard.cjs [app-client] (ecmascript)");
|
||
const _jsxruntime = __turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/compiled/react/jsx-runtime.js [app-client] (ecmascript)");
|
||
const _react = /*#__PURE__*/ _interop_require_wildcard._(__turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/compiled/react/index.js [app-client] (ecmascript)"));
|
||
const _reactdom = /*#__PURE__*/ _interop_require_default._(__turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/compiled/react-dom/index.js [app-client] (ecmascript)"));
|
||
const _head = /*#__PURE__*/ _interop_require_default._(__turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/shared/lib/head.js [app-client] (ecmascript)"));
|
||
const _getimgprops = __turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/shared/lib/get-img-props.js [app-client] (ecmascript)");
|
||
const _imageconfig = __turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/shared/lib/image-config.js [app-client] (ecmascript)");
|
||
const _imageconfigcontextsharedruntime = __turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/shared/lib/image-config-context.shared-runtime.js [app-client] (ecmascript)");
|
||
const _warnonce = __turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/shared/lib/utils/warn-once.js [app-client] (ecmascript)");
|
||
const _routercontextsharedruntime = __turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/shared/lib/router-context.shared-runtime.js [app-client] (ecmascript)");
|
||
const _imageloader = /*#__PURE__*/ _interop_require_default._(__turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/shared/lib/image-loader.js [app-client] (ecmascript)"));
|
||
const _usemergedref = __turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/client/use-merged-ref.js [app-client] (ecmascript)");
|
||
// This is replaced by webpack define plugin
|
||
const configEnv = ("TURBOPACK compile-time value", {
|
||
"deviceSizes": ("TURBOPACK compile-time value", [
|
||
("TURBOPACK compile-time value", 640),
|
||
("TURBOPACK compile-time value", 750),
|
||
("TURBOPACK compile-time value", 828),
|
||
("TURBOPACK compile-time value", 1080),
|
||
("TURBOPACK compile-time value", 1200),
|
||
("TURBOPACK compile-time value", 1920),
|
||
("TURBOPACK compile-time value", 2048),
|
||
("TURBOPACK compile-time value", 3840)
|
||
]),
|
||
"imageSizes": ("TURBOPACK compile-time value", [
|
||
("TURBOPACK compile-time value", 32),
|
||
("TURBOPACK compile-time value", 48),
|
||
("TURBOPACK compile-time value", 64),
|
||
("TURBOPACK compile-time value", 96),
|
||
("TURBOPACK compile-time value", 128),
|
||
("TURBOPACK compile-time value", 256),
|
||
("TURBOPACK compile-time value", 384)
|
||
]),
|
||
"qualities": ("TURBOPACK compile-time value", [
|
||
("TURBOPACK compile-time value", 75)
|
||
]),
|
||
"path": ("TURBOPACK compile-time value", "/_next/image"),
|
||
"loader": ("TURBOPACK compile-time value", "default"),
|
||
"dangerouslyAllowSVG": ("TURBOPACK compile-time value", false),
|
||
"unoptimized": ("TURBOPACK compile-time value", true),
|
||
"domains": ("TURBOPACK compile-time value", []),
|
||
"remotePatterns": ("TURBOPACK compile-time value", []),
|
||
"localPatterns": ("TURBOPACK compile-time value", [
|
||
("TURBOPACK compile-time value", {
|
||
"pathname": ("TURBOPACK compile-time value", "**"),
|
||
"search": ("TURBOPACK compile-time value", "")
|
||
})
|
||
])
|
||
});
|
||
if (typeof window === 'undefined') {
|
||
;
|
||
globalThis.__NEXT_IMAGE_IMPORTED = true;
|
||
}
|
||
// See https://stackoverflow.com/q/39777833/266535 for why we use this ref
|
||
// handler instead of the img's onLoad attribute.
|
||
function handleLoading(img, placeholder, onLoadRef, onLoadingCompleteRef, setBlurComplete, unoptimized, sizesInput) {
|
||
const src = img?.src;
|
||
if (!img || img['data-loaded-src'] === src) {
|
||
return;
|
||
}
|
||
img['data-loaded-src'] = src;
|
||
const p = 'decode' in img ? img.decode() : Promise.resolve();
|
||
p.catch(()=>{}).then(()=>{
|
||
if (!img.parentElement || !img.isConnected) {
|
||
// Exit early in case of race condition:
|
||
// - onload() is called
|
||
// - decode() is called but incomplete
|
||
// - unmount is called
|
||
// - decode() completes
|
||
return;
|
||
}
|
||
if (placeholder !== 'empty') {
|
||
setBlurComplete(true);
|
||
}
|
||
if (onLoadRef?.current) {
|
||
// Since we don't have the SyntheticEvent here,
|
||
// we must create one with the same shape.
|
||
// See https://reactjs.org/docs/events.html
|
||
const event = new Event('load');
|
||
Object.defineProperty(event, 'target', {
|
||
writable: false,
|
||
value: img
|
||
});
|
||
let prevented = false;
|
||
let stopped = false;
|
||
onLoadRef.current({
|
||
...event,
|
||
nativeEvent: event,
|
||
currentTarget: img,
|
||
target: img,
|
||
isDefaultPrevented: ()=>prevented,
|
||
isPropagationStopped: ()=>stopped,
|
||
persist: ()=>{},
|
||
preventDefault: ()=>{
|
||
prevented = true;
|
||
event.preventDefault();
|
||
},
|
||
stopPropagation: ()=>{
|
||
stopped = true;
|
||
event.stopPropagation();
|
||
}
|
||
});
|
||
}
|
||
if (onLoadingCompleteRef?.current) {
|
||
onLoadingCompleteRef.current(img);
|
||
}
|
||
if ("TURBOPACK compile-time truthy", 1) {
|
||
const origSrc = new URL(src, 'http://n').searchParams.get('url') || src;
|
||
if (img.getAttribute('data-nimg') === 'fill') {
|
||
if (!unoptimized && (!sizesInput || sizesInput === '100vw')) {
|
||
let widthViewportRatio = img.getBoundingClientRect().width / window.innerWidth;
|
||
if (widthViewportRatio < 0.6) {
|
||
if (sizesInput === '100vw') {
|
||
(0, _warnonce.warnOnce)(`Image with src "${origSrc}" has "fill" prop and "sizes" prop of "100vw", but image is not rendered at full viewport width. Please adjust "sizes" to improve page performance. Read more: https://nextjs.org/docs/api-reference/next/image#sizes`);
|
||
} else {
|
||
(0, _warnonce.warnOnce)(`Image with src "${origSrc}" has "fill" but is missing "sizes" prop. Please add it to improve page performance. Read more: https://nextjs.org/docs/api-reference/next/image#sizes`);
|
||
}
|
||
}
|
||
}
|
||
if (img.parentElement) {
|
||
const { position } = window.getComputedStyle(img.parentElement);
|
||
const valid = [
|
||
'absolute',
|
||
'fixed',
|
||
'relative'
|
||
];
|
||
if (!valid.includes(position)) {
|
||
(0, _warnonce.warnOnce)(`Image with src "${origSrc}" has "fill" and parent element with invalid "position". Provided "${position}" should be one of ${valid.map(String).join(',')}.`);
|
||
}
|
||
}
|
||
if (img.height === 0) {
|
||
(0, _warnonce.warnOnce)(`Image with src "${origSrc}" has "fill" and a height value of 0. This is likely because the parent element of the image has not been styled to have a set height.`);
|
||
}
|
||
}
|
||
const heightModified = img.height.toString() !== img.getAttribute('height');
|
||
const widthModified = img.width.toString() !== img.getAttribute('width');
|
||
if (heightModified && !widthModified || !heightModified && widthModified) {
|
||
(0, _warnonce.warnOnce)(`Image with src "${origSrc}" has either width or height modified, but not the other. If you use CSS to change the size of your image, also include the styles 'width: "auto"' or 'height: "auto"' to maintain the aspect ratio.`);
|
||
}
|
||
}
|
||
});
|
||
}
|
||
function getDynamicProps(fetchPriority) {
|
||
if (Boolean(_react.use)) {
|
||
// In React 19.0.0 or newer, we must use camelCase
|
||
// prop to avoid "Warning: Invalid DOM property".
|
||
// See https://github.com/facebook/react/pull/25927
|
||
return {
|
||
fetchPriority
|
||
};
|
||
}
|
||
// In React 18.2.0 or older, we must use lowercase prop
|
||
// to avoid "Warning: Invalid DOM property".
|
||
return {
|
||
fetchpriority: fetchPriority
|
||
};
|
||
}
|
||
const ImageElement = /*#__PURE__*/ (0, _react.forwardRef)(({ src, srcSet, sizes, height, width, decoding, className, style, fetchPriority, placeholder, loading, unoptimized, fill, onLoadRef, onLoadingCompleteRef, setBlurComplete, setShowAltText, sizesInput, onLoad, onError, ...rest }, forwardedRef)=>{
|
||
const ownRef = (0, _react.useCallback)((img)=>{
|
||
if (!img) {
|
||
return;
|
||
}
|
||
if (onError) {
|
||
// If the image has an error before react hydrates, then the error is lost.
|
||
// The workaround is to wait until the image is mounted which is after hydration,
|
||
// then we set the src again to trigger the error handler (if there was an error).
|
||
// eslint-disable-next-line no-self-assign
|
||
img.src = img.src;
|
||
}
|
||
if ("TURBOPACK compile-time truthy", 1) {
|
||
if (!src) {
|
||
console.error(`Image is missing required "src" property:`, img);
|
||
}
|
||
if (img.getAttribute('alt') === null) {
|
||
console.error(`Image is missing required "alt" property. Please add Alternative Text to describe the image for screen readers and search engines.`);
|
||
}
|
||
}
|
||
if (img.complete) {
|
||
handleLoading(img, placeholder, onLoadRef, onLoadingCompleteRef, setBlurComplete, unoptimized, sizesInput);
|
||
}
|
||
}, [
|
||
src,
|
||
placeholder,
|
||
onLoadRef,
|
||
onLoadingCompleteRef,
|
||
setBlurComplete,
|
||
onError,
|
||
unoptimized,
|
||
sizesInput
|
||
]);
|
||
const ref = (0, _usemergedref.useMergedRef)(forwardedRef, ownRef);
|
||
return /*#__PURE__*/ (0, _jsxruntime.jsx)("img", {
|
||
...rest,
|
||
...getDynamicProps(fetchPriority),
|
||
// It's intended to keep `loading` before `src` because React updates
|
||
// props in order which causes Safari/Firefox to not lazy load properly.
|
||
// See https://github.com/facebook/react/issues/25883
|
||
loading: loading,
|
||
width: width,
|
||
height: height,
|
||
decoding: decoding,
|
||
"data-nimg": fill ? 'fill' : '1',
|
||
className: className,
|
||
style: style,
|
||
// It's intended to keep `src` the last attribute because React updates
|
||
// attributes in order. If we keep `src` the first one, Safari will
|
||
// immediately start to fetch `src`, before `sizes` and `srcSet` are even
|
||
// updated by React. That causes multiple unnecessary requests if `srcSet`
|
||
// and `sizes` are defined.
|
||
// This bug cannot be reproduced in Chrome or Firefox.
|
||
sizes: sizes,
|
||
srcSet: srcSet,
|
||
src: src,
|
||
ref: ref,
|
||
onLoad: (event)=>{
|
||
const img = event.currentTarget;
|
||
handleLoading(img, placeholder, onLoadRef, onLoadingCompleteRef, setBlurComplete, unoptimized, sizesInput);
|
||
},
|
||
onError: (event)=>{
|
||
// if the real image fails to load, this will ensure "alt" is visible
|
||
setShowAltText(true);
|
||
if (placeholder !== 'empty') {
|
||
// If the real image fails to load, this will still remove the placeholder.
|
||
setBlurComplete(true);
|
||
}
|
||
if (onError) {
|
||
onError(event);
|
||
}
|
||
}
|
||
});
|
||
});
|
||
function ImagePreload({ isAppRouter, imgAttributes }) {
|
||
const opts = {
|
||
as: 'image',
|
||
imageSrcSet: imgAttributes.srcSet,
|
||
imageSizes: imgAttributes.sizes,
|
||
crossOrigin: imgAttributes.crossOrigin,
|
||
referrerPolicy: imgAttributes.referrerPolicy,
|
||
...getDynamicProps(imgAttributes.fetchPriority)
|
||
};
|
||
if (isAppRouter && _reactdom.default.preload) {
|
||
_reactdom.default.preload(imgAttributes.src, opts);
|
||
return null;
|
||
}
|
||
return /*#__PURE__*/ (0, _jsxruntime.jsx)(_head.default, {
|
||
children: /*#__PURE__*/ (0, _jsxruntime.jsx)("link", {
|
||
rel: "preload",
|
||
// Note how we omit the `href` attribute, as it would only be relevant
|
||
// for browsers that do not support `imagesrcset`, and in those cases
|
||
// it would cause the incorrect image to be preloaded.
|
||
//
|
||
// https://html.spec.whatwg.org/multipage/semantics.html#attr-link-imagesrcset
|
||
href: imgAttributes.srcSet ? undefined : imgAttributes.src,
|
||
...opts
|
||
}, '__nimg-' + imgAttributes.src + imgAttributes.srcSet + imgAttributes.sizes)
|
||
});
|
||
}
|
||
const Image = /*#__PURE__*/ (0, _react.forwardRef)((props, forwardedRef)=>{
|
||
const pagesRouter = (0, _react.useContext)(_routercontextsharedruntime.RouterContext);
|
||
// We're in the app directory if there is no pages router.
|
||
const isAppRouter = !pagesRouter;
|
||
const configContext = (0, _react.useContext)(_imageconfigcontextsharedruntime.ImageConfigContext);
|
||
const config = (0, _react.useMemo)(()=>{
|
||
const c = configEnv || configContext || _imageconfig.imageConfigDefault;
|
||
const allSizes = [
|
||
...c.deviceSizes,
|
||
...c.imageSizes
|
||
].sort((a, b)=>a - b);
|
||
const deviceSizes = c.deviceSizes.sort((a, b)=>a - b);
|
||
const qualities = c.qualities?.sort((a, b)=>a - b);
|
||
return {
|
||
...c,
|
||
allSizes,
|
||
deviceSizes,
|
||
qualities,
|
||
// During the SSR, configEnv (__NEXT_IMAGE_OPTS) does not include
|
||
// security sensitive configs like `localPatterns`, which is needed
|
||
// during the server render to ensure it's validated. Therefore use
|
||
// configContext, which holds the config from the server for validation.
|
||
localPatterns: typeof window === 'undefined' ? configContext?.localPatterns : c.localPatterns
|
||
};
|
||
}, [
|
||
configContext
|
||
]);
|
||
const { onLoad, onLoadingComplete } = props;
|
||
const onLoadRef = (0, _react.useRef)(onLoad);
|
||
(0, _react.useEffect)(()=>{
|
||
onLoadRef.current = onLoad;
|
||
}, [
|
||
onLoad
|
||
]);
|
||
const onLoadingCompleteRef = (0, _react.useRef)(onLoadingComplete);
|
||
(0, _react.useEffect)(()=>{
|
||
onLoadingCompleteRef.current = onLoadingComplete;
|
||
}, [
|
||
onLoadingComplete
|
||
]);
|
||
const [blurComplete, setBlurComplete] = (0, _react.useState)(false);
|
||
const [showAltText, setShowAltText] = (0, _react.useState)(false);
|
||
const { props: imgAttributes, meta: imgMeta } = (0, _getimgprops.getImgProps)(props, {
|
||
defaultLoader: _imageloader.default,
|
||
imgConf: config,
|
||
blurComplete,
|
||
showAltText
|
||
});
|
||
return /*#__PURE__*/ (0, _jsxruntime.jsxs)(_jsxruntime.Fragment, {
|
||
children: [
|
||
/*#__PURE__*/ (0, _jsxruntime.jsx)(ImageElement, {
|
||
...imgAttributes,
|
||
unoptimized: imgMeta.unoptimized,
|
||
placeholder: imgMeta.placeholder,
|
||
fill: imgMeta.fill,
|
||
onLoadRef: onLoadRef,
|
||
onLoadingCompleteRef: onLoadingCompleteRef,
|
||
setBlurComplete: setBlurComplete,
|
||
setShowAltText: setShowAltText,
|
||
sizesInput: props.sizes,
|
||
ref: forwardedRef
|
||
}),
|
||
imgMeta.preload ? /*#__PURE__*/ (0, _jsxruntime.jsx)(ImagePreload, {
|
||
isAppRouter: isAppRouter,
|
||
imgAttributes: imgAttributes
|
||
}) : null
|
||
]
|
||
});
|
||
});
|
||
if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
|
||
Object.defineProperty(exports.default, '__esModule', {
|
||
value: true
|
||
});
|
||
Object.assign(exports.default, exports);
|
||
module.exports = exports.default;
|
||
} //# sourceMappingURL=image-component.js.map
|
||
}),
|
||
"[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/shared/lib/image-external.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
"use strict";
|
||
|
||
var __TURBOPACK__imported__module__$5b$project$5d2f$Documents$2f$go$2d$new$2f$chinese$2d$family$2d$tree$2f$node_modules$2f2e$pnpm$2f$next$40$16$2e$0$2e$3_react$2d$dom$40$19$2e$2$2e$0_react$40$19$2e$2$2e$0_$5f$react$40$19$2e$2$2e$0$2f$node_modules$2f$next$2f$dist$2f$build$2f$polyfills$2f$process$2e$js__$5b$app$2d$client$5d$__$28$ecmascript$29$__ = /*#__PURE__*/ __turbopack_context__.i("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/build/polyfills/process.js [app-client] (ecmascript)");
|
||
"use strict";
|
||
Object.defineProperty(exports, "__esModule", {
|
||
value: true
|
||
});
|
||
0 && (module.exports = {
|
||
default: null,
|
||
getImageProps: null
|
||
});
|
||
function _export(target, all) {
|
||
for(var name in all)Object.defineProperty(target, name, {
|
||
enumerable: true,
|
||
get: all[name]
|
||
});
|
||
}
|
||
_export(exports, {
|
||
default: function() {
|
||
return _default;
|
||
},
|
||
getImageProps: function() {
|
||
return getImageProps;
|
||
}
|
||
});
|
||
const _interop_require_default = __turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/@swc+helpers@0.5.15/node_modules/@swc/helpers/cjs/_interop_require_default.cjs [app-client] (ecmascript)");
|
||
const _getimgprops = __turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/shared/lib/get-img-props.js [app-client] (ecmascript)");
|
||
const _imagecomponent = __turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/client/image-component.js [app-client] (ecmascript)");
|
||
const _imageloader = /*#__PURE__*/ _interop_require_default._(__turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/shared/lib/image-loader.js [app-client] (ecmascript)"));
|
||
function getImageProps(imgProps) {
|
||
const { props } = (0, _getimgprops.getImgProps)(imgProps, {
|
||
defaultLoader: _imageloader.default,
|
||
// This is replaced by webpack define plugin
|
||
imgConf: ("TURBOPACK compile-time value", {
|
||
"deviceSizes": ("TURBOPACK compile-time value", [
|
||
("TURBOPACK compile-time value", 640),
|
||
("TURBOPACK compile-time value", 750),
|
||
("TURBOPACK compile-time value", 828),
|
||
("TURBOPACK compile-time value", 1080),
|
||
("TURBOPACK compile-time value", 1200),
|
||
("TURBOPACK compile-time value", 1920),
|
||
("TURBOPACK compile-time value", 2048),
|
||
("TURBOPACK compile-time value", 3840)
|
||
]),
|
||
"imageSizes": ("TURBOPACK compile-time value", [
|
||
("TURBOPACK compile-time value", 32),
|
||
("TURBOPACK compile-time value", 48),
|
||
("TURBOPACK compile-time value", 64),
|
||
("TURBOPACK compile-time value", 96),
|
||
("TURBOPACK compile-time value", 128),
|
||
("TURBOPACK compile-time value", 256),
|
||
("TURBOPACK compile-time value", 384)
|
||
]),
|
||
"qualities": ("TURBOPACK compile-time value", [
|
||
("TURBOPACK compile-time value", 75)
|
||
]),
|
||
"path": ("TURBOPACK compile-time value", "/_next/image"),
|
||
"loader": ("TURBOPACK compile-time value", "default"),
|
||
"dangerouslyAllowSVG": ("TURBOPACK compile-time value", false),
|
||
"unoptimized": ("TURBOPACK compile-time value", true),
|
||
"domains": ("TURBOPACK compile-time value", []),
|
||
"remotePatterns": ("TURBOPACK compile-time value", []),
|
||
"localPatterns": ("TURBOPACK compile-time value", [
|
||
("TURBOPACK compile-time value", {
|
||
"pathname": ("TURBOPACK compile-time value", "**"),
|
||
"search": ("TURBOPACK compile-time value", "")
|
||
})
|
||
])
|
||
})
|
||
});
|
||
// Normally we don't care about undefined props because we pass to JSX,
|
||
// but this exported function could be used by the end user for anything
|
||
// so we delete undefined props to clean it up a little.
|
||
for (const [key, value] of Object.entries(props)){
|
||
if (value === undefined) {
|
||
delete props[key];
|
||
}
|
||
}
|
||
return {
|
||
props
|
||
};
|
||
}
|
||
const _default = _imagecomponent.Image; //# sourceMappingURL=image-external.js.map
|
||
}),
|
||
"[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/image.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
|
||
module.exports = __turbopack_context__.r("[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/shared/lib/image-external.js [app-client] (ecmascript)");
|
||
}),
|
||
"[project]/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/compiled/buffer/index.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
|
||
|
||
(function() {
|
||
var e = {
|
||
675: function(e, r) {
|
||
"use strict";
|
||
r.byteLength = byteLength;
|
||
r.toByteArray = toByteArray;
|
||
r.fromByteArray = fromByteArray;
|
||
var t = [];
|
||
var f = [];
|
||
var n = typeof Uint8Array !== "undefined" ? Uint8Array : Array;
|
||
var i = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
||
for(var o = 0, u = i.length; o < u; ++o){
|
||
t[o] = i[o];
|
||
f[i.charCodeAt(o)] = o;
|
||
}
|
||
f["-".charCodeAt(0)] = 62;
|
||
f["_".charCodeAt(0)] = 63;
|
||
function getLens(e) {
|
||
var r = e.length;
|
||
if (r % 4 > 0) {
|
||
throw new Error("Invalid string. Length must be a multiple of 4");
|
||
}
|
||
var t = e.indexOf("=");
|
||
if (t === -1) t = r;
|
||
var f = t === r ? 0 : 4 - t % 4;
|
||
return [
|
||
t,
|
||
f
|
||
];
|
||
}
|
||
function byteLength(e) {
|
||
var r = getLens(e);
|
||
var t = r[0];
|
||
var f = r[1];
|
||
return (t + f) * 3 / 4 - f;
|
||
}
|
||
function _byteLength(e, r, t) {
|
||
return (r + t) * 3 / 4 - t;
|
||
}
|
||
function toByteArray(e) {
|
||
var r;
|
||
var t = getLens(e);
|
||
var i = t[0];
|
||
var o = t[1];
|
||
var u = new n(_byteLength(e, i, o));
|
||
var a = 0;
|
||
var s = o > 0 ? i - 4 : i;
|
||
var h;
|
||
for(h = 0; h < s; h += 4){
|
||
r = f[e.charCodeAt(h)] << 18 | f[e.charCodeAt(h + 1)] << 12 | f[e.charCodeAt(h + 2)] << 6 | f[e.charCodeAt(h + 3)];
|
||
u[a++] = r >> 16 & 255;
|
||
u[a++] = r >> 8 & 255;
|
||
u[a++] = r & 255;
|
||
}
|
||
if (o === 2) {
|
||
r = f[e.charCodeAt(h)] << 2 | f[e.charCodeAt(h + 1)] >> 4;
|
||
u[a++] = r & 255;
|
||
}
|
||
if (o === 1) {
|
||
r = f[e.charCodeAt(h)] << 10 | f[e.charCodeAt(h + 1)] << 4 | f[e.charCodeAt(h + 2)] >> 2;
|
||
u[a++] = r >> 8 & 255;
|
||
u[a++] = r & 255;
|
||
}
|
||
return u;
|
||
}
|
||
function tripletToBase64(e) {
|
||
return t[e >> 18 & 63] + t[e >> 12 & 63] + t[e >> 6 & 63] + t[e & 63];
|
||
}
|
||
function encodeChunk(e, r, t) {
|
||
var f;
|
||
var n = [];
|
||
for(var i = r; i < t; i += 3){
|
||
f = (e[i] << 16 & 16711680) + (e[i + 1] << 8 & 65280) + (e[i + 2] & 255);
|
||
n.push(tripletToBase64(f));
|
||
}
|
||
return n.join("");
|
||
}
|
||
function fromByteArray(e) {
|
||
var r;
|
||
var f = e.length;
|
||
var n = f % 3;
|
||
var i = [];
|
||
var o = 16383;
|
||
for(var u = 0, a = f - n; u < a; u += o){
|
||
i.push(encodeChunk(e, u, u + o > a ? a : u + o));
|
||
}
|
||
if (n === 1) {
|
||
r = e[f - 1];
|
||
i.push(t[r >> 2] + t[r << 4 & 63] + "==");
|
||
} else if (n === 2) {
|
||
r = (e[f - 2] << 8) + e[f - 1];
|
||
i.push(t[r >> 10] + t[r >> 4 & 63] + t[r << 2 & 63] + "=");
|
||
}
|
||
return i.join("");
|
||
}
|
||
},
|
||
72: function(e, r, t) {
|
||
"use strict";
|
||
/*!
|
||
* The buffer module from node.js, for the browser.
|
||
*
|
||
* @author Feross Aboukhadijeh <https://feross.org>
|
||
* @license MIT
|
||
*/ var f = t(675);
|
||
var n = t(783);
|
||
var i = typeof Symbol === "function" && typeof Symbol.for === "function" ? Symbol.for("nodejs.util.inspect.custom") : null;
|
||
r.Buffer = Buffer;
|
||
r.SlowBuffer = SlowBuffer;
|
||
r.INSPECT_MAX_BYTES = 50;
|
||
var o = 2147483647;
|
||
r.kMaxLength = o;
|
||
Buffer.TYPED_ARRAY_SUPPORT = typedArraySupport();
|
||
if (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== "undefined" && typeof console.error === "function") {
|
||
console.error("This browser lacks typed array (Uint8Array) support which is required by " + "`buffer` v5.x. Use `buffer` v4.x if you require old browser support.");
|
||
}
|
||
function typedArraySupport() {
|
||
try {
|
||
var e = new Uint8Array(1);
|
||
var r = {
|
||
foo: function() {
|
||
return 42;
|
||
}
|
||
};
|
||
Object.setPrototypeOf(r, Uint8Array.prototype);
|
||
Object.setPrototypeOf(e, r);
|
||
return e.foo() === 42;
|
||
} catch (e) {
|
||
return false;
|
||
}
|
||
}
|
||
Object.defineProperty(Buffer.prototype, "parent", {
|
||
enumerable: true,
|
||
get: function() {
|
||
if (!Buffer.isBuffer(this)) return undefined;
|
||
return this.buffer;
|
||
}
|
||
});
|
||
Object.defineProperty(Buffer.prototype, "offset", {
|
||
enumerable: true,
|
||
get: function() {
|
||
if (!Buffer.isBuffer(this)) return undefined;
|
||
return this.byteOffset;
|
||
}
|
||
});
|
||
function createBuffer(e) {
|
||
if (e > o) {
|
||
throw new RangeError('The value "' + e + '" is invalid for option "size"');
|
||
}
|
||
var r = new Uint8Array(e);
|
||
Object.setPrototypeOf(r, Buffer.prototype);
|
||
return r;
|
||
}
|
||
function Buffer(e, r, t) {
|
||
if (typeof e === "number") {
|
||
if (typeof r === "string") {
|
||
throw new TypeError('The "string" argument must be of type string. Received type number');
|
||
}
|
||
return allocUnsafe(e);
|
||
}
|
||
return from(e, r, t);
|
||
}
|
||
Buffer.poolSize = 8192;
|
||
function from(e, r, t) {
|
||
if (typeof e === "string") {
|
||
return fromString(e, r);
|
||
}
|
||
if (ArrayBuffer.isView(e)) {
|
||
return fromArrayLike(e);
|
||
}
|
||
if (e == null) {
|
||
throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, " + "or Array-like Object. Received type " + typeof e);
|
||
}
|
||
if (isInstance(e, ArrayBuffer) || e && isInstance(e.buffer, ArrayBuffer)) {
|
||
return fromArrayBuffer(e, r, t);
|
||
}
|
||
if (typeof SharedArrayBuffer !== "undefined" && (isInstance(e, SharedArrayBuffer) || e && isInstance(e.buffer, SharedArrayBuffer))) {
|
||
return fromArrayBuffer(e, r, t);
|
||
}
|
||
if (typeof e === "number") {
|
||
throw new TypeError('The "value" argument must not be of type number. Received type number');
|
||
}
|
||
var f = e.valueOf && e.valueOf();
|
||
if (f != null && f !== e) {
|
||
return Buffer.from(f, r, t);
|
||
}
|
||
var n = fromObject(e);
|
||
if (n) return n;
|
||
if (typeof Symbol !== "undefined" && Symbol.toPrimitive != null && typeof e[Symbol.toPrimitive] === "function") {
|
||
return Buffer.from(e[Symbol.toPrimitive]("string"), r, t);
|
||
}
|
||
throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, " + "or Array-like Object. Received type " + typeof e);
|
||
}
|
||
Buffer.from = function(e, r, t) {
|
||
return from(e, r, t);
|
||
};
|
||
Object.setPrototypeOf(Buffer.prototype, Uint8Array.prototype);
|
||
Object.setPrototypeOf(Buffer, Uint8Array);
|
||
function assertSize(e) {
|
||
if (typeof e !== "number") {
|
||
throw new TypeError('"size" argument must be of type number');
|
||
} else if (e < 0) {
|
||
throw new RangeError('The value "' + e + '" is invalid for option "size"');
|
||
}
|
||
}
|
||
function alloc(e, r, t) {
|
||
assertSize(e);
|
||
if (e <= 0) {
|
||
return createBuffer(e);
|
||
}
|
||
if (r !== undefined) {
|
||
return typeof t === "string" ? createBuffer(e).fill(r, t) : createBuffer(e).fill(r);
|
||
}
|
||
return createBuffer(e);
|
||
}
|
||
Buffer.alloc = function(e, r, t) {
|
||
return alloc(e, r, t);
|
||
};
|
||
function allocUnsafe(e) {
|
||
assertSize(e);
|
||
return createBuffer(e < 0 ? 0 : checked(e) | 0);
|
||
}
|
||
Buffer.allocUnsafe = function(e) {
|
||
return allocUnsafe(e);
|
||
};
|
||
Buffer.allocUnsafeSlow = function(e) {
|
||
return allocUnsafe(e);
|
||
};
|
||
function fromString(e, r) {
|
||
if (typeof r !== "string" || r === "") {
|
||
r = "utf8";
|
||
}
|
||
if (!Buffer.isEncoding(r)) {
|
||
throw new TypeError("Unknown encoding: " + r);
|
||
}
|
||
var t = byteLength(e, r) | 0;
|
||
var f = createBuffer(t);
|
||
var n = f.write(e, r);
|
||
if (n !== t) {
|
||
f = f.slice(0, n);
|
||
}
|
||
return f;
|
||
}
|
||
function fromArrayLike(e) {
|
||
var r = e.length < 0 ? 0 : checked(e.length) | 0;
|
||
var t = createBuffer(r);
|
||
for(var f = 0; f < r; f += 1){
|
||
t[f] = e[f] & 255;
|
||
}
|
||
return t;
|
||
}
|
||
function fromArrayBuffer(e, r, t) {
|
||
if (r < 0 || e.byteLength < r) {
|
||
throw new RangeError('"offset" is outside of buffer bounds');
|
||
}
|
||
if (e.byteLength < r + (t || 0)) {
|
||
throw new RangeError('"length" is outside of buffer bounds');
|
||
}
|
||
var f;
|
||
if (r === undefined && t === undefined) {
|
||
f = new Uint8Array(e);
|
||
} else if (t === undefined) {
|
||
f = new Uint8Array(e, r);
|
||
} else {
|
||
f = new Uint8Array(e, r, t);
|
||
}
|
||
Object.setPrototypeOf(f, Buffer.prototype);
|
||
return f;
|
||
}
|
||
function fromObject(e) {
|
||
if (Buffer.isBuffer(e)) {
|
||
var r = checked(e.length) | 0;
|
||
var t = createBuffer(r);
|
||
if (t.length === 0) {
|
||
return t;
|
||
}
|
||
e.copy(t, 0, 0, r);
|
||
return t;
|
||
}
|
||
if (e.length !== undefined) {
|
||
if (typeof e.length !== "number" || numberIsNaN(e.length)) {
|
||
return createBuffer(0);
|
||
}
|
||
return fromArrayLike(e);
|
||
}
|
||
if (e.type === "Buffer" && Array.isArray(e.data)) {
|
||
return fromArrayLike(e.data);
|
||
}
|
||
}
|
||
function checked(e) {
|
||
if (e >= o) {
|
||
throw new RangeError("Attempt to allocate Buffer larger than maximum " + "size: 0x" + o.toString(16) + " bytes");
|
||
}
|
||
return e | 0;
|
||
}
|
||
function SlowBuffer(e) {
|
||
if (+e != e) {
|
||
e = 0;
|
||
}
|
||
return Buffer.alloc(+e);
|
||
}
|
||
Buffer.isBuffer = function isBuffer(e) {
|
||
return e != null && e._isBuffer === true && e !== Buffer.prototype;
|
||
};
|
||
Buffer.compare = function compare(e, r) {
|
||
if (isInstance(e, Uint8Array)) e = Buffer.from(e, e.offset, e.byteLength);
|
||
if (isInstance(r, Uint8Array)) r = Buffer.from(r, r.offset, r.byteLength);
|
||
if (!Buffer.isBuffer(e) || !Buffer.isBuffer(r)) {
|
||
throw new TypeError('The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array');
|
||
}
|
||
if (e === r) return 0;
|
||
var t = e.length;
|
||
var f = r.length;
|
||
for(var n = 0, i = Math.min(t, f); n < i; ++n){
|
||
if (e[n] !== r[n]) {
|
||
t = e[n];
|
||
f = r[n];
|
||
break;
|
||
}
|
||
}
|
||
if (t < f) return -1;
|
||
if (f < t) return 1;
|
||
return 0;
|
||
};
|
||
Buffer.isEncoding = function isEncoding(e) {
|
||
switch(String(e).toLowerCase()){
|
||
case "hex":
|
||
case "utf8":
|
||
case "utf-8":
|
||
case "ascii":
|
||
case "latin1":
|
||
case "binary":
|
||
case "base64":
|
||
case "ucs2":
|
||
case "ucs-2":
|
||
case "utf16le":
|
||
case "utf-16le":
|
||
return true;
|
||
default:
|
||
return false;
|
||
}
|
||
};
|
||
Buffer.concat = function concat(e, r) {
|
||
if (!Array.isArray(e)) {
|
||
throw new TypeError('"list" argument must be an Array of Buffers');
|
||
}
|
||
if (e.length === 0) {
|
||
return Buffer.alloc(0);
|
||
}
|
||
var t;
|
||
if (r === undefined) {
|
||
r = 0;
|
||
for(t = 0; t < e.length; ++t){
|
||
r += e[t].length;
|
||
}
|
||
}
|
||
var f = Buffer.allocUnsafe(r);
|
||
var n = 0;
|
||
for(t = 0; t < e.length; ++t){
|
||
var i = e[t];
|
||
if (isInstance(i, Uint8Array)) {
|
||
i = Buffer.from(i);
|
||
}
|
||
if (!Buffer.isBuffer(i)) {
|
||
throw new TypeError('"list" argument must be an Array of Buffers');
|
||
}
|
||
i.copy(f, n);
|
||
n += i.length;
|
||
}
|
||
return f;
|
||
};
|
||
function byteLength(e, r) {
|
||
if (Buffer.isBuffer(e)) {
|
||
return e.length;
|
||
}
|
||
if (ArrayBuffer.isView(e) || isInstance(e, ArrayBuffer)) {
|
||
return e.byteLength;
|
||
}
|
||
if (typeof e !== "string") {
|
||
throw new TypeError('The "string" argument must be one of type string, Buffer, or ArrayBuffer. ' + "Received type " + typeof e);
|
||
}
|
||
var t = e.length;
|
||
var f = arguments.length > 2 && arguments[2] === true;
|
||
if (!f && t === 0) return 0;
|
||
var n = false;
|
||
for(;;){
|
||
switch(r){
|
||
case "ascii":
|
||
case "latin1":
|
||
case "binary":
|
||
return t;
|
||
case "utf8":
|
||
case "utf-8":
|
||
return utf8ToBytes(e).length;
|
||
case "ucs2":
|
||
case "ucs-2":
|
||
case "utf16le":
|
||
case "utf-16le":
|
||
return t * 2;
|
||
case "hex":
|
||
return t >>> 1;
|
||
case "base64":
|
||
return base64ToBytes(e).length;
|
||
default:
|
||
if (n) {
|
||
return f ? -1 : utf8ToBytes(e).length;
|
||
}
|
||
r = ("" + r).toLowerCase();
|
||
n = true;
|
||
}
|
||
}
|
||
}
|
||
Buffer.byteLength = byteLength;
|
||
function slowToString(e, r, t) {
|
||
var f = false;
|
||
if (r === undefined || r < 0) {
|
||
r = 0;
|
||
}
|
||
if (r > this.length) {
|
||
return "";
|
||
}
|
||
if (t === undefined || t > this.length) {
|
||
t = this.length;
|
||
}
|
||
if (t <= 0) {
|
||
return "";
|
||
}
|
||
t >>>= 0;
|
||
r >>>= 0;
|
||
if (t <= r) {
|
||
return "";
|
||
}
|
||
if (!e) e = "utf8";
|
||
while(true){
|
||
switch(e){
|
||
case "hex":
|
||
return hexSlice(this, r, t);
|
||
case "utf8":
|
||
case "utf-8":
|
||
return utf8Slice(this, r, t);
|
||
case "ascii":
|
||
return asciiSlice(this, r, t);
|
||
case "latin1":
|
||
case "binary":
|
||
return latin1Slice(this, r, t);
|
||
case "base64":
|
||
return base64Slice(this, r, t);
|
||
case "ucs2":
|
||
case "ucs-2":
|
||
case "utf16le":
|
||
case "utf-16le":
|
||
return utf16leSlice(this, r, t);
|
||
default:
|
||
if (f) throw new TypeError("Unknown encoding: " + e);
|
||
e = (e + "").toLowerCase();
|
||
f = true;
|
||
}
|
||
}
|
||
}
|
||
Buffer.prototype._isBuffer = true;
|
||
function swap(e, r, t) {
|
||
var f = e[r];
|
||
e[r] = e[t];
|
||
e[t] = f;
|
||
}
|
||
Buffer.prototype.swap16 = function swap16() {
|
||
var e = this.length;
|
||
if (e % 2 !== 0) {
|
||
throw new RangeError("Buffer size must be a multiple of 16-bits");
|
||
}
|
||
for(var r = 0; r < e; r += 2){
|
||
swap(this, r, r + 1);
|
||
}
|
||
return this;
|
||
};
|
||
Buffer.prototype.swap32 = function swap32() {
|
||
var e = this.length;
|
||
if (e % 4 !== 0) {
|
||
throw new RangeError("Buffer size must be a multiple of 32-bits");
|
||
}
|
||
for(var r = 0; r < e; r += 4){
|
||
swap(this, r, r + 3);
|
||
swap(this, r + 1, r + 2);
|
||
}
|
||
return this;
|
||
};
|
||
Buffer.prototype.swap64 = function swap64() {
|
||
var e = this.length;
|
||
if (e % 8 !== 0) {
|
||
throw new RangeError("Buffer size must be a multiple of 64-bits");
|
||
}
|
||
for(var r = 0; r < e; r += 8){
|
||
swap(this, r, r + 7);
|
||
swap(this, r + 1, r + 6);
|
||
swap(this, r + 2, r + 5);
|
||
swap(this, r + 3, r + 4);
|
||
}
|
||
return this;
|
||
};
|
||
Buffer.prototype.toString = function toString() {
|
||
var e = this.length;
|
||
if (e === 0) return "";
|
||
if (arguments.length === 0) return utf8Slice(this, 0, e);
|
||
return slowToString.apply(this, arguments);
|
||
};
|
||
Buffer.prototype.toLocaleString = Buffer.prototype.toString;
|
||
Buffer.prototype.equals = function equals(e) {
|
||
if (!Buffer.isBuffer(e)) throw new TypeError("Argument must be a Buffer");
|
||
if (this === e) return true;
|
||
return Buffer.compare(this, e) === 0;
|
||
};
|
||
Buffer.prototype.inspect = function inspect() {
|
||
var e = "";
|
||
var t = r.INSPECT_MAX_BYTES;
|
||
e = this.toString("hex", 0, t).replace(/(.{2})/g, "$1 ").trim();
|
||
if (this.length > t) e += " ... ";
|
||
return "<Buffer " + e + ">";
|
||
};
|
||
if (i) {
|
||
Buffer.prototype[i] = Buffer.prototype.inspect;
|
||
}
|
||
Buffer.prototype.compare = function compare(e, r, t, f, n) {
|
||
if (isInstance(e, Uint8Array)) {
|
||
e = Buffer.from(e, e.offset, e.byteLength);
|
||
}
|
||
if (!Buffer.isBuffer(e)) {
|
||
throw new TypeError('The "target" argument must be one of type Buffer or Uint8Array. ' + "Received type " + typeof e);
|
||
}
|
||
if (r === undefined) {
|
||
r = 0;
|
||
}
|
||
if (t === undefined) {
|
||
t = e ? e.length : 0;
|
||
}
|
||
if (f === undefined) {
|
||
f = 0;
|
||
}
|
||
if (n === undefined) {
|
||
n = this.length;
|
||
}
|
||
if (r < 0 || t > e.length || f < 0 || n > this.length) {
|
||
throw new RangeError("out of range index");
|
||
}
|
||
if (f >= n && r >= t) {
|
||
return 0;
|
||
}
|
||
if (f >= n) {
|
||
return -1;
|
||
}
|
||
if (r >= t) {
|
||
return 1;
|
||
}
|
||
r >>>= 0;
|
||
t >>>= 0;
|
||
f >>>= 0;
|
||
n >>>= 0;
|
||
if (this === e) return 0;
|
||
var i = n - f;
|
||
var o = t - r;
|
||
var u = Math.min(i, o);
|
||
var a = this.slice(f, n);
|
||
var s = e.slice(r, t);
|
||
for(var h = 0; h < u; ++h){
|
||
if (a[h] !== s[h]) {
|
||
i = a[h];
|
||
o = s[h];
|
||
break;
|
||
}
|
||
}
|
||
if (i < o) return -1;
|
||
if (o < i) return 1;
|
||
return 0;
|
||
};
|
||
function bidirectionalIndexOf(e, r, t, f, n) {
|
||
if (e.length === 0) return -1;
|
||
if (typeof t === "string") {
|
||
f = t;
|
||
t = 0;
|
||
} else if (t > 2147483647) {
|
||
t = 2147483647;
|
||
} else if (t < -2147483648) {
|
||
t = -2147483648;
|
||
}
|
||
t = +t;
|
||
if (numberIsNaN(t)) {
|
||
t = n ? 0 : e.length - 1;
|
||
}
|
||
if (t < 0) t = e.length + t;
|
||
if (t >= e.length) {
|
||
if (n) return -1;
|
||
else t = e.length - 1;
|
||
} else if (t < 0) {
|
||
if (n) t = 0;
|
||
else return -1;
|
||
}
|
||
if (typeof r === "string") {
|
||
r = Buffer.from(r, f);
|
||
}
|
||
if (Buffer.isBuffer(r)) {
|
||
if (r.length === 0) {
|
||
return -1;
|
||
}
|
||
return arrayIndexOf(e, r, t, f, n);
|
||
} else if (typeof r === "number") {
|
||
r = r & 255;
|
||
if (typeof Uint8Array.prototype.indexOf === "function") {
|
||
if (n) {
|
||
return Uint8Array.prototype.indexOf.call(e, r, t);
|
||
} else {
|
||
return Uint8Array.prototype.lastIndexOf.call(e, r, t);
|
||
}
|
||
}
|
||
return arrayIndexOf(e, [
|
||
r
|
||
], t, f, n);
|
||
}
|
||
throw new TypeError("val must be string, number or Buffer");
|
||
}
|
||
function arrayIndexOf(e, r, t, f, n) {
|
||
var i = 1;
|
||
var o = e.length;
|
||
var u = r.length;
|
||
if (f !== undefined) {
|
||
f = String(f).toLowerCase();
|
||
if (f === "ucs2" || f === "ucs-2" || f === "utf16le" || f === "utf-16le") {
|
||
if (e.length < 2 || r.length < 2) {
|
||
return -1;
|
||
}
|
||
i = 2;
|
||
o /= 2;
|
||
u /= 2;
|
||
t /= 2;
|
||
}
|
||
}
|
||
function read(e, r) {
|
||
if (i === 1) {
|
||
return e[r];
|
||
} else {
|
||
return e.readUInt16BE(r * i);
|
||
}
|
||
}
|
||
var a;
|
||
if (n) {
|
||
var s = -1;
|
||
for(a = t; a < o; a++){
|
||
if (read(e, a) === read(r, s === -1 ? 0 : a - s)) {
|
||
if (s === -1) s = a;
|
||
if (a - s + 1 === u) return s * i;
|
||
} else {
|
||
if (s !== -1) a -= a - s;
|
||
s = -1;
|
||
}
|
||
}
|
||
} else {
|
||
if (t + u > o) t = o - u;
|
||
for(a = t; a >= 0; a--){
|
||
var h = true;
|
||
for(var c = 0; c < u; c++){
|
||
if (read(e, a + c) !== read(r, c)) {
|
||
h = false;
|
||
break;
|
||
}
|
||
}
|
||
if (h) return a;
|
||
}
|
||
}
|
||
return -1;
|
||
}
|
||
Buffer.prototype.includes = function includes(e, r, t) {
|
||
return this.indexOf(e, r, t) !== -1;
|
||
};
|
||
Buffer.prototype.indexOf = function indexOf(e, r, t) {
|
||
return bidirectionalIndexOf(this, e, r, t, true);
|
||
};
|
||
Buffer.prototype.lastIndexOf = function lastIndexOf(e, r, t) {
|
||
return bidirectionalIndexOf(this, e, r, t, false);
|
||
};
|
||
function hexWrite(e, r, t, f) {
|
||
t = Number(t) || 0;
|
||
var n = e.length - t;
|
||
if (!f) {
|
||
f = n;
|
||
} else {
|
||
f = Number(f);
|
||
if (f > n) {
|
||
f = n;
|
||
}
|
||
}
|
||
var i = r.length;
|
||
if (f > i / 2) {
|
||
f = i / 2;
|
||
}
|
||
for(var o = 0; o < f; ++o){
|
||
var u = parseInt(r.substr(o * 2, 2), 16);
|
||
if (numberIsNaN(u)) return o;
|
||
e[t + o] = u;
|
||
}
|
||
return o;
|
||
}
|
||
function utf8Write(e, r, t, f) {
|
||
return blitBuffer(utf8ToBytes(r, e.length - t), e, t, f);
|
||
}
|
||
function asciiWrite(e, r, t, f) {
|
||
return blitBuffer(asciiToBytes(r), e, t, f);
|
||
}
|
||
function latin1Write(e, r, t, f) {
|
||
return asciiWrite(e, r, t, f);
|
||
}
|
||
function base64Write(e, r, t, f) {
|
||
return blitBuffer(base64ToBytes(r), e, t, f);
|
||
}
|
||
function ucs2Write(e, r, t, f) {
|
||
return blitBuffer(utf16leToBytes(r, e.length - t), e, t, f);
|
||
}
|
||
Buffer.prototype.write = function write(e, r, t, f) {
|
||
if (r === undefined) {
|
||
f = "utf8";
|
||
t = this.length;
|
||
r = 0;
|
||
} else if (t === undefined && typeof r === "string") {
|
||
f = r;
|
||
t = this.length;
|
||
r = 0;
|
||
} else if (isFinite(r)) {
|
||
r = r >>> 0;
|
||
if (isFinite(t)) {
|
||
t = t >>> 0;
|
||
if (f === undefined) f = "utf8";
|
||
} else {
|
||
f = t;
|
||
t = undefined;
|
||
}
|
||
} else {
|
||
throw new Error("Buffer.write(string, encoding, offset[, length]) is no longer supported");
|
||
}
|
||
var n = this.length - r;
|
||
if (t === undefined || t > n) t = n;
|
||
if (e.length > 0 && (t < 0 || r < 0) || r > this.length) {
|
||
throw new RangeError("Attempt to write outside buffer bounds");
|
||
}
|
||
if (!f) f = "utf8";
|
||
var i = false;
|
||
for(;;){
|
||
switch(f){
|
||
case "hex":
|
||
return hexWrite(this, e, r, t);
|
||
case "utf8":
|
||
case "utf-8":
|
||
return utf8Write(this, e, r, t);
|
||
case "ascii":
|
||
return asciiWrite(this, e, r, t);
|
||
case "latin1":
|
||
case "binary":
|
||
return latin1Write(this, e, r, t);
|
||
case "base64":
|
||
return base64Write(this, e, r, t);
|
||
case "ucs2":
|
||
case "ucs-2":
|
||
case "utf16le":
|
||
case "utf-16le":
|
||
return ucs2Write(this, e, r, t);
|
||
default:
|
||
if (i) throw new TypeError("Unknown encoding: " + f);
|
||
f = ("" + f).toLowerCase();
|
||
i = true;
|
||
}
|
||
}
|
||
};
|
||
Buffer.prototype.toJSON = function toJSON() {
|
||
return {
|
||
type: "Buffer",
|
||
data: Array.prototype.slice.call(this._arr || this, 0)
|
||
};
|
||
};
|
||
function base64Slice(e, r, t) {
|
||
if (r === 0 && t === e.length) {
|
||
return f.fromByteArray(e);
|
||
} else {
|
||
return f.fromByteArray(e.slice(r, t));
|
||
}
|
||
}
|
||
function utf8Slice(e, r, t) {
|
||
t = Math.min(e.length, t);
|
||
var f = [];
|
||
var n = r;
|
||
while(n < t){
|
||
var i = e[n];
|
||
var o = null;
|
||
var u = i > 239 ? 4 : i > 223 ? 3 : i > 191 ? 2 : 1;
|
||
if (n + u <= t) {
|
||
var a, s, h, c;
|
||
switch(u){
|
||
case 1:
|
||
if (i < 128) {
|
||
o = i;
|
||
}
|
||
break;
|
||
case 2:
|
||
a = e[n + 1];
|
||
if ((a & 192) === 128) {
|
||
c = (i & 31) << 6 | a & 63;
|
||
if (c > 127) {
|
||
o = c;
|
||
}
|
||
}
|
||
break;
|
||
case 3:
|
||
a = e[n + 1];
|
||
s = e[n + 2];
|
||
if ((a & 192) === 128 && (s & 192) === 128) {
|
||
c = (i & 15) << 12 | (a & 63) << 6 | s & 63;
|
||
if (c > 2047 && (c < 55296 || c > 57343)) {
|
||
o = c;
|
||
}
|
||
}
|
||
break;
|
||
case 4:
|
||
a = e[n + 1];
|
||
s = e[n + 2];
|
||
h = e[n + 3];
|
||
if ((a & 192) === 128 && (s & 192) === 128 && (h & 192) === 128) {
|
||
c = (i & 15) << 18 | (a & 63) << 12 | (s & 63) << 6 | h & 63;
|
||
if (c > 65535 && c < 1114112) {
|
||
o = c;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if (o === null) {
|
||
o = 65533;
|
||
u = 1;
|
||
} else if (o > 65535) {
|
||
o -= 65536;
|
||
f.push(o >>> 10 & 1023 | 55296);
|
||
o = 56320 | o & 1023;
|
||
}
|
||
f.push(o);
|
||
n += u;
|
||
}
|
||
return decodeCodePointsArray(f);
|
||
}
|
||
var u = 4096;
|
||
function decodeCodePointsArray(e) {
|
||
var r = e.length;
|
||
if (r <= u) {
|
||
return String.fromCharCode.apply(String, e);
|
||
}
|
||
var t = "";
|
||
var f = 0;
|
||
while(f < r){
|
||
t += String.fromCharCode.apply(String, e.slice(f, f += u));
|
||
}
|
||
return t;
|
||
}
|
||
function asciiSlice(e, r, t) {
|
||
var f = "";
|
||
t = Math.min(e.length, t);
|
||
for(var n = r; n < t; ++n){
|
||
f += String.fromCharCode(e[n] & 127);
|
||
}
|
||
return f;
|
||
}
|
||
function latin1Slice(e, r, t) {
|
||
var f = "";
|
||
t = Math.min(e.length, t);
|
||
for(var n = r; n < t; ++n){
|
||
f += String.fromCharCode(e[n]);
|
||
}
|
||
return f;
|
||
}
|
||
function hexSlice(e, r, t) {
|
||
var f = e.length;
|
||
if (!r || r < 0) r = 0;
|
||
if (!t || t < 0 || t > f) t = f;
|
||
var n = "";
|
||
for(var i = r; i < t; ++i){
|
||
n += s[e[i]];
|
||
}
|
||
return n;
|
||
}
|
||
function utf16leSlice(e, r, t) {
|
||
var f = e.slice(r, t);
|
||
var n = "";
|
||
for(var i = 0; i < f.length; i += 2){
|
||
n += String.fromCharCode(f[i] + f[i + 1] * 256);
|
||
}
|
||
return n;
|
||
}
|
||
Buffer.prototype.slice = function slice(e, r) {
|
||
var t = this.length;
|
||
e = ~~e;
|
||
r = r === undefined ? t : ~~r;
|
||
if (e < 0) {
|
||
e += t;
|
||
if (e < 0) e = 0;
|
||
} else if (e > t) {
|
||
e = t;
|
||
}
|
||
if (r < 0) {
|
||
r += t;
|
||
if (r < 0) r = 0;
|
||
} else if (r > t) {
|
||
r = t;
|
||
}
|
||
if (r < e) r = e;
|
||
var f = this.subarray(e, r);
|
||
Object.setPrototypeOf(f, Buffer.prototype);
|
||
return f;
|
||
};
|
||
function checkOffset(e, r, t) {
|
||
if (e % 1 !== 0 || e < 0) throw new RangeError("offset is not uint");
|
||
if (e + r > t) throw new RangeError("Trying to access beyond buffer length");
|
||
}
|
||
Buffer.prototype.readUIntLE = function readUIntLE(e, r, t) {
|
||
e = e >>> 0;
|
||
r = r >>> 0;
|
||
if (!t) checkOffset(e, r, this.length);
|
||
var f = this[e];
|
||
var n = 1;
|
||
var i = 0;
|
||
while(++i < r && (n *= 256)){
|
||
f += this[e + i] * n;
|
||
}
|
||
return f;
|
||
};
|
||
Buffer.prototype.readUIntBE = function readUIntBE(e, r, t) {
|
||
e = e >>> 0;
|
||
r = r >>> 0;
|
||
if (!t) {
|
||
checkOffset(e, r, this.length);
|
||
}
|
||
var f = this[e + --r];
|
||
var n = 1;
|
||
while(r > 0 && (n *= 256)){
|
||
f += this[e + --r] * n;
|
||
}
|
||
return f;
|
||
};
|
||
Buffer.prototype.readUInt8 = function readUInt8(e, r) {
|
||
e = e >>> 0;
|
||
if (!r) checkOffset(e, 1, this.length);
|
||
return this[e];
|
||
};
|
||
Buffer.prototype.readUInt16LE = function readUInt16LE(e, r) {
|
||
e = e >>> 0;
|
||
if (!r) checkOffset(e, 2, this.length);
|
||
return this[e] | this[e + 1] << 8;
|
||
};
|
||
Buffer.prototype.readUInt16BE = function readUInt16BE(e, r) {
|
||
e = e >>> 0;
|
||
if (!r) checkOffset(e, 2, this.length);
|
||
return this[e] << 8 | this[e + 1];
|
||
};
|
||
Buffer.prototype.readUInt32LE = function readUInt32LE(e, r) {
|
||
e = e >>> 0;
|
||
if (!r) checkOffset(e, 4, this.length);
|
||
return (this[e] | this[e + 1] << 8 | this[e + 2] << 16) + this[e + 3] * 16777216;
|
||
};
|
||
Buffer.prototype.readUInt32BE = function readUInt32BE(e, r) {
|
||
e = e >>> 0;
|
||
if (!r) checkOffset(e, 4, this.length);
|
||
return this[e] * 16777216 + (this[e + 1] << 16 | this[e + 2] << 8 | this[e + 3]);
|
||
};
|
||
Buffer.prototype.readIntLE = function readIntLE(e, r, t) {
|
||
e = e >>> 0;
|
||
r = r >>> 0;
|
||
if (!t) checkOffset(e, r, this.length);
|
||
var f = this[e];
|
||
var n = 1;
|
||
var i = 0;
|
||
while(++i < r && (n *= 256)){
|
||
f += this[e + i] * n;
|
||
}
|
||
n *= 128;
|
||
if (f >= n) f -= Math.pow(2, 8 * r);
|
||
return f;
|
||
};
|
||
Buffer.prototype.readIntBE = function readIntBE(e, r, t) {
|
||
e = e >>> 0;
|
||
r = r >>> 0;
|
||
if (!t) checkOffset(e, r, this.length);
|
||
var f = r;
|
||
var n = 1;
|
||
var i = this[e + --f];
|
||
while(f > 0 && (n *= 256)){
|
||
i += this[e + --f] * n;
|
||
}
|
||
n *= 128;
|
||
if (i >= n) i -= Math.pow(2, 8 * r);
|
||
return i;
|
||
};
|
||
Buffer.prototype.readInt8 = function readInt8(e, r) {
|
||
e = e >>> 0;
|
||
if (!r) checkOffset(e, 1, this.length);
|
||
if (!(this[e] & 128)) return this[e];
|
||
return (255 - this[e] + 1) * -1;
|
||
};
|
||
Buffer.prototype.readInt16LE = function readInt16LE(e, r) {
|
||
e = e >>> 0;
|
||
if (!r) checkOffset(e, 2, this.length);
|
||
var t = this[e] | this[e + 1] << 8;
|
||
return t & 32768 ? t | 4294901760 : t;
|
||
};
|
||
Buffer.prototype.readInt16BE = function readInt16BE(e, r) {
|
||
e = e >>> 0;
|
||
if (!r) checkOffset(e, 2, this.length);
|
||
var t = this[e + 1] | this[e] << 8;
|
||
return t & 32768 ? t | 4294901760 : t;
|
||
};
|
||
Buffer.prototype.readInt32LE = function readInt32LE(e, r) {
|
||
e = e >>> 0;
|
||
if (!r) checkOffset(e, 4, this.length);
|
||
return this[e] | this[e + 1] << 8 | this[e + 2] << 16 | this[e + 3] << 24;
|
||
};
|
||
Buffer.prototype.readInt32BE = function readInt32BE(e, r) {
|
||
e = e >>> 0;
|
||
if (!r) checkOffset(e, 4, this.length);
|
||
return this[e] << 24 | this[e + 1] << 16 | this[e + 2] << 8 | this[e + 3];
|
||
};
|
||
Buffer.prototype.readFloatLE = function readFloatLE(e, r) {
|
||
e = e >>> 0;
|
||
if (!r) checkOffset(e, 4, this.length);
|
||
return n.read(this, e, true, 23, 4);
|
||
};
|
||
Buffer.prototype.readFloatBE = function readFloatBE(e, r) {
|
||
e = e >>> 0;
|
||
if (!r) checkOffset(e, 4, this.length);
|
||
return n.read(this, e, false, 23, 4);
|
||
};
|
||
Buffer.prototype.readDoubleLE = function readDoubleLE(e, r) {
|
||
e = e >>> 0;
|
||
if (!r) checkOffset(e, 8, this.length);
|
||
return n.read(this, e, true, 52, 8);
|
||
};
|
||
Buffer.prototype.readDoubleBE = function readDoubleBE(e, r) {
|
||
e = e >>> 0;
|
||
if (!r) checkOffset(e, 8, this.length);
|
||
return n.read(this, e, false, 52, 8);
|
||
};
|
||
function checkInt(e, r, t, f, n, i) {
|
||
if (!Buffer.isBuffer(e)) throw new TypeError('"buffer" argument must be a Buffer instance');
|
||
if (r > n || r < i) throw new RangeError('"value" argument is out of bounds');
|
||
if (t + f > e.length) throw new RangeError("Index out of range");
|
||
}
|
||
Buffer.prototype.writeUIntLE = function writeUIntLE(e, r, t, f) {
|
||
e = +e;
|
||
r = r >>> 0;
|
||
t = t >>> 0;
|
||
if (!f) {
|
||
var n = Math.pow(2, 8 * t) - 1;
|
||
checkInt(this, e, r, t, n, 0);
|
||
}
|
||
var i = 1;
|
||
var o = 0;
|
||
this[r] = e & 255;
|
||
while(++o < t && (i *= 256)){
|
||
this[r + o] = e / i & 255;
|
||
}
|
||
return r + t;
|
||
};
|
||
Buffer.prototype.writeUIntBE = function writeUIntBE(e, r, t, f) {
|
||
e = +e;
|
||
r = r >>> 0;
|
||
t = t >>> 0;
|
||
if (!f) {
|
||
var n = Math.pow(2, 8 * t) - 1;
|
||
checkInt(this, e, r, t, n, 0);
|
||
}
|
||
var i = t - 1;
|
||
var o = 1;
|
||
this[r + i] = e & 255;
|
||
while(--i >= 0 && (o *= 256)){
|
||
this[r + i] = e / o & 255;
|
||
}
|
||
return r + t;
|
||
};
|
||
Buffer.prototype.writeUInt8 = function writeUInt8(e, r, t) {
|
||
e = +e;
|
||
r = r >>> 0;
|
||
if (!t) checkInt(this, e, r, 1, 255, 0);
|
||
this[r] = e & 255;
|
||
return r + 1;
|
||
};
|
||
Buffer.prototype.writeUInt16LE = function writeUInt16LE(e, r, t) {
|
||
e = +e;
|
||
r = r >>> 0;
|
||
if (!t) checkInt(this, e, r, 2, 65535, 0);
|
||
this[r] = e & 255;
|
||
this[r + 1] = e >>> 8;
|
||
return r + 2;
|
||
};
|
||
Buffer.prototype.writeUInt16BE = function writeUInt16BE(e, r, t) {
|
||
e = +e;
|
||
r = r >>> 0;
|
||
if (!t) checkInt(this, e, r, 2, 65535, 0);
|
||
this[r] = e >>> 8;
|
||
this[r + 1] = e & 255;
|
||
return r + 2;
|
||
};
|
||
Buffer.prototype.writeUInt32LE = function writeUInt32LE(e, r, t) {
|
||
e = +e;
|
||
r = r >>> 0;
|
||
if (!t) checkInt(this, e, r, 4, 4294967295, 0);
|
||
this[r + 3] = e >>> 24;
|
||
this[r + 2] = e >>> 16;
|
||
this[r + 1] = e >>> 8;
|
||
this[r] = e & 255;
|
||
return r + 4;
|
||
};
|
||
Buffer.prototype.writeUInt32BE = function writeUInt32BE(e, r, t) {
|
||
e = +e;
|
||
r = r >>> 0;
|
||
if (!t) checkInt(this, e, r, 4, 4294967295, 0);
|
||
this[r] = e >>> 24;
|
||
this[r + 1] = e >>> 16;
|
||
this[r + 2] = e >>> 8;
|
||
this[r + 3] = e & 255;
|
||
return r + 4;
|
||
};
|
||
Buffer.prototype.writeIntLE = function writeIntLE(e, r, t, f) {
|
||
e = +e;
|
||
r = r >>> 0;
|
||
if (!f) {
|
||
var n = Math.pow(2, 8 * t - 1);
|
||
checkInt(this, e, r, t, n - 1, -n);
|
||
}
|
||
var i = 0;
|
||
var o = 1;
|
||
var u = 0;
|
||
this[r] = e & 255;
|
||
while(++i < t && (o *= 256)){
|
||
if (e < 0 && u === 0 && this[r + i - 1] !== 0) {
|
||
u = 1;
|
||
}
|
||
this[r + i] = (e / o >> 0) - u & 255;
|
||
}
|
||
return r + t;
|
||
};
|
||
Buffer.prototype.writeIntBE = function writeIntBE(e, r, t, f) {
|
||
e = +e;
|
||
r = r >>> 0;
|
||
if (!f) {
|
||
var n = Math.pow(2, 8 * t - 1);
|
||
checkInt(this, e, r, t, n - 1, -n);
|
||
}
|
||
var i = t - 1;
|
||
var o = 1;
|
||
var u = 0;
|
||
this[r + i] = e & 255;
|
||
while(--i >= 0 && (o *= 256)){
|
||
if (e < 0 && u === 0 && this[r + i + 1] !== 0) {
|
||
u = 1;
|
||
}
|
||
this[r + i] = (e / o >> 0) - u & 255;
|
||
}
|
||
return r + t;
|
||
};
|
||
Buffer.prototype.writeInt8 = function writeInt8(e, r, t) {
|
||
e = +e;
|
||
r = r >>> 0;
|
||
if (!t) checkInt(this, e, r, 1, 127, -128);
|
||
if (e < 0) e = 255 + e + 1;
|
||
this[r] = e & 255;
|
||
return r + 1;
|
||
};
|
||
Buffer.prototype.writeInt16LE = function writeInt16LE(e, r, t) {
|
||
e = +e;
|
||
r = r >>> 0;
|
||
if (!t) checkInt(this, e, r, 2, 32767, -32768);
|
||
this[r] = e & 255;
|
||
this[r + 1] = e >>> 8;
|
||
return r + 2;
|
||
};
|
||
Buffer.prototype.writeInt16BE = function writeInt16BE(e, r, t) {
|
||
e = +e;
|
||
r = r >>> 0;
|
||
if (!t) checkInt(this, e, r, 2, 32767, -32768);
|
||
this[r] = e >>> 8;
|
||
this[r + 1] = e & 255;
|
||
return r + 2;
|
||
};
|
||
Buffer.prototype.writeInt32LE = function writeInt32LE(e, r, t) {
|
||
e = +e;
|
||
r = r >>> 0;
|
||
if (!t) checkInt(this, e, r, 4, 2147483647, -2147483648);
|
||
this[r] = e & 255;
|
||
this[r + 1] = e >>> 8;
|
||
this[r + 2] = e >>> 16;
|
||
this[r + 3] = e >>> 24;
|
||
return r + 4;
|
||
};
|
||
Buffer.prototype.writeInt32BE = function writeInt32BE(e, r, t) {
|
||
e = +e;
|
||
r = r >>> 0;
|
||
if (!t) checkInt(this, e, r, 4, 2147483647, -2147483648);
|
||
if (e < 0) e = 4294967295 + e + 1;
|
||
this[r] = e >>> 24;
|
||
this[r + 1] = e >>> 16;
|
||
this[r + 2] = e >>> 8;
|
||
this[r + 3] = e & 255;
|
||
return r + 4;
|
||
};
|
||
function checkIEEE754(e, r, t, f, n, i) {
|
||
if (t + f > e.length) throw new RangeError("Index out of range");
|
||
if (t < 0) throw new RangeError("Index out of range");
|
||
}
|
||
function writeFloat(e, r, t, f, i) {
|
||
r = +r;
|
||
t = t >>> 0;
|
||
if (!i) {
|
||
checkIEEE754(e, r, t, 4, 34028234663852886e22, -34028234663852886e22);
|
||
}
|
||
n.write(e, r, t, f, 23, 4);
|
||
return t + 4;
|
||
}
|
||
Buffer.prototype.writeFloatLE = function writeFloatLE(e, r, t) {
|
||
return writeFloat(this, e, r, true, t);
|
||
};
|
||
Buffer.prototype.writeFloatBE = function writeFloatBE(e, r, t) {
|
||
return writeFloat(this, e, r, false, t);
|
||
};
|
||
function writeDouble(e, r, t, f, i) {
|
||
r = +r;
|
||
t = t >>> 0;
|
||
if (!i) {
|
||
checkIEEE754(e, r, t, 8, 17976931348623157e292, -17976931348623157e292);
|
||
}
|
||
n.write(e, r, t, f, 52, 8);
|
||
return t + 8;
|
||
}
|
||
Buffer.prototype.writeDoubleLE = function writeDoubleLE(e, r, t) {
|
||
return writeDouble(this, e, r, true, t);
|
||
};
|
||
Buffer.prototype.writeDoubleBE = function writeDoubleBE(e, r, t) {
|
||
return writeDouble(this, e, r, false, t);
|
||
};
|
||
Buffer.prototype.copy = function copy(e, r, t, f) {
|
||
if (!Buffer.isBuffer(e)) throw new TypeError("argument should be a Buffer");
|
||
if (!t) t = 0;
|
||
if (!f && f !== 0) f = this.length;
|
||
if (r >= e.length) r = e.length;
|
||
if (!r) r = 0;
|
||
if (f > 0 && f < t) f = t;
|
||
if (f === t) return 0;
|
||
if (e.length === 0 || this.length === 0) return 0;
|
||
if (r < 0) {
|
||
throw new RangeError("targetStart out of bounds");
|
||
}
|
||
if (t < 0 || t >= this.length) throw new RangeError("Index out of range");
|
||
if (f < 0) throw new RangeError("sourceEnd out of bounds");
|
||
if (f > this.length) f = this.length;
|
||
if (e.length - r < f - t) {
|
||
f = e.length - r + t;
|
||
}
|
||
var n = f - t;
|
||
if (this === e && typeof Uint8Array.prototype.copyWithin === "function") {
|
||
this.copyWithin(r, t, f);
|
||
} else if (this === e && t < r && r < f) {
|
||
for(var i = n - 1; i >= 0; --i){
|
||
e[i + r] = this[i + t];
|
||
}
|
||
} else {
|
||
Uint8Array.prototype.set.call(e, this.subarray(t, f), r);
|
||
}
|
||
return n;
|
||
};
|
||
Buffer.prototype.fill = function fill(e, r, t, f) {
|
||
if (typeof e === "string") {
|
||
if (typeof r === "string") {
|
||
f = r;
|
||
r = 0;
|
||
t = this.length;
|
||
} else if (typeof t === "string") {
|
||
f = t;
|
||
t = this.length;
|
||
}
|
||
if (f !== undefined && typeof f !== "string") {
|
||
throw new TypeError("encoding must be a string");
|
||
}
|
||
if (typeof f === "string" && !Buffer.isEncoding(f)) {
|
||
throw new TypeError("Unknown encoding: " + f);
|
||
}
|
||
if (e.length === 1) {
|
||
var n = e.charCodeAt(0);
|
||
if (f === "utf8" && n < 128 || f === "latin1") {
|
||
e = n;
|
||
}
|
||
}
|
||
} else if (typeof e === "number") {
|
||
e = e & 255;
|
||
} else if (typeof e === "boolean") {
|
||
e = Number(e);
|
||
}
|
||
if (r < 0 || this.length < r || this.length < t) {
|
||
throw new RangeError("Out of range index");
|
||
}
|
||
if (t <= r) {
|
||
return this;
|
||
}
|
||
r = r >>> 0;
|
||
t = t === undefined ? this.length : t >>> 0;
|
||
if (!e) e = 0;
|
||
var i;
|
||
if (typeof e === "number") {
|
||
for(i = r; i < t; ++i){
|
||
this[i] = e;
|
||
}
|
||
} else {
|
||
var o = Buffer.isBuffer(e) ? e : Buffer.from(e, f);
|
||
var u = o.length;
|
||
if (u === 0) {
|
||
throw new TypeError('The value "' + e + '" is invalid for argument "value"');
|
||
}
|
||
for(i = 0; i < t - r; ++i){
|
||
this[i + r] = o[i % u];
|
||
}
|
||
}
|
||
return this;
|
||
};
|
||
var a = /[^+/0-9A-Za-z-_]/g;
|
||
function base64clean(e) {
|
||
e = e.split("=")[0];
|
||
e = e.trim().replace(a, "");
|
||
if (e.length < 2) return "";
|
||
while(e.length % 4 !== 0){
|
||
e = e + "=";
|
||
}
|
||
return e;
|
||
}
|
||
function utf8ToBytes(e, r) {
|
||
r = r || Infinity;
|
||
var t;
|
||
var f = e.length;
|
||
var n = null;
|
||
var i = [];
|
||
for(var o = 0; o < f; ++o){
|
||
t = e.charCodeAt(o);
|
||
if (t > 55295 && t < 57344) {
|
||
if (!n) {
|
||
if (t > 56319) {
|
||
if ((r -= 3) > -1) i.push(239, 191, 189);
|
||
continue;
|
||
} else if (o + 1 === f) {
|
||
if ((r -= 3) > -1) i.push(239, 191, 189);
|
||
continue;
|
||
}
|
||
n = t;
|
||
continue;
|
||
}
|
||
if (t < 56320) {
|
||
if ((r -= 3) > -1) i.push(239, 191, 189);
|
||
n = t;
|
||
continue;
|
||
}
|
||
t = (n - 55296 << 10 | t - 56320) + 65536;
|
||
} else if (n) {
|
||
if ((r -= 3) > -1) i.push(239, 191, 189);
|
||
}
|
||
n = null;
|
||
if (t < 128) {
|
||
if ((r -= 1) < 0) break;
|
||
i.push(t);
|
||
} else if (t < 2048) {
|
||
if ((r -= 2) < 0) break;
|
||
i.push(t >> 6 | 192, t & 63 | 128);
|
||
} else if (t < 65536) {
|
||
if ((r -= 3) < 0) break;
|
||
i.push(t >> 12 | 224, t >> 6 & 63 | 128, t & 63 | 128);
|
||
} else if (t < 1114112) {
|
||
if ((r -= 4) < 0) break;
|
||
i.push(t >> 18 | 240, t >> 12 & 63 | 128, t >> 6 & 63 | 128, t & 63 | 128);
|
||
} else {
|
||
throw new Error("Invalid code point");
|
||
}
|
||
}
|
||
return i;
|
||
}
|
||
function asciiToBytes(e) {
|
||
var r = [];
|
||
for(var t = 0; t < e.length; ++t){
|
||
r.push(e.charCodeAt(t) & 255);
|
||
}
|
||
return r;
|
||
}
|
||
function utf16leToBytes(e, r) {
|
||
var t, f, n;
|
||
var i = [];
|
||
for(var o = 0; o < e.length; ++o){
|
||
if ((r -= 2) < 0) break;
|
||
t = e.charCodeAt(o);
|
||
f = t >> 8;
|
||
n = t % 256;
|
||
i.push(n);
|
||
i.push(f);
|
||
}
|
||
return i;
|
||
}
|
||
function base64ToBytes(e) {
|
||
return f.toByteArray(base64clean(e));
|
||
}
|
||
function blitBuffer(e, r, t, f) {
|
||
for(var n = 0; n < f; ++n){
|
||
if (n + t >= r.length || n >= e.length) break;
|
||
r[n + t] = e[n];
|
||
}
|
||
return n;
|
||
}
|
||
function isInstance(e, r) {
|
||
return e instanceof r || e != null && e.constructor != null && e.constructor.name != null && e.constructor.name === r.name;
|
||
}
|
||
function numberIsNaN(e) {
|
||
return e !== e;
|
||
}
|
||
var s = function() {
|
||
var e = "0123456789abcdef";
|
||
var r = new Array(256);
|
||
for(var t = 0; t < 16; ++t){
|
||
var f = t * 16;
|
||
for(var n = 0; n < 16; ++n){
|
||
r[f + n] = e[t] + e[n];
|
||
}
|
||
}
|
||
return r;
|
||
}();
|
||
},
|
||
783: function(e, r) {
|
||
/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */ r.read = function(e, r, t, f, n) {
|
||
var i, o;
|
||
var u = n * 8 - f - 1;
|
||
var a = (1 << u) - 1;
|
||
var s = a >> 1;
|
||
var h = -7;
|
||
var c = t ? n - 1 : 0;
|
||
var l = t ? -1 : 1;
|
||
var p = e[r + c];
|
||
c += l;
|
||
i = p & (1 << -h) - 1;
|
||
p >>= -h;
|
||
h += u;
|
||
for(; h > 0; i = i * 256 + e[r + c], c += l, h -= 8){}
|
||
o = i & (1 << -h) - 1;
|
||
i >>= -h;
|
||
h += f;
|
||
for(; h > 0; o = o * 256 + e[r + c], c += l, h -= 8){}
|
||
if (i === 0) {
|
||
i = 1 - s;
|
||
} else if (i === a) {
|
||
return o ? NaN : (p ? -1 : 1) * Infinity;
|
||
} else {
|
||
o = o + Math.pow(2, f);
|
||
i = i - s;
|
||
}
|
||
return (p ? -1 : 1) * o * Math.pow(2, i - f);
|
||
};
|
||
r.write = function(e, r, t, f, n, i) {
|
||
var o, u, a;
|
||
var s = i * 8 - n - 1;
|
||
var h = (1 << s) - 1;
|
||
var c = h >> 1;
|
||
var l = n === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;
|
||
var p = f ? 0 : i - 1;
|
||
var y = f ? 1 : -1;
|
||
var g = r < 0 || r === 0 && 1 / r < 0 ? 1 : 0;
|
||
r = Math.abs(r);
|
||
if (isNaN(r) || r === Infinity) {
|
||
u = isNaN(r) ? 1 : 0;
|
||
o = h;
|
||
} else {
|
||
o = Math.floor(Math.log(r) / Math.LN2);
|
||
if (r * (a = Math.pow(2, -o)) < 1) {
|
||
o--;
|
||
a *= 2;
|
||
}
|
||
if (o + c >= 1) {
|
||
r += l / a;
|
||
} else {
|
||
r += l * Math.pow(2, 1 - c);
|
||
}
|
||
if (r * a >= 2) {
|
||
o++;
|
||
a /= 2;
|
||
}
|
||
if (o + c >= h) {
|
||
u = 0;
|
||
o = h;
|
||
} else if (o + c >= 1) {
|
||
u = (r * a - 1) * Math.pow(2, n);
|
||
o = o + c;
|
||
} else {
|
||
u = r * Math.pow(2, c - 1) * Math.pow(2, n);
|
||
o = 0;
|
||
}
|
||
}
|
||
for(; n >= 8; e[t + p] = u & 255, p += y, u /= 256, n -= 8){}
|
||
o = o << n | u;
|
||
s += n;
|
||
for(; s > 0; e[t + p] = o & 255, p += y, o /= 256, s -= 8){}
|
||
e[t + p - y] |= g * 128;
|
||
};
|
||
}
|
||
};
|
||
var r = {};
|
||
function __nccwpck_require__(t) {
|
||
var f = r[t];
|
||
if (f !== undefined) {
|
||
return f.exports;
|
||
}
|
||
var n = r[t] = {
|
||
exports: {}
|
||
};
|
||
var i = true;
|
||
try {
|
||
e[t](n, n.exports, __nccwpck_require__);
|
||
i = false;
|
||
} finally{
|
||
if (i) delete r[t];
|
||
}
|
||
return n.exports;
|
||
}
|
||
if (typeof __nccwpck_require__ !== "undefined") __nccwpck_require__.ab = ("TURBOPACK compile-time value", "/ROOT/Documents/go-new/chinese-family-tree/node_modules/.pnpm/next@16.0.3_react-dom@19.2.0_react@19.2.0__react@19.2.0/node_modules/next/dist/compiled/buffer") + "/";
|
||
var t = __nccwpck_require__(72);
|
||
module.exports = t;
|
||
})();
|
||
}),
|
||
]);
|
||
|
||
//# sourceMappingURL=4e98a_next_a824e303._.js.map
|