mirror of
https://github.com/wailsapp/wails.git
synced 2025-05-06 20:01:37 +08:00
2b9891da2c
* Cleanup bundled runtime entry point * Fix JS representation of Screen struct * Expose IsFocused method in Window interface * Update JS window API * Fix cleanup of WML listeners * Bundle runtime as ES module * Update runtime dependencies * Update runtime types and events * Update bundled runtime * Update changelog --------- Co-authored-by: Lea Anthony <lea.anthony@gmail.com>
1566 lines
177 KiB
JavaScript
1566 lines
177 KiB
JavaScript
var __defProp = Object.defineProperty;
|
|
var __export = (target, all) => {
|
|
for (var name in all)
|
|
__defProp(target, name, { get: all[name], enumerable: true });
|
|
};
|
|
|
|
// desktop/@wailsio/runtime/src/index.js
|
|
var src_exports = {};
|
|
__export(src_exports, {
|
|
Application: () => application_exports,
|
|
Browser: () => browser_exports,
|
|
Call: () => calls_exports,
|
|
Clipboard: () => clipboard_exports,
|
|
Dialogs: () => dialogs_exports,
|
|
Events: () => events_exports,
|
|
Flags: () => flags_exports,
|
|
Screens: () => screens_exports,
|
|
System: () => system_exports,
|
|
WML: () => wml_exports,
|
|
Window: () => window_default
|
|
});
|
|
|
|
// desktop/@wailsio/runtime/src/wml.js
|
|
var wml_exports = {};
|
|
__export(wml_exports, {
|
|
Enable: () => Enable,
|
|
Reload: () => Reload
|
|
});
|
|
|
|
// desktop/@wailsio/runtime/src/browser.js
|
|
var browser_exports = {};
|
|
__export(browser_exports, {
|
|
OpenURL: () => OpenURL
|
|
});
|
|
|
|
// node_modules/nanoid/non-secure/index.js
|
|
var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
|
|
var nanoid = (size = 21) => {
|
|
let id = "";
|
|
let i = size;
|
|
while (i--) {
|
|
id += urlAlphabet[Math.random() * 64 | 0];
|
|
}
|
|
return id;
|
|
};
|
|
|
|
// desktop/@wailsio/runtime/src/runtime.js
|
|
var runtimeURL = window.location.origin + "/wails/runtime";
|
|
var objectNames = {
|
|
Call: 0,
|
|
Clipboard: 1,
|
|
Application: 2,
|
|
Events: 3,
|
|
ContextMenu: 4,
|
|
Dialog: 5,
|
|
Window: 6,
|
|
Screens: 7,
|
|
System: 8,
|
|
Browser: 9,
|
|
CancelCall: 10
|
|
};
|
|
var clientId = nanoid();
|
|
function newRuntimeCallerWithID(object, windowName) {
|
|
return function(method, args = null) {
|
|
return runtimeCallWithID(object, method, windowName, args);
|
|
};
|
|
}
|
|
function runtimeCallWithID(objectID, method, windowName, args) {
|
|
let url = new URL(runtimeURL);
|
|
url.searchParams.append("object", objectID);
|
|
url.searchParams.append("method", method);
|
|
let fetchOptions = {
|
|
headers: {}
|
|
};
|
|
if (windowName) {
|
|
fetchOptions.headers["x-wails-window-name"] = windowName;
|
|
}
|
|
if (args) {
|
|
url.searchParams.append("args", JSON.stringify(args));
|
|
}
|
|
fetchOptions.headers["x-wails-client-id"] = clientId;
|
|
return new Promise((resolve, reject) => {
|
|
fetch(url, fetchOptions).then((response) => {
|
|
if (response.ok) {
|
|
if (response.headers.get("Content-Type") && response.headers.get("Content-Type").indexOf("application/json") !== -1) {
|
|
return response.json();
|
|
} else {
|
|
return response.text();
|
|
}
|
|
}
|
|
reject(Error(response.statusText));
|
|
}).then((data) => resolve(data)).catch((error) => reject(error));
|
|
});
|
|
}
|
|
|
|
// desktop/@wailsio/runtime/src/browser.js
|
|
var call = newRuntimeCallerWithID(objectNames.Browser, "");
|
|
var BrowserOpenURL = 0;
|
|
function OpenURL(url) {
|
|
return call(BrowserOpenURL, { url });
|
|
}
|
|
|
|
// desktop/@wailsio/runtime/src/dialogs.js
|
|
var dialogs_exports = {};
|
|
__export(dialogs_exports, {
|
|
Error: () => Error2,
|
|
Info: () => Info,
|
|
OpenFile: () => OpenFile,
|
|
Question: () => Question,
|
|
SaveFile: () => SaveFile,
|
|
Warning: () => Warning
|
|
});
|
|
window._wails = window._wails || {};
|
|
window._wails.dialogErrorCallback = dialogErrorCallback;
|
|
window._wails.dialogResultCallback = dialogResultCallback;
|
|
var DialogInfo = 0;
|
|
var DialogWarning = 1;
|
|
var DialogError = 2;
|
|
var DialogQuestion = 3;
|
|
var DialogOpenFile = 4;
|
|
var DialogSaveFile = 5;
|
|
var call2 = newRuntimeCallerWithID(objectNames.Dialog, "");
|
|
var dialogResponses = /* @__PURE__ */ new Map();
|
|
function generateID() {
|
|
let result;
|
|
do {
|
|
result = nanoid();
|
|
} while (dialogResponses.has(result));
|
|
return result;
|
|
}
|
|
function dialog(type, options = {}) {
|
|
const id = generateID();
|
|
options["dialog-id"] = id;
|
|
return new Promise((resolve, reject) => {
|
|
dialogResponses.set(id, { resolve, reject });
|
|
call2(type, options).catch((error) => {
|
|
reject(error);
|
|
dialogResponses.delete(id);
|
|
});
|
|
});
|
|
}
|
|
function dialogResultCallback(id, data, isJSON) {
|
|
let p = dialogResponses.get(id);
|
|
if (p) {
|
|
if (isJSON) {
|
|
p.resolve(JSON.parse(data));
|
|
} else {
|
|
p.resolve(data);
|
|
}
|
|
dialogResponses.delete(id);
|
|
}
|
|
}
|
|
function dialogErrorCallback(id, message) {
|
|
let p = dialogResponses.get(id);
|
|
if (p) {
|
|
p.reject(message);
|
|
dialogResponses.delete(id);
|
|
}
|
|
}
|
|
var Info = (options) => dialog(DialogInfo, options);
|
|
var Warning = (options) => dialog(DialogWarning, options);
|
|
var Error2 = (options) => dialog(DialogError, options);
|
|
var Question = (options) => dialog(DialogQuestion, options);
|
|
var OpenFile = (options) => dialog(DialogOpenFile, options);
|
|
var SaveFile = (options) => dialog(DialogSaveFile, options);
|
|
|
|
// desktop/@wailsio/runtime/src/events.js
|
|
var events_exports = {};
|
|
__export(events_exports, {
|
|
Emit: () => Emit,
|
|
Off: () => Off,
|
|
OffAll: () => OffAll,
|
|
On: () => On,
|
|
OnMultiple: () => OnMultiple,
|
|
Once: () => Once,
|
|
Types: () => Types,
|
|
WailsEvent: () => WailsEvent,
|
|
setup: () => setup
|
|
});
|
|
|
|
// desktop/@wailsio/runtime/src/event_types.js
|
|
var EventTypes = {
|
|
Windows: {
|
|
SystemThemeChanged: "windows:SystemThemeChanged",
|
|
APMPowerStatusChange: "windows:APMPowerStatusChange",
|
|
APMSuspend: "windows:APMSuspend",
|
|
APMResumeAutomatic: "windows:APMResumeAutomatic",
|
|
APMResumeSuspend: "windows:APMResumeSuspend",
|
|
APMPowerSettingChange: "windows:APMPowerSettingChange",
|
|
ApplicationStarted: "windows:ApplicationStarted",
|
|
WebViewNavigationCompleted: "windows:WebViewNavigationCompleted",
|
|
WindowInactive: "windows:WindowInactive",
|
|
WindowActive: "windows:WindowActive",
|
|
WindowClickActive: "windows:WindowClickActive",
|
|
WindowMaximise: "windows:WindowMaximise",
|
|
WindowUnMaximise: "windows:WindowUnMaximise",
|
|
WindowFullscreen: "windows:WindowFullscreen",
|
|
WindowUnFullscreen: "windows:WindowUnFullscreen",
|
|
WindowRestore: "windows:WindowRestore",
|
|
WindowMinimise: "windows:WindowMinimise",
|
|
WindowUnMinimise: "windows:WindowUnMinimise",
|
|
WindowClose: "windows:WindowClose",
|
|
WindowSetFocus: "windows:WindowSetFocus",
|
|
WindowKillFocus: "windows:WindowKillFocus",
|
|
WindowDragDrop: "windows:WindowDragDrop",
|
|
WindowDragEnter: "windows:WindowDragEnter",
|
|
WindowDragLeave: "windows:WindowDragLeave",
|
|
WindowDragOver: "windows:WindowDragOver"
|
|
},
|
|
Mac: {
|
|
ApplicationDidBecomeActive: "mac:ApplicationDidBecomeActive",
|
|
ApplicationDidChangeBackingProperties: "mac:ApplicationDidChangeBackingProperties",
|
|
ApplicationDidChangeEffectiveAppearance: "mac:ApplicationDidChangeEffectiveAppearance",
|
|
ApplicationDidChangeIcon: "mac:ApplicationDidChangeIcon",
|
|
ApplicationDidChangeOcclusionState: "mac:ApplicationDidChangeOcclusionState",
|
|
ApplicationDidChangeScreenParameters: "mac:ApplicationDidChangeScreenParameters",
|
|
ApplicationDidChangeStatusBarFrame: "mac:ApplicationDidChangeStatusBarFrame",
|
|
ApplicationDidChangeStatusBarOrientation: "mac:ApplicationDidChangeStatusBarOrientation",
|
|
ApplicationDidFinishLaunching: "mac:ApplicationDidFinishLaunching",
|
|
ApplicationDidHide: "mac:ApplicationDidHide",
|
|
ApplicationDidResignActiveNotification: "mac:ApplicationDidResignActiveNotification",
|
|
ApplicationDidUnhide: "mac:ApplicationDidUnhide",
|
|
ApplicationDidUpdate: "mac:ApplicationDidUpdate",
|
|
ApplicationWillBecomeActive: "mac:ApplicationWillBecomeActive",
|
|
ApplicationWillFinishLaunching: "mac:ApplicationWillFinishLaunching",
|
|
ApplicationWillHide: "mac:ApplicationWillHide",
|
|
ApplicationWillResignActive: "mac:ApplicationWillResignActive",
|
|
ApplicationWillTerminate: "mac:ApplicationWillTerminate",
|
|
ApplicationWillUnhide: "mac:ApplicationWillUnhide",
|
|
ApplicationWillUpdate: "mac:ApplicationWillUpdate",
|
|
ApplicationDidChangeTheme: "mac:ApplicationDidChangeTheme!",
|
|
ApplicationShouldHandleReopen: "mac:ApplicationShouldHandleReopen!",
|
|
WindowDidBecomeKey: "mac:WindowDidBecomeKey",
|
|
WindowDidBecomeMain: "mac:WindowDidBecomeMain",
|
|
WindowDidBeginSheet: "mac:WindowDidBeginSheet",
|
|
WindowDidChangeAlpha: "mac:WindowDidChangeAlpha",
|
|
WindowDidChangeBackingLocation: "mac:WindowDidChangeBackingLocation",
|
|
WindowDidChangeBackingProperties: "mac:WindowDidChangeBackingProperties",
|
|
WindowDidChangeCollectionBehavior: "mac:WindowDidChangeCollectionBehavior",
|
|
WindowDidChangeEffectiveAppearance: "mac:WindowDidChangeEffectiveAppearance",
|
|
WindowDidChangeOcclusionState: "mac:WindowDidChangeOcclusionState",
|
|
WindowDidChangeOrderingMode: "mac:WindowDidChangeOrderingMode",
|
|
WindowDidChangeScreen: "mac:WindowDidChangeScreen",
|
|
WindowDidChangeScreenParameters: "mac:WindowDidChangeScreenParameters",
|
|
WindowDidChangeScreenProfile: "mac:WindowDidChangeScreenProfile",
|
|
WindowDidChangeScreenSpace: "mac:WindowDidChangeScreenSpace",
|
|
WindowDidChangeScreenSpaceProperties: "mac:WindowDidChangeScreenSpaceProperties",
|
|
WindowDidChangeSharingType: "mac:WindowDidChangeSharingType",
|
|
WindowDidChangeSpace: "mac:WindowDidChangeSpace",
|
|
WindowDidChangeSpaceOrderingMode: "mac:WindowDidChangeSpaceOrderingMode",
|
|
WindowDidChangeTitle: "mac:WindowDidChangeTitle",
|
|
WindowDidChangeToolbar: "mac:WindowDidChangeToolbar",
|
|
WindowDidChangeVisibility: "mac:WindowDidChangeVisibility",
|
|
WindowDidDeminiaturize: "mac:WindowDidDeminiaturize",
|
|
WindowDidEndSheet: "mac:WindowDidEndSheet",
|
|
WindowDidEnterFullScreen: "mac:WindowDidEnterFullScreen",
|
|
WindowDidEnterVersionBrowser: "mac:WindowDidEnterVersionBrowser",
|
|
WindowDidExitFullScreen: "mac:WindowDidExitFullScreen",
|
|
WindowDidExitVersionBrowser: "mac:WindowDidExitVersionBrowser",
|
|
WindowDidExpose: "mac:WindowDidExpose",
|
|
WindowDidFocus: "mac:WindowDidFocus",
|
|
WindowDidMiniaturize: "mac:WindowDidMiniaturize",
|
|
WindowDidMove: "mac:WindowDidMove",
|
|
WindowDidOrderOffScreen: "mac:WindowDidOrderOffScreen",
|
|
WindowDidOrderOnScreen: "mac:WindowDidOrderOnScreen",
|
|
WindowDidResignKey: "mac:WindowDidResignKey",
|
|
WindowDidResignMain: "mac:WindowDidResignMain",
|
|
WindowDidResize: "mac:WindowDidResize",
|
|
WindowDidUpdate: "mac:WindowDidUpdate",
|
|
WindowDidUpdateAlpha: "mac:WindowDidUpdateAlpha",
|
|
WindowDidUpdateCollectionBehavior: "mac:WindowDidUpdateCollectionBehavior",
|
|
WindowDidUpdateCollectionProperties: "mac:WindowDidUpdateCollectionProperties",
|
|
WindowDidUpdateShadow: "mac:WindowDidUpdateShadow",
|
|
WindowDidUpdateTitle: "mac:WindowDidUpdateTitle",
|
|
WindowDidUpdateToolbar: "mac:WindowDidUpdateToolbar",
|
|
WindowDidUpdateVisibility: "mac:WindowDidUpdateVisibility",
|
|
WindowShouldClose: "mac:WindowShouldClose!",
|
|
WindowWillBecomeKey: "mac:WindowWillBecomeKey",
|
|
WindowWillBecomeMain: "mac:WindowWillBecomeMain",
|
|
WindowWillBeginSheet: "mac:WindowWillBeginSheet",
|
|
WindowWillChangeOrderingMode: "mac:WindowWillChangeOrderingMode",
|
|
WindowWillClose: "mac:WindowWillClose",
|
|
WindowWillDeminiaturize: "mac:WindowWillDeminiaturize",
|
|
WindowWillEnterFullScreen: "mac:WindowWillEnterFullScreen",
|
|
WindowWillEnterVersionBrowser: "mac:WindowWillEnterVersionBrowser",
|
|
WindowWillExitFullScreen: "mac:WindowWillExitFullScreen",
|
|
WindowWillExitVersionBrowser: "mac:WindowWillExitVersionBrowser",
|
|
WindowWillFocus: "mac:WindowWillFocus",
|
|
WindowWillMiniaturize: "mac:WindowWillMiniaturize",
|
|
WindowWillMove: "mac:WindowWillMove",
|
|
WindowWillOrderOffScreen: "mac:WindowWillOrderOffScreen",
|
|
WindowWillOrderOnScreen: "mac:WindowWillOrderOnScreen",
|
|
WindowWillResignMain: "mac:WindowWillResignMain",
|
|
WindowWillResize: "mac:WindowWillResize",
|
|
WindowWillUnfocus: "mac:WindowWillUnfocus",
|
|
WindowWillUpdate: "mac:WindowWillUpdate",
|
|
WindowWillUpdateAlpha: "mac:WindowWillUpdateAlpha",
|
|
WindowWillUpdateCollectionBehavior: "mac:WindowWillUpdateCollectionBehavior",
|
|
WindowWillUpdateCollectionProperties: "mac:WindowWillUpdateCollectionProperties",
|
|
WindowWillUpdateShadow: "mac:WindowWillUpdateShadow",
|
|
WindowWillUpdateTitle: "mac:WindowWillUpdateTitle",
|
|
WindowWillUpdateToolbar: "mac:WindowWillUpdateToolbar",
|
|
WindowWillUpdateVisibility: "mac:WindowWillUpdateVisibility",
|
|
WindowWillUseStandardFrame: "mac:WindowWillUseStandardFrame",
|
|
MenuWillOpen: "mac:MenuWillOpen",
|
|
MenuDidOpen: "mac:MenuDidOpen",
|
|
MenuDidClose: "mac:MenuDidClose",
|
|
MenuWillSendAction: "mac:MenuWillSendAction",
|
|
MenuDidSendAction: "mac:MenuDidSendAction",
|
|
MenuWillHighlightItem: "mac:MenuWillHighlightItem",
|
|
MenuDidHighlightItem: "mac:MenuDidHighlightItem",
|
|
MenuWillDisplayItem: "mac:MenuWillDisplayItem",
|
|
MenuDidDisplayItem: "mac:MenuDidDisplayItem",
|
|
MenuWillAddItem: "mac:MenuWillAddItem",
|
|
MenuDidAddItem: "mac:MenuDidAddItem",
|
|
MenuWillRemoveItem: "mac:MenuWillRemoveItem",
|
|
MenuDidRemoveItem: "mac:MenuDidRemoveItem",
|
|
MenuWillBeginTracking: "mac:MenuWillBeginTracking",
|
|
MenuDidBeginTracking: "mac:MenuDidBeginTracking",
|
|
MenuWillEndTracking: "mac:MenuWillEndTracking",
|
|
MenuDidEndTracking: "mac:MenuDidEndTracking",
|
|
MenuWillUpdate: "mac:MenuWillUpdate",
|
|
MenuDidUpdate: "mac:MenuDidUpdate",
|
|
MenuWillPopUp: "mac:MenuWillPopUp",
|
|
MenuDidPopUp: "mac:MenuDidPopUp",
|
|
MenuWillSendActionToItem: "mac:MenuWillSendActionToItem",
|
|
MenuDidSendActionToItem: "mac:MenuDidSendActionToItem",
|
|
WebViewDidStartProvisionalNavigation: "mac:WebViewDidStartProvisionalNavigation",
|
|
WebViewDidReceiveServerRedirectForProvisionalNavigation: "mac:WebViewDidReceiveServerRedirectForProvisionalNavigation",
|
|
WebViewDidFinishNavigation: "mac:WebViewDidFinishNavigation",
|
|
WebViewDidCommitNavigation: "mac:WebViewDidCommitNavigation",
|
|
WindowFileDraggingEntered: "mac:WindowFileDraggingEntered",
|
|
WindowFileDraggingPerformed: "mac:WindowFileDraggingPerformed",
|
|
WindowFileDraggingExited: "mac:WindowFileDraggingExited"
|
|
},
|
|
Linux: {
|
|
SystemThemeChanged: "linux:SystemThemeChanged",
|
|
WindowLoadChanged: "linux:WindowLoadChanged",
|
|
WindowDeleteEvent: "linux:WindowDeleteEvent",
|
|
WindowFocusIn: "linux:WindowFocusIn",
|
|
WindowFocusOut: "linux:WindowFocusOut",
|
|
ApplicationStartup: "linux:ApplicationStartup"
|
|
},
|
|
Common: {
|
|
ApplicationStarted: "common:ApplicationStarted",
|
|
WindowMaximise: "common:WindowMaximise",
|
|
WindowUnMaximise: "common:WindowUnMaximise",
|
|
WindowFullscreen: "common:WindowFullscreen",
|
|
WindowUnFullscreen: "common:WindowUnFullscreen",
|
|
WindowRestore: "common:WindowRestore",
|
|
WindowMinimise: "common:WindowMinimise",
|
|
WindowUnMinimise: "common:WindowUnMinimise",
|
|
WindowClosing: "common:WindowClosing",
|
|
WindowZoom: "common:WindowZoom",
|
|
WindowZoomIn: "common:WindowZoomIn",
|
|
WindowZoomOut: "common:WindowZoomOut",
|
|
WindowZoomReset: "common:WindowZoomReset",
|
|
WindowFocus: "common:WindowFocus",
|
|
WindowLostFocus: "common:WindowLostFocus",
|
|
WindowShow: "common:WindowShow",
|
|
WindowHide: "common:WindowHide",
|
|
WindowDPIChanged: "common:WindowDPIChanged",
|
|
WindowFilesDropped: "common:WindowFilesDropped",
|
|
WindowRuntimeReady: "common:WindowRuntimeReady",
|
|
ThemeChanged: "common:ThemeChanged"
|
|
}
|
|
};
|
|
|
|
// desktop/@wailsio/runtime/src/events.js
|
|
var Types = EventTypes;
|
|
window._wails = window._wails || {};
|
|
window._wails.dispatchWailsEvent = dispatchWailsEvent;
|
|
var call3 = newRuntimeCallerWithID(objectNames.Events, "");
|
|
var EmitMethod = 0;
|
|
var eventListeners = /* @__PURE__ */ new Map();
|
|
var Listener = class {
|
|
constructor(eventName, callback, maxCallbacks) {
|
|
this.eventName = eventName;
|
|
this.maxCallbacks = maxCallbacks || -1;
|
|
this.Callback = (data) => {
|
|
callback(data);
|
|
if (this.maxCallbacks === -1)
|
|
return false;
|
|
this.maxCallbacks -= 1;
|
|
return this.maxCallbacks === 0;
|
|
};
|
|
}
|
|
};
|
|
var WailsEvent = class {
|
|
constructor(name, data = null) {
|
|
this.name = name;
|
|
this.data = data;
|
|
}
|
|
};
|
|
function setup() {
|
|
}
|
|
function dispatchWailsEvent(event) {
|
|
let listeners = eventListeners.get(event.name);
|
|
if (listeners) {
|
|
let toRemove = listeners.filter((listener) => {
|
|
let remove = listener.Callback(event);
|
|
if (remove)
|
|
return true;
|
|
});
|
|
if (toRemove.length > 0) {
|
|
listeners = listeners.filter((l) => !toRemove.includes(l));
|
|
if (listeners.length === 0)
|
|
eventListeners.delete(event.name);
|
|
else
|
|
eventListeners.set(event.name, listeners);
|
|
}
|
|
}
|
|
}
|
|
function OnMultiple(eventName, callback, maxCallbacks) {
|
|
let listeners = eventListeners.get(eventName) || [];
|
|
const thisListener = new Listener(eventName, callback, maxCallbacks);
|
|
listeners.push(thisListener);
|
|
eventListeners.set(eventName, listeners);
|
|
return () => listenerOff(thisListener);
|
|
}
|
|
function On(eventName, callback) {
|
|
return OnMultiple(eventName, callback, -1);
|
|
}
|
|
function Once(eventName, callback) {
|
|
return OnMultiple(eventName, callback, 1);
|
|
}
|
|
function listenerOff(listener) {
|
|
const eventName = listener.eventName;
|
|
let listeners = eventListeners.get(eventName).filter((l) => l !== listener);
|
|
if (listeners.length === 0)
|
|
eventListeners.delete(eventName);
|
|
else
|
|
eventListeners.set(eventName, listeners);
|
|
}
|
|
function Off(eventName, ...additionalEventNames) {
|
|
let eventsToRemove = [eventName, ...additionalEventNames];
|
|
eventsToRemove.forEach((eventName2) => eventListeners.delete(eventName2));
|
|
}
|
|
function OffAll() {
|
|
eventListeners.clear();
|
|
}
|
|
function Emit(event) {
|
|
return call3(EmitMethod, event);
|
|
}
|
|
|
|
// desktop/@wailsio/runtime/src/utils.js
|
|
function debugLog(message) {
|
|
console.log(
|
|
"%c wails3 %c " + message + " ",
|
|
"background: #aa0000; color: #fff; border-radius: 3px 0px 0px 3px; padding: 1px; font-size: 0.7rem",
|
|
"background: #009900; color: #fff; border-radius: 0px 3px 3px 0px; padding: 1px; font-size: 0.7rem"
|
|
);
|
|
}
|
|
function canAbortListeners() {
|
|
if (!EventTarget || !AbortSignal || !AbortController)
|
|
return false;
|
|
let result = true;
|
|
const target = new EventTarget();
|
|
const controller = new AbortController();
|
|
target.addEventListener("test", () => {
|
|
result = false;
|
|
}, { signal: controller.signal });
|
|
controller.abort();
|
|
target.dispatchEvent(new CustomEvent("test"));
|
|
return result;
|
|
}
|
|
var isReady = false;
|
|
document.addEventListener("DOMContentLoaded", () => isReady = true);
|
|
function whenReady(callback) {
|
|
if (isReady || document.readyState === "complete") {
|
|
callback();
|
|
} else {
|
|
document.addEventListener("DOMContentLoaded", callback);
|
|
}
|
|
}
|
|
|
|
// desktop/@wailsio/runtime/src/window.js
|
|
var AbsolutePositionMethod = 0;
|
|
var CenterMethod = 1;
|
|
var CloseMethod = 2;
|
|
var DisableSizeConstraintsMethod = 3;
|
|
var EnableSizeConstraintsMethod = 4;
|
|
var FocusMethod = 5;
|
|
var ForceReloadMethod = 6;
|
|
var FullscreenMethod = 7;
|
|
var GetScreenMethod = 8;
|
|
var GetZoomMethod = 9;
|
|
var HeightMethod = 10;
|
|
var HideMethod = 11;
|
|
var IsFocusedMethod = 12;
|
|
var IsFullscreenMethod = 13;
|
|
var IsMaximisedMethod = 14;
|
|
var IsMinimisedMethod = 15;
|
|
var MaximiseMethod = 16;
|
|
var MinimiseMethod = 17;
|
|
var NameMethod = 18;
|
|
var OpenDevToolsMethod = 19;
|
|
var RelativePositionMethod = 20;
|
|
var ReloadMethod = 21;
|
|
var ResizableMethod = 22;
|
|
var RestoreMethod = 23;
|
|
var SetAbsolutePositionMethod = 24;
|
|
var SetAlwaysOnTopMethod = 25;
|
|
var SetBackgroundColourMethod = 26;
|
|
var SetFramelessMethod = 27;
|
|
var SetFullscreenButtonEnabledMethod = 28;
|
|
var SetMaxSizeMethod = 29;
|
|
var SetMinSizeMethod = 30;
|
|
var SetRelativePositionMethod = 31;
|
|
var SetResizableMethod = 32;
|
|
var SetSizeMethod = 33;
|
|
var SetTitleMethod = 34;
|
|
var SetZoomMethod = 35;
|
|
var ShowMethod = 36;
|
|
var SizeMethod = 37;
|
|
var ToggleFullscreenMethod = 38;
|
|
var ToggleMaximiseMethod = 39;
|
|
var UnFullscreenMethod = 40;
|
|
var UnMaximiseMethod = 41;
|
|
var UnMinimiseMethod = 42;
|
|
var WidthMethod = 43;
|
|
var ZoomMethod = 44;
|
|
var ZoomInMethod = 45;
|
|
var ZoomOutMethod = 46;
|
|
var ZoomResetMethod = 47;
|
|
var Window = class _Window {
|
|
/**
|
|
* @private
|
|
* @type {(...args: any[]) => any}
|
|
*/
|
|
#call = null;
|
|
/**
|
|
* Initialises a window object with the specified name.
|
|
*
|
|
* @private
|
|
* @param {string} name - The name of the target window.
|
|
*/
|
|
constructor(name = "") {
|
|
this.#call = newRuntimeCallerWithID(objectNames.Window, name);
|
|
for (const method of Object.getOwnPropertyNames(_Window.prototype)) {
|
|
if (method !== "constructor" && typeof this[method] === "function") {
|
|
this[method] = this[method].bind(this);
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Gets the specified window.
|
|
*
|
|
* @public
|
|
* @param {string} name - The name of the window to get.
|
|
* @return {Window} - The corresponding window object.
|
|
*/
|
|
Get(name) {
|
|
return new _Window(name);
|
|
}
|
|
/**
|
|
* Returns the absolute position of the window to the screen.
|
|
*
|
|
* @public
|
|
* @return {Promise<Position>} - The current absolute position of the window.
|
|
*/
|
|
AbsolutePosition() {
|
|
return this.#call(AbsolutePositionMethod);
|
|
}
|
|
/**
|
|
* Centers the window on the screen.
|
|
*
|
|
* @public
|
|
* @return {Promise<void>}
|
|
*/
|
|
Center() {
|
|
return this.#call(CenterMethod);
|
|
}
|
|
/**
|
|
* Closes the window.
|
|
*
|
|
* @public
|
|
* @return {Promise<void>}
|
|
*/
|
|
Close() {
|
|
return this.#call(CloseMethod);
|
|
}
|
|
/**
|
|
* Disables min/max size constraints.
|
|
*
|
|
* @public
|
|
* @return {Promise<void>}
|
|
*/
|
|
DisableSizeConstraints() {
|
|
return this.#call(DisableSizeConstraintsMethod);
|
|
}
|
|
/**
|
|
* Enables min/max size constraints.
|
|
*
|
|
* @public
|
|
* @return {Promise<void>}
|
|
*/
|
|
EnableSizeConstraints() {
|
|
return this.#call(EnableSizeConstraintsMethod);
|
|
}
|
|
/**
|
|
* Focuses the window.
|
|
*
|
|
* @public
|
|
* @return {Promise<void>}
|
|
*/
|
|
Focus() {
|
|
return this.#call(FocusMethod);
|
|
}
|
|
/**
|
|
* Forces the window to reload the page assets.
|
|
*
|
|
* @public
|
|
* @return {Promise<void>}
|
|
*/
|
|
ForceReload() {
|
|
return this.#call(ForceReloadMethod);
|
|
}
|
|
/**
|
|
* Doc.
|
|
*
|
|
* @public
|
|
* @return {Promise<void>}
|
|
*/
|
|
Fullscreen() {
|
|
return this.#call(FullscreenMethod);
|
|
}
|
|
/**
|
|
* Returns the screen that the window is on.
|
|
*
|
|
* @public
|
|
* @return {Promise<Screen>} - The screen the window is currently on
|
|
*/
|
|
GetScreen() {
|
|
return this.#call(GetScreenMethod);
|
|
}
|
|
/**
|
|
* Returns the current zoom level of the window.
|
|
*
|
|
* @public
|
|
* @return {Promise<number>} - The current zoom level
|
|
*/
|
|
GetZoom() {
|
|
return this.#call(GetZoomMethod);
|
|
}
|
|
/**
|
|
* Returns the height of the window.
|
|
*
|
|
* @public
|
|
* @return {Promise<number>} - The current height of the window
|
|
*/
|
|
Height() {
|
|
return this.#call(HeightMethod);
|
|
}
|
|
/**
|
|
* Hides the window.
|
|
*
|
|
* @public
|
|
* @return {Promise<void>}
|
|
*/
|
|
Hide() {
|
|
return this.#call(HideMethod);
|
|
}
|
|
/**
|
|
* Returns true if the window is focused.
|
|
*
|
|
* @public
|
|
* @return {Promise<boolean>} - Whether the window is currently focused
|
|
*/
|
|
IsFocused() {
|
|
return this.#call(IsFocusedMethod);
|
|
}
|
|
/**
|
|
* Returns true if the window is fullscreen.
|
|
*
|
|
* @public
|
|
* @return {Promise<boolean>} - Whether the window is currently fullscreen
|
|
*/
|
|
IsFullscreen() {
|
|
return this.#call(IsFullscreenMethod);
|
|
}
|
|
/**
|
|
* Returns true if the window is maximised.
|
|
*
|
|
* @public
|
|
* @return {Promise<boolean>} - Whether the window is currently maximised
|
|
*/
|
|
IsMaximised() {
|
|
return this.#call(IsMaximisedMethod);
|
|
}
|
|
/**
|
|
* Returns true if the window is minimised.
|
|
*
|
|
* @public
|
|
* @return {Promise<boolean>} - Whether the window is currently minimised
|
|
*/
|
|
IsMinimised() {
|
|
return this.#call(IsMinimisedMethod);
|
|
}
|
|
/**
|
|
* Maximises the window.
|
|
*
|
|
* @public
|
|
* @return {Promise<void>}
|
|
*/
|
|
Maximise() {
|
|
return this.#call(MaximiseMethod);
|
|
}
|
|
/**
|
|
* Minimises the window.
|
|
*
|
|
* @public
|
|
* @return {Promise<void>}
|
|
*/
|
|
Minimise() {
|
|
return this.#call(MinimiseMethod);
|
|
}
|
|
/**
|
|
* Returns the name of the window.
|
|
*
|
|
* @public
|
|
* @return {Promise<string>} - The name of the window
|
|
*/
|
|
Name() {
|
|
return this.#call(NameMethod);
|
|
}
|
|
/**
|
|
* Opens the development tools pane.
|
|
*
|
|
* @public
|
|
* @return {Promise<void>}
|
|
*/
|
|
OpenDevTools() {
|
|
return this.#call(OpenDevToolsMethod);
|
|
}
|
|
/**
|
|
* Returns the relative position of the window to the screen.
|
|
*
|
|
* @public
|
|
* @return {Promise<Position>} - The current relative position of the window
|
|
*/
|
|
RelativePosition() {
|
|
return this.#call(RelativePositionMethod);
|
|
}
|
|
/**
|
|
* Reloads the page assets.
|
|
*
|
|
* @public
|
|
* @return {Promise<void>}
|
|
*/
|
|
Reload() {
|
|
return this.#call(ReloadMethod);
|
|
}
|
|
/**
|
|
* Returns true if the window is resizable.
|
|
*
|
|
* @public
|
|
* @return {Promise<boolean>} - Whether the window is currently resizable
|
|
*/
|
|
Resizable() {
|
|
return this.#call(ResizableMethod);
|
|
}
|
|
/**
|
|
* Restores the window to its previous state if it was previously minimised, maximised or fullscreen.
|
|
*
|
|
* @public
|
|
* @return {Promise<void>}
|
|
*/
|
|
Restore() {
|
|
return this.#call(RestoreMethod);
|
|
}
|
|
/**
|
|
* Sets the absolute position of the window to the screen.
|
|
*
|
|
* @public
|
|
* @param {number} x - The desired horizontal absolute position of the window
|
|
* @param {number} y - The desired vertical absolute position of the window
|
|
* @return {Promise<void>}
|
|
*/
|
|
SetAbsolutePosition(x, y) {
|
|
return this.#call(SetAbsolutePositionMethod, { x, y });
|
|
}
|
|
/**
|
|
* Sets the window to be always on top.
|
|
*
|
|
* @public
|
|
* @param {boolean} alwaysOnTop - Whether the window should stay on top
|
|
* @return {Promise<void>}
|
|
*/
|
|
SetAlwaysOnTop(alwaysOnTop) {
|
|
return this.#call(SetAlwaysOnTopMethod, { alwaysOnTop });
|
|
}
|
|
/**
|
|
* Sets the background colour of the window.
|
|
*
|
|
* @public
|
|
* @param {number} r - The desired red component of the window background
|
|
* @param {number} g - The desired green component of the window background
|
|
* @param {number} b - The desired blue component of the window background
|
|
* @param {number} a - The desired alpha component of the window background
|
|
* @return {Promise<void>}
|
|
*/
|
|
SetBackgroundColour(r, g, b, a) {
|
|
return this.#call(SetBackgroundColourMethod, { r, g, b, a });
|
|
}
|
|
/**
|
|
* Removes the window frame and title bar.
|
|
*
|
|
* @public
|
|
* @param {boolean} frameless - Whether the window should be frameless
|
|
* @return {Promise<void>}
|
|
*/
|
|
SetFrameless(frameless) {
|
|
return this.#call(SetFramelessMethod, { frameless });
|
|
}
|
|
/**
|
|
* Disables the system fullscreen button.
|
|
*
|
|
* @public
|
|
* @param {boolean} enabled - Whether the fullscreen button should be enabled
|
|
* @return {Promise<void>}
|
|
*/
|
|
SetFullscreenButtonEnabled(enabled) {
|
|
return this.#call(SetFullscreenButtonEnabledMethod, { enabled });
|
|
}
|
|
/**
|
|
* Sets the maximum size of the window.
|
|
*
|
|
* @public
|
|
* @param {number} width - The desired maximum width of the window
|
|
* @param {number} height - The desired maximum height of the window
|
|
* @return {Promise<void>}
|
|
*/
|
|
SetMaxSize(width, height) {
|
|
return this.#call(SetMaxSizeMethod, { width, height });
|
|
}
|
|
/**
|
|
* Sets the minimum size of the window.
|
|
*
|
|
* @public
|
|
* @param {number} width - The desired minimum width of the window
|
|
* @param {number} height - The desired minimum height of the window
|
|
* @return {Promise<void>}
|
|
*/
|
|
SetMinSize(width, height) {
|
|
return this.#call(SetMinSizeMethod, { width, height });
|
|
}
|
|
/**
|
|
* Sets the relative position of the window to the screen.
|
|
*
|
|
* @public
|
|
* @param {number} x - The desired horizontal relative position of the window
|
|
* @param {number} y - The desired vertical relative position of the window
|
|
* @return {Promise<void>}
|
|
*/
|
|
SetRelativePosition(x, y) {
|
|
return this.#call(SetRelativePositionMethod, { x, y });
|
|
}
|
|
/**
|
|
* Sets whether the window is resizable.
|
|
*
|
|
* @public
|
|
* @param {boolean} resizable - Whether the window should be resizable
|
|
* @return {Promise<void>}
|
|
*/
|
|
SetResizable(resizable2) {
|
|
return this.#call(SetResizableMethod, { resizable: resizable2 });
|
|
}
|
|
/**
|
|
* Sets the size of the window.
|
|
*
|
|
* @public
|
|
* @param {number} width - The desired width of the window
|
|
* @param {number} height - The desired height of the window
|
|
* @return {Promise<void>}
|
|
*/
|
|
SetSize(width, height) {
|
|
return this.#call(SetSizeMethod, { width, height });
|
|
}
|
|
/**
|
|
* Sets the title of the window.
|
|
*
|
|
* @public
|
|
* @param {string} title - The desired title of the window
|
|
* @return {Promise<void>}
|
|
*/
|
|
SetTitle(title) {
|
|
return this.#call(SetTitleMethod, { title });
|
|
}
|
|
/**
|
|
* Sets the zoom level of the window.
|
|
*
|
|
* @public
|
|
* @param {number} zoom - The desired zoom level
|
|
* @return {Promise<void>}
|
|
*/
|
|
SetZoom(zoom) {
|
|
return this.#call(SetZoomMethod, { zoom });
|
|
}
|
|
/**
|
|
* Shows the window.
|
|
*
|
|
* @public
|
|
* @return {Promise<void>}
|
|
*/
|
|
Show() {
|
|
return this.#call(ShowMethod);
|
|
}
|
|
/**
|
|
* Returns the size of the window.
|
|
*
|
|
* @public
|
|
* @return {Promise<Size>} - The current size of the window
|
|
*/
|
|
Size() {
|
|
return this.#call(SizeMethod);
|
|
}
|
|
/**
|
|
* Toggles the window between fullscreen and normal.
|
|
*
|
|
* @public
|
|
* @return {Promise<void>}
|
|
*/
|
|
ToggleFullscreen() {
|
|
return this.#call(ToggleFullscreenMethod);
|
|
}
|
|
/**
|
|
* Toggles the window between maximised and normal.
|
|
*
|
|
* @public
|
|
* @return {Promise<void>}
|
|
*/
|
|
ToggleMaximise() {
|
|
return this.#call(ToggleMaximiseMethod);
|
|
}
|
|
/**
|
|
* Un-fullscreens the window.
|
|
*
|
|
* @public
|
|
* @return {Promise<void>}
|
|
*/
|
|
UnFullscreen() {
|
|
return this.#call(UnFullscreenMethod);
|
|
}
|
|
/**
|
|
* Un-maximises the window.
|
|
*
|
|
* @public
|
|
* @return {Promise<void>}
|
|
*/
|
|
UnMaximise() {
|
|
return this.#call(UnMaximiseMethod);
|
|
}
|
|
/**
|
|
* Un-minimises the window.
|
|
*
|
|
* @public
|
|
* @return {Promise<void>}
|
|
*/
|
|
UnMinimise() {
|
|
return this.#call(UnMinimiseMethod);
|
|
}
|
|
/**
|
|
* Returns the width of the window.
|
|
*
|
|
* @public
|
|
* @return {Promise<number>} - The current width of the window
|
|
*/
|
|
Width() {
|
|
return this.#call(WidthMethod);
|
|
}
|
|
/**
|
|
* Zooms the window.
|
|
*
|
|
* @public
|
|
* @return {Promise<void>}
|
|
*/
|
|
Zoom() {
|
|
return this.#call(ZoomMethod);
|
|
}
|
|
/**
|
|
* Increases the zoom level of the webview content.
|
|
*
|
|
* @public
|
|
* @return {Promise<void>}
|
|
*/
|
|
ZoomIn() {
|
|
return this.#call(ZoomInMethod);
|
|
}
|
|
/**
|
|
* Decreases the zoom level of the webview content.
|
|
*
|
|
* @public
|
|
* @return {Promise<void>}
|
|
*/
|
|
ZoomOut() {
|
|
return this.#call(ZoomOutMethod);
|
|
}
|
|
/**
|
|
* Resets the zoom level of the webview content.
|
|
*
|
|
* @public
|
|
* @return {Promise<void>}
|
|
*/
|
|
ZoomReset() {
|
|
return this.#call(ZoomResetMethod);
|
|
}
|
|
};
|
|
var thisWindow = new Window("");
|
|
var window_default = thisWindow;
|
|
|
|
// desktop/@wailsio/runtime/src/wml.js
|
|
function sendEvent(eventName, data = null) {
|
|
Emit(new WailsEvent(eventName, data));
|
|
}
|
|
function callWindowMethod(windowName, methodName) {
|
|
const targetWindow = window_default.Get(windowName);
|
|
const method = targetWindow[methodName];
|
|
if (typeof method !== "function") {
|
|
console.error(`Window method '${methodName}' not found`);
|
|
return;
|
|
}
|
|
try {
|
|
method.call(targetWindow);
|
|
} catch (e) {
|
|
console.error(`Error calling window method '${methodName}': `, e);
|
|
}
|
|
}
|
|
function onWMLTriggered(ev) {
|
|
const element = ev.currentTarget;
|
|
function runEffect(choice = "Yes") {
|
|
if (choice !== "Yes")
|
|
return;
|
|
const eventType = element.getAttribute("wml-event");
|
|
const targetWindow = element.getAttribute("wml-target-window") || "";
|
|
const windowMethod = element.getAttribute("wml-window");
|
|
const url = element.getAttribute("wml-openurl");
|
|
if (eventType !== null)
|
|
sendEvent(eventType);
|
|
if (windowMethod !== null)
|
|
callWindowMethod(targetWindow, windowMethod);
|
|
if (url !== null)
|
|
void OpenURL(url);
|
|
}
|
|
const confirm = element.getAttribute("wml-confirm");
|
|
if (confirm) {
|
|
Question({
|
|
Title: "Confirm",
|
|
Message: confirm,
|
|
Detached: false,
|
|
Buttons: [
|
|
{ Label: "Yes" },
|
|
{ Label: "No", IsDefault: true }
|
|
]
|
|
}).then(runEffect);
|
|
} else {
|
|
runEffect();
|
|
}
|
|
}
|
|
var AbortControllerRegistry = class {
|
|
/**
|
|
* Stores the AbortController that can be used to remove all currently active listeners.
|
|
*
|
|
* @private
|
|
* @type {AbortController}
|
|
*/
|
|
#controller;
|
|
constructor() {
|
|
this.#controller = new AbortController();
|
|
}
|
|
/**
|
|
* Returns an options object for addEventListener that ties the listener
|
|
* to the AbortSignal from the current AbortController.
|
|
*
|
|
* @param {HTMLElement} element An HTML element
|
|
* @param {string[]} triggers The list of active WML trigger events for the specified elements
|
|
* @returns {AddEventListenerOptions}
|
|
*/
|
|
set(element, triggers) {
|
|
return { signal: this.#controller.signal };
|
|
}
|
|
/**
|
|
* Removes all registered event listeners.
|
|
*
|
|
* @returns {void}
|
|
*/
|
|
reset() {
|
|
this.#controller.abort();
|
|
this.#controller = new AbortController();
|
|
}
|
|
};
|
|
var WeakMapRegistry = class {
|
|
/**
|
|
* Stores the current element-to-trigger mapping.
|
|
*
|
|
* @private
|
|
* @type {WeakMap<HTMLElement, string[]>}
|
|
*/
|
|
#triggerMap;
|
|
/**
|
|
* Counts the number of elements with active WML triggers.
|
|
*
|
|
* @private
|
|
* @type {number}
|
|
*/
|
|
#elementCount = 0;
|
|
constructor() {
|
|
this.#triggerMap = /* @__PURE__ */ new WeakMap();
|
|
}
|
|
/**
|
|
* Sets the active triggers for the specified element.
|
|
*
|
|
* @param {HTMLElement} element An HTML element
|
|
* @param {string[]} triggers The list of active WML trigger events for the specified element
|
|
* @returns {AddEventListenerOptions}
|
|
*/
|
|
set(element, triggers) {
|
|
this.#elementCount += !this.#triggerMap.has(element);
|
|
this.#triggerMap.set(element, triggers);
|
|
return {};
|
|
}
|
|
/**
|
|
* Removes all registered event listeners.
|
|
*
|
|
* @returns {void}
|
|
*/
|
|
reset() {
|
|
if (this.#elementCount <= 0)
|
|
return;
|
|
for (const element of document.body.querySelectorAll("*")) {
|
|
if (this.#elementCount <= 0)
|
|
break;
|
|
const triggers = this.#triggerMap.get(element);
|
|
this.#elementCount -= typeof triggers !== "undefined";
|
|
for (const trigger of triggers || [])
|
|
element.removeEventListener(trigger, onWMLTriggered);
|
|
}
|
|
this.#triggerMap = /* @__PURE__ */ new WeakMap();
|
|
this.#elementCount = 0;
|
|
}
|
|
};
|
|
var triggerRegistry = canAbortListeners() ? new AbortControllerRegistry() : new WeakMapRegistry();
|
|
function addWMLListeners(element) {
|
|
const triggerRegExp = /\S+/g;
|
|
const triggerAttr = element.getAttribute("wml-trigger") || "click";
|
|
const triggers = [];
|
|
let match;
|
|
while ((match = triggerRegExp.exec(triggerAttr)) !== null)
|
|
triggers.push(match[0]);
|
|
const options = triggerRegistry.set(element, triggers);
|
|
for (const trigger of triggers)
|
|
element.addEventListener(trigger, onWMLTriggered, options);
|
|
}
|
|
function Enable() {
|
|
whenReady(Reload);
|
|
}
|
|
function Reload() {
|
|
triggerRegistry.reset();
|
|
document.body.querySelectorAll("[wml-event], [wml-window], [wml-openurl]").forEach(addWMLListeners);
|
|
}
|
|
|
|
// desktop/compiled/main.js
|
|
window.wails = src_exports;
|
|
Enable();
|
|
if (true) {
|
|
debugLog("Wails Runtime Loaded");
|
|
}
|
|
|
|
// desktop/@wailsio/runtime/src/system.js
|
|
var system_exports = {};
|
|
__export(system_exports, {
|
|
Capabilities: () => Capabilities,
|
|
Environment: () => Environment,
|
|
IsAMD64: () => IsAMD64,
|
|
IsARM: () => IsARM,
|
|
IsARM64: () => IsARM64,
|
|
IsDarkMode: () => IsDarkMode,
|
|
IsDebug: () => IsDebug,
|
|
IsLinux: () => IsLinux,
|
|
IsMac: () => IsMac,
|
|
IsWindows: () => IsWindows,
|
|
invoke: () => invoke
|
|
});
|
|
var call4 = newRuntimeCallerWithID(objectNames.System, "");
|
|
var systemIsDarkMode = 0;
|
|
var environment = 1;
|
|
function invoke(msg) {
|
|
if (window.chrome) {
|
|
return window.chrome.webview.postMessage(msg);
|
|
}
|
|
return window.webkit.messageHandlers.external.postMessage(msg);
|
|
}
|
|
function IsDarkMode() {
|
|
return call4(systemIsDarkMode);
|
|
}
|
|
function Capabilities() {
|
|
let response = fetch("/wails/capabilities");
|
|
return response.json();
|
|
}
|
|
function Environment() {
|
|
return call4(environment);
|
|
}
|
|
function IsWindows() {
|
|
return window._wails.environment.OS === "windows";
|
|
}
|
|
function IsLinux() {
|
|
return window._wails.environment.OS === "linux";
|
|
}
|
|
function IsMac() {
|
|
return window._wails.environment.OS === "darwin";
|
|
}
|
|
function IsAMD64() {
|
|
return window._wails.environment.Arch === "amd64";
|
|
}
|
|
function IsARM() {
|
|
return window._wails.environment.Arch === "arm";
|
|
}
|
|
function IsARM64() {
|
|
return window._wails.environment.Arch === "arm64";
|
|
}
|
|
function IsDebug() {
|
|
return window._wails.environment.Debug === true;
|
|
}
|
|
|
|
// desktop/@wailsio/runtime/src/contextmenu.js
|
|
window.addEventListener("contextmenu", contextMenuHandler);
|
|
var call5 = newRuntimeCallerWithID(objectNames.ContextMenu, "");
|
|
var ContextMenuOpen = 0;
|
|
function openContextMenu(id, x, y, data) {
|
|
void call5(ContextMenuOpen, { id, x, y, data });
|
|
}
|
|
function contextMenuHandler(event) {
|
|
let element = event.target;
|
|
let customContextMenu = window.getComputedStyle(element).getPropertyValue("--custom-contextmenu");
|
|
customContextMenu = customContextMenu ? customContextMenu.trim() : "";
|
|
if (customContextMenu) {
|
|
event.preventDefault();
|
|
let customContextMenuData = window.getComputedStyle(element).getPropertyValue("--custom-contextmenu-data");
|
|
openContextMenu(customContextMenu, event.clientX, event.clientY, customContextMenuData);
|
|
return;
|
|
}
|
|
processDefaultContextMenu(event);
|
|
}
|
|
function processDefaultContextMenu(event) {
|
|
if (IsDebug()) {
|
|
return;
|
|
}
|
|
const element = event.target;
|
|
const computedStyle = window.getComputedStyle(element);
|
|
const defaultContextMenuAction = computedStyle.getPropertyValue("--default-contextmenu").trim();
|
|
switch (defaultContextMenuAction) {
|
|
case "show":
|
|
return;
|
|
case "hide":
|
|
event.preventDefault();
|
|
return;
|
|
default:
|
|
if (element.isContentEditable) {
|
|
return;
|
|
}
|
|
const selection = window.getSelection();
|
|
const hasSelection = selection.toString().length > 0;
|
|
if (hasSelection) {
|
|
for (let i = 0; i < selection.rangeCount; i++) {
|
|
const range = selection.getRangeAt(i);
|
|
const rects = range.getClientRects();
|
|
for (let j = 0; j < rects.length; j++) {
|
|
const rect = rects[j];
|
|
if (document.elementFromPoint(rect.left, rect.top) === element) {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (element.tagName === "INPUT" || element.tagName === "TEXTAREA") {
|
|
if (hasSelection || !element.readOnly && !element.disabled) {
|
|
return;
|
|
}
|
|
}
|
|
event.preventDefault();
|
|
}
|
|
}
|
|
|
|
// desktop/@wailsio/runtime/src/flags.js
|
|
var flags_exports = {};
|
|
__export(flags_exports, {
|
|
GetFlag: () => GetFlag
|
|
});
|
|
function GetFlag(keyString) {
|
|
try {
|
|
return window._wails.flags[keyString];
|
|
} catch (e) {
|
|
throw new Error("Unable to retrieve flag '" + keyString + "': " + e);
|
|
}
|
|
}
|
|
|
|
// desktop/@wailsio/runtime/src/drag.js
|
|
window._wails = window._wails || {};
|
|
window._wails.setResizable = setResizable;
|
|
window._wails.endDrag = endDrag;
|
|
window.addEventListener("mousedown", onMouseDown);
|
|
window.addEventListener("mousemove", onMouseMove);
|
|
window.addEventListener("mouseup", onMouseUp);
|
|
var shouldDrag = false;
|
|
var resizeEdge = null;
|
|
var resizable = false;
|
|
var defaultCursor = "auto";
|
|
function dragTest(e) {
|
|
let val = window.getComputedStyle(e.target).getPropertyValue("--webkit-app-region");
|
|
if (!val || val === "" || val.trim() !== "drag" || e.buttons !== 1) {
|
|
return false;
|
|
}
|
|
return e.detail === 1;
|
|
}
|
|
function setResizable(value) {
|
|
resizable = value;
|
|
}
|
|
function endDrag() {
|
|
document.body.style.cursor = "default";
|
|
shouldDrag = false;
|
|
}
|
|
function testResize() {
|
|
if (resizeEdge) {
|
|
invoke(`resize:${resizeEdge}`);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function onMouseDown(e) {
|
|
if (IsWindows() && testResize() || dragTest(e)) {
|
|
shouldDrag = !!isValidDrag(e);
|
|
}
|
|
}
|
|
function isValidDrag(e) {
|
|
return !(e.offsetX > e.target.clientWidth || e.offsetY > e.target.clientHeight);
|
|
}
|
|
function onMouseUp(e) {
|
|
let mousePressed = e.buttons !== void 0 ? e.buttons : e.which;
|
|
if (mousePressed > 0) {
|
|
endDrag();
|
|
}
|
|
}
|
|
function setResize(cursor = defaultCursor) {
|
|
document.documentElement.style.cursor = cursor;
|
|
resizeEdge = cursor;
|
|
}
|
|
function onMouseMove(e) {
|
|
shouldDrag = checkDrag(e);
|
|
if (IsWindows() && resizable) {
|
|
handleResize(e);
|
|
}
|
|
}
|
|
function checkDrag(e) {
|
|
let mousePressed = e.buttons !== void 0 ? e.buttons : e.which;
|
|
if (shouldDrag && mousePressed > 0) {
|
|
invoke("drag");
|
|
return false;
|
|
}
|
|
return shouldDrag;
|
|
}
|
|
function handleResize(e) {
|
|
let resizeHandleHeight = GetFlag("system.resizeHandleHeight") || 5;
|
|
let resizeHandleWidth = GetFlag("system.resizeHandleWidth") || 5;
|
|
let cornerExtra = GetFlag("resizeCornerExtra") || 10;
|
|
let rightBorder = window.outerWidth - e.clientX < resizeHandleWidth;
|
|
let leftBorder = e.clientX < resizeHandleWidth;
|
|
let topBorder = e.clientY < resizeHandleHeight;
|
|
let bottomBorder = window.outerHeight - e.clientY < resizeHandleHeight;
|
|
let rightCorner = window.outerWidth - e.clientX < resizeHandleWidth + cornerExtra;
|
|
let leftCorner = e.clientX < resizeHandleWidth + cornerExtra;
|
|
let topCorner = e.clientY < resizeHandleHeight + cornerExtra;
|
|
let bottomCorner = window.outerHeight - e.clientY < resizeHandleHeight + cornerExtra;
|
|
if (!leftBorder && !rightBorder && !topBorder && !bottomBorder && resizeEdge !== void 0) {
|
|
setResize();
|
|
} else if (rightCorner && bottomCorner)
|
|
setResize("se-resize");
|
|
else if (leftCorner && bottomCorner)
|
|
setResize("sw-resize");
|
|
else if (leftCorner && topCorner)
|
|
setResize("nw-resize");
|
|
else if (topCorner && rightCorner)
|
|
setResize("ne-resize");
|
|
else if (leftBorder)
|
|
setResize("w-resize");
|
|
else if (topBorder)
|
|
setResize("n-resize");
|
|
else if (bottomBorder)
|
|
setResize("s-resize");
|
|
else if (rightBorder)
|
|
setResize("e-resize");
|
|
}
|
|
|
|
// desktop/@wailsio/runtime/src/application.js
|
|
var application_exports = {};
|
|
__export(application_exports, {
|
|
Hide: () => Hide,
|
|
Quit: () => Quit,
|
|
Show: () => Show
|
|
});
|
|
var call6 = newRuntimeCallerWithID(objectNames.Application, "");
|
|
var HideMethod2 = 0;
|
|
var ShowMethod2 = 1;
|
|
var QuitMethod = 2;
|
|
function Hide() {
|
|
return call6(HideMethod2);
|
|
}
|
|
function Show() {
|
|
return call6(ShowMethod2);
|
|
}
|
|
function Quit() {
|
|
return call6(QuitMethod);
|
|
}
|
|
|
|
// desktop/@wailsio/runtime/src/calls.js
|
|
var calls_exports = {};
|
|
__export(calls_exports, {
|
|
ByID: () => ByID,
|
|
ByName: () => ByName,
|
|
Call: () => Call,
|
|
Plugin: () => Plugin
|
|
});
|
|
window._wails = window._wails || {};
|
|
window._wails.callResultHandler = resultHandler;
|
|
window._wails.callErrorHandler = errorHandler;
|
|
var CallBinding = 0;
|
|
var call7 = newRuntimeCallerWithID(objectNames.Call, "");
|
|
var cancelCall = newRuntimeCallerWithID(objectNames.CancelCall, "");
|
|
var callResponses = /* @__PURE__ */ new Map();
|
|
function generateID2() {
|
|
let result;
|
|
do {
|
|
result = nanoid();
|
|
} while (callResponses.has(result));
|
|
return result;
|
|
}
|
|
function resultHandler(id, data, isJSON) {
|
|
const promiseHandler = getAndDeleteResponse(id);
|
|
if (promiseHandler) {
|
|
promiseHandler.resolve(isJSON ? JSON.parse(data) : data);
|
|
}
|
|
}
|
|
function errorHandler(id, message) {
|
|
const promiseHandler = getAndDeleteResponse(id);
|
|
if (promiseHandler) {
|
|
promiseHandler.reject(message);
|
|
}
|
|
}
|
|
function getAndDeleteResponse(id) {
|
|
const response = callResponses.get(id);
|
|
callResponses.delete(id);
|
|
return response;
|
|
}
|
|
function callBinding(type, options = {}) {
|
|
const id = generateID2();
|
|
const doCancel = () => {
|
|
cancelCall(type, { "call-id": id });
|
|
};
|
|
var queuedCancel = false, callRunning = false;
|
|
var p = new Promise((resolve, reject) => {
|
|
options["call-id"] = id;
|
|
callResponses.set(id, { resolve, reject });
|
|
call7(type, options).then((_) => {
|
|
callRunning = true;
|
|
if (queuedCancel) {
|
|
doCancel();
|
|
}
|
|
}).catch((error) => {
|
|
reject(error);
|
|
callResponses.delete(id);
|
|
});
|
|
});
|
|
p.cancel = () => {
|
|
if (callRunning) {
|
|
doCancel();
|
|
} else {
|
|
queuedCancel = true;
|
|
}
|
|
};
|
|
return p;
|
|
}
|
|
function Call(options) {
|
|
return callBinding(CallBinding, options);
|
|
}
|
|
function ByName(name, ...args) {
|
|
if (typeof name !== "string" || name.split(".").length !== 3) {
|
|
throw new Error("CallByName requires a string in the format 'package.struct.method'");
|
|
}
|
|
let [packageName, structName, methodName] = name.split(".");
|
|
return callBinding(CallBinding, {
|
|
packageName,
|
|
structName,
|
|
methodName,
|
|
args
|
|
});
|
|
}
|
|
function ByID(methodID, ...args) {
|
|
return callBinding(CallBinding, {
|
|
methodID,
|
|
args
|
|
});
|
|
}
|
|
function Plugin(pluginName, methodName, ...args) {
|
|
return callBinding(CallBinding, {
|
|
packageName: "wails-plugins",
|
|
structName: pluginName,
|
|
methodName,
|
|
args
|
|
});
|
|
}
|
|
|
|
// desktop/@wailsio/runtime/src/clipboard.js
|
|
var clipboard_exports = {};
|
|
__export(clipboard_exports, {
|
|
SetText: () => SetText,
|
|
Text: () => Text
|
|
});
|
|
var call8 = newRuntimeCallerWithID(objectNames.Clipboard, "");
|
|
var ClipboardSetText = 0;
|
|
var ClipboardText = 1;
|
|
function SetText(text) {
|
|
return call8(ClipboardSetText, { text });
|
|
}
|
|
function Text() {
|
|
return call8(ClipboardText);
|
|
}
|
|
|
|
// desktop/@wailsio/runtime/src/screens.js
|
|
var screens_exports = {};
|
|
__export(screens_exports, {
|
|
GetAll: () => GetAll,
|
|
GetCurrent: () => GetCurrent,
|
|
GetPrimary: () => GetPrimary
|
|
});
|
|
var call9 = newRuntimeCallerWithID(objectNames.Screens, "");
|
|
var getAll = 0;
|
|
var getPrimary = 1;
|
|
var getCurrent = 2;
|
|
function GetAll() {
|
|
return call9(getAll);
|
|
}
|
|
function GetPrimary() {
|
|
return call9(getPrimary);
|
|
}
|
|
function GetCurrent() {
|
|
return call9(getCurrent);
|
|
}
|
|
|
|
// desktop/@wailsio/runtime/src/index.js
|
|
window._wails = window._wails || {};
|
|
window._wails.invoke = invoke;
|
|
invoke("wails:runtime:ready");
|
|
export {
|
|
application_exports as Application,
|
|
browser_exports as Browser,
|
|
calls_exports as Call,
|
|
clipboard_exports as Clipboard,
|
|
dialogs_exports as Dialogs,
|
|
events_exports as Events,
|
|
flags_exports as Flags,
|
|
screens_exports as Screens,
|
|
system_exports as System,
|
|
wml_exports as WML,
|
|
window_default as Window
|
|
};
|
|
//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../runtime/desktop/@wailsio/runtime/src/index.js", "../../runtime/desktop/@wailsio/runtime/src/wml.js", "../../runtime/desktop/@wailsio/runtime/src/browser.js", "../../runtime/node_modules/nanoid/non-secure/index.js", "../../runtime/desktop/@wailsio/runtime/src/runtime.js", "../../runtime/desktop/@wailsio/runtime/src/dialogs.js", "../../runtime/desktop/@wailsio/runtime/src/events.js", "../../runtime/desktop/@wailsio/runtime/src/event_types.js", "../../runtime/desktop/@wailsio/runtime/src/utils.js", "../../runtime/desktop/@wailsio/runtime/src/window.js", "../../runtime/desktop/compiled/main.js", "../../runtime/desktop/@wailsio/runtime/src/system.js", "../../runtime/desktop/@wailsio/runtime/src/contextmenu.js", "../../runtime/desktop/@wailsio/runtime/src/flags.js", "../../runtime/desktop/@wailsio/runtime/src/drag.js", "../../runtime/desktop/@wailsio/runtime/src/application.js", "../../runtime/desktop/@wailsio/runtime/src/calls.js", "../../runtime/desktop/@wailsio/runtime/src/clipboard.js", "../../runtime/desktop/@wailsio/runtime/src/screens.js"],
  "sourcesContent": ["/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n// Setup\nwindow._wails = window._wails || {};\n\nimport \"./contextmenu\";\nimport \"./drag\";\n\n// Re-export public API\nimport * as Application from \"./application\";\nimport * as Browser from \"./browser\";\nimport * as Call from \"./calls\";\nimport * as Clipboard from \"./clipboard\";\nimport * as Dialogs from \"./dialogs\";\nimport * as Events from \"./events\";\nimport * as Flags from \"./flags\";\nimport * as Screens from \"./screens\";\nimport * as System from \"./system\";\nimport Window from \"./window\";\nimport * as WML from \"./wml\";\n\nexport {\n    Application,\n    Browser,\n    Call,\n    Clipboard,\n    Dialogs,\n    Events,\n    Flags,\n    Screens,\n    System,\n    Window,\n    WML\n};\n\n// Notify backend\nwindow._wails.invoke = System.invoke;\nSystem.invoke(\"wails:runtime:ready\");\n", "/*\n _     __     _ __\n| |  / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport {OpenURL} from \"./browser\";\nimport {Question} from \"./dialogs\";\nimport {Emit, WailsEvent} from \"./events\";\nimport {canAbortListeners, whenReady} from \"./utils\";\nimport Window from \"./window\";\n\n/**\n * Sends an event with the given name and optional data.\n *\n * @param {string} eventName - The name of the event to send.\n * @param {any} [data=null] - Optional data to send along with the event.\n *\n * @return {void}\n */\nfunction sendEvent(eventName, data=null) {\n    Emit(new WailsEvent(eventName, data));\n}\n\n/**\n * Calls a method on a specified window.\n * @param {string} windowName - The name of the window to call the method on.\n * @param {string} methodName - The name of the method to call.\n */\nfunction callWindowMethod(windowName, methodName) {\n    const targetWindow = Window.Get(windowName);\n    const method = targetWindow[methodName];\n\n    if (typeof method !== \"function\") {\n        console.error(`Window method '${methodName}' not found`);\n        return;\n    }\n\n    try {\n        method.call(targetWindow);\n    } catch (e) {\n        console.error(`Error calling window method '${methodName}': `, e);\n    }\n}\n\n/**\n * Responds to a triggering event by running appropriate WML actions for the current target\n *\n * @param {Event} ev\n * @return {void}\n */\nfunction onWMLTriggered(ev) {\n    const element = ev.currentTarget;\n\n    function runEffect(choice = \"Yes\") {\n        if (choice !== \"Yes\")\n            return;\n\n        const eventType = element.getAttribute('wml-event');\n        const targetWindow = element.getAttribute('wml-target-window') || \"\";\n        const windowMethod = element.getAttribute('wml-window');\n        const url = element.getAttribute('wml-openurl');\n\n        if (eventType !== null)\n            sendEvent(eventType);\n        if (windowMethod !== null)\n            callWindowMethod(targetWindow, windowMethod);\n        if (url !== null)\n            void OpenURL(url);\n    }\n\n    const confirm = element.getAttribute('wml-confirm');\n\n    if (confirm) {\n        Question({\n            Title: \"Confirm\",\n            Message: confirm,\n            Detached: false,\n            Buttons: [\n                { Label: \"Yes\" },\n                { Label: \"No\", IsDefault: true }\n            ]\n        }).then(runEffect);\n    } else {\n        runEffect();\n    }\n}\n\n/**\n * AbortControllerRegistry does not actually remember active event listeners: instead\n * it ties them to an AbortSignal and uses an AbortController to remove them all at once.\n */\nclass AbortControllerRegistry {\n    /**\n     * Stores the AbortController that can be used to remove all currently active listeners.\n     *\n     * @private\n     * @type {AbortController}\n     */\n    #controller;\n\n    constructor() {\n        this.#controller = new AbortController();\n    }\n\n    /**\n     * Returns an options object for addEventListener that ties the listener\n     * to the AbortSignal from the current AbortController.\n     *\n     * @param {HTMLElement} element An HTML element\n     * @param {string[]} triggers The list of active WML trigger events for the specified elements\n     * @returns {AddEventListenerOptions}\n     */\n    set(element, triggers) {\n        return { signal: this.#controller.signal };\n    }\n\n    /**\n     * Removes all registered event listeners.\n     *\n     * @returns {void}\n     */\n    reset() {\n        this.#controller.abort();\n        this.#controller = new AbortController();\n    }\n}\n\n/**\n * WeakMapRegistry maps active trigger events to each DOM element through a WeakMap.\n * This ensures that the mapping remains private to this module, while still allowing garbage\n * collection of the involved elements.\n */\nclass WeakMapRegistry {\n    /**\n     * Stores the current element-to-trigger mapping.\n     *\n     * @private\n     * @type {WeakMap<HTMLElement, string[]>}\n     */\n    #triggerMap;\n\n    /**\n     * Counts the number of elements with active WML triggers.\n     *\n     * @private\n     * @type {number}\n     */\n    #elementCount = 0;\n\n    constructor() {\n        this.#triggerMap = new WeakMap();\n    }\n\n    /**\n     * Sets the active triggers for the specified element.\n     *\n     * @param {HTMLElement} element An HTML element\n     * @param {string[]} triggers The list of active WML trigger events for the specified element\n     * @returns {AddEventListenerOptions}\n     */\n    set(element, triggers) {\n        this.#elementCount += !this.#triggerMap.has(element);\n        this.#triggerMap.set(element, triggers);\n        return {};\n    }\n\n    /**\n     * Removes all registered event listeners.\n     *\n     * @returns {void}\n     */\n    reset() {\n        if (this.#elementCount <= 0)\n            return;\n\n        for (const element of document.body.querySelectorAll('*')) {\n            if (this.#elementCount <= 0)\n                break;\n\n            const triggers = this.#triggerMap.get(element);\n            this.#elementCount -= (typeof triggers !== \"undefined\");\n\n            for (const trigger of triggers || [])\n                element.removeEventListener(trigger, onWMLTriggered);\n        }\n\n        this.#triggerMap = new WeakMap();\n        this.#elementCount = 0;\n    }\n}\n\nconst triggerRegistry = canAbortListeners() ? new AbortControllerRegistry() : new WeakMapRegistry();\n\n/**\n * Adds event listeners to the specified element.\n *\n * @param {HTMLElement} element\n * @return {void}\n */\nfunction addWMLListeners(element) {\n    const triggerRegExp = /\\S+/g;\n    const triggerAttr = (element.getAttribute('wml-trigger') || \"click\");\n    const triggers = [];\n\n    let match;\n    while ((match = triggerRegExp.exec(triggerAttr)) !== null)\n        triggers.push(match[0]);\n\n    const options = triggerRegistry.set(element, triggers);\n    for (const trigger of triggers)\n        element.addEventListener(trigger, onWMLTriggered, options);\n}\n\n/**\n * Schedules an automatic reload of WML to be performed as soon as the document is fully loaded.\n *\n * @return {void}\n */\nexport function Enable() {\n    whenReady(Reload);\n}\n\n/**\n * Reloads the WML page by adding necessary event listeners and browser listeners.\n *\n * @return {void}\n */\nexport function Reload() {\n    triggerRegistry.reset();\n    document.body.querySelectorAll('[wml-event], [wml-window], [wml-openurl]').forEach(addWMLListeners);\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/* jshint esversion: 9 */\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\n\nconst call = newRuntimeCallerWithID(objectNames.Browser, '');\nconst BrowserOpenURL = 0;\n\n/**\n * Open a browser window to the given URL\n * @param {string} url - The URL to open\n * @returns {Promise<string>}\n */\nexport function OpenURL(url) {\n    return call(BrowserOpenURL, {url});\n}\n", "let urlAlphabet =\n  'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict'\nexport let customAlphabet = (alphabet, defaultSize = 21) => {\n  return (size = defaultSize) => {\n    let id = ''\n    let i = size\n    while (i--) {\n      id += alphabet[(Math.random() * alphabet.length) | 0]\n    }\n    return id\n  }\n}\nexport let nanoid = (size = 21) => {\n  let id = ''\n  let i = size\n  while (i--) {\n    id += urlAlphabet[(Math.random() * 64) | 0]\n  }\n  return id\n}\n", "/*\n _     __     _ __\n| |  / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/* jshint esversion: 9 */\nimport { nanoid } from 'nanoid/non-secure';\n\nconst runtimeURL = window.location.origin + \"/wails/runtime\";\n\n// Object Names\nexport const objectNames = {\n    Call: 0,\n    Clipboard: 1,\n    Application: 2,\n    Events: 3,\n    ContextMenu: 4,\n    Dialog: 5,\n    Window: 6,\n    Screens: 7,\n    System: 8,\n    Browser: 9,\n    CancelCall: 10,\n}\nexport let clientId = nanoid();\n\n/**\n * Creates a runtime caller function that invokes a specified method on a given object within a specified window context.\n *\n * @param {Object} object - The object on which the method is to be invoked.\n * @param {string} windowName - The name of the window context in which the method should be called.\n * @returns {Function} A runtime caller function that takes the method name and optionally arguments and invokes the method within the specified window context.\n */\nexport function newRuntimeCaller(object, windowName) {\n    return function (method, args=null) {\n        return runtimeCall(object + \".\" + method, windowName, args);\n    };\n}\n\n/**\n * Creates a new runtime caller with specified ID.\n *\n * @param {object} object - The object to invoke the method on.\n * @param {string} windowName - The name of the window.\n * @return {Function} - The new runtime caller function.\n */\nexport function newRuntimeCallerWithID(object, windowName) {\n    return function (method, args=null) {\n        return runtimeCallWithID(object, method, windowName, args);\n    };\n}\n\n\nfunction runtimeCall(method, windowName, args) {\n    let url = new URL(runtimeURL);\n    if( method ) {\n        url.searchParams.append(\"method\", method);\n    }\n    let fetchOptions = {\n        headers: {},\n    };\n    if (windowName) {\n        fetchOptions.headers[\"x-wails-window-name\"] = windowName;\n    }\n    if (args) {\n        url.searchParams.append(\"args\", JSON.stringify(args));\n    }\n    fetchOptions.headers[\"x-wails-client-id\"] = clientId;\n\n    return new Promise((resolve, reject) => {\n        fetch(url, fetchOptions)\n            .then(response => {\n                if (response.ok) {\n                    // check content type\n                    if (response.headers.get(\"Content-Type\") && response.headers.get(\"Content-Type\").indexOf(\"application/json\") !== -1) {\n                        return response.json();\n                    } else {\n                        return response.text();\n                    }\n                }\n                reject(Error(response.statusText));\n            })\n            .then(data => resolve(data))\n            .catch(error => reject(error));\n    });\n}\n\nfunction runtimeCallWithID(objectID, method, windowName, args) {\n    let url = new URL(runtimeURL);\n    url.searchParams.append(\"object\", objectID);\n    url.searchParams.append(\"method\", method);\n    let fetchOptions = {\n        headers: {},\n    };\n    if (windowName) {\n        fetchOptions.headers[\"x-wails-window-name\"] = windowName;\n    }\n    if (args) {\n        url.searchParams.append(\"args\", JSON.stringify(args));\n    }\n    fetchOptions.headers[\"x-wails-client-id\"] = clientId;\n    return new Promise((resolve, reject) => {\n        fetch(url, fetchOptions)\n            .then(response => {\n                if (response.ok) {\n                    // check content type\n                    if (response.headers.get(\"Content-Type\") && response.headers.get(\"Content-Type\").indexOf(\"application/json\") !== -1) {\n                        return response.json();\n                    } else {\n                        return response.text();\n                    }\n                }\n                reject(Error(response.statusText));\n            })\n            .then(data => resolve(data))\n            .catch(error => reject(error));\n    });\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/* jshint esversion: 9 */\n\n/**\n * @typedef {Object} OpenFileDialogOptions\n * @property {boolean} [CanChooseDirectories] - Indicates if directories can be chosen.\n * @property {boolean} [CanChooseFiles] - Indicates if files can be chosen.\n * @property {boolean} [CanCreateDirectories] - Indicates if directories can be created.\n * @property {boolean} [ShowHiddenFiles] - Indicates if hidden files should be shown.\n * @property {boolean} [ResolvesAliases] - Indicates if aliases should be resolved.\n * @property {boolean} [AllowsMultipleSelection] - Indicates if multiple selection is allowed.\n * @property {boolean} [HideExtension] - Indicates if the extension should be hidden.\n * @property {boolean} [CanSelectHiddenExtension] - Indicates if hidden extensions can be selected.\n * @property {boolean} [TreatsFilePackagesAsDirectories] - Indicates if file packages should be treated as directories.\n * @property {boolean} [AllowsOtherFiletypes] - Indicates if other file types are allowed.\n * @property {FileFilter[]} [Filters] - Array of file filters.\n * @property {string} [Title] - Title of the dialog.\n * @property {string} [Message] - Message to show in the dialog.\n * @property {string} [ButtonText] - Text to display on the button.\n * @property {string} [Directory] - Directory to open in the dialog.\n * @property {boolean} [Detached] - Indicates if the dialog should appear detached from the main window.\n */\n\n\n/**\n * @typedef {Object} SaveFileDialogOptions\n * @property {string} [Filename] - Default filename to use in the dialog.\n * @property {boolean} [CanChooseDirectories] - Indicates if directories can be chosen.\n * @property {boolean} [CanChooseFiles] - Indicates if files can be chosen.\n * @property {boolean} [CanCreateDirectories] - Indicates if directories can be created.\n * @property {boolean} [ShowHiddenFiles] - Indicates if hidden files should be shown.\n * @property {boolean} [ResolvesAliases] - Indicates if aliases should be resolved.\n * @property {boolean} [AllowsMultipleSelection] - Indicates if multiple selection is allowed.\n * @property {boolean} [HideExtension] - Indicates if the extension should be hidden.\n * @property {boolean} [CanSelectHiddenExtension] - Indicates if hidden extensions can be selected.\n * @property {boolean} [TreatsFilePackagesAsDirectories] - Indicates if file packages should be treated as directories.\n * @property {boolean} [AllowsOtherFiletypes] - Indicates if other file types are allowed.\n * @property {FileFilter[]} [Filters] - Array of file filters.\n * @property {string} [Title] - Title of the dialog.\n * @property {string} [Message] - Message to show in the dialog.\n * @property {string} [ButtonText] - Text to display on the button.\n * @property {string} [Directory] - Directory to open in the dialog.\n * @property {boolean} [Detached] - Indicates if the dialog should appear detached from the main window.\n */\n\n/**\n * @typedef {Object} MessageDialogOptions\n * @property {string} [Title] - The title of the dialog window.\n * @property {string} [Message] - The main message to show in the dialog.\n * @property {Button[]} [Buttons] - Array of button options to show in the dialog.\n * @property {boolean} [Detached] - True if the dialog should appear detached from the main window (if applicable).\n */\n\n/**\n * @typedef {Object} Button\n * @property {string} [Label] - Text that appears within the button.\n * @property {boolean} [IsCancel] - True if the button should cancel an operation when clicked.\n * @property {boolean} [IsDefault] - True if the button should be the default action when the user presses enter.\n */\n\n/**\n * @typedef {Object} FileFilter\n * @property {string} [DisplayName] - Display name for the filter, it could be \"Text Files\", \"Images\" etc.\n * @property {string} [Pattern] - Pattern to match for the filter, e.g. \"*.txt;*.md\" for text markdown files.\n */\n\n// setup\nwindow._wails = window._wails || {};\nwindow._wails.dialogErrorCallback = dialogErrorCallback;\nwindow._wails.dialogResultCallback = dialogResultCallback;\n\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\n\nimport { nanoid } from 'nanoid/non-secure';\n\n// Define constants from the `methods` object in Title Case\nconst DialogInfo = 0;\nconst DialogWarning = 1;\nconst DialogError = 2;\nconst DialogQuestion = 3;\nconst DialogOpenFile = 4;\nconst DialogSaveFile = 5;\n\nconst call = newRuntimeCallerWithID(objectNames.Dialog, '');\nconst dialogResponses = new Map();\n\n/**\n * Generates a unique id that is not present in dialogResponses.\n * @returns {string} unique id\n */\nfunction generateID() {\n    let result;\n    do {\n        result = nanoid();\n    } while (dialogResponses.has(result));\n    return result;\n}\n\n/**\n * Shows a dialog of specified type with the given options.\n * @param {number} type - type of dialog\n * @param {MessageDialogOptions|OpenFileDialogOptions|SaveFileDialogOptions} options - options for the dialog\n * @returns {Promise} promise that resolves with result of dialog\n */\nfunction dialog(type, options = {}) {\n    const id = generateID();\n    options[\"dialog-id\"] = id;\n    return new Promise((resolve, reject) => {\n        dialogResponses.set(id, {resolve, reject});\n        call(type, options).catch((error) => {\n            reject(error);\n            dialogResponses.delete(id);\n        });\n    });\n}\n\n/**\n * Handles the callback from a dialog.\n *\n * @param {string} id - The ID of the dialog response.\n * @param {string} data - The data received from the dialog.\n * @param {boolean} isJSON - Flag indicating whether the data is in JSON format.\n *\n * @return {undefined}\n */\nfunction dialogResultCallback(id, data, isJSON) {\n    let p = dialogResponses.get(id);\n    if (p) {\n        if (isJSON) {\n            p.resolve(JSON.parse(data));\n        } else {\n            p.resolve(data);\n        }\n        dialogResponses.delete(id);\n    }\n}\n\n/**\n * Callback function for handling errors in dialog.\n *\n * @param {string} id - The id of the dialog response.\n * @param {string} message - The error message.\n *\n * @return {void}\n */\nfunction dialogErrorCallback(id, message) {\n    let p = dialogResponses.get(id);\n    if (p) {\n        p.reject(message);\n        dialogResponses.delete(id);\n    }\n}\n\n\n// Replace `methods` with constants in Title Case\n\n/**\n * @param {MessageDialogOptions} options - Dialog options\n * @returns {Promise<string>} - The label of the button pressed\n */\nexport const Info = (options) => dialog(DialogInfo, options);\n\n/**\n * @param {MessageDialogOptions} options - Dialog options\n * @returns {Promise<string>} - The label of the button pressed\n */\nexport const Warning = (options) => dialog(DialogWarning, options);\n\n/**\n * @param {MessageDialogOptions} options - Dialog options\n * @returns {Promise<string>} - The label of the button pressed\n */\nexport const Error = (options) => dialog(DialogError, options);\n\n/**\n * @param {MessageDialogOptions} options - Dialog options\n * @returns {Promise<string>} - The label of the button pressed\n */\nexport const Question = (options) => dialog(DialogQuestion, options);\n\n/**\n * @param {OpenFileDialogOptions} options - Dialog options\n * @returns {Promise<string[]|string>} Returns selected file or list of files. Returns blank string if no file is selected.\n */\nexport const OpenFile = (options) => dialog(DialogOpenFile, options);\n\n/**\n * @param {SaveFileDialogOptions} options - Dialog options\n * @returns {Promise<string>} Returns the selected file. Returns blank string if no file is selected.\n */\nexport const SaveFile = (options) => dialog(DialogSaveFile, options);\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/* jshint esversion: 9 */\n\n/**\n * @typedef {import(\"./types\").WailsEvent} WailsEvent\n */\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\n\nimport {EventTypes} from \"./event_types\";\nexport const Types = EventTypes;\n\n// Setup\nwindow._wails = window._wails || {};\nwindow._wails.dispatchWailsEvent = dispatchWailsEvent;\n\nconst call = newRuntimeCallerWithID(objectNames.Events, '');\nconst EmitMethod = 0;\nconst eventListeners = new Map();\n\nclass Listener {\n    constructor(eventName, callback, maxCallbacks) {\n        this.eventName = eventName;\n        this.maxCallbacks = maxCallbacks || -1;\n        this.Callback = (data) => {\n            callback(data);\n            if (this.maxCallbacks === -1) return false;\n            this.maxCallbacks -= 1;\n            return this.maxCallbacks === 0;\n        };\n    }\n}\n\nexport class WailsEvent {\n    constructor(name, data = null) {\n        this.name = name;\n        this.data = data;\n    }\n}\n\nexport function setup() {\n}\n\nfunction dispatchWailsEvent(event) {\n    let listeners = eventListeners.get(event.name);\n    if (listeners) {\n        let toRemove = listeners.filter(listener => {\n            let remove = listener.Callback(event);\n            if (remove) return true;\n        });\n        if (toRemove.length > 0) {\n            listeners = listeners.filter(l => !toRemove.includes(l));\n            if (listeners.length === 0) eventListeners.delete(event.name);\n            else eventListeners.set(event.name, listeners);\n        }\n    }\n}\n\n/**\n * Register a callback function to be called multiple times for a specific event.\n *\n * @param {string} eventName - The name of the event to register the callback for.\n * @param {function} callback - The callback function to be called when the event is triggered.\n * @param {number} maxCallbacks - The maximum number of times the callback can be called for the event. Once the maximum number is reached, the callback will no longer be called.\n *\n @return {function} - A function that, when called, will unregister the callback from the event.\n */\nexport function OnMultiple(eventName, callback, maxCallbacks) {\n    let listeners = eventListeners.get(eventName) || [];\n    const thisListener = new Listener(eventName, callback, maxCallbacks);\n    listeners.push(thisListener);\n    eventListeners.set(eventName, listeners);\n    return () => listenerOff(thisListener);\n}\n\n/**\n * Registers a callback function to be executed when the specified event occurs.\n *\n * @param {string} eventName - The name of the event.\n * @param {function} callback - The callback function to be executed. It takes no parameters.\n * @return {function} - A function that, when called, will unregister the callback from the event. */\nexport function On(eventName, callback) { return OnMultiple(eventName, callback, -1); }\n\n/**\n * Registers a callback function to be executed only once for the specified event.\n *\n * @param {string} eventName - The name of the event.\n * @param {function} callback - The function to be executed when the event occurs.\n * @return {function} - A function that, when called, will unregister the callback from the event.\n */\nexport function Once(eventName, callback) { return OnMultiple(eventName, callback, 1); }\n\n/**\n * Removes the specified listener from the event listeners collection.\n * If all listeners for the event are removed, the event key is deleted from the collection.\n *\n * @param {Object} listener - The listener to be removed.\n */\nfunction listenerOff(listener) {\n    const eventName = listener.eventName;\n    let listeners = eventListeners.get(eventName).filter(l => l !== listener);\n    if (listeners.length === 0) eventListeners.delete(eventName);\n    else eventListeners.set(eventName, listeners);\n}\n\n\n/**\n * Removes event listeners for the specified event names.\n *\n * @param {string} eventName - The name of the event to remove listeners for.\n * @param {...string} additionalEventNames - Additional event names to remove listeners for.\n * @return {undefined}\n */\nexport function Off(eventName, ...additionalEventNames) {\n    let eventsToRemove = [eventName, ...additionalEventNames];\n    eventsToRemove.forEach(eventName => eventListeners.delete(eventName));\n}\n/**\n * Removes all event listeners.\n *\n * @function OffAll\n * @returns {void}\n */\nexport function OffAll() { eventListeners.clear(); }\n\n/**\n * Emits an event using the given event name.\n *\n * @param {WailsEvent} event - The name of the event to emit.\n * @returns {any} - The result of the emitted event.\n */\nexport function Emit(event) { return call(EmitMethod, event); }\n", "\nexport const EventTypes = {\n\tWindows: {\n\t\tSystemThemeChanged: \"windows:SystemThemeChanged\",\n\t\tAPMPowerStatusChange: \"windows:APMPowerStatusChange\",\n\t\tAPMSuspend: \"windows:APMSuspend\",\n\t\tAPMResumeAutomatic: \"windows:APMResumeAutomatic\",\n\t\tAPMResumeSuspend: \"windows:APMResumeSuspend\",\n\t\tAPMPowerSettingChange: \"windows:APMPowerSettingChange\",\n\t\tApplicationStarted: \"windows:ApplicationStarted\",\n\t\tWebViewNavigationCompleted: \"windows:WebViewNavigationCompleted\",\n\t\tWindowInactive: \"windows:WindowInactive\",\n\t\tWindowActive: \"windows:WindowActive\",\n\t\tWindowClickActive: \"windows:WindowClickActive\",\n\t\tWindowMaximise: \"windows:WindowMaximise\",\n\t\tWindowUnMaximise: \"windows:WindowUnMaximise\",\n\t\tWindowFullscreen: \"windows:WindowFullscreen\",\n\t\tWindowUnFullscreen: \"windows:WindowUnFullscreen\",\n\t\tWindowRestore: \"windows:WindowRestore\",\n\t\tWindowMinimise: \"windows:WindowMinimise\",\n\t\tWindowUnMinimise: \"windows:WindowUnMinimise\",\n\t\tWindowClose: \"windows:WindowClose\",\n\t\tWindowSetFocus: \"windows:WindowSetFocus\",\n\t\tWindowKillFocus: \"windows:WindowKillFocus\",\n\t\tWindowDragDrop: \"windows:WindowDragDrop\",\n\t\tWindowDragEnter: \"windows:WindowDragEnter\",\n\t\tWindowDragLeave: \"windows:WindowDragLeave\",\n\t\tWindowDragOver: \"windows:WindowDragOver\",\n\t},\n\tMac: {\n\t\tApplicationDidBecomeActive: \"mac:ApplicationDidBecomeActive\",\n\t\tApplicationDidChangeBackingProperties: \"mac:ApplicationDidChangeBackingProperties\",\n\t\tApplicationDidChangeEffectiveAppearance: \"mac:ApplicationDidChangeEffectiveAppearance\",\n\t\tApplicationDidChangeIcon: \"mac:ApplicationDidChangeIcon\",\n\t\tApplicationDidChangeOcclusionState: \"mac:ApplicationDidChangeOcclusionState\",\n\t\tApplicationDidChangeScreenParameters: \"mac:ApplicationDidChangeScreenParameters\",\n\t\tApplicationDidChangeStatusBarFrame: \"mac:ApplicationDidChangeStatusBarFrame\",\n\t\tApplicationDidChangeStatusBarOrientation: \"mac:ApplicationDidChangeStatusBarOrientation\",\n\t\tApplicationDidFinishLaunching: \"mac:ApplicationDidFinishLaunching\",\n\t\tApplicationDidHide: \"mac:ApplicationDidHide\",\n\t\tApplicationDidResignActiveNotification: \"mac:ApplicationDidResignActiveNotification\",\n\t\tApplicationDidUnhide: \"mac:ApplicationDidUnhide\",\n\t\tApplicationDidUpdate: \"mac:ApplicationDidUpdate\",\n\t\tApplicationWillBecomeActive: \"mac:ApplicationWillBecomeActive\",\n\t\tApplicationWillFinishLaunching: \"mac:ApplicationWillFinishLaunching\",\n\t\tApplicationWillHide: \"mac:ApplicationWillHide\",\n\t\tApplicationWillResignActive: \"mac:ApplicationWillResignActive\",\n\t\tApplicationWillTerminate: \"mac:ApplicationWillTerminate\",\n\t\tApplicationWillUnhide: \"mac:ApplicationWillUnhide\",\n\t\tApplicationWillUpdate: \"mac:ApplicationWillUpdate\",\n\t\tApplicationDidChangeTheme: \"mac:ApplicationDidChangeTheme!\",\n\t\tApplicationShouldHandleReopen: \"mac:ApplicationShouldHandleReopen!\",\n\t\tWindowDidBecomeKey: \"mac:WindowDidBecomeKey\",\n\t\tWindowDidBecomeMain: \"mac:WindowDidBecomeMain\",\n\t\tWindowDidBeginSheet: \"mac:WindowDidBeginSheet\",\n\t\tWindowDidChangeAlpha: \"mac:WindowDidChangeAlpha\",\n\t\tWindowDidChangeBackingLocation: \"mac:WindowDidChangeBackingLocation\",\n\t\tWindowDidChangeBackingProperties: \"mac:WindowDidChangeBackingProperties\",\n\t\tWindowDidChangeCollectionBehavior: \"mac:WindowDidChangeCollectionBehavior\",\n\t\tWindowDidChangeEffectiveAppearance: \"mac:WindowDidChangeEffectiveAppearance\",\n\t\tWindowDidChangeOcclusionState: \"mac:WindowDidChangeOcclusionState\",\n\t\tWindowDidChangeOrderingMode: \"mac:WindowDidChangeOrderingMode\",\n\t\tWindowDidChangeScreen: \"mac:WindowDidChangeScreen\",\n\t\tWindowDidChangeScreenParameters: \"mac:WindowDidChangeScreenParameters\",\n\t\tWindowDidChangeScreenProfile: \"mac:WindowDidChangeScreenProfile\",\n\t\tWindowDidChangeScreenSpace: \"mac:WindowDidChangeScreenSpace\",\n\t\tWindowDidChangeScreenSpaceProperties: \"mac:WindowDidChangeScreenSpaceProperties\",\n\t\tWindowDidChangeSharingType: \"mac:WindowDidChangeSharingType\",\n\t\tWindowDidChangeSpace: \"mac:WindowDidChangeSpace\",\n\t\tWindowDidChangeSpaceOrderingMode: \"mac:WindowDidChangeSpaceOrderingMode\",\n\t\tWindowDidChangeTitle: \"mac:WindowDidChangeTitle\",\n\t\tWindowDidChangeToolbar: \"mac:WindowDidChangeToolbar\",\n\t\tWindowDidChangeVisibility: \"mac:WindowDidChangeVisibility\",\n\t\tWindowDidDeminiaturize: \"mac:WindowDidDeminiaturize\",\n\t\tWindowDidEndSheet: \"mac:WindowDidEndSheet\",\n\t\tWindowDidEnterFullScreen: \"mac:WindowDidEnterFullScreen\",\n\t\tWindowDidEnterVersionBrowser: \"mac:WindowDidEnterVersionBrowser\",\n\t\tWindowDidExitFullScreen: \"mac:WindowDidExitFullScreen\",\n\t\tWindowDidExitVersionBrowser: \"mac:WindowDidExitVersionBrowser\",\n\t\tWindowDidExpose: \"mac:WindowDidExpose\",\n\t\tWindowDidFocus: \"mac:WindowDidFocus\",\n\t\tWindowDidMiniaturize: \"mac:WindowDidMiniaturize\",\n\t\tWindowDidMove: \"mac:WindowDidMove\",\n\t\tWindowDidOrderOffScreen: \"mac:WindowDidOrderOffScreen\",\n\t\tWindowDidOrderOnScreen: \"mac:WindowDidOrderOnScreen\",\n\t\tWindowDidResignKey: \"mac:WindowDidResignKey\",\n\t\tWindowDidResignMain: \"mac:WindowDidResignMain\",\n\t\tWindowDidResize: \"mac:WindowDidResize\",\n\t\tWindowDidUpdate: \"mac:WindowDidUpdate\",\n\t\tWindowDidUpdateAlpha: \"mac:WindowDidUpdateAlpha\",\n\t\tWindowDidUpdateCollectionBehavior: \"mac:WindowDidUpdateCollectionBehavior\",\n\t\tWindowDidUpdateCollectionProperties: \"mac:WindowDidUpdateCollectionProperties\",\n\t\tWindowDidUpdateShadow: \"mac:WindowDidUpdateShadow\",\n\t\tWindowDidUpdateTitle: \"mac:WindowDidUpdateTitle\",\n\t\tWindowDidUpdateToolbar: \"mac:WindowDidUpdateToolbar\",\n\t\tWindowDidUpdateVisibility: \"mac:WindowDidUpdateVisibility\",\n\t\tWindowShouldClose: \"mac:WindowShouldClose!\",\n\t\tWindowWillBecomeKey: \"mac:WindowWillBecomeKey\",\n\t\tWindowWillBecomeMain: \"mac:WindowWillBecomeMain\",\n\t\tWindowWillBeginSheet: \"mac:WindowWillBeginSheet\",\n\t\tWindowWillChangeOrderingMode: \"mac:WindowWillChangeOrderingMode\",\n\t\tWindowWillClose: \"mac:WindowWillClose\",\n\t\tWindowWillDeminiaturize: \"mac:WindowWillDeminiaturize\",\n\t\tWindowWillEnterFullScreen: \"mac:WindowWillEnterFullScreen\",\n\t\tWindowWillEnterVersionBrowser: \"mac:WindowWillEnterVersionBrowser\",\n\t\tWindowWillExitFullScreen: \"mac:WindowWillExitFullScreen\",\n\t\tWindowWillExitVersionBrowser: \"mac:WindowWillExitVersionBrowser\",\n\t\tWindowWillFocus: \"mac:WindowWillFocus\",\n\t\tWindowWillMiniaturize: \"mac:WindowWillMiniaturize\",\n\t\tWindowWillMove: \"mac:WindowWillMove\",\n\t\tWindowWillOrderOffScreen: \"mac:WindowWillOrderOffScreen\",\n\t\tWindowWillOrderOnScreen: \"mac:WindowWillOrderOnScreen\",\n\t\tWindowWillResignMain: \"mac:WindowWillResignMain\",\n\t\tWindowWillResize: \"mac:WindowWillResize\",\n\t\tWindowWillUnfocus: \"mac:WindowWillUnfocus\",\n\t\tWindowWillUpdate: \"mac:WindowWillUpdate\",\n\t\tWindowWillUpdateAlpha: \"mac:WindowWillUpdateAlpha\",\n\t\tWindowWillUpdateCollectionBehavior: \"mac:WindowWillUpdateCollectionBehavior\",\n\t\tWindowWillUpdateCollectionProperties: \"mac:WindowWillUpdateCollectionProperties\",\n\t\tWindowWillUpdateShadow: \"mac:WindowWillUpdateShadow\",\n\t\tWindowWillUpdateTitle: \"mac:WindowWillUpdateTitle\",\n\t\tWindowWillUpdateToolbar: \"mac:WindowWillUpdateToolbar\",\n\t\tWindowWillUpdateVisibility: \"mac:WindowWillUpdateVisibility\",\n\t\tWindowWillUseStandardFrame: \"mac:WindowWillUseStandardFrame\",\n\t\tMenuWillOpen: \"mac:MenuWillOpen\",\n\t\tMenuDidOpen: \"mac:MenuDidOpen\",\n\t\tMenuDidClose: \"mac:MenuDidClose\",\n\t\tMenuWillSendAction: \"mac:MenuWillSendAction\",\n\t\tMenuDidSendAction: \"mac:MenuDidSendAction\",\n\t\tMenuWillHighlightItem: \"mac:MenuWillHighlightItem\",\n\t\tMenuDidHighlightItem: \"mac:MenuDidHighlightItem\",\n\t\tMenuWillDisplayItem: \"mac:MenuWillDisplayItem\",\n\t\tMenuDidDisplayItem: \"mac:MenuDidDisplayItem\",\n\t\tMenuWillAddItem: \"mac:MenuWillAddItem\",\n\t\tMenuDidAddItem: \"mac:MenuDidAddItem\",\n\t\tMenuWillRemoveItem: \"mac:MenuWillRemoveItem\",\n\t\tMenuDidRemoveItem: \"mac:MenuDidRemoveItem\",\n\t\tMenuWillBeginTracking: \"mac:MenuWillBeginTracking\",\n\t\tMenuDidBeginTracking: \"mac:MenuDidBeginTracking\",\n\t\tMenuWillEndTracking: \"mac:MenuWillEndTracking\",\n\t\tMenuDidEndTracking: \"mac:MenuDidEndTracking\",\n\t\tMenuWillUpdate: \"mac:MenuWillUpdate\",\n\t\tMenuDidUpdate: \"mac:MenuDidUpdate\",\n\t\tMenuWillPopUp: \"mac:MenuWillPopUp\",\n\t\tMenuDidPopUp: \"mac:MenuDidPopUp\",\n\t\tMenuWillSendActionToItem: \"mac:MenuWillSendActionToItem\",\n\t\tMenuDidSendActionToItem: \"mac:MenuDidSendActionToItem\",\n\t\tWebViewDidStartProvisionalNavigation: \"mac:WebViewDidStartProvisionalNavigation\",\n\t\tWebViewDidReceiveServerRedirectForProvisionalNavigation: \"mac:WebViewDidReceiveServerRedirectForProvisionalNavigation\",\n\t\tWebViewDidFinishNavigation: \"mac:WebViewDidFinishNavigation\",\n\t\tWebViewDidCommitNavigation: \"mac:WebViewDidCommitNavigation\",\n\t\tWindowFileDraggingEntered: \"mac:WindowFileDraggingEntered\",\n\t\tWindowFileDraggingPerformed: \"mac:WindowFileDraggingPerformed\",\n\t\tWindowFileDraggingExited: \"mac:WindowFileDraggingExited\",\n\t},\n\tLinux: {\n\t\tSystemThemeChanged: \"linux:SystemThemeChanged\",\n\t\tWindowLoadChanged: \"linux:WindowLoadChanged\",\n\t\tWindowDeleteEvent: \"linux:WindowDeleteEvent\",\n\t\tWindowFocusIn: \"linux:WindowFocusIn\",\n\t\tWindowFocusOut: \"linux:WindowFocusOut\",\n\t\tApplicationStartup: \"linux:ApplicationStartup\",\n\t},\n\tCommon: {\n\t\tApplicationStarted: \"common:ApplicationStarted\",\n\t\tWindowMaximise: \"common:WindowMaximise\",\n\t\tWindowUnMaximise: \"common:WindowUnMaximise\",\n\t\tWindowFullscreen: \"common:WindowFullscreen\",\n\t\tWindowUnFullscreen: \"common:WindowUnFullscreen\",\n\t\tWindowRestore: \"common:WindowRestore\",\n\t\tWindowMinimise: \"common:WindowMinimise\",\n\t\tWindowUnMinimise: \"common:WindowUnMinimise\",\n\t\tWindowClosing: \"common:WindowClosing\",\n\t\tWindowZoom: \"common:WindowZoom\",\n\t\tWindowZoomIn: \"common:WindowZoomIn\",\n\t\tWindowZoomOut: \"common:WindowZoomOut\",\n\t\tWindowZoomReset: \"common:WindowZoomReset\",\n\t\tWindowFocus: \"common:WindowFocus\",\n\t\tWindowLostFocus: \"common:WindowLostFocus\",\n\t\tWindowShow: \"common:WindowShow\",\n\t\tWindowHide: \"common:WindowHide\",\n\t\tWindowDPIChanged: \"common:WindowDPIChanged\",\n\t\tWindowFilesDropped: \"common:WindowFilesDropped\",\n\t\tWindowRuntimeReady: \"common:WindowRuntimeReady\",\n\t\tThemeChanged: \"common:ThemeChanged\",\n\t},\n};\n", "/*\n _     __     _ __\n| |  / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/**\n * Logs a message to the console with custom formatting.\n * @param {string} message - The message to be logged.\n * @return {void}\n */\nexport function debugLog(message) {\n    // eslint-disable-next-line\n    console.log(\n        '%c wails3 %c ' + message + ' ',\n        'background: #aa0000; color: #fff; border-radius: 3px 0px 0px 3px; padding: 1px; font-size: 0.7rem',\n        'background: #009900; color: #fff; border-radius: 0px 3px 3px 0px; padding: 1px; font-size: 0.7rem'\n    );\n}\n\n/**\n * Checks whether the browser supports removing listeners by triggering an AbortSignal\n * (see https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#signal)\n *\n * @return {boolean}\n */\nexport function canAbortListeners() {\n    if (!EventTarget || !AbortSignal || !AbortController)\n        return false;\n\n    let result = true;\n\n    const target = new EventTarget();\n    const controller = new AbortController();\n    target.addEventListener('test', () => { result = false; }, { signal: controller.signal });\n    controller.abort();\n    target.dispatchEvent(new CustomEvent('test'));\n\n    return result;\n}\n\n/***\n This technique for proper load detection is taken from HTMX:\n\n BSD 2-Clause License\n\n Copyright (c) 2020, Big Sky Software\n All rights reserved.\n\n Redistribution and use in source and binary forms, with or without\n modification, are permitted provided that the following conditions are met:\n\n 1. Redistributions of source code must retain the above copyright notice, this\n list of conditions and the following disclaimer.\n\n 2. Redistributions in binary form must reproduce the above copyright notice,\n this list of conditions and the following disclaimer in the documentation\n and/or other materials provided with the distribution.\n\n THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\n FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\n DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\n SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\n CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\n OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n ***/\n\nlet isReady = false;\ndocument.addEventListener('DOMContentLoaded', () => isReady = true);\n\nexport function whenReady(callback) {\n    if (isReady || document.readyState === 'complete') {\n        callback();\n    } else {\n        document.addEventListener('DOMContentLoaded', callback);\n    }\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/* jshint esversion: 9 */\n\n// Import screen jsdoc definition from ./screens.js\n/**\n * @typedef {import(\"./screens\").Screen} Screen\n */\n\n\n/**\n * A record describing the position of a window.\n *\n * @typedef {Object} Position\n * @property {number} x - The horizontal position of the window\n * @property {number} y - The vertical position of the window\n */\n\n\n/**\n * A record describing the size of a window.\n *\n * @typedef {Object} Size\n * @property {number} width - The width of the window\n * @property {number} height - The height of the window\n */\n\n\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\n\nconst AbsolutePositionMethod            = 0;\nconst CenterMethod                      = 1;\nconst CloseMethod                       = 2;\nconst DisableSizeConstraintsMethod      = 3;\nconst EnableSizeConstraintsMethod       = 4;\nconst FocusMethod                       = 5;\nconst ForceReloadMethod                 = 6;\nconst FullscreenMethod                  = 7;\nconst GetScreenMethod                   = 8;\nconst GetZoomMethod                     = 9;\nconst HeightMethod                      = 10;\nconst HideMethod                        = 11;\nconst IsFocusedMethod                   = 12;\nconst IsFullscreenMethod                = 13;\nconst IsMaximisedMethod                 = 14;\nconst IsMinimisedMethod                 = 15;\nconst MaximiseMethod                    = 16;\nconst MinimiseMethod                    = 17;\nconst NameMethod                        = 18;\nconst OpenDevToolsMethod                = 19;\nconst RelativePositionMethod            = 20;\nconst ReloadMethod                      = 21;\nconst ResizableMethod                   = 22;\nconst RestoreMethod                     = 23;\nconst SetAbsolutePositionMethod         = 24;\nconst SetAlwaysOnTopMethod              = 25;\nconst SetBackgroundColourMethod         = 26;\nconst SetFramelessMethod                = 27;\nconst SetFullscreenButtonEnabledMethod  = 28;\nconst SetMaxSizeMethod                  = 29;\nconst SetMinSizeMethod                  = 30;\nconst SetRelativePositionMethod         = 31;\nconst SetResizableMethod                = 32;\nconst SetSizeMethod                     = 33;\nconst SetTitleMethod                    = 34;\nconst SetZoomMethod                     = 35;\nconst ShowMethod                        = 36;\nconst SizeMethod                        = 37;\nconst ToggleFullscreenMethod            = 38;\nconst ToggleMaximiseMethod              = 39;\nconst UnFullscreenMethod                = 40;\nconst UnMaximiseMethod                  = 41;\nconst UnMinimiseMethod                  = 42;\nconst WidthMethod                       = 43;\nconst ZoomMethod                        = 44;\nconst ZoomInMethod                      = 45;\nconst ZoomOutMethod                     = 46;\nconst ZoomResetMethod                   = 47;\n\nclass Window {\n    /**\n     * @private\n     * @type {(...args: any[]) => any}\n     */\n    #call = null;\n\n    /**\n     * Initialises a window object with the specified name.\n     *\n     * @private\n     * @param {string} name - The name of the target window.\n     */\n    constructor(name = '') {\n        this.#call = newRuntimeCallerWithID(objectNames.Window, name)\n\n        // bind instance method to make them easily usable in event handlers\n        for (const method of Object.getOwnPropertyNames(Window.prototype)) {\n            if (\n                method !== \"constructor\"\n                && typeof this[method] === \"function\"\n            ) {\n                this[method] = this[method].bind(this);\n            }\n        }\n    }\n\n    /**\n     * Gets the specified window.\n     *\n     * @public\n     * @param {string} name - The name of the window to get.\n     * @return {Window} - The corresponding window object.\n     */\n    Get(name) {\n        return new Window(name);\n    }\n\n    /**\n     * Returns the absolute position of the window to the screen.\n     *\n     * @public\n     * @return {Promise<Position>} - The current absolute position of the window.\n     */\n    AbsolutePosition() {\n        return this.#call(AbsolutePositionMethod);\n    }\n\n    /**\n     * Centers the window on the screen.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    Center() {\n        return this.#call(CenterMethod);\n    }\n\n    /**\n     * Closes the window.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    Close() {\n        return this.#call(CloseMethod);\n    }\n\n    /**\n     * Disables min/max size constraints.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    DisableSizeConstraints() {\n        return this.#call(DisableSizeConstraintsMethod);\n    }\n\n    /**\n     * Enables min/max size constraints.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    EnableSizeConstraints() {\n        return this.#call(EnableSizeConstraintsMethod);\n    }\n\n    /**\n     * Focuses the window.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    Focus() {\n        return this.#call(FocusMethod);\n    }\n\n    /**\n     * Forces the window to reload the page assets.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    ForceReload() {\n        return this.#call(ForceReloadMethod);\n    }\n\n    /**\n     * Doc.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    Fullscreen() {\n        return this.#call(FullscreenMethod);\n    }\n\n    /**\n     * Returns the screen that the window is on.\n     *\n     * @public\n     * @return {Promise<Screen>} - The screen the window is currently on\n     */\n    GetScreen() {\n        return this.#call(GetScreenMethod);\n    }\n\n    /**\n     * Returns the current zoom level of the window.\n     *\n     * @public\n     * @return {Promise<number>} - The current zoom level\n     */\n    GetZoom() {\n        return this.#call(GetZoomMethod);\n    }\n\n    /**\n     * Returns the height of the window.\n     *\n     * @public\n     * @return {Promise<number>} - The current height of the window\n     */\n    Height() {\n        return this.#call(HeightMethod);\n    }\n\n    /**\n     * Hides the window.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    Hide() {\n        return this.#call(HideMethod);\n    }\n\n    /**\n     * Returns true if the window is focused.\n     *\n     * @public\n     * @return {Promise<boolean>} - Whether the window is currently focused\n     */\n    IsFocused() {\n        return this.#call(IsFocusedMethod);\n    }\n\n    /**\n     * Returns true if the window is fullscreen.\n     *\n     * @public\n     * @return {Promise<boolean>} - Whether the window is currently fullscreen\n     */\n    IsFullscreen() {\n        return this.#call(IsFullscreenMethod);\n    }\n\n    /**\n     * Returns true if the window is maximised.\n     *\n     * @public\n     * @return {Promise<boolean>} - Whether the window is currently maximised\n     */\n    IsMaximised() {\n        return this.#call(IsMaximisedMethod);\n    }\n\n    /**\n     * Returns true if the window is minimised.\n     *\n     * @public\n     * @return {Promise<boolean>} - Whether the window is currently minimised\n     */\n    IsMinimised() {\n        return this.#call(IsMinimisedMethod);\n    }\n\n    /**\n     * Maximises the window.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    Maximise() {\n        return this.#call(MaximiseMethod);\n    }\n\n    /**\n     * Minimises the window.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    Minimise() {\n        return this.#call(MinimiseMethod);\n    }\n\n    /**\n     * Returns the name of the window.\n     *\n     * @public\n     * @return {Promise<string>} - The name of the window\n     */\n    Name() {\n        return this.#call(NameMethod);\n    }\n\n    /**\n     * Opens the development tools pane.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    OpenDevTools() {\n        return this.#call(OpenDevToolsMethod);\n    }\n\n    /**\n     * Returns the relative position of the window to the screen.\n     *\n     * @public\n     * @return {Promise<Position>} - The current relative position of the window\n     */\n    RelativePosition() {\n        return this.#call(RelativePositionMethod);\n    }\n\n    /**\n     * Reloads the page assets.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    Reload() {\n        return this.#call(ReloadMethod);\n    }\n\n    /**\n     * Returns true if the window is resizable.\n     *\n     * @public\n     * @return {Promise<boolean>} - Whether the window is currently resizable\n     */\n    Resizable() {\n        return this.#call(ResizableMethod);\n    }\n\n    /**\n     * Restores the window to its previous state if it was previously minimised, maximised or fullscreen.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    Restore() {\n        return this.#call(RestoreMethod);\n    }\n\n    /**\n     * Sets the absolute position of the window to the screen.\n     *\n     * @public\n     * @param {number} x - The desired horizontal absolute position of the window\n     * @param {number} y - The desired vertical absolute position of the window\n     * @return {Promise<void>}\n     */\n    SetAbsolutePosition(x, y) {\n        return this.#call(SetAbsolutePositionMethod, { x, y });\n    }\n\n    /**\n     * Sets the window to be always on top.\n     *\n     * @public\n     * @param {boolean} alwaysOnTop - Whether the window should stay on top\n     * @return {Promise<void>}\n     */\n    SetAlwaysOnTop(alwaysOnTop) {\n        return this.#call(SetAlwaysOnTopMethod, { alwaysOnTop });\n    }\n\n    /**\n     * Sets the background colour of the window.\n     *\n     * @public\n     * @param {number} r - The desired red component of the window background\n     * @param {number} g - The desired green component of the window background\n     * @param {number} b - The desired blue component of the window background\n     * @param {number} a - The desired alpha component of the window background\n     * @return {Promise<void>}\n     */\n    SetBackgroundColour(r, g, b, a) {\n        return this.#call(SetBackgroundColourMethod, { r, g, b, a });\n    }\n\n    /**\n     * Removes the window frame and title bar.\n     *\n     * @public\n     * @param {boolean} frameless - Whether the window should be frameless\n     * @return {Promise<void>}\n     */\n    SetFrameless(frameless) {\n        return this.#call(SetFramelessMethod, { frameless });\n    }\n\n    /**\n     * Disables the system fullscreen button.\n     *\n     * @public\n     * @param {boolean} enabled - Whether the fullscreen button should be enabled\n     * @return {Promise<void>}\n     */\n    SetFullscreenButtonEnabled(enabled) {\n        return this.#call(SetFullscreenButtonEnabledMethod, { enabled });\n    }\n\n    /**\n     * Sets the maximum size of the window.\n     *\n     * @public\n     * @param {number} width - The desired maximum width of the window\n     * @param {number} height - The desired maximum height of the window\n     * @return {Promise<void>}\n     */\n    SetMaxSize(width, height) {\n        return this.#call(SetMaxSizeMethod, { width, height });\n    }\n\n    /**\n     * Sets the minimum size of the window.\n     *\n     * @public\n     * @param {number} width - The desired minimum width of the window\n     * @param {number} height - The desired minimum height of the window\n     * @return {Promise<void>}\n     */\n    SetMinSize(width, height) {\n        return this.#call(SetMinSizeMethod, { width, height });\n    }\n\n    /**\n     * Sets the relative position of the window to the screen.\n     *\n     * @public\n     * @param {number} x - The desired horizontal relative position of the window\n     * @param {number} y - The desired vertical relative position of the window\n     * @return {Promise<void>}\n     */\n    SetRelativePosition(x, y) {\n        return this.#call(SetRelativePositionMethod, { x, y });\n    }\n\n    /**\n     * Sets whether the window is resizable.\n     *\n     * @public\n     * @param {boolean} resizable - Whether the window should be resizable\n     * @return {Promise<void>}\n     */\n    SetResizable(resizable) {\n        return this.#call(SetResizableMethod, { resizable });\n    }\n\n    /**\n     * Sets the size of the window.\n     *\n     * @public\n     * @param {number} width - The desired width of the window\n     * @param {number} height - The desired height of the window\n     * @return {Promise<void>}\n     */\n    SetSize(width, height) {\n        return this.#call(SetSizeMethod, { width, height });\n    }\n\n    /**\n     * Sets the title of the window.\n     *\n     * @public\n     * @param {string} title - The desired title of the window\n     * @return {Promise<void>}\n     */\n    SetTitle(title) {\n        return this.#call(SetTitleMethod, { title });\n    }\n\n    /**\n     * Sets the zoom level of the window.\n     *\n     * @public\n     * @param {number} zoom - The desired zoom level\n     * @return {Promise<void>}\n     */\n    SetZoom(zoom) {\n        return this.#call(SetZoomMethod, { zoom });\n    }\n\n    /**\n     * Shows the window.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    Show() {\n        return this.#call(ShowMethod);\n    }\n\n    /**\n     * Returns the size of the window.\n     *\n     * @public\n     * @return {Promise<Size>} - The current size of the window\n     */\n    Size() {\n        return this.#call(SizeMethod);\n    }\n\n    /**\n     * Toggles the window between fullscreen and normal.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    ToggleFullscreen() {\n        return this.#call(ToggleFullscreenMethod);\n    }\n\n    /**\n     * Toggles the window between maximised and normal.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    ToggleMaximise() {\n        return this.#call(ToggleMaximiseMethod);\n    }\n\n    /**\n     * Un-fullscreens the window.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    UnFullscreen() {\n        return this.#call(UnFullscreenMethod);\n    }\n\n    /**\n     * Un-maximises the window.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    UnMaximise() {\n        return this.#call(UnMaximiseMethod);\n    }\n\n    /**\n     * Un-minimises the window.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    UnMinimise() {\n        return this.#call(UnMinimiseMethod);\n    }\n\n    /**\n     * Returns the width of the window.\n     *\n     * @public\n     * @return {Promise<number>} - The current width of the window\n     */\n    Width() {\n        return this.#call(WidthMethod);\n    }\n\n    /**\n     * Zooms the window.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    Zoom() {\n        return this.#call(ZoomMethod);\n    }\n\n    /**\n     * Increases the zoom level of the webview content.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    ZoomIn() {\n        return this.#call(ZoomInMethod);\n    }\n\n    /**\n     * Decreases the zoom level of the webview content.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    ZoomOut() {\n        return this.#call(ZoomOutMethod);\n    }\n\n    /**\n     * Resets the zoom level of the webview content.\n     *\n     * @public\n     * @return {Promise<void>}\n     */\n    ZoomReset() {\n        return this.#call(ZoomResetMethod);\n    }\n}\n\n/**\n * The window within which the script is running.\n *\n * @type {Window}\n */\nconst thisWindow = new Window('');\n\nexport default thisWindow;\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\nimport * as Runtime from \"../@wailsio/runtime/src\";\n\n// NOTE: the following methods MUST be imported explicitly because of how esbuild injection works\nimport {Enable as EnableWML} from \"../@wailsio/runtime/src/wml\";\nimport {debugLog} from \"../@wailsio/runtime/src/utils\";\n\nwindow.wails = Runtime;\nEnableWML();\n\nif (DEBUG) {\n    debugLog(\"Wails Runtime Loaded\")\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/* jshint esversion: 9 */\n\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\nlet call = newRuntimeCallerWithID(objectNames.System, '');\nconst systemIsDarkMode = 0;\nconst environment = 1;\n\nexport function invoke(msg) {\n    if(window.chrome) {\n        return window.chrome.webview.postMessage(msg);\n    }\n    return window.webkit.messageHandlers.external.postMessage(msg);\n}\n\n/**\n * @function\n * Retrieves the system dark mode status.\n * @returns {Promise<boolean>} - A promise that resolves to a boolean value indicating if the system is in dark mode.\n */\nexport function IsDarkMode() {\n    return call(systemIsDarkMode);\n}\n\n/**\n * Fetches the capabilities of the application from the server.\n *\n * @async\n * @function Capabilities\n * @returns {Promise<Object>} A promise that resolves to an object containing the capabilities.\n */\nexport function Capabilities() {\n    let response = fetch(\"/wails/capabilities\");\n    return response.json();\n}\n\n/**\n * @typedef {Object} OSInfo\n * @property {string} Branding - The branding of the OS.\n * @property {string} ID - The ID of the OS.\n * @property {string} Name - The name of the OS.\n * @property {string} Version - The version of the OS.\n */\n\n/**\n * @typedef {Object} EnvironmentInfo\n * @property {string} Arch - The architecture of the system.\n * @property {boolean} Debug - True if the application is running in debug mode, otherwise false.\n * @property {string} OS - The operating system in use.\n * @property {OSInfo} OSInfo - Details of the operating system.\n * @property {Object} PlatformInfo - Additional platform information.\n */\n\n/**\n * @function\n * Retrieves environment details.\n * @returns {Promise<EnvironmentInfo>} - A promise that resolves to an object containing OS and system architecture.\n */\nexport function Environment() {\n    return call(environment);\n}\n\n/**\n * Checks if the current operating system is Windows.\n *\n * @return {boolean} True if the operating system is Windows, otherwise false.\n */\nexport function IsWindows() {\n    return window._wails.environment.OS === \"windows\";\n}\n\n/**\n * Checks if the current operating system is Linux.\n *\n * @returns {boolean} Returns true if the current operating system is Linux, false otherwise.\n */\nexport function IsLinux() {\n    return window._wails.environment.OS === \"linux\";\n}\n\n/**\n * Checks if the current environment is a macOS operating system.\n *\n * @returns {boolean} True if the environment is macOS, false otherwise.\n */\nexport function IsMac() {\n    return window._wails.environment.OS === \"darwin\";\n}\n\n/**\n * Checks if the current environment architecture is AMD64.\n * @returns {boolean} True if the current environment architecture is AMD64, false otherwise.\n */\nexport function IsAMD64() {\n    return window._wails.environment.Arch === \"amd64\";\n}\n\n/**\n * Checks if the current architecture is ARM.\n *\n * @returns {boolean} True if the current architecture is ARM, false otherwise.\n */\nexport function IsARM() {\n    return window._wails.environment.Arch === \"arm\";\n}\n\n/**\n * Checks if the current environment is ARM64 architecture.\n *\n * @returns {boolean} - Returns true if the environment is ARM64 architecture, otherwise returns false.\n */\nexport function IsARM64() {\n    return window._wails.environment.Arch === \"arm64\";\n}\n\nexport function IsDebug() {\n    return window._wails.environment.Debug === true;\n}\n\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/* jshint esversion: 9 */\n\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\nimport {IsDebug} from \"./system\";\n\n// setup\nwindow.addEventListener('contextmenu', contextMenuHandler);\n\nconst call = newRuntimeCallerWithID(objectNames.ContextMenu, '');\nconst ContextMenuOpen = 0;\n\nfunction openContextMenu(id, x, y, data) {\n    void call(ContextMenuOpen, {id, x, y, data});\n}\n\nfunction contextMenuHandler(event) {\n    // Check for custom context menu\n    let element = event.target;\n    let customContextMenu = window.getComputedStyle(element).getPropertyValue(\"--custom-contextmenu\");\n    customContextMenu = customContextMenu ? customContextMenu.trim() : \"\";\n    if (customContextMenu) {\n        event.preventDefault();\n        let customContextMenuData = window.getComputedStyle(element).getPropertyValue(\"--custom-contextmenu-data\");\n        openContextMenu(customContextMenu, event.clientX, event.clientY, customContextMenuData);\n        return\n    }\n\n    processDefaultContextMenu(event);\n}\n\n\n/*\n--default-contextmenu: auto; (default) will show the default context menu if contentEditable is true OR text has been selected OR element is input or textarea\n--default-contextmenu: show; will always show the default context menu\n--default-contextmenu: hide; will always hide the default context menu\n\nThis rule is inherited like normal CSS rules, so nesting works as expected\n*/\nfunction processDefaultContextMenu(event) {\n\n    // Debug builds always show the menu\n    if (IsDebug()) {\n        return;\n    }\n\n    // Process default context menu\n    const element = event.target;\n    const computedStyle = window.getComputedStyle(element);\n    const defaultContextMenuAction = computedStyle.getPropertyValue(\"--default-contextmenu\").trim();\n    switch (defaultContextMenuAction) {\n        case \"show\":\n            return;\n        case \"hide\":\n            event.preventDefault();\n            return;\n        default:\n            // Check if contentEditable is true\n            if (element.isContentEditable) {\n                return;\n            }\n\n            // Check if text has been selected\n            const selection = window.getSelection();\n            const hasSelection = (selection.toString().length > 0)\n            if (hasSelection) {\n                for (let i = 0; i < selection.rangeCount; i++) {\n                    const range = selection.getRangeAt(i);\n                    const rects = range.getClientRects();\n                    for (let j = 0; j < rects.length; j++) {\n                        const rect = rects[j];\n                        if (document.elementFromPoint(rect.left, rect.top) === element) {\n                            return;\n                        }\n                    }\n                }\n            }\n            // Check if tagname is input or textarea\n            if (element.tagName === \"INPUT\" || element.tagName === \"TEXTAREA\") {\n                if (hasSelection || (!element.readOnly && !element.disabled)) {\n                    return;\n                }\n            }\n\n            // hide default context menu\n            event.preventDefault();\n    }\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/* jshint esversion: 9 */\n\n/**\n * Retrieves the value associated with the specified key from the flag map.\n *\n * @param {string} keyString - The key to retrieve the value for.\n * @return {*} - The value associated with the specified key.\n */\nexport function GetFlag(keyString) {\n    try {\n        return window._wails.flags[keyString];\n    } catch (e) {\n        throw new Error(\"Unable to retrieve flag '\" + keyString + \"': \" + e);\n    }\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/* jshint esversion: 9 */\n\nimport {invoke, IsWindows} from \"./system\";\nimport {GetFlag} from \"./flags\";\n\n// Setup\nwindow._wails = window._wails || {};\nwindow._wails.setResizable = setResizable;\nwindow._wails.endDrag = endDrag;\nwindow.addEventListener('mousedown', onMouseDown);\nwindow.addEventListener('mousemove', onMouseMove);\nwindow.addEventListener('mouseup', onMouseUp);\n\n\nlet shouldDrag = false;\nlet resizeEdge = null;\nlet resizable = false;\nlet defaultCursor = \"auto\";\n\nfunction dragTest(e) {\n    let val = window.getComputedStyle(e.target).getPropertyValue(\"--webkit-app-region\");\n    if (!val || val === \"\" || val.trim() !== \"drag\" || e.buttons !== 1) {\n        return false;\n    }\n    return e.detail === 1;\n}\n\nfunction setResizable(value) {\n    resizable = value;\n}\n\nfunction endDrag() {\n    document.body.style.cursor = 'default';\n    shouldDrag = false;\n}\n\nfunction testResize() {\n    if( resizeEdge ) {\n        invoke(`resize:${resizeEdge}`);\n        return true\n    }\n    return false;\n}\n\nfunction onMouseDown(e) {\n    if(IsWindows() && testResize() || dragTest(e)) {\n        shouldDrag = !!isValidDrag(e);\n    }\n}\n\nfunction isValidDrag(e) {\n    // Ignore drag on scrollbars\n    return !(e.offsetX > e.target.clientWidth || e.offsetY > e.target.clientHeight);\n}\n\nfunction onMouseUp(e) {\n    let mousePressed = e.buttons !== undefined ? e.buttons : e.which;\n    if (mousePressed > 0) {\n        endDrag();\n    }\n}\n\nfunction setResize(cursor = defaultCursor) {\n    document.documentElement.style.cursor = cursor;\n    resizeEdge = cursor;\n}\n\nfunction onMouseMove(e) {\n    shouldDrag = checkDrag(e);\n    if (IsWindows() && resizable) {\n        handleResize(e);\n    }\n}\n\nfunction checkDrag(e) {\n    let mousePressed = e.buttons !== undefined ? e.buttons : e.which;\n    if(shouldDrag && mousePressed > 0) {\n        invoke(\"drag\");\n        return false;\n    }\n    return shouldDrag;\n}\n\nfunction handleResize(e) {\n    let resizeHandleHeight = GetFlag(\"system.resizeHandleHeight\") || 5;\n    let resizeHandleWidth = GetFlag(\"system.resizeHandleWidth\") || 5;\n\n    // Extra pixels for the corner areas\n    let cornerExtra = GetFlag(\"resizeCornerExtra\") || 10;\n\n    let rightBorder = window.outerWidth - e.clientX < resizeHandleWidth;\n    let leftBorder = e.clientX < resizeHandleWidth;\n    let topBorder = e.clientY < resizeHandleHeight;\n    let bottomBorder = window.outerHeight - e.clientY < resizeHandleHeight;\n\n    // Adjust for corners\n    let rightCorner = window.outerWidth - e.clientX < (resizeHandleWidth + cornerExtra);\n    let leftCorner = e.clientX < (resizeHandleWidth + cornerExtra);\n    let topCorner = e.clientY < (resizeHandleHeight + cornerExtra);\n    let bottomCorner = window.outerHeight - e.clientY < (resizeHandleHeight + cornerExtra);\n\n    // If we aren't on an edge, but were, reset the cursor to default\n    if (!leftBorder && !rightBorder && !topBorder && !bottomBorder && resizeEdge !== undefined) {\n        setResize();\n    }\n    // Adjusted for corner areas\n    else if (rightCorner && bottomCorner) setResize(\"se-resize\");\n    else if (leftCorner && bottomCorner) setResize(\"sw-resize\");\n    else if (leftCorner && topCorner) setResize(\"nw-resize\");\n    else if (topCorner && rightCorner) setResize(\"ne-resize\");\n    else if (leftBorder) setResize(\"w-resize\");\n    else if (topBorder) setResize(\"n-resize\");\n    else if (bottomBorder) setResize(\"s-resize\");\n    else if (rightBorder) setResize(\"e-resize\");\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/* jshint esversion: 9 */\n\nimport { newRuntimeCallerWithID, objectNames } from \"./runtime\";\nconst call = newRuntimeCallerWithID(objectNames.Application, '');\n\nconst HideMethod = 0;\nconst ShowMethod = 1;\nconst QuitMethod = 2;\n\n/**\n * Hides a certain method by calling the HideMethod function.\n *\n * @return {Promise<void>}\n *\n */\nexport function Hide() {\n    return call(HideMethod);\n}\n\n/**\n * Calls the ShowMethod and returns the result.\n *\n * @return {Promise<void>}\n */\nexport function Show() {\n    return call(ShowMethod);\n}\n\n/**\n * Calls the QuitMethod to terminate the program.\n *\n * @return {Promise<void>}\n */\nexport function Quit() {\n    return call(QuitMethod);\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/* jshint esversion: 9 */\nimport { newRuntimeCallerWithID, objectNames } from \"./runtime\";\nimport { nanoid } from 'nanoid/non-secure';\n\n// Setup\nwindow._wails = window._wails || {};\nwindow._wails.callResultHandler = resultHandler;\nwindow._wails.callErrorHandler = errorHandler;\n\n\nconst CallBinding = 0;\nconst call = newRuntimeCallerWithID(objectNames.Call, '');\nconst cancelCall = newRuntimeCallerWithID(objectNames.CancelCall, '');\nlet callResponses = new Map();\n\n/**\n * Generates a unique ID using the nanoid library.\n *\n * @return {string} - A unique ID that does not exist in the callResponses set.\n */\nfunction generateID() {\n    let result;\n    do {\n        result = nanoid();\n    } while (callResponses.has(result));\n    return result;\n}\n\n/**\n * Handles the result of a call request.\n *\n * @param {string} id - The id of the request to handle the result for.\n * @param {string} data - The result data of the request.\n * @param {boolean} isJSON - Indicates whether the data is JSON or not.\n *\n * @return {undefined} - This method does not return any value.\n */\nfunction resultHandler(id, data, isJSON) {\n    const promiseHandler = getAndDeleteResponse(id);\n    if (promiseHandler) {\n        promiseHandler.resolve(isJSON ? JSON.parse(data) : data);\n    }\n}\n\n/**\n * Handles the error from a call request.\n *\n * @param {string} id - The id of the promise handler.\n * @param {string} message - The error message to reject the promise handler with.\n *\n * @return {void}\n */\nfunction errorHandler(id, message) {\n    const promiseHandler = getAndDeleteResponse(id);\n    if (promiseHandler) {\n        promiseHandler.reject(message);\n    }\n}\n\n/**\n * Retrieves and removes the response associated with the given ID from the callResponses map.\n *\n * @param {any} id - The ID of the response to be retrieved and removed.\n *\n * @returns {any} The response object associated with the given ID.\n */\nfunction getAndDeleteResponse(id) {\n    const response = callResponses.get(id);\n    callResponses.delete(id);\n    return response;\n}\n\n/**\n * Executes a call using the provided type and options.\n *\n * @param {string|number} type - The type of call to execute.\n * @param {Object} [options={}] - Additional options for the call.\n * @return {Promise} - A promise that will be resolved or rejected based on the result of the call. It also has a cancel method to cancel a long running request.\n */\nfunction callBinding(type, options = {}) {\n    const id = generateID();\n    const doCancel = () => { cancelCall(type, {\"call-id\": id}) };\n    var queuedCancel = false, callRunning = false;\n    var p = new Promise((resolve, reject) => {\n        options[\"call-id\"] = id;\n        callResponses.set(id, { resolve, reject });\n        call(type, options).\n            then((_) => {\n                callRunning = true;\n                if (queuedCancel) {\n                    doCancel();\n                }\n            }).\n            catch((error) => {\n                reject(error);\n                callResponses.delete(id);\n            });\n    });\n    p.cancel = () => {\n        if (callRunning) {\n            doCancel();\n        } else {\n            queuedCancel = true;\n        }\n    };\n    \n    return p;\n}\n\n/**\n * Call method.\n *\n * @param {Object} options - The options for the method.\n * @returns {Object} - The result of the call.\n */\nexport function Call(options) {\n    return callBinding(CallBinding, options);\n}\n\n/**\n * Executes a method by name.\n *\n * @param {string} name - The name of the method in the format 'package.struct.method'.\n * @param {...*} args - The arguments to pass to the method.\n * @throws {Error} If the name is not a string or is not in the correct format.\n * @returns {*} The result of the method execution.\n */\nexport function ByName(name, ...args) {\n    if (typeof name !== \"string\" || name.split(\".\").length !== 3) {\n        throw new Error(\"CallByName requires a string in the format 'package.struct.method'\");\n    }\n    let [packageName, structName, methodName] = name.split(\".\");\n    return callBinding(CallBinding, {\n        packageName,\n        structName,\n        methodName,\n        args\n    });\n}\n\n/**\n * Calls a method by its ID with the specified arguments.\n *\n * @param {number} methodID - The ID of the method to call.\n * @param {...*} args - The arguments to pass to the method.\n * @return {*} - The result of the method call.\n */\nexport function ByID(methodID, ...args) {\n    return callBinding(CallBinding, {\n        methodID,\n        args\n    });\n}\n\n/**\n * Calls a method on a plugin.\n *\n * @param {string} pluginName - The name of the plugin.\n * @param {string} methodName - The name of the method to call.\n * @param {...*} args - The arguments to pass to the method.\n * @returns {*} - The result of the method call.\n */\nexport function Plugin(pluginName, methodName, ...args) {\n    return callBinding(CallBinding, {\n        packageName: \"wails-plugins\",\n        structName: pluginName,\n        methodName,\n        args\n    });\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/* jshint esversion: 9 */\n\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\n\nconst call = newRuntimeCallerWithID(objectNames.Clipboard, '');\nconst ClipboardSetText = 0;\nconst ClipboardText = 1;\n\n/**\n * Sets the text to the Clipboard.\n *\n * @param {string} text - The text to be set to the Clipboard.\n * @return {Promise} - A Promise that resolves when the operation is successful.\n */\nexport function SetText(text) {\n    return call(ClipboardSetText, {text});\n}\n\n/**\n * Get the Clipboard text\n * @returns {Promise<string>} A promise that resolves with the text from the Clipboard.\n */\nexport function Text() {\n    return call(ClipboardText);\n}\n", "/*\n _\t   __\t  _ __\n| |\t / /___ _(_) /____\n| | /| / / __ `/ / / ___/\n| |/ |/ / /_/ / / (__  )\n|__/|__/\\__,_/_/_/____/\nThe electron alternative for Go\n(c) Lea Anthony 2019-present\n*/\n\n/* jshint esversion: 9 */\n\n/**\n * @typedef {Object} Position\n * @property {number} X - The X coordinate.\n * @property {number} Y - The Y coordinate.\n */\n\n/**\n * @typedef {Object} Size\n * @property {number} X - The width.\n * @property {number} Y - The height.\n */\n\n\n/**\n * @typedef {Object} Rect\n * @property {number} X - The X coordinate of the top-left corner.\n * @property {number} Y - The Y coordinate of the top-left corner.\n * @property {number} Width - The width of the rectangle.\n * @property {number} Height - The height of the rectangle.\n */\n\n\n/**\n * @typedef {Object} Screen\n * @property {string} Id - Unique identifier for the screen.\n * @property {string} Name - Human readable name of the screen.\n * @property {number} Scale - The resolution scale of the screen. 1 = standard resolution, 2 = high (Retina), etc.\n * @property {Position} Position - Contains the X and Y coordinates of the screen's position.\n * @property {Size} Size - Contains the width and height of the screen.\n * @property {Rect} Bounds - Contains the bounds of the screen in terms of X, Y, Width, and Height.\n * @property {Rect} WorkArea - Contains the area of the screen that is actually usable (excluding taskbar and other system UI).\n * @property {boolean} IsPrimary - True if this is the primary monitor selected by the user in the operating system.\n * @property {number} Rotation - The rotation of the screen.\n */\n\n\nimport {newRuntimeCallerWithID, objectNames} from \"./runtime\";\nconst call = newRuntimeCallerWithID(objectNames.Screens, '');\n\nconst getAll = 0;\nconst getPrimary = 1;\nconst getCurrent = 2;\n\n/**\n * Gets all screens.\n * @returns {Promise<Screen[]>} A promise that resolves to an array of Screen objects.\n */\nexport function GetAll() {\n    return call(getAll);\n}\n/**\n * Gets the primary screen.\n * @returns {Promise<Screen>} A promise that resolves to the primary screen.\n */\nexport function GetPrimary() {\n    return call(getPrimary);\n}\n/**\n * Gets the current active screen.\n *\n * @returns {Promise<Screen>} A promise that resolves with the current active screen.\n */\nexport function GetCurrent() {\n    return call(getCurrent);\n}\n"],
  "mappings": "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",
  "names": ["Error", "call", "Error", "call", "eventName", "resizable", "call", "call", "call", "HideMethod", "ShowMethod", "call", "generateID", "call", "call"]
}

|