@silvery/examples 0.5.6 → 0.17.4

package/dist/jsx-runtime-dMs_8fNu.mjs

@@ -0,0 +1,241 @@
+import { i as __require, t as __commonJSMin } from "./chunk-BSw8zbkd.mjs";
+//#region ../../../node_modules/.bun/react@19.2.4/node_modules/react/cjs/react-jsx-runtime.production.js
+/**
+* @license React
+* react-jsx-runtime.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_react_jsx_runtime_production = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"), REACT_FRAGMENT_TYPE = Symbol.for("react.fragment");
+	function jsxProd(type, config, maybeKey) {
+		var key = null;
+		void 0 !== maybeKey && (key = "" + maybeKey);
+		void 0 !== config.key && (key = "" + config.key);
+		if ("key" in config) {
+			maybeKey = {};
+			for (var propName in config) "key" !== propName && (maybeKey[propName] = config[propName]);
+		} else maybeKey = config;
+		config = maybeKey.ref;
+		return {
+			$$typeof: REACT_ELEMENT_TYPE,
+			type,
+			key,
+			ref: void 0 !== config ? config : null,
+			props: maybeKey
+		};
+	}
+	exports.Fragment = REACT_FRAGMENT_TYPE;
+	exports.jsx = jsxProd;
+	exports.jsxs = jsxProd;
+}));
+//#endregion
+//#region ../../../node_modules/.bun/react@19.2.4/node_modules/react/cjs/react-jsx-runtime.development.js
+/**
+* @license React
+* react-jsx-runtime.development.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_react_jsx_runtime_development = /* @__PURE__ */ __commonJSMin(((exports) => {
+	"production" !== process.env.NODE_ENV && (function() {
+		function getComponentNameFromType(type) {
+			if (null == type) return null;
+			if ("function" === typeof type) return type.$$typeof === REACT_CLIENT_REFERENCE ? null : type.displayName || type.name || null;
+			if ("string" === typeof type) return type;
+			switch (type) {
+				case REACT_FRAGMENT_TYPE: return "Fragment";
+				case REACT_PROFILER_TYPE: return "Profiler";
+				case REACT_STRICT_MODE_TYPE: return "StrictMode";
+				case REACT_SUSPENSE_TYPE: return "Suspense";
+				case REACT_SUSPENSE_LIST_TYPE: return "SuspenseList";
+				case REACT_ACTIVITY_TYPE: return "Activity";
+			}
+			if ("object" === typeof type) switch ("number" === typeof type.tag && console.error("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), type.$$typeof) {
+				case REACT_PORTAL_TYPE: return "Portal";
+				case REACT_CONTEXT_TYPE: return type.displayName || "Context";
+				case REACT_CONSUMER_TYPE: return (type._context.displayName || "Context") + ".Consumer";
+				case REACT_FORWARD_REF_TYPE:
+					var innerType = type.render;
+					type = type.displayName;
+					type || (type = innerType.displayName || innerType.name || "", type = "" !== type ? "ForwardRef(" + type + ")" : "ForwardRef");
+					return type;
+				case REACT_MEMO_TYPE: return innerType = type.displayName || null, null !== innerType ? innerType : getComponentNameFromType(type.type) || "Memo";
+				case REACT_LAZY_TYPE:
+					innerType = type._payload;
+					type = type._init;
+					try {
+						return getComponentNameFromType(type(innerType));
+					} catch (x) {}
+			}
+			return null;
+		}
+		function testStringCoercion(value) {
+			return "" + value;
+		}
+		function checkKeyStringCoercion(value) {
+			try {
+				testStringCoercion(value);
+				var JSCompiler_inline_result = !1;
+			} catch (e) {
+				JSCompiler_inline_result = !0;
+			}
+			if (JSCompiler_inline_result) {
+				JSCompiler_inline_result = console;
+				var JSCompiler_temp_const = JSCompiler_inline_result.error;
+				var JSCompiler_inline_result$jscomp$0 = "function" === typeof Symbol && Symbol.toStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object";
+				JSCompiler_temp_const.call(JSCompiler_inline_result, "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.", JSCompiler_inline_result$jscomp$0);
+				return testStringCoercion(value);
+			}
+		}
+		function getTaskName(type) {
+			if (type === REACT_FRAGMENT_TYPE) return "<>";
+			if ("object" === typeof type && null !== type && type.$$typeof === REACT_LAZY_TYPE) return "<...>";
+			try {
+				var name = getComponentNameFromType(type);
+				return name ? "<" + name + ">" : "<...>";
+			} catch (x) {
+				return "<...>";
+			}
+		}
+		function getOwner() {
+			var dispatcher = ReactSharedInternals.A;
+			return null === dispatcher ? null : dispatcher.getOwner();
+		}
+		function UnknownOwner() {
+			return Error("react-stack-top-frame");
+		}
+		function hasValidKey(config) {
+			if (hasOwnProperty.call(config, "key")) {
+				var getter = Object.getOwnPropertyDescriptor(config, "key").get;
+				if (getter && getter.isReactWarning) return !1;
+			}
+			return void 0 !== config.key;
+		}
+		function defineKeyPropWarningGetter(props, displayName) {
+			function warnAboutAccessingKey() {
+				specialPropKeyWarningShown || (specialPropKeyWarningShown = !0, console.error("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)", displayName));
+			}
+			warnAboutAccessingKey.isReactWarning = !0;
+			Object.defineProperty(props, "key", {
+				get: warnAboutAccessingKey,
+				configurable: !0
+			});
+		}
+		function elementRefGetterWithDeprecationWarning() {
+			var componentName = getComponentNameFromType(this.type);
+			didWarnAboutElementRef[componentName] || (didWarnAboutElementRef[componentName] = !0, console.error("Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."));
+			componentName = this.props.ref;
+			return void 0 !== componentName ? componentName : null;
+		}
+		function ReactElement(type, key, props, owner, debugStack, debugTask) {
+			var refProp = props.ref;
+			type = {
+				$$typeof: REACT_ELEMENT_TYPE,
+				type,
+				key,
+				props,
+				_owner: owner
+			};
+			null !== (void 0 !== refProp ? refProp : null) ? Object.defineProperty(type, "ref", {
+				enumerable: !1,
+				get: elementRefGetterWithDeprecationWarning
+			}) : Object.defineProperty(type, "ref", {
+				enumerable: !1,
+				value: null
+			});
+			type._store = {};
+			Object.defineProperty(type._store, "validated", {
+				configurable: !1,
+				enumerable: !1,
+				writable: !0,
+				value: 0
+			});
+			Object.defineProperty(type, "_debugInfo", {
+				configurable: !1,
+				enumerable: !1,
+				writable: !0,
+				value: null
+			});
+			Object.defineProperty(type, "_debugStack", {
+				configurable: !1,
+				enumerable: !1,
+				writable: !0,
+				value: debugStack
+			});
+			Object.defineProperty(type, "_debugTask", {
+				configurable: !1,
+				enumerable: !1,
+				writable: !0,
+				value: debugTask
+			});
+			Object.freeze && (Object.freeze(type.props), Object.freeze(type));
+			return type;
+		}
+		function jsxDEVImpl(type, config, maybeKey, isStaticChildren, debugStack, debugTask) {
+			var children = config.children;
+			if (void 0 !== children) if (isStaticChildren) if (isArrayImpl(children)) {
+				for (isStaticChildren = 0; isStaticChildren < children.length; isStaticChildren++) validateChildKeys(children[isStaticChildren]);
+				Object.freeze && Object.freeze(children);
+			} else console.error("React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead.");
+			else validateChildKeys(children);
+			if (hasOwnProperty.call(config, "key")) {
+				children = getComponentNameFromType(type);
+				var keys = Object.keys(config).filter(function(k) {
+					return "key" !== k;
+				});
+				isStaticChildren = 0 < keys.length ? "{key: someKey, " + keys.join(": ..., ") + ": ...}" : "{key: someKey}";
+				didWarnAboutKeySpread[children + isStaticChildren] || (keys = 0 < keys.length ? "{" + keys.join(": ..., ") + ": ...}" : "{}", console.error("A props object containing a \"key\" prop is being spread into JSX:\n  let props = %s;\n  <%s {...props} />\nReact keys must be passed directly to JSX without using spread:\n  let props = %s;\n  <%s key={someKey} {...props} />", isStaticChildren, children, keys, children), didWarnAboutKeySpread[children + isStaticChildren] = !0);
+			}
+			children = null;
+			void 0 !== maybeKey && (checkKeyStringCoercion(maybeKey), children = "" + maybeKey);
+			hasValidKey(config) && (checkKeyStringCoercion(config.key), children = "" + config.key);
+			if ("key" in config) {
+				maybeKey = {};
+				for (var propName in config) "key" !== propName && (maybeKey[propName] = config[propName]);
+			} else maybeKey = config;
+			children && defineKeyPropWarningGetter(maybeKey, "function" === typeof type ? type.displayName || type.name || "Unknown" : type);
+			return ReactElement(type, children, maybeKey, getOwner(), debugStack, debugTask);
+		}
+		function validateChildKeys(node) {
+			isValidElement(node) ? node._store && (node._store.validated = 1) : "object" === typeof node && null !== node && node.$$typeof === REACT_LAZY_TYPE && ("fulfilled" === node._payload.status ? isValidElement(node._payload.value) && node._payload.value._store && (node._payload.value._store.validated = 1) : node._store && (node._store.validated = 1));
+		}
+		function isValidElement(object) {
+			return "object" === typeof object && null !== object && object.$$typeof === REACT_ELEMENT_TYPE;
+		}
+		var React = __require("react"), REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = Symbol.for("react.profiler"), REACT_CONSUMER_TYPE = Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = Symbol.for("react.memo"), REACT_LAZY_TYPE = Symbol.for("react.lazy"), REACT_ACTIVITY_TYPE = Symbol.for("react.activity"), REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference"), ReactSharedInternals = React.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE, hasOwnProperty = Object.prototype.hasOwnProperty, isArrayImpl = Array.isArray, createTask = console.createTask ? console.createTask : function() {
+			return null;
+		};
+		React = { react_stack_bottom_frame: function(callStackForError) {
+			return callStackForError();
+		} };
+		var specialPropKeyWarningShown;
+		var didWarnAboutElementRef = {};
+		var unknownOwnerDebugStack = React.react_stack_bottom_frame.bind(React, UnknownOwner)();
+		var unknownOwnerDebugTask = createTask(getTaskName(UnknownOwner));
+		var didWarnAboutKeySpread = {};
+		exports.Fragment = REACT_FRAGMENT_TYPE;
+		exports.jsx = function(type, config, maybeKey) {
+			var trackActualOwner = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
+			return jsxDEVImpl(type, config, maybeKey, !1, trackActualOwner ? Error("react-stack-top-frame") : unknownOwnerDebugStack, trackActualOwner ? createTask(getTaskName(type)) : unknownOwnerDebugTask);
+		};
+		exports.jsxs = function(type, config, maybeKey) {
+			var trackActualOwner = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
+			return jsxDEVImpl(type, config, maybeKey, !0, trackActualOwner ? Error("react-stack-top-frame") : unknownOwnerDebugStack, trackActualOwner ? createTask(getTaskName(type)) : unknownOwnerDebugTask);
+		};
+	})();
+}));
+//#endregion
+//#region ../../../node_modules/.bun/react@19.2.4/node_modules/react/jsx-runtime.js
+var require_jsx_runtime = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	if (process.env.NODE_ENV === "production") module.exports = require_react_jsx_runtime_production();
+	else module.exports = require_react_jsx_runtime_development();
+}));
+//#endregion
+export { require_jsx_runtime as t };

