sliftutils 1.2.23 → 1.2.25

package/misc/openrouter.ts

@@ -1,5 +1,7 @@
 import { parseYAML } from "./yaml";
 import { retryFunctional } from "socket-function/src/batching";
+
+const CANNOT_RETRY = "(CANNOT RETRY)";
 import { formatNumber } from "socket-function/src/formatting/format";
 import { getAPIKey } from "./apiKeys";
 
@@ -97,7 +99,6 @@ export async function openRouterCallBase(config: {
     let time = Date.now();
     let stillRunning = true;
 
-    // Spawn monitoring loop
     void (async () => {
         while (stillRunning) {
             await new Promise(resolve => setTimeout(resolve, 5000));
@@ -126,7 +127,6 @@ export async function openRouterCallBase(config: {
                 }),
             });
 
-            // If it failed, throw
             if (response.status !== 200) {
                 let responseText = await response.text();
                 throw new Error(`Failed to call OpenRouter: ${response.status} ${response.statusText} ${responseText}`);
@@ -136,11 +136,34 @@ export async function openRouterCallBase(config: {
                     cost: number;
                 };
                 choices: {
+                    finish_reason?: string;
                     message: {
                         content: string;
+                        refusal?: string | null;
                     };
                 }[];
+                error?: {
+                    code?: number | string;
+                    message?: string;
+                    metadata?: unknown;
+                };
             };
+            if (responseObj.error) {
+                throw new Error(`OpenRouter returned an error: ${responseObj.error.code} ${responseObj.error.message} ${JSON.stringify(responseObj.error.metadata)}`);
+            }
+            let choice = responseObj.choices?.[0];
+            if (!choice) {
+                throw new Error(`OpenRouter returned no choices: ${JSON.stringify(responseObj)}`);
+            }
+            if (choice.message.refusal) {
+                throw new Error(`OpenRouter model refused content: ${choice.message.refusal} ${CANNOT_RETRY}`);
+            }
+            if (choice.finish_reason === "content_filter") {
+                throw new Error(`OpenRouter content filter triggered (finish_reason=content_filter): ${choice.message.content ?? ""} ${CANNOT_RETRY}`);
+            }
+            if (choice.finish_reason === "error") {
+                throw new Error(`OpenRouter completion errored (finish_reason=error): ${choice.message.content ?? ""}`);
+            }
             let newCost = responseObj.usage.cost;
             totalCost += newCost;
             onCost?.(newCost);
@@ -161,7 +184,10 @@ export async function openRouterCallBase(config: {
             pendingLog.duration += Date.now() - time;
             pendingLog.cost += newCost;
             return responseObj.choices[0].message.content as string;
-        }, { maxRetries: config.retries || 3 })();
+        }, {
+            maxRetries: config.retries || 3,
+            shouldRetry: message => !message.includes(CANNOT_RETRY),
+        })();
     } finally {
         stillRunning = false;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "sliftutils",
-    "version": "1.2.23",
+    "version": "1.2.25",
     "main": "index.js",
     "license": "MIT",
     "files": [
@@ -25,7 +25,8 @@
         "watch-web": "node ./builders/watchRun.js --port 9877 \"web/*.ts\" \"web/*.tsx\" \"yarn build-web\"",
         "watch-extension": "node ./builders/watchRun.js --port 9878 \"extension/*.ts\" \"extension/*.tsx\" \"yarn build-extension\"",
         "watch-electron": "node ./builders/watchRun.js --port 9879 \"electron/*.ts\" \"electron/*.tsx\" \"yarn build-electron\"",
-        "notes": "mobx, preact, socket-function, typenode SHOULD be peerDependencies. But we want to use yarn (better dependency deduplication), so we can't use peerDependencies (as they aren't installed by default, which makes them a nightmare to use). If you want to override the versions, feel free to use overrides/resolutions."
+        "notes": "mobx, preact, socket-function, typenode SHOULD be peerDependencies. But we want to use yarn (better dependency deduplication), so we can't use peerDependencies (as they aren't installed by default, which makes them a nightmare to use). If you want to override the versions, feel free to use overrides/resolutions.",
+        "test": "typenode ./test.ts"
     },
     "bin": {
         "build-nodejs": "./builders/nodeJSBuildRun.js",

package/render-utils/dist/Input.tsx.cache

@@ -0,0 +1,319 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule && mod.default) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.Input = void 0;
+const preact_1 = __importDefault(require("preact"));
+const typesafecss_1 = require("typesafecss");
+const observer_1 = require("./observer");
+const misc_1 = require("socket-function/src/misc");
+let Input = class Input extends preact_1.default.Component {
+    constructor() {
+        super(...arguments);
+        this.onFocusText = "";
+        this.firstFocus = true;
+        this.elem = null;
+        this.lastValue = null;
+        this.lastChecked = null;
+        this.onChangeThrottle = undefined;
+    }
+    render() {
+        let flavorOverrides = {};
+        const { flavor, textarea, hot, inputKey, fillWidth, ...nativeProps } = this.props;
+        let props = { ...nativeProps };
+        if (props.onChangeValue) {
+            let throttle = this.props.throttle;
+            if (throttle) {
+                let existingThrottle = this.onChangeThrottle;
+                if ((existingThrottle === null || existingThrottle === void 0 ? void 0 : existingThrottle.throttle) !== throttle) {
+                    existingThrottle = this.onChangeThrottle = {
+                        throttle,
+                        run: (0, misc_1.throttleFunction)(throttle, (newValue) => {
+                            var _a, _b;
+                            (_b = (_a = this.props).onChangeValue) === null || _b === void 0 ? void 0 : _b.call(_a, newValue);
+                        })
+                    };
+                }
+                props.onChangeValue = existingThrottle.run;
+            }
+        }
+        if (flavor === "large") {
+            flavorOverrides = {
+                fontSize: 18,
+                padding: "10px 15px",
+            };
+            if (props.type === "checkbox") {
+                flavorOverrides.width = 16;
+                flavorOverrides.height = 16;
+            }
+        }
+        if (flavor === "small") {
+            flavorOverrides = {
+                fontSize: 12,
+                padding: "5px 10px",
+            };
+        }
+        // IMPORTANT! When focused, preserve the input value, otherwise typing is annoying.
+        //  This doesn't usually happen, but can if background tasks are updating the UI
+        //  while the user is typing.
+        let attributes = {
+            ...nativeProps,
+            key: inputKey || "input",
+            ref: x => {
+                if (x) {
+                    this.elem = x;
+                }
+                if (x && props.focusOnMount && this.firstFocus) {
+                    this.firstFocus = false;
+                    setTimeout(() => {
+                        x.focus();
+                    }, 0);
+                }
+                let ref = props.inputRef;
+                if (typeof ref === "function") {
+                    ref(x);
+                }
+            },
+            class: undefined,
+            className: ((props.className || props.class || " ")
+                + typesafecss_1.css.display("flex", "soft")
+                    .outline("3px solid hsl(204, 100%, 50%)", "focus", "soft")
+                + (fillWidth && typesafecss_1.css.fillWidth)),
+            style: {
+                ...flavorOverrides,
+                ...props.style,
+            },
+            onFocus: e => {
+                var _a;
+                if (props.type === "checkbox")
+                    return;
+                this.onFocusText = e.currentTarget.value;
+                if (!props.noFocusSelect) {
+                    e.currentTarget.select();
+                }
+                (_a = props.onFocus) === null || _a === void 0 ? void 0 : _a.call(props, e);
+            },
+            onBlur: e => {
+                var _a, _b, _c, _d;
+                if (props.type === "checkbox")
+                    return;
+                (_a = props.onBlur) === null || _a === void 0 ? void 0 : _a.call(props, e);
+                if (e.currentTarget.value === this.lastValue && e.currentTarget.checked === this.lastChecked && hot)
+                    return;
+                this.lastValue = e.currentTarget.value;
+                this.lastChecked = e.currentTarget.checked;
+                let result = (_b = props.onInput) === null || _b === void 0 ? void 0 : _b.call(props, e);
+                result = ((_c = props.onChange) === null || _c === void 0 ? void 0 : _c.call(props, e)) || result;
+                result = ((_d = props.onChangeValue) === null || _d === void 0 ? void 0 : _d.call(props, e.currentTarget.value)) || result;
+                return result;
+            },
+            onChange: e => {
+                var _a, _b;
+                if (props.type !== "checkbox" && e.currentTarget.value === this.lastValue && e.currentTarget.checked === this.lastChecked)
+                    return;
+                this.lastValue = e.currentTarget.value;
+                this.lastChecked = e.currentTarget.checked;
+                let result = undefined;
+                if (!props.onChangeValue || hot) {
+                    result = ((_a = props.onChange) === null || _a === void 0 ? void 0 : _a.call(props, e)) || result;
+                }
+                if (hot) {
+                    result = ((_b = props.onChangeValue) === null || _b === void 0 ? void 0 : _b.call(props, e.currentTarget.value)) || result;
+                }
+                return result;
+            },
+            onKeyDown: e => {
+                var _a, _b, _c;
+                if (e.defaultPrevented)
+                    return;
+                // if (textarea && e.code === "Tab") {
+                //     e.preventDefault();
+                //     // Inject 4 spaces into the current position
+                //     let elem = e.currentTarget;
+                //     let value = elem.value;
+                //     let start = elem.selectionStart ?? elem.value.length;
+                //     let end = elem.selectionEnd ?? elem.value.length;
+                //     elem.value = value.slice(0, start) + "    " + value.slice(end);
+                //     elem.selectionStart = elem.selectionEnd = start + 4;
+                //     return;
+                // }
+                (_a = props.onKeyDown) === null || _a === void 0 ? void 0 : _a.call(props, e);
+                if (e.code === "Enter" && e.ctrlKey) {
+                    e.currentTarget.blur();
+                }
+                let callback = props.onInput;
+                if (!callback && hot) {
+                    callback = props.onChange;
+                }
+                // Convert tab to 4 spaces
+                if (e.code === "Tab" && textarea) {
+                    e.preventDefault();
+                    let elem = e.currentTarget;
+                    let value = elem.value;
+                    let start = (_b = elem.selectionStart) !== null && _b !== void 0 ? _b : elem.value.length;
+                    let end = (_c = elem.selectionEnd) !== null && _c !== void 0 ? _c : elem.value.length;
+                    elem.value = value.slice(0, start) + "    " + value.slice(end);
+                    elem.selectionStart = elem.selectionEnd = start + 4;
+                    callback === null || callback === void 0 ? void 0 : callback(e);
+                    return;
+                }
+                if (this.elem && props.type === "number") {
+                    let delta = 0;
+                    let magnitude = 1;
+                    if (e.shiftKey) {
+                        if (props.integer) {
+                            magnitude = 10;
+                        }
+                        else {
+                            magnitude = 0.1;
+                        }
+                    }
+                    if (e.code === "ArrowUp") {
+                        delta = magnitude;
+                    }
+                    else if (e.code === "ArrowDown") {
+                        delta = -magnitude;
+                    }
+                    if (props.reverseArrowKeyDirection) {
+                        delta *= -1;
+                    }
+                    if (delta !== 0) {
+                        e.preventDefault();
+                        let newValue = Math.round(((+this.elem.value || 0) + delta) * 100) / 100;
+                        e.currentTarget.value = newValue.toString();
+                        callback === null || callback === void 0 ? void 0 : callback(e);
+                    }
+                }
+                let { noEnterKeyBlur, onInput, onChange } = props;
+                // Detach from the synced function, to prevent double calls. This is important, as apparently .blur()
+                //  synchronously triggers onChange, BUT, only if the input is changing the first time. Which means
+                //  if this function reruns, it won't trigger the change again. Detaching it causes any triggered
+                //  functions to become root synced functions, which will allow them to correctly run the sync loop.
+                void Promise.resolve().finally(() => {
+                    if (e.defaultPrevented)
+                        return;
+                    if (e.code === "Escape") {
+                        let changed = e.currentTarget.value !== this.onFocusText;
+                        e.currentTarget.value = this.onFocusText;
+                        if (onInput) {
+                            onInput === null || onInput === void 0 ? void 0 : onInput(e);
+                        }
+                        else if (changed) {
+                            if (onChange) {
+                                onChange === null || onChange === void 0 ? void 0 : onChange(e);
+                            }
+                        }
+                        e.currentTarget.blur();
+                    }
+                    if (!noEnterKeyBlur && e.code === "Enter" && (!textarea || e.shiftKey || e.ctrlKey) || props.autocompleteValues && e.code === "Tab") {
+                        e.currentTarget.blur();
+                    }
+                    else if (e.ctrlKey && (e.code.startsWith("Key") || e.code === "Enter") || e.shiftKey && e.code === "Enter") {
+                        onChange === null || onChange === void 0 ? void 0 : onChange(e);
+                    }
+                });
+            },
+            onInput: e => {
+                var _a;
+                if (props.autocompleteValues) {
+                    if (e.inputType === "insertText") {
+                        let curValue = e.currentTarget.value.toLowerCase();
+                        let match = props.autocompleteValues.find(x => x.toLowerCase().startsWith(curValue));
+                        if (match) {
+                            e.currentTarget.value = match || "";
+                            // Select the part after the previous match, so when they type, they clobber the match part
+                            let start = curValue.length;
+                            let end = e.currentTarget.value.length;
+                            e.currentTarget.selectionStart = start;
+                            e.currentTarget.selectionEnd = end;
+                        }
+                    }
+                }
+                (_a = props.onInput) === null || _a === void 0 ? void 0 : _a.call(props, e);
+            },
+        };
+        if ("value" in props && props.type !== "checkbox") {
+            let elem = this.elem;
+            let newValue = props.value;
+            if (!this.props.forceInputValueUpdatesWhenFocused && elem && elem === document.activeElement) {
+                newValue = elem.value;
+            }
+            attributes.value = newValue;
+            this.lastValue = String(props.value);
+        }
+        if ("checked" in props) {
+            this.lastChecked = !!props.checked;
+        }
+        if (attributes.type === "number") {
+            // Fix stuff like 55.00000000000001
+            let value = attributes.value;
+            if (typeof value === "number") {
+                value = niceNumberStringify(value);
+            }
+        }
+        // We do number handling ourselves
+        if (attributes["type"] === "number") {
+            delete attributes["type"];
+        }
+        if (props.type === "checkbox") {
+        }
+        else if (hot) {
+            attributes.onInput = attributes.onChange;
+        }
+        else {
+            // We use onChange from onBlur, so don't use the onChange handler, as preact will hook this up
+            //  with onInput, which will cause it to trigger as if the component is hot!
+            delete attributes.onChange;
+        }
+        if (textarea) {
+            return preact_1.default.createElement("textarea", { ...attributes });
+        }
+        else {
+            return preact_1.default.createElement("input", { ...attributes });
+        }
+    }
+};
+exports.Input = Input;
+exports.Input = Input = __decorate([
+    observer_1.observer
+], Input);
+function niceNumberStringify(valueIn) {
+    if (Math.abs(valueIn) < 0.0000000001) {
+        return "0";
+    }
+    let value = valueIn.toString();
+    // TODO: Do this MUCH better...
+    if (value.slice(0, -1).endsWith("00000000000")) {
+        value = value.slice(0, -1);
+        while (value.endsWith("0")) {
+            value = value.slice(0, -1);
+        }
+        if (value.endsWith(".")) {
+            value = value.slice(0, -1);
+        }
+        return value;
+    }
+    if (value.slice(0, -1).endsWith("9999999999")) {
+        value = value.slice(0, -1);
+        while (value.endsWith("9")) {
+            value = value.slice(0, -1);
+        }
+        if (value.endsWith(".")) {
+            value = value.slice(0, -1);
+        }
+        // NOTE: Interestingly enough... because we remove all trailing 9s, it means if the last number is not 9,
+        //  so... we can do this hack to round up
+        value = value.slice(0, -1) + (parseInt(value.slice(-1)) + 1);
+        return value;
+    }
+    return value;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Input.js","sourceRoot":"","sources":["Input.tsx"],"names":[],"mappings":"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","sourcesContent":["import preact from \"preact\";\nimport { css } from \"typesafecss\";\nimport { observer } from \"./observer\";\nimport { throttleFunction } from \"socket-function/src/misc\";\n\n// TODO: Autogrow mode while typing\n\n// NOTE: \"value\" is optional. If you don't pass \"value\", we will preserve the value.\n//  This is useful for inputs which you want to run an action on, such as \"add new item\",\n//      as it allows you to remove a local state value to cache the value, by just\n//      doing the add on \"onChangeValue\".\n// IMPORTANT! InputProps is in both InputLabel.tsx and Input.tsx, so the types export correctly\nexport type InputProps = (\n    preact.JSX.HTMLAttributes<HTMLInputElement>\n    & {\n        /** ONLY throttles onChangeValue */\n        throttle?: number;\n\n        flavor?: \"large\" | \"small\" | \"none\";\n        focusOnMount?: boolean;\n        textarea?: boolean;\n        /** Update on key stroke, not on blur (just does onInput = onChange, as onInput already does this) */\n        hot?: boolean;\n        /** Updates arrow keys with modifier behavior to use larger numbers, instead of decimals. */\n        integer?: boolean;\n\n        /** Only works with number/integer */\n        reverseArrowKeyDirection?: boolean;\n\n        inputRef?: (x: HTMLInputElement | null) => void;\n        /** Don't blur on enter key */\n        noEnterKeyBlur?: boolean;\n        noFocusSelect?: boolean;\n        inputKey?: string;\n        fillWidth?: boolean;\n\n\n        autocompleteValues?: string[];\n\n        /** Forces the input to update when focused. Usually we hold updates, to prevent the user's\n         *      typing to be interrupted by background updates.\n         *      NOTE: \"hot\" is usually required when using this.\n         */\n        forceInputValueUpdatesWhenFocused?: boolean;\n\n        // NOTE: We trigger onChange (and onChangeValue) whenever\n        //      e.ctrlKey && (e.code.startsWith(\"Key\") || e.code === \"Enter\") || e.code === \"Enter\" && e.shiftKey\n        //  This is because ctrl usually means a hotkey, and hotkeys usually want committed values.\n        onChangeValue?: (value: string) => void;\n    }\n);\n\n\n@observer\nexport class Input extends preact.Component<InputProps> {\n    onFocusText = \"\";\n    firstFocus = true;\n\n    elem: HTMLInputElement | null = null;\n    lastValue: unknown = null;\n    lastChecked: unknown = null;\n\n    onChangeThrottle: undefined | {\n        throttle: number;\n        run: (newValue: string) => void;\n    } = undefined;\n\n    render() {\n        let flavorOverrides: preact.JSX.CSSProperties = {};\n        const { flavor, textarea, hot, inputKey, fillWidth, ...nativeProps } = this.props;\n        let props = { ...nativeProps } as preact.RenderableProps<InputProps>;\n\n        if (props.onChangeValue) {\n            let throttle = this.props.throttle;\n            if (throttle) {\n                let existingThrottle = this.onChangeThrottle;\n                if (existingThrottle?.throttle !== throttle) {\n                    existingThrottle = this.onChangeThrottle = {\n                        throttle,\n                        run: throttleFunction(throttle, (newValue) => {\n                            this.props.onChangeValue?.(newValue);\n                        })\n                    };\n                }\n                props.onChangeValue = existingThrottle.run;\n            }\n        }\n        if (flavor === \"large\") {\n            flavorOverrides = {\n                fontSize: 18,\n                padding: \"10px 15px\",\n            };\n            if (props.type === \"checkbox\") {\n                flavorOverrides.width = 16;\n                flavorOverrides.height = 16;\n            }\n        }\n        if (flavor === \"small\") {\n            flavorOverrides = {\n                fontSize: 12,\n                padding: \"5px 10px\",\n            };\n        }\n\n        // IMPORTANT! When focused, preserve the input value, otherwise typing is annoying.\n        //  This doesn't usually happen, but can if background tasks are updating the UI\n        //  while the user is typing.\n\n\n        let attributes: preact.JSX.HTMLAttributes<HTMLInputElement> = {\n            ...nativeProps,\n            key: inputKey || \"input\",\n            ref: x => {\n                if (x) {\n                    this.elem = x;\n                }\n                if (x && props.focusOnMount && this.firstFocus) {\n                    this.firstFocus = false;\n                    setTimeout(() => {\n                        x.focus();\n                    }, 0);\n                }\n                let ref = props.inputRef;\n                if (typeof ref === \"function\") {\n                    ref(x);\n                }\n            },\n            class: undefined,\n            className: (\n                (props.className || props.class || \" \")\n                + css.display(\"flex\", \"soft\")\n                    .outline(\"3px solid hsl(204, 100%, 50%)\", \"focus\", \"soft\")\n                + (fillWidth && css.fillWidth)\n            ),\n            style: {\n                ...flavorOverrides,\n                ...props.style as any,\n            },\n            onFocus: e => {\n                if (props.type === \"checkbox\") return;\n                this.onFocusText = e.currentTarget.value;\n                if (!props.noFocusSelect) {\n                    e.currentTarget.select();\n                }\n                props.onFocus?.(e);\n            },\n            onBlur: e => {\n                if (props.type === \"checkbox\") return;\n                props.onBlur?.(e);\n                if (e.currentTarget.value === this.lastValue && e.currentTarget.checked === this.lastChecked && hot) return;\n                this.lastValue = e.currentTarget.value;\n                this.lastChecked = e.currentTarget.checked;\n                let result = props.onInput?.(e as any);\n                result = props.onChange?.(e) || result;\n                result = props.onChangeValue?.(e.currentTarget.value) || result;\n                return result;\n            },\n            onChange: e => {\n                if (props.type !== \"checkbox\" && e.currentTarget.value === this.lastValue && e.currentTarget.checked === this.lastChecked) return;\n                this.lastValue = e.currentTarget.value;\n                this.lastChecked = e.currentTarget.checked;\n                let result: unknown = undefined;\n                if (!props.onChangeValue || hot) {\n                    result = props.onChange?.(e) || result;\n                }\n                if (hot) {\n                    result = props.onChangeValue?.(e.currentTarget.value) || result;\n                }\n                return result;\n            },\n            onKeyDown: e => {\n                if (e.defaultPrevented) return;\n                // if (textarea && e.code === \"Tab\") {\n                //     e.preventDefault();\n                //     // Inject 4 spaces into the current position\n                //     let elem = e.currentTarget;\n                //     let value = elem.value;\n                //     let start = elem.selectionStart ?? elem.value.length;\n                //     let end = elem.selectionEnd ?? elem.value.length;\n                //     elem.value = value.slice(0, start) + \"    \" + value.slice(end);\n                //     elem.selectionStart = elem.selectionEnd = start + 4;\n                //     return;\n                // }\n                props.onKeyDown?.(e);\n                if (e.code === \"Enter\" && e.ctrlKey) {\n                    e.currentTarget.blur();\n                }\n                let callback = props.onInput;\n                if (!callback && hot) {\n                    callback = props.onChange;\n                }\n\n                // Convert tab to 4 spaces\n                if (e.code === \"Tab\" && textarea) {\n                    e.preventDefault();\n                    let elem = e.currentTarget;\n                    let value = elem.value;\n                    let start = elem.selectionStart ?? elem.value.length;\n                    let end = elem.selectionEnd ?? elem.value.length;\n                    elem.value = value.slice(0, start) + \"    \" + value.slice(end);\n                    elem.selectionStart = elem.selectionEnd = start + 4;\n                    callback?.(e as unknown as preact.JSX.TargetedInputEvent<HTMLInputElement>);\n                    return;\n                }\n                if (this.elem && props.type === \"number\") {\n                    let delta = 0;\n                    let magnitude = 1;\n                    if (e.shiftKey) {\n                        if (props.integer) {\n                            magnitude = 10;\n                        } else {\n                            magnitude = 0.1;\n                        }\n                    }\n                    if (e.code === \"ArrowUp\") {\n                        delta = magnitude;\n                    } else if (e.code === \"ArrowDown\") {\n                        delta = -magnitude;\n                    }\n                    if (props.reverseArrowKeyDirection) {\n                        delta *= -1;\n                    }\n                    if (delta !== 0) {\n                        e.preventDefault();\n                        let newValue = Math.round(((+this.elem.value || 0) + delta) * 100) / 100;\n                        e.currentTarget.value = newValue.toString();\n                        callback?.(e as unknown as preact.JSX.TargetedInputEvent<HTMLInputElement>);\n                    }\n                }\n                let { noEnterKeyBlur, onInput, onChange } = props;\n                // Detach from the synced function, to prevent double calls. This is important, as apparently .blur()\n                //  synchronously triggers onChange, BUT, only if the input is changing the first time. Which means\n                //  if this function reruns, it won't trigger the change again. Detaching it causes any triggered\n                //  functions to become root synced functions, which will allow them to correctly run the sync loop.\n                void Promise.resolve().finally(() => {\n                    if (e.defaultPrevented) return;\n                    if (e.code === \"Escape\") {\n                        let changed = e.currentTarget.value !== this.onFocusText;\n                        e.currentTarget.value = this.onFocusText;\n                        if (onInput) {\n                            onInput?.(e as unknown as preact.JSX.TargetedInputEvent<HTMLInputElement>);\n                        } else if (changed) {\n                            if (onChange) {\n                                onChange?.(e);\n                            }\n                        }\n                        e.currentTarget.blur();\n                    }\n                    if (!noEnterKeyBlur && e.code === \"Enter\" && (!textarea || e.shiftKey || e.ctrlKey) || props.autocompleteValues && e.code === \"Tab\") {\n                        e.currentTarget.blur();\n                    } else if (e.ctrlKey && (e.code.startsWith(\"Key\") || e.code === \"Enter\") || e.shiftKey && e.code === \"Enter\") {\n                        onChange?.(e);\n                    }\n                });\n            },\n            onInput: e => {\n                if (props.autocompleteValues) {\n                    if (e.inputType === \"insertText\") {\n                        let curValue = e.currentTarget.value.toLowerCase();\n                        let match = props.autocompleteValues.find(x => x.toLowerCase().startsWith(curValue));\n                        if (match) {\n                            e.currentTarget.value = match || \"\";\n                            // Select the part after the previous match, so when they type, they clobber the match part\n                            let start = curValue.length;\n                            let end = e.currentTarget.value.length;\n                            e.currentTarget.selectionStart = start;\n                            e.currentTarget.selectionEnd = end;\n                        }\n                    }\n                }\n                props.onInput?.(e);\n            },\n        };\n\n\n        if (\"value\" in props && props.type !== \"checkbox\") {\n            let elem = this.elem;\n            let newValue = props.value;\n            if (!this.props.forceInputValueUpdatesWhenFocused && elem && elem === document.activeElement) {\n                newValue = elem.value;\n            }\n            attributes.value = newValue;\n            this.lastValue = String(props.value);\n        }\n        if (\"checked\" in props) {\n            this.lastChecked = !!props.checked;\n        }\n\n\n        if (attributes.type === \"number\") {\n            // Fix stuff like 55.00000000000001\n            let value = attributes.value;\n            if (typeof value === \"number\") {\n                value = niceNumberStringify(value);\n            }\n        }\n\n        // We do number handling ourselves\n        if (attributes[\"type\"] === \"number\") {\n            delete attributes[\"type\"];\n        }\n\n        if (props.type === \"checkbox\") {\n\n        } else if (hot) {\n            attributes.onInput = attributes.onChange;\n        } else {\n            // We use onChange from onBlur, so don't use the onChange handler, as preact will hook this up\n            //  with onInput, which will cause it to trigger as if the component is hot!\n            delete attributes.onChange;\n        }\n        if (textarea) {\n            return <textarea {...attributes as any} />;\n        } else {\n            return <input {...attributes} />;\n        }\n    }\n}\n\n\nfunction niceNumberStringify(valueIn: number) {\n    if (Math.abs(valueIn) < 0.0000000001) {\n        return \"0\";\n    }\n    let value = valueIn.toString();\n    // TODO: Do this MUCH better...\n    if (value.slice(0, -1).endsWith(\"00000000000\")) {\n        value = value.slice(0, -1);\n        while (value.endsWith(\"0\")) {\n            value = value.slice(0, -1);\n        }\n        if (value.endsWith(\".\")) {\n            value = value.slice(0, -1);\n        }\n        return value;\n    }\n    if (value.slice(0, -1).endsWith(\"9999999999\")) {\n        value = value.slice(0, -1);\n        while (value.endsWith(\"9\")) {\n            value = value.slice(0, -1);\n        }\n        if (value.endsWith(\".\")) {\n            value = value.slice(0, -1);\n        }\n        // NOTE: Interestingly enough... because we remove all trailing 9s, it means if the last number is not 9,\n        //  so... we can do this hack to round up\n        value = value.slice(0, -1) + (parseInt(value.slice(-1)) + 1);\n        return value;\n    }\n    return value;\n}\n"]}
+ /* _JS_SOURCE_HASH = "ead59135606a7adefa7e3d0c8ca818085281ac9c57be874a210a55d6ecc8b305"; */