@kky42/pievo-server 1.0.0

package/.output/server/_libs/pinojs__redact.mjs

@@ -0,0 +1,280 @@
+import { t as __commonJSMin } from "../_runtime.mjs";
+//#region ../../node_modules/.pnpm/@pinojs+redact@0.4.0/node_modules/@pinojs/redact/index.js
+var require_redact = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function deepClone(obj) {
+		if (obj === null || typeof obj !== "object") return obj;
+		if (obj instanceof Date) return new Date(obj.getTime());
+		if (obj instanceof Array) {
+			const cloned = [];
+			for (let i = 0; i < obj.length; i++) cloned[i] = deepClone(obj[i]);
+			return cloned;
+		}
+		if (typeof obj === "object") {
+			const cloned = Object.create(Object.getPrototypeOf(obj));
+			for (const key in obj) if (Object.prototype.hasOwnProperty.call(obj, key)) cloned[key] = deepClone(obj[key]);
+			return cloned;
+		}
+		return obj;
+	}
+	function parsePath(path) {
+		const parts = [];
+		let current = "";
+		let inBrackets = false;
+		let inQuotes = false;
+		let quoteChar = "";
+		for (let i = 0; i < path.length; i++) {
+			const char = path[i];
+			if (!inBrackets && char === ".") {
+				if (current) {
+					parts.push(current);
+					current = "";
+				}
+			} else if (char === "[") {
+				if (current) {
+					parts.push(current);
+					current = "";
+				}
+				inBrackets = true;
+			} else if (char === "]" && inBrackets) {
+				parts.push(current);
+				current = "";
+				inBrackets = false;
+				inQuotes = false;
+			} else if ((char === "\"" || char === "'") && inBrackets) if (!inQuotes) {
+				inQuotes = true;
+				quoteChar = char;
+			} else if (char === quoteChar) {
+				inQuotes = false;
+				quoteChar = "";
+			} else current += char;
+			else current += char;
+		}
+		if (current) parts.push(current);
+		return parts;
+	}
+	function setValue(obj, parts, value) {
+		let current = obj;
+		for (let i = 0; i < parts.length - 1; i++) {
+			const key = parts[i];
+			if (typeof current !== "object" || current === null || !(key in current)) return false;
+			if (typeof current[key] !== "object" || current[key] === null) return false;
+			current = current[key];
+		}
+		const lastKey = parts[parts.length - 1];
+		if (lastKey === "*") {
+			if (Array.isArray(current)) for (let i = 0; i < current.length; i++) current[i] = value;
+			else if (typeof current === "object" && current !== null) {
+				for (const key in current) if (Object.prototype.hasOwnProperty.call(current, key)) current[key] = value;
+			}
+		} else if (typeof current === "object" && current !== null && lastKey in current && Object.prototype.hasOwnProperty.call(current, lastKey)) current[lastKey] = value;
+		return true;
+	}
+	function removeKey(obj, parts) {
+		let current = obj;
+		for (let i = 0; i < parts.length - 1; i++) {
+			const key = parts[i];
+			if (typeof current !== "object" || current === null || !(key in current)) return false;
+			if (typeof current[key] !== "object" || current[key] === null) return false;
+			current = current[key];
+		}
+		const lastKey = parts[parts.length - 1];
+		if (lastKey === "*") {
+			if (Array.isArray(current)) for (let i = 0; i < current.length; i++) current[i] = void 0;
+			else if (typeof current === "object" && current !== null) {
+				for (const key in current) if (Object.prototype.hasOwnProperty.call(current, key)) delete current[key];
+			}
+		} else if (typeof current === "object" && current !== null && lastKey in current && Object.prototype.hasOwnProperty.call(current, lastKey)) delete current[lastKey];
+		return true;
+	}
+	var PATH_NOT_FOUND = Symbol("PATH_NOT_FOUND");
+	function getValueIfExists(obj, parts) {
+		let current = obj;
+		for (const part of parts) {
+			if (current === null || current === void 0) return PATH_NOT_FOUND;
+			if (typeof current !== "object" || current === null) return PATH_NOT_FOUND;
+			if (!(part in current)) return PATH_NOT_FOUND;
+			current = current[part];
+		}
+		return current;
+	}
+	function getValue(obj, parts) {
+		let current = obj;
+		for (const part of parts) {
+			if (current === null || current === void 0) return;
+			if (typeof current !== "object" || current === null) return;
+			current = current[part];
+		}
+		return current;
+	}
+	function redactPaths(obj, paths, censor, remove = false) {
+		for (const path of paths) {
+			const parts = parsePath(path);
+			if (parts.includes("*")) redactWildcardPath(obj, parts, censor, path, remove);
+			else if (remove) removeKey(obj, parts);
+			else {
+				const value = getValueIfExists(obj, parts);
+				if (value === PATH_NOT_FOUND) continue;
+				setValue(obj, parts, typeof censor === "function" ? censor(value, parts) : censor);
+			}
+		}
+	}
+	function redactWildcardPath(obj, parts, censor, originalPath, remove = false) {
+		const wildcardIndex = parts.indexOf("*");
+		if (wildcardIndex === parts.length - 1) {
+			const parentParts = parts.slice(0, -1);
+			let current = obj;
+			for (const part of parentParts) {
+				if (current === null || current === void 0) return;
+				if (typeof current !== "object" || current === null) return;
+				current = current[part];
+			}
+			if (Array.isArray(current)) if (remove) for (let i = 0; i < current.length; i++) current[i] = void 0;
+			else for (let i = 0; i < current.length; i++) {
+				const indexPath = [...parentParts, i.toString()];
+				const actualCensor = typeof censor === "function" ? censor(current[i], indexPath) : censor;
+				current[i] = actualCensor;
+			}
+			else if (typeof current === "object" && current !== null) if (remove) {
+				const keysToDelete = [];
+				for (const key in current) if (Object.prototype.hasOwnProperty.call(current, key)) keysToDelete.push(key);
+				for (const key of keysToDelete) delete current[key];
+			} else for (const key in current) {
+				const keyPath = [...parentParts, key];
+				const actualCensor = typeof censor === "function" ? censor(current[key], keyPath) : censor;
+				current[key] = actualCensor;
+			}
+		} else redactIntermediateWildcard(obj, parts, censor, wildcardIndex, originalPath, remove);
+	}
+	function redactIntermediateWildcard(obj, parts, censor, wildcardIndex, originalPath, remove = false) {
+		const beforeWildcard = parts.slice(0, wildcardIndex);
+		const afterWildcard = parts.slice(wildcardIndex + 1);
+		const pathArray = [];
+		function traverse(current, pathLength) {
+			if (pathLength === beforeWildcard.length) {
+				if (Array.isArray(current)) for (let i = 0; i < current.length; i++) {
+					pathArray[pathLength] = i.toString();
+					traverse(current[i], pathLength + 1);
+				}
+				else if (typeof current === "object" && current !== null) for (const key in current) {
+					pathArray[pathLength] = key;
+					traverse(current[key], pathLength + 1);
+				}
+			} else if (pathLength < beforeWildcard.length) {
+				const nextKey = beforeWildcard[pathLength];
+				if (current && typeof current === "object" && current !== null && nextKey in current) {
+					pathArray[pathLength] = nextKey;
+					traverse(current[nextKey], pathLength + 1);
+				}
+			} else if (afterWildcard.includes("*")) redactWildcardPath(current, afterWildcard, typeof censor === "function" ? (value, path) => {
+				return censor(value, [...pathArray.slice(0, pathLength), ...path]);
+			} : censor, originalPath, remove);
+			else if (remove) removeKey(current, afterWildcard);
+			else setValue(current, afterWildcard, typeof censor === "function" ? censor(getValue(current, afterWildcard), [...pathArray.slice(0, pathLength), ...afterWildcard]) : censor);
+		}
+		if (beforeWildcard.length === 0) traverse(obj, 0);
+		else {
+			let current = obj;
+			for (let i = 0; i < beforeWildcard.length; i++) {
+				const part = beforeWildcard[i];
+				if (current === null || current === void 0) return;
+				if (typeof current !== "object" || current === null) return;
+				current = current[part];
+				pathArray[i] = part;
+			}
+			if (current !== null && current !== void 0) traverse(current, beforeWildcard.length);
+		}
+	}
+	function buildPathStructure(pathsToClone) {
+		if (pathsToClone.length === 0) return null;
+		const pathStructure = /* @__PURE__ */ new Map();
+		for (const path of pathsToClone) {
+			const parts = parsePath(path);
+			let current = pathStructure;
+			for (let i = 0; i < parts.length; i++) {
+				const part = parts[i];
+				if (!current.has(part)) current.set(part, /* @__PURE__ */ new Map());
+				current = current.get(part);
+			}
+		}
+		return pathStructure;
+	}
+	function selectiveClone(obj, pathStructure) {
+		if (!pathStructure) return obj;
+		function cloneSelectively(source, pathMap, depth = 0) {
+			if (!pathMap || pathMap.size === 0) return source;
+			if (source === null || typeof source !== "object") return source;
+			if (source instanceof Date) return new Date(source.getTime());
+			if (Array.isArray(source)) {
+				const cloned = [];
+				for (let i = 0; i < source.length; i++) {
+					const indexStr = i.toString();
+					if (pathMap.has(indexStr) || pathMap.has("*")) cloned[i] = cloneSelectively(source[i], pathMap.get(indexStr) || pathMap.get("*"));
+					else cloned[i] = source[i];
+				}
+				return cloned;
+			}
+			const cloned = Object.create(Object.getPrototypeOf(source));
+			for (const key in source) if (Object.prototype.hasOwnProperty.call(source, key)) if (pathMap.has(key) || pathMap.has("*")) cloned[key] = cloneSelectively(source[key], pathMap.get(key) || pathMap.get("*"));
+			else cloned[key] = source[key];
+			return cloned;
+		}
+		return cloneSelectively(obj, pathStructure);
+	}
+	function validatePath(path) {
+		if (typeof path !== "string") throw new Error("Paths must be (non-empty) strings");
+		if (path === "") throw new Error("Invalid redaction path ()");
+		if (path.includes("..")) throw new Error(`Invalid redaction path (${path})`);
+		if (path.includes(",")) throw new Error(`Invalid redaction path (${path})`);
+		let bracketCount = 0;
+		let inQuotes = false;
+		let quoteChar = "";
+		for (let i = 0; i < path.length; i++) {
+			const char = path[i];
+			if ((char === "\"" || char === "'") && bracketCount > 0) {
+				if (!inQuotes) {
+					inQuotes = true;
+					quoteChar = char;
+				} else if (char === quoteChar) {
+					inQuotes = false;
+					quoteChar = "";
+				}
+			} else if (char === "[" && !inQuotes) bracketCount++;
+			else if (char === "]" && !inQuotes) {
+				bracketCount--;
+				if (bracketCount < 0) throw new Error(`Invalid redaction path (${path})`);
+			}
+		}
+		if (bracketCount !== 0) throw new Error(`Invalid redaction path (${path})`);
+	}
+	function validatePaths(paths) {
+		if (!Array.isArray(paths)) throw new TypeError("paths must be an array");
+		for (const path of paths) validatePath(path);
+	}
+	function slowRedact(options = {}) {
+		const { paths = [], censor = "[REDACTED]", serialize = JSON.stringify, strict = true, remove = false } = options;
+		validatePaths(paths);
+		const pathStructure = buildPathStructure(paths);
+		return function redact(obj) {
+			if (strict && (obj === null || typeof obj !== "object")) {
+				if (obj === null || obj === void 0) return serialize ? serialize(obj) : obj;
+				if (typeof obj !== "object") return serialize ? serialize(obj) : obj;
+			}
+			const cloned = selectiveClone(obj, pathStructure);
+			const original = obj;
+			let actualCensor = censor;
+			if (typeof censor === "function") actualCensor = censor;
+			redactPaths(cloned, paths, actualCensor, remove);
+			if (serialize === false) {
+				cloned.restore = function() {
+					return deepClone(original);
+				};
+				return cloned;
+			}
+			if (typeof serialize === "function") return serialize(cloned);
+			return JSON.stringify(cloned);
+		};
+	}
+	module.exports = slowRedact;
+}));
+//#endregion
+export { require_redact as t };

package/.output/server/_libs/react-redux+[...].mjs

@@ -0,0 +1,205 @@
+import { o as __toESM, t as __commonJSMin } from "../_runtime.mjs";
+import { S as require_react } from "./@base-ui/react+[...].mjs";
+//#region ../../node_modules/.pnpm/use-sync-external-store@1.6.0_react@19.2.7/node_modules/use-sync-external-store/cjs/use-sync-external-store-with-selector.production.js
+/**
+* @license React
+* use-sync-external-store-with-selector.production.js
+*
+* Copyright (c) Meta Platforms, Inc. and affiliates.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+var require_use_sync_external_store_with_selector_production = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var React = require_react();
+	React.useSyncExternalStore;
+	React.useRef;
+	React.useEffect;
+	React.useMemo;
+	React.useDebugValue;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/use-sync-external-store@1.6.0_react@19.2.7/node_modules/use-sync-external-store/with-selector.js
+var require_with_selector = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = require_use_sync_external_store_with_selector_production();
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/react-redux@9.3.0_@types+react@19.2.17_react@19.2.7_redux@5.0.1/node_modules/react-redux/dist/react-redux.mjs
+var import_react = /* @__PURE__ */ __toESM(require_react(), 1);
+require_with_selector();
+function defaultNoopBatch(callback) {
+	callback();
+}
+function createListenerCollection() {
+	let first = null;
+	let last = null;
+	return {
+		clear() {
+			first = null;
+			last = null;
+		},
+		notify() {
+			defaultNoopBatch(() => {
+				let listener = first;
+				while (listener) {
+					listener.callback();
+					listener = listener.next;
+				}
+			});
+		},
+		get() {
+			const listeners = [];
+			let listener = first;
+			while (listener) {
+				listeners.push(listener);
+				listener = listener.next;
+			}
+			return listeners;
+		},
+		subscribe(callback) {
+			let isSubscribed = true;
+			const listener = last = {
+				callback,
+				next: null,
+				prev: last
+			};
+			if (listener.prev) listener.prev.next = listener;
+			else first = listener;
+			return function unsubscribe() {
+				if (!isSubscribed || first === null) return;
+				isSubscribed = false;
+				if (listener.next) listener.next.prev = listener.prev;
+				else last = listener.prev;
+				if (listener.prev) listener.prev.next = listener.next;
+				else first = listener.next;
+			};
+		}
+	};
+}
+var nullListeners = {
+	notify() {},
+	get: () => []
+};
+function createSubscription(store, parentSub) {
+	let unsubscribe;
+	let listeners = nullListeners;
+	let subscriptionsAmount = 0;
+	let selfSubscribed = false;
+	function addNestedSub(listener) {
+		trySubscribe();
+		const cleanupListener = listeners.subscribe(listener);
+		let removed = false;
+		return () => {
+			if (!removed) {
+				removed = true;
+				cleanupListener();
+				tryUnsubscribe();
+			}
+		};
+	}
+	function notifyNestedSubs() {
+		listeners.notify();
+	}
+	function handleChangeWrapper() {
+		if (subscription.onStateChange) subscription.onStateChange();
+	}
+	function isSubscribed() {
+		return selfSubscribed;
+	}
+	function trySubscribe() {
+		subscriptionsAmount++;
+		if (!unsubscribe) {
+			unsubscribe = parentSub ? parentSub.addNestedSub(handleChangeWrapper) : store.subscribe(handleChangeWrapper);
+			listeners = createListenerCollection();
+		}
+	}
+	function tryUnsubscribe() {
+		subscriptionsAmount--;
+		if (unsubscribe && subscriptionsAmount === 0) {
+			unsubscribe();
+			unsubscribe = void 0;
+			listeners.clear();
+			listeners = nullListeners;
+		}
+	}
+	function trySubscribeSelf() {
+		if (!selfSubscribed) {
+			selfSubscribed = true;
+			trySubscribe();
+		}
+	}
+	function tryUnsubscribeSelf() {
+		if (selfSubscribed) {
+			selfSubscribed = false;
+			tryUnsubscribe();
+		}
+	}
+	const subscription = {
+		addNestedSub,
+		notifyNestedSubs,
+		handleChangeWrapper,
+		isSubscribed,
+		trySubscribe: trySubscribeSelf,
+		tryUnsubscribe: tryUnsubscribeSelf,
+		getListeners: () => listeners
+	};
+	return subscription;
+}
+var canUseDOM = () => !!(typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined");
+var isDOM = /* @__PURE__ */ canUseDOM();
+var isRunningInReactNative = () => typeof navigator !== "undefined" && navigator.product === "ReactNative";
+var isReactNative = /* @__PURE__ */ isRunningInReactNative();
+var getUseIsomorphicLayoutEffect = () => isDOM || isReactNative ? import_react.useLayoutEffect : import_react.useEffect;
+var useIsomorphicLayoutEffect = /* @__PURE__ */ getUseIsomorphicLayoutEffect();
+function is(x, y) {
+	if (x === y) return x !== 0 || y !== 0 || 1 / x === 1 / y;
+	else return x !== x && y !== y;
+}
+function shallowEqual(objA, objB) {
+	if (is(objA, objB)) return true;
+	if (typeof objA !== "object" || objA === null || typeof objB !== "object" || objB === null) return false;
+	const keysA = Object.keys(objA);
+	const keysB = Object.keys(objB);
+	if (keysA.length !== keysB.length) return false;
+	for (let i = 0; i < keysA.length; i++) if (!Object.prototype.hasOwnProperty.call(objB, keysA[i]) || !is(objA[keysA[i]], objB[keysA[i]])) return false;
+	return true;
+}
+var ContextKey = /* @__PURE__ */ Symbol.for(`react-redux-context`);
+var gT = typeof globalThis !== "undefined" ? globalThis : {};
+function getContext() {
+	if (!import_react.createContext) return {};
+	const contextMap = gT[ContextKey] ??= /* @__PURE__ */ new Map();
+	let realContext = contextMap.get(import_react.createContext);
+	if (!realContext) {
+		realContext = import_react.createContext(null);
+		contextMap.set(import_react.createContext, realContext);
+	}
+	return realContext;
+}
+var ReactReduxContext = /* @__PURE__ */ getContext();
+function Provider(providerProps) {
+	const { children, context, serverState, store } = providerProps;
+	const contextValue = import_react.useMemo(() => {
+		return {
+			store,
+			subscription: createSubscription(store),
+			getServerState: serverState ? () => serverState : void 0
+		};
+	}, [store, serverState]);
+	const previousState = import_react.useMemo(() => store.getState(), [store]);
+	useIsomorphicLayoutEffect(() => {
+		const { subscription } = contextValue;
+		subscription.onStateChange = subscription.notifyNestedSubs;
+		subscription.trySubscribe();
+		if (previousState !== store.getState()) subscription.notifyNestedSubs();
+		return () => {
+			subscription.tryUnsubscribe();
+			subscription.onStateChange = void 0;
+		};
+	}, [contextValue, previousState]);
+	const Context = context || ReactReduxContext;
+	return /* @__PURE__ */ import_react.createElement(Context.Provider, { value: contextValue }, children);
+}
+var Provider_default = Provider;
+//#endregion
+export { shallowEqual as n, Provider_default as t };