@aussieljk/forkbook 0.0.1-4 → 0.0.1-6

package/dist/manager/_manager-chunks/globals-runtime-CBviMKtt.js

@@ -0,0 +1,446 @@
+import { n as __esmMin } from "./globals-runtime-BdGkqNEt.js";
+//#region ../../node_modules/@remix-run/router/dist/router.js
+/**
+* @remix-run/router v1.8.0
+*
+* Copyright (c) Remix Software Inc.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE.md file in the root directory of this source tree.
+*
+* @license MIT
+*/
+function _extends() {
+	_extends = Object.assign ? Object.assign.bind() : function(target) {
+		for (var i = 1; i < arguments.length; i++) {
+			var source = arguments[i];
+			for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
+		}
+		return target;
+	};
+	return _extends.apply(this, arguments);
+}
+/**
+* Memory history stores the current location in memory. It is designed for use
+* in stateful non-browser environments like tests and React Native.
+*/
+function createMemoryHistory(options) {
+	if (options === void 0) options = {};
+	let { initialEntries = ["/"], initialIndex, v5Compat = false } = options;
+	let entries;
+	entries = initialEntries.map((entry, index) => createMemoryLocation(entry, typeof entry === "string" ? null : entry.state, index === 0 ? "default" : void 0));
+	let index = clampIndex(initialIndex == null ? entries.length - 1 : initialIndex);
+	let action = Action.Pop;
+	let listener = null;
+	function clampIndex(n) {
+		return Math.min(Math.max(n, 0), entries.length - 1);
+	}
+	function getCurrentLocation() {
+		return entries[index];
+	}
+	function createMemoryLocation(to, state, key) {
+		if (state === void 0) state = null;
+		let location = createLocation(entries ? getCurrentLocation().pathname : "/", to, state, key);
+		warning(location.pathname.charAt(0) === "/", "relative pathnames are not supported in memory history: " + JSON.stringify(to));
+		return location;
+	}
+	function createHref(to) {
+		return typeof to === "string" ? to : createPath(to);
+	}
+	return {
+		get index() {
+			return index;
+		},
+		get action() {
+			return action;
+		},
+		get location() {
+			return getCurrentLocation();
+		},
+		createHref,
+		createURL(to) {
+			return new URL(createHref(to), "http://localhost");
+		},
+		encodeLocation(to) {
+			let path = typeof to === "string" ? parsePath(to) : to;
+			return {
+				pathname: path.pathname || "",
+				search: path.search || "",
+				hash: path.hash || ""
+			};
+		},
+		push(to, state) {
+			action = Action.Push;
+			let nextLocation = createMemoryLocation(to, state);
+			index += 1;
+			entries.splice(index, entries.length, nextLocation);
+			if (v5Compat && listener) listener({
+				action,
+				location: nextLocation,
+				delta: 1
+			});
+		},
+		replace(to, state) {
+			action = Action.Replace;
+			let nextLocation = createMemoryLocation(to, state);
+			entries[index] = nextLocation;
+			if (v5Compat && listener) listener({
+				action,
+				location: nextLocation,
+				delta: 0
+			});
+		},
+		go(delta) {
+			action = Action.Pop;
+			let nextIndex = clampIndex(index + delta);
+			let nextLocation = entries[nextIndex];
+			index = nextIndex;
+			if (listener) listener({
+				action,
+				location: nextLocation,
+				delta
+			});
+		},
+		listen(fn) {
+			listener = fn;
+			return () => {
+				listener = null;
+			};
+		}
+	};
+}
+/**
+* Browser history stores the location in regular URLs. This is the standard for
+* most web apps, but it requires some configuration on the server to ensure you
+* serve the same app at multiple URLs.
+*
+* @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createbrowserhistory
+*/
+function createBrowserHistory(options) {
+	if (options === void 0) options = {};
+	function createBrowserLocation(window, globalHistory) {
+		let { pathname, search, hash } = window.location;
+		return createLocation("", {
+			pathname,
+			search,
+			hash
+		}, globalHistory.state && globalHistory.state.usr || null, globalHistory.state && globalHistory.state.key || "default");
+	}
+	function createBrowserHref(window, to) {
+		return typeof to === "string" ? to : createPath(to);
+	}
+	return getUrlBasedHistory(createBrowserLocation, createBrowserHref, null, options);
+}
+function invariant(value, message) {
+	if (value === false || value === null || typeof value === "undefined") throw new Error(message);
+}
+function warning(cond, message) {
+	if (!cond) {
+		if (typeof console !== "undefined") console.warn(message);
+		try {
+			throw new Error(message);
+		} catch (e) {}
+	}
+}
+function createKey() {
+	return Math.random().toString(36).substr(2, 8);
+}
+/**
+* For browser-based histories, we combine the state and key into an object
+*/
+function getHistoryState(location, index) {
+	return {
+		usr: location.state,
+		key: location.key,
+		idx: index
+	};
+}
+/**
+* Creates a Location object with a unique key from the given Path
+*/
+function createLocation(current, to, state, key) {
+	if (state === void 0) state = null;
+	return _extends({
+		pathname: typeof current === "string" ? current : current.pathname,
+		search: "",
+		hash: ""
+	}, typeof to === "string" ? parsePath(to) : to, {
+		state,
+		key: to && to.key || key || createKey()
+	});
+}
+/**
+* Creates a string URL path from the given pathname, search, and hash components.
+*/
+function createPath(_ref) {
+	let { pathname = "/", search = "", hash = "" } = _ref;
+	if (search && search !== "?") pathname += search.charAt(0) === "?" ? search : "?" + search;
+	if (hash && hash !== "#") pathname += hash.charAt(0) === "#" ? hash : "#" + hash;
+	return pathname;
+}
+/**
+* Parses a string URL path into its separate pathname, search, and hash components.
+*/
+function parsePath(path) {
+	let parsedPath = {};
+	if (path) {
+		let hashIndex = path.indexOf("#");
+		if (hashIndex >= 0) {
+			parsedPath.hash = path.substr(hashIndex);
+			path = path.substr(0, hashIndex);
+		}
+		let searchIndex = path.indexOf("?");
+		if (searchIndex >= 0) {
+			parsedPath.search = path.substr(searchIndex);
+			path = path.substr(0, searchIndex);
+		}
+		if (path) parsedPath.pathname = path;
+	}
+	return parsedPath;
+}
+function getUrlBasedHistory(getLocation, createHref, validateLocation, options) {
+	if (options === void 0) options = {};
+	let { window = document.defaultView, v5Compat = false } = options;
+	let globalHistory = window.history;
+	let action = Action.Pop;
+	let listener = null;
+	let index = getIndex();
+	if (index == null) {
+		index = 0;
+		globalHistory.replaceState(_extends({}, globalHistory.state, { idx: index }), "");
+	}
+	function getIndex() {
+		return (globalHistory.state || { idx: null }).idx;
+	}
+	function handlePop() {
+		action = Action.Pop;
+		let nextIndex = getIndex();
+		let delta = nextIndex == null ? null : nextIndex - index;
+		index = nextIndex;
+		if (listener) listener({
+			action,
+			location: history.location,
+			delta
+		});
+	}
+	function push(to, state) {
+		action = Action.Push;
+		let location = createLocation(history.location, to, state);
+		if (validateLocation) validateLocation(location, to);
+		index = getIndex() + 1;
+		let historyState = getHistoryState(location, index);
+		let url = history.createHref(location);
+		try {
+			globalHistory.pushState(historyState, "", url);
+		} catch (error) {
+			if (error instanceof DOMException && error.name === "DataCloneError") throw error;
+			window.location.assign(url);
+		}
+		if (v5Compat && listener) listener({
+			action,
+			location: history.location,
+			delta: 1
+		});
+	}
+	function replace(to, state) {
+		action = Action.Replace;
+		let location = createLocation(history.location, to, state);
+		if (validateLocation) validateLocation(location, to);
+		index = getIndex();
+		let historyState = getHistoryState(location, index);
+		let url = history.createHref(location);
+		globalHistory.replaceState(historyState, "", url);
+		if (v5Compat && listener) listener({
+			action,
+			location: history.location,
+			delta: 0
+		});
+	}
+	function createURL(to) {
+		let base = window.location.origin !== "null" ? window.location.origin : window.location.href;
+		let href = typeof to === "string" ? to : createPath(to);
+		invariant(base, "No window.location.(origin|href) available to create URL for href: " + href);
+		return new URL(href, base);
+	}
+	let history = {
+		get action() {
+			return action;
+		},
+		get location() {
+			return getLocation(window, globalHistory);
+		},
+		listen(fn) {
+			if (listener) throw new Error("A history only accepts one active listener");
+			window.addEventListener(PopStateEventType, handlePop);
+			listener = fn;
+			return () => {
+				window.removeEventListener(PopStateEventType, handlePop);
+				listener = null;
+			};
+		},
+		createHref(to) {
+			return createHref(window, to);
+		},
+		createURL,
+		encodeLocation(to) {
+			let url = createURL(to);
+			return {
+				pathname: url.pathname,
+				search: url.search,
+				hash: url.hash
+			};
+		},
+		push,
+		replace,
+		go(n) {
+			return globalHistory.go(n);
+		}
+	};
+	return history;
+}
+/**
+* @private
+*/
+function stripBasename(pathname, basename) {
+	if (basename === "/") return pathname;
+	if (!pathname.toLowerCase().startsWith(basename.toLowerCase())) return null;
+	let startIndex = basename.endsWith("/") ? basename.length - 1 : basename.length;
+	let nextChar = pathname.charAt(startIndex);
+	if (nextChar && nextChar !== "/") return null;
+	return pathname.slice(startIndex) || "/";
+}
+/**
+* Returns a resolved path object relative to the given pathname.
+*
+* @see https://reactrouter.com/utils/resolve-path
+*/
+function resolvePath(to, fromPathname) {
+	if (fromPathname === void 0) fromPathname = "/";
+	let { pathname: toPathname, search = "", hash = "" } = typeof to === "string" ? parsePath(to) : to;
+	return {
+		pathname: toPathname ? toPathname.startsWith("/") ? toPathname : resolvePathname(toPathname, fromPathname) : fromPathname,
+		search: normalizeSearch(search),
+		hash: normalizeHash(hash)
+	};
+}
+function resolvePathname(relativePath, fromPathname) {
+	let segments = fromPathname.replace(/\/+$/, "").split("/");
+	relativePath.split("/").forEach((segment) => {
+		if (segment === "..") {
+			if (segments.length > 1) segments.pop();
+		} else if (segment !== ".") segments.push(segment);
+	});
+	return segments.length > 1 ? segments.join("/") : "/";
+}
+function getInvalidPathError(char, field, dest, path) {
+	return "Cannot include a '" + char + "' character in a manually specified " + ("`to." + field + "` field [" + JSON.stringify(path) + "].  Please separate it out to the ") + ("`to." + dest + "` field. Alternatively you may provide the full path as ") + "a string in <Link to=\"...\"> and the router will parse it for you.";
+}
+/**
+* @private
+*
+* When processing relative navigation we want to ignore ancestor routes that
+* do not contribute to the path, such that index/pathless layout routes don't
+* interfere.
+*
+* For example, when moving a route element into an index route and/or a
+* pathless layout route, relative link behavior contained within should stay
+* the same.  Both of the following examples should link back to the root:
+*
+*   <Route path="/">
+*     <Route path="accounts" element={<Link to=".."}>
+*   </Route>
+*
+*   <Route path="/">
+*     <Route path="accounts">
+*       <Route element={<AccountsLayout />}>       // <-- Does not contribute
+*         <Route index element={<Link to=".."} />  // <-- Does not contribute
+*       </Route
+*     </Route>
+*   </Route>
+*/
+function getPathContributingMatches(matches) {
+	return matches.filter((match, index) => index === 0 || match.route.path && match.route.path.length > 0);
+}
+/**
+* @private
+*/
+function resolveTo(toArg, routePathnames, locationPathname, isPathRelative) {
+	if (isPathRelative === void 0) isPathRelative = false;
+	let to;
+	if (typeof toArg === "string") to = parsePath(toArg);
+	else {
+		to = _extends({}, toArg);
+		invariant(!to.pathname || !to.pathname.includes("?"), getInvalidPathError("?", "pathname", "search", to));
+		invariant(!to.pathname || !to.pathname.includes("#"), getInvalidPathError("#", "pathname", "hash", to));
+		invariant(!to.search || !to.search.includes("#"), getInvalidPathError("#", "search", "hash", to));
+	}
+	let isEmptyPath = toArg === "" || to.pathname === "";
+	let toPathname = isEmptyPath ? "/" : to.pathname;
+	let from;
+	if (isPathRelative || toPathname == null) from = locationPathname;
+	else {
+		let routePathnameIndex = routePathnames.length - 1;
+		if (toPathname.startsWith("..")) {
+			let toSegments = toPathname.split("/");
+			while (toSegments[0] === "..") {
+				toSegments.shift();
+				routePathnameIndex -= 1;
+			}
+			to.pathname = toSegments.join("/");
+		}
+		from = routePathnameIndex >= 0 ? routePathnames[routePathnameIndex] : "/";
+	}
+	let path = resolvePath(to, from);
+	let hasExplicitTrailingSlash = toPathname && toPathname !== "/" && toPathname.endsWith("/");
+	let hasCurrentTrailingSlash = (isEmptyPath || toPathname === ".") && locationPathname.endsWith("/");
+	if (!path.pathname.endsWith("/") && (hasExplicitTrailingSlash || hasCurrentTrailingSlash)) path.pathname += "/";
+	return path;
+}
+var Action, PopStateEventType, ResultType, joinPaths, normalizeSearch, normalizeHash, AbortedDeferredError, validMutationMethodsArr, validRequestMethodsArr;
+function init_router() {
+	return (init_router = __esmMin((() => {
+		(function(Action) {
+			/**
+			* A POP indicates a change to an arbitrary index in the history stack, such
+			* as a back or forward navigation. It does not describe the direction of the
+			* navigation, only that the current index changed.
+			*
+			* Note: This is the default action for newly created history objects.
+			*/
+			Action["Pop"] = "POP";
+			/**
+			* A PUSH indicates a new entry being added to the history stack, such as when
+			* a link is clicked and a new page loads. When this happens, all subsequent
+			* entries in the stack are lost.
+			*/
+			Action["Push"] = "PUSH";
+			/**
+			* A REPLACE indicates the entry at the current index in the history stack
+			* being replaced by a new one.
+			*/
+			Action["Replace"] = "REPLACE";
+		})(Action || (Action = {}));
+		PopStateEventType = "popstate";
+		(function(ResultType) {
+			ResultType["data"] = "data";
+			ResultType["deferred"] = "deferred";
+			ResultType["redirect"] = "redirect";
+			ResultType["error"] = "error";
+		})(ResultType || (ResultType = {}));
+		joinPaths = (paths) => paths.join("/").replace(/\/\/+/g, "/");
+		normalizeSearch = (search) => !search || search === "?" ? "" : search.startsWith("?") ? search : "?" + search;
+		normalizeHash = (hash) => !hash || hash === "#" ? "" : hash.startsWith("#") ? hash : "#" + hash;
+		AbortedDeferredError = class extends Error {};
+		validMutationMethodsArr = [
+			"post",
+			"put",
+			"patch",
+			"delete"
+		];
+		new Set(validMutationMethodsArr);
+		validRequestMethodsArr = ["get", ...validMutationMethodsArr];
+		new Set(validRequestMethodsArr);
+	})))();
+}
+//#endregion
+export { createPath as a, invariant as c, resolveTo as d, stripBasename as f, createMemoryHistory as i, joinPaths as l, Action as n, getPathContributingMatches as o, createBrowserHistory as r, init_router as s, AbortedDeferredError as t, parsePath as u };

package/dist/manager/_manager-chunks/{globals-runtime-eLPTIfX-.js → globals-runtime-CYNosEiD.js}

@@ -1,6 +1,5 @@
 import { a as __toESM$1, n as __esmMin, r as __exportAll, t as __commonJSMin } from "./globals-runtime-BdGkqNEt.js";
-import { j as require_react } from "./globals-runtime-ZHrQFa3-.js";
-import { S as require_min_indent, x as require_indent_string } from "./globals-runtime-BvM-NY2g.js";
+import { F as require_react, b as require_min_indent, y as require_indent_string } from "./globals-runtime-CrIF09P8.js";
 //#region ../../node_modules/ts-dedent/esm/index.js
 function dedent(templ) {
 	var values = [];