package/dist/key-mapping-5oYQdAQE.mjs

@@ -0,0 +1,3 @@
+import { n as keyToAnsi, r as parseKey, t as init_key_mapping } from "./key-mapping-D4LR1go6.mjs";
+init_key_mapping();
+export { keyToAnsi, parseKey };

package/dist/key-mapping-D4LR1go6.mjs

@@ -0,0 +1,130 @@
+import { n as __esmMin } from "./chunk-BSw8zbkd.mjs";
+//#region ../../termless/src/key-mapping.ts
+function normalizeModifier(mod) {
+	return MODIFIER_ALIASES[mod.toLowerCase()] ?? mod.toLowerCase();
+}
+/**
+* Parse a key string like "Ctrl+a", "ArrowUp", "Shift+Tab" into a KeyDescriptor.
+*
+* Supports modifier prefixes: Ctrl, Control, Alt, Shift, Meta, Cmd, Option, Super.
+* Modifiers are case-insensitive and separated by "+".
+*/
+function parseKey(key) {
+	const parts = key.split("+");
+	const result = { key: parts.pop() };
+	for (const part of parts) switch (normalizeModifier(part)) {
+		case "ctrl":
+			result.ctrl = true;
+			break;
+		case "shift":
+			result.shift = true;
+			break;
+		case "alt":
+			result.alt = true;
+			break;
+		case "super":
+			result.super = true;
+			break;
+	}
+	return result;
+}
+/**
+* Convert a key descriptor or key string to its ANSI escape sequence.
+*
+* Handles:
+* - Single characters: returned as-is
+* - Named keys (ArrowUp, Enter, Tab, etc.): mapped to standard ANSI sequences
+* - Function keys (F1-F12): mapped to VT220/xterm sequences
+* - Ctrl+letter: ASCII control codes 1-26
+* - Ctrl+Enter: newline (\n)
+* - Alt+key: ESC prefix + key
+*/
+function keyToAnsi(key) {
+	const desc = typeof key === "string" ? parseKey(key) : key;
+	const { key: mainKey, ctrl, alt, shift } = desc;
+	const hasSuperOrMeta = desc.super;
+	if (ctrl && mainKey.length === 1) {
+		const code = mainKey.toLowerCase().charCodeAt(0) - 96;
+		if (code >= 1 && code <= 26) return String.fromCharCode(code);
+	}
+	if (ctrl && mainKey === "Enter") return "\n";
+	if ((alt || hasSuperOrMeta) && mainKey.length === 1) return `\x1b${mainKey}`;
+	const fkey = FKEY_MAP[mainKey];
+	if (fkey !== void 0) {
+		if (ctrl || alt || shift || hasSuperOrMeta) {
+			const mod = 1 + (shift ? 1 : 0) + (alt ? 2 : 0) + (ctrl ? 4 : 0) + (hasSuperOrMeta ? 8 : 0);
+			const fkeyNum = parseInt(mainKey.slice(1));
+			if (fkeyNum <= 4) return `\x1b[${fkeyNum + 10};${mod}~`;
+			const match = fkey.match(/\x1b\[(\d+)~/);
+			if (match) return `\x1b[${match[1]};${mod}~`;
+		}
+		return fkey;
+	}
+	const mapped = KEY_MAP[mainKey];
+	if (mapped !== void 0) {
+		if (mapped === null) return "";
+		if ((ctrl || alt || shift || hasSuperOrMeta) && mapped.startsWith("\x1B[")) {
+			const mod = 1 + (shift ? 1 : 0) + (alt ? 2 : 0) + (ctrl ? 4 : 0) + (hasSuperOrMeta ? 8 : 0);
+			const letterMatch = mapped.match(/\x1b\[([A-H])$/);
+			if (letterMatch) return `\x1b[1;${mod}${letterMatch[1]}`;
+			const tildeMatch = mapped.match(/\x1b\[(\d+)~$/);
+			if (tildeMatch) return `\x1b[${tildeMatch[1]};${mod}~`;
+		}
+		if (shift && mainKey === "Tab") return "\x1B[Z";
+		return mapped;
+	}
+	if (mainKey.length === 1) {
+		if (shift && mainKey.match(/[a-z]/)) return mainKey.toUpperCase();
+		return mainKey;
+	}
+	return mainKey;
+}
+var KEY_MAP, FKEY_MAP, MODIFIER_ALIASES;
+var init_key_mapping = __esmMin((() => {
+	KEY_MAP = {
+		ArrowUp: "\x1B[A",
+		ArrowDown: "\x1B[B",
+		ArrowLeft: "\x1B[D",
+		ArrowRight: "\x1B[C",
+		Home: "\x1B[H",
+		End: "\x1B[F",
+		PageUp: "\x1B[5~",
+		PageDown: "\x1B[6~",
+		Enter: "\r",
+		Tab: "	",
+		Backspace: "",
+		Delete: "\x1B[3~",
+		Escape: "\x1B",
+		Space: " ",
+		Control: null,
+		Shift: null,
+		Alt: null,
+		Meta: null
+	};
+	FKEY_MAP = {
+		F1: "\x1BOP",
+		F2: "\x1BOQ",
+		F3: "\x1BOR",
+		F4: "\x1BOS",
+		F5: "\x1B[15~",
+		F6: "\x1B[17~",
+		F7: "\x1B[18~",
+		F8: "\x1B[19~",
+		F9: "\x1B[20~",
+		F10: "\x1B[21~",
+		F11: "\x1B[23~",
+		F12: "\x1B[24~"
+	};
+	MODIFIER_ALIASES = {
+		ctrl: "ctrl",
+		control: "ctrl",
+		shift: "shift",
+		alt: "alt",
+		meta: "super",
+		cmd: "super",
+		option: "alt",
+		super: "super"
+	};
+}));
+//#endregion
+export { keyToAnsi as n, parseKey as r, init_key_mapping as t };