From 6bd4dd0489fb72419f5354e2c0553e99d08b4996 Mon Sep 17 00:00:00 2001 From: Jonas Kruckenberg Date: Thu, 3 Nov 2022 11:09:17 +0100 Subject: [PATCH 1/6] feat: add window module --- Cargo.toml | 8 +- build.rs | 7 +- dist/window.js | 1004 ++++++++++++++++++++++++++++++ examples/api/src/main.rs | 3 + examples/api/src/views/mod.rs | 4 + examples/api/src/views/window.rs | 63 ++ src/lib.rs | 2 + src/window.rs | 744 ++++++++++++++++++++++ 8 files changed, 1830 insertions(+), 5 deletions(-) create mode 100644 dist/window.js create mode 100644 examples/api/src/views/window.rs create mode 100644 src/window.rs diff --git a/Cargo.toml b/Cargo.toml index 8c2523a..6c3aecd 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -19,10 +19,14 @@ semver = { version = "1.0.14", optional = true } wasm-bindgen-test = "0.3.33" tauri-sys = { path = ".", features = ["all"] } +[package.metadata.docs.rs] +all-features = true + [features] -all = ["app", "clipboard", "event", "mocks", "tauri"] +all = ["app", "clipboard", "event", "mocks", "tauri", "window"] app = ["dep:semver"] clipboard = [] event = [] mocks = [] -tauri = ["dep:url"] \ No newline at end of file +tauri = ["dep:url"] +window = [] \ No newline at end of file diff --git a/build.rs b/build.rs index f0eae84..edbc302 100644 --- a/build.rs +++ b/build.rs @@ -2,7 +2,7 @@ use std::process::Command; fn main() { /* Shared arguments */ - let sargs: [&str; 8] = [ + let sargs: &[&str] = &[ "--outdir=dist", "--format=esm", "--bundle", @@ -11,18 +11,19 @@ fn main() { "tauri/tooling/api/src/tauri.ts", "tauri/tooling/api/src/event.ts", "tauri/tooling/api/src/mocks.ts", + "tauri/tooling/api/src/window.ts" ]; if cfg!(windows) { /* Use cmd if the target is windows */ Command::new("cmd") .args(&["/C", "esbuild"]) - .args(&sargs) + .args(sargs) .output() .unwrap(); } else if cfg!(unix) { Command::new("esbuild") - .args(&sargs) + .args(sargs) .output() .unwrap(); } else { diff --git a/dist/window.js b/dist/window.js new file mode 100644 index 0000000..e0b637b --- /dev/null +++ b/dist/window.js @@ -0,0 +1,1004 @@ +// tauri/tooling/api/src/tauri.ts +function uid() { + return window.crypto.getRandomValues(new Uint32Array(1))[0]; +} +function transformCallback(callback, once2 = false) { + const identifier = uid(); + const prop = `_${identifier}`; + Object.defineProperty(window, prop, { + value: (result) => { + if (once2) { + Reflect.deleteProperty(window, prop); + } + return callback?.(result); + }, + writable: false, + configurable: true + }); + return identifier; +} +async function invoke(cmd, args = {}) { + return new Promise((resolve, reject) => { + const callback = transformCallback((e) => { + resolve(e); + Reflect.deleteProperty(window, `_${error}`); + }, true); + const error = transformCallback((e) => { + reject(e); + Reflect.deleteProperty(window, `_${callback}`); + }, true); + window.__TAURI_IPC__({ + cmd, + callback, + error, + ...args + }); + }); +} + +// tauri/tooling/api/src/helpers/tauri.ts +async function invokeTauriCommand(command) { + return invoke("tauri", command); +} + +// tauri/tooling/api/src/helpers/event.ts +async function _unlisten(event, eventId) { + return invokeTauriCommand({ + __tauriModule: "Event", + message: { + cmd: "unlisten", + event, + eventId + } + }); +} +async function emit(event, windowLabel, payload) { + await invokeTauriCommand({ + __tauriModule: "Event", + message: { + cmd: "emit", + event, + windowLabel, + payload + } + }); +} +async function listen(event, windowLabel, handler) { + return invokeTauriCommand({ + __tauriModule: "Event", + message: { + cmd: "listen", + event, + windowLabel, + handler: transformCallback(handler) + } + }).then((eventId) => { + return async () => _unlisten(event, eventId); + }); +} +async function once(event, windowLabel, handler) { + return listen(event, windowLabel, (eventData) => { + handler(eventData); + _unlisten(event, eventData.id).catch(() => { + }); + }); +} + +// tauri/tooling/api/src/window.ts +var LogicalSize = class { + constructor(width, height) { + this.type = "Logical"; + this.width = width; + this.height = height; + } +}; +var PhysicalSize = class { + constructor(width, height) { + this.type = "Physical"; + this.width = width; + this.height = height; + } + toLogical(scaleFactor) { + return new LogicalSize(this.width / scaleFactor, this.height / scaleFactor); + } +}; +var LogicalPosition = class { + constructor(x, y) { + this.type = "Logical"; + this.x = x; + this.y = y; + } +}; +var PhysicalPosition = class { + constructor(x, y) { + this.type = "Physical"; + this.x = x; + this.y = y; + } + toLogical(scaleFactor) { + return new LogicalPosition(this.x / scaleFactor, this.y / scaleFactor); + } +}; +var UserAttentionType = /* @__PURE__ */ ((UserAttentionType2) => { + UserAttentionType2[UserAttentionType2["Critical"] = 1] = "Critical"; + UserAttentionType2[UserAttentionType2["Informational"] = 2] = "Informational"; + return UserAttentionType2; +})(UserAttentionType || {}); +function getCurrent() { + return new WebviewWindow(window.__TAURI_METADATA__.__currentWindow.label, { + skip: true + }); +} +function getAll() { + return window.__TAURI_METADATA__.__windows.map( + (w) => new WebviewWindow(w.label, { + skip: true + }) + ); +} +var localTauriEvents = ["tauri://created", "tauri://error"]; +var WebviewWindowHandle = class { + constructor(label) { + this.label = label; + this.listeners = /* @__PURE__ */ Object.create(null); + } + async listen(event, handler) { + if (this._handleTauriEvent(event, handler)) { + return Promise.resolve(() => { + const listeners = this.listeners[event]; + listeners.splice(listeners.indexOf(handler), 1); + }); + } + return listen(event, this.label, handler); + } + async once(event, handler) { + if (this._handleTauriEvent(event, handler)) { + return Promise.resolve(() => { + const listeners = this.listeners[event]; + listeners.splice(listeners.indexOf(handler), 1); + }); + } + return once(event, this.label, handler); + } + async emit(event, payload) { + if (localTauriEvents.includes(event)) { + for (const handler of this.listeners[event] || []) { + handler({ event, id: -1, windowLabel: this.label, payload }); + } + return Promise.resolve(); + } + return emit(event, this.label, payload); + } + _handleTauriEvent(event, handler) { + if (localTauriEvents.includes(event)) { + if (!(event in this.listeners)) { + this.listeners[event] = [handler]; + } else { + this.listeners[event].push(handler); + } + return true; + } + return false; + } +}; +var WindowManager = class extends WebviewWindowHandle { + async scaleFactor() { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "scaleFactor" + } + } + } + }); + } + async innerPosition() { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "innerPosition" + } + } + } + }).then(({ x, y }) => new PhysicalPosition(x, y)); + } + async outerPosition() { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "outerPosition" + } + } + } + }).then(({ x, y }) => new PhysicalPosition(x, y)); + } + async innerSize() { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "innerSize" + } + } + } + }).then(({ width, height }) => new PhysicalSize(width, height)); + } + async outerSize() { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "outerSize" + } + } + } + }).then(({ width, height }) => new PhysicalSize(width, height)); + } + async isFullscreen() { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "isFullscreen" + } + } + } + }); + } + async isMaximized() { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "isMaximized" + } + } + } + }); + } + async isDecorated() { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "isDecorated" + } + } + } + }); + } + async isResizable() { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "isResizable" + } + } + } + }); + } + async isVisible() { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "isVisible" + } + } + } + }); + } + async theme() { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "theme" + } + } + } + }); + } + async center() { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "center" + } + } + } + }); + } + async requestUserAttention(requestType) { + let requestType_ = null; + if (requestType) { + if (requestType === 1 /* Critical */) { + requestType_ = { type: "Critical" }; + } else { + requestType_ = { type: "Informational" }; + } + } + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "requestUserAttention", + payload: requestType_ + } + } + } + }); + } + async setResizable(resizable) { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "setResizable", + payload: resizable + } + } + } + }); + } + async setTitle(title) { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "setTitle", + payload: title + } + } + } + }); + } + async maximize() { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "maximize" + } + } + } + }); + } + async unmaximize() { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "unmaximize" + } + } + } + }); + } + async toggleMaximize() { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "toggleMaximize" + } + } + } + }); + } + async minimize() { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "minimize" + } + } + } + }); + } + async unminimize() { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "unminimize" + } + } + } + }); + } + async show() { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "show" + } + } + } + }); + } + async hide() { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "hide" + } + } + } + }); + } + async close() { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "close" + } + } + } + }); + } + async setDecorations(decorations) { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "setDecorations", + payload: decorations + } + } + } + }); + } + async setAlwaysOnTop(alwaysOnTop) { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "setAlwaysOnTop", + payload: alwaysOnTop + } + } + } + }); + } + async setSize(size) { + if (!size || size.type !== "Logical" && size.type !== "Physical") { + throw new Error( + "the `size` argument must be either a LogicalSize or a PhysicalSize instance" + ); + } + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "setSize", + payload: { + type: size.type, + data: { + width: size.width, + height: size.height + } + } + } + } + } + }); + } + async setMinSize(size) { + if (size && size.type !== "Logical" && size.type !== "Physical") { + throw new Error( + "the `size` argument must be either a LogicalSize or a PhysicalSize instance" + ); + } + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "setMinSize", + payload: size ? { + type: size.type, + data: { + width: size.width, + height: size.height + } + } : null + } + } + } + }); + } + async setMaxSize(size) { + if (size && size.type !== "Logical" && size.type !== "Physical") { + throw new Error( + "the `size` argument must be either a LogicalSize or a PhysicalSize instance" + ); + } + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "setMaxSize", + payload: size ? { + type: size.type, + data: { + width: size.width, + height: size.height + } + } : null + } + } + } + }); + } + async setPosition(position) { + if (!position || position.type !== "Logical" && position.type !== "Physical") { + throw new Error( + "the `position` argument must be either a LogicalPosition or a PhysicalPosition instance" + ); + } + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "setPosition", + payload: { + type: position.type, + data: { + x: position.x, + y: position.y + } + } + } + } + } + }); + } + async setFullscreen(fullscreen) { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "setFullscreen", + payload: fullscreen + } + } + } + }); + } + async setFocus() { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "setFocus" + } + } + } + }); + } + async setIcon(icon) { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "setIcon", + payload: { + icon: typeof icon === "string" ? icon : Array.from(icon) + } + } + } + } + }); + } + async setSkipTaskbar(skip) { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "setSkipTaskbar", + payload: skip + } + } + } + }); + } + async setCursorGrab(grab) { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "setCursorGrab", + payload: grab + } + } + } + }); + } + async setCursorVisible(visible) { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "setCursorVisible", + payload: visible + } + } + } + }); + } + async setCursorIcon(icon) { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "setCursorIcon", + payload: icon + } + } + } + }); + } + async setCursorPosition(position) { + if (!position || position.type !== "Logical" && position.type !== "Physical") { + throw new Error( + "the `position` argument must be either a LogicalPosition or a PhysicalPosition instance" + ); + } + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "setCursorPosition", + payload: { + type: position.type, + data: { + x: position.x, + y: position.y + } + } + } + } + } + }); + } + async setIgnoreCursorEvents(ignore) { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "setIgnoreCursorEvents", + payload: ignore + } + } + } + }); + } + async startDragging() { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "startDragging" + } + } + } + }); + } + async onResized(handler) { + return this.listen("tauri://resize" /* WINDOW_RESIZED */, handler); + } + async onMoved(handler) { + return this.listen("tauri://move" /* WINDOW_MOVED */, handler); + } + async onCloseRequested(handler) { + return this.listen("tauri://close-requested" /* WINDOW_CLOSE_REQUESTED */, (event) => { + const evt = new CloseRequestedEvent(event); + void Promise.resolve(handler(evt)).then(() => { + if (!evt.isPreventDefault()) { + return this.close(); + } + }); + }); + } + async onFocusChanged(handler) { + const unlistenFocus = await this.listen( + "tauri://focus" /* WINDOW_FOCUS */, + (event) => { + handler({ ...event, payload: true }); + } + ); + const unlistenBlur = await this.listen( + "tauri://blur" /* WINDOW_BLUR */, + (event) => { + handler({ ...event, payload: false }); + } + ); + return () => { + unlistenFocus(); + unlistenBlur(); + }; + } + async onScaleChanged(handler) { + return this.listen( + "tauri://scale-change" /* WINDOW_SCALE_FACTOR_CHANGED */, + handler + ); + } + async onMenuClicked(handler) { + return this.listen("tauri://menu" /* MENU */, handler); + } + async onFileDropEvent(handler) { + const unlistenFileDrop = await this.listen( + "tauri://file-drop" /* WINDOW_FILE_DROP */, + (event) => { + handler({ ...event, payload: { type: "drop", paths: event.payload } }); + } + ); + const unlistenFileHover = await this.listen( + "tauri://file-drop-hover" /* WINDOW_FILE_DROP_HOVER */, + (event) => { + handler({ ...event, payload: { type: "hover", paths: event.payload } }); + } + ); + const unlistenCancel = await this.listen( + "tauri://file-drop-cancelled" /* WINDOW_FILE_DROP_CANCELLED */, + (event) => { + handler({ ...event, payload: { type: "cancel" } }); + } + ); + return () => { + unlistenFileDrop(); + unlistenFileHover(); + unlistenCancel(); + }; + } + async onThemeChanged(handler) { + return this.listen("tauri://theme-changed" /* WINDOW_THEME_CHANGED */, handler); + } +}; +var CloseRequestedEvent = class { + constructor(event) { + this._preventDefault = false; + this.event = event.event; + this.windowLabel = event.windowLabel; + this.id = event.id; + } + preventDefault() { + this._preventDefault = true; + } + isPreventDefault() { + return this._preventDefault; + } +}; +var WebviewWindow = class extends WindowManager { + constructor(label, options = {}) { + super(label); + if (!options?.skip) { + invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "createWebview", + data: { + options: { + label, + ...options + } + } + } + }).then(async () => this.emit("tauri://created")).catch(async (e) => this.emit("tauri://error", e)); + } + } + static getByLabel(label) { + if (getAll().some((w) => w.label === label)) { + return new WebviewWindow(label, { skip: true }); + } + return null; + } +}; +var appWindow; +if ("__TAURI_METADATA__" in window) { + appWindow = new WebviewWindow( + window.__TAURI_METADATA__.__currentWindow.label, + { + skip: true + } + ); +} else { + console.warn( + `Could not find "window.__TAURI_METADATA__". The "appWindow" value will reference the "main" window label. +Note that this is not an issue if running this frontend on a browser instead of a Tauri window.` + ); + appWindow = new WebviewWindow("main", { + skip: true + }); +} +function mapMonitor(m) { + return m === null ? null : { + name: m.name, + scaleFactor: m.scaleFactor, + position: new PhysicalPosition(m.position.x, m.position.y), + size: new PhysicalSize(m.size.width, m.size.height) + }; +} +async function currentMonitor() { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + cmd: { + type: "currentMonitor" + } + } + } + }).then(mapMonitor); +} +async function primaryMonitor() { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + cmd: { + type: "primaryMonitor" + } + } + } + }).then(mapMonitor); +} +async function availableMonitors() { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + cmd: { + type: "availableMonitors" + } + } + } + }).then((ms) => ms.map(mapMonitor)); +} +export { + CloseRequestedEvent, + LogicalPosition, + LogicalSize, + PhysicalPosition, + PhysicalSize, + UserAttentionType, + WebviewWindow, + WebviewWindowHandle, + WindowManager, + appWindow, + availableMonitors, + currentMonitor, + getAll, + getCurrent, + primaryMonitor +}; diff --git a/examples/api/src/main.rs b/examples/api/src/main.rs index c317bcc..c3f88ef 100644 --- a/examples/api/src/main.rs +++ b/examples/api/src/main.rs @@ -20,6 +20,9 @@ fn Header(cx: Scope) -> View { a(href="/communication") { "Communication" } + a(href="/window") { + "Window" + } } } } diff --git a/examples/api/src/views/mod.rs b/examples/api/src/views/mod.rs index 88f6dca..f735ed2 100644 --- a/examples/api/src/views/mod.rs +++ b/examples/api/src/views/mod.rs @@ -2,6 +2,7 @@ mod app; mod clipboard; mod communication; mod welcome; +mod window; use sycamore::view::View; use sycamore_router::Route; @@ -15,6 +16,8 @@ pub enum Page { Clipboard, #[to("/communication")] Communication, + #[to("/window")] + Window, #[not_found] NotFound } @@ -24,6 +27,7 @@ pub fn switch(cx: Scope, route: &ReadSignal) -> View { Page::App => app::App(cx), Page::Clipboard => clipboard::Clipboard(cx), Page::Communication => communication::Communication(cx), + Page::Window => window::Window(cx), Page::NotFound => welcome::Welcome(cx) } } \ No newline at end of file diff --git a/examples/api/src/views/window.rs b/examples/api/src/views/window.rs new file mode 100644 index 0000000..a8e67e8 --- /dev/null +++ b/examples/api/src/views/window.rs @@ -0,0 +1,63 @@ +use sycamore::prelude::*; +use tauri_sys::window; + +#[component] +pub fn Window(cx: Scope) -> View { + let get_current = |_| { + let win = window::current_window(); + + log::debug!("{:?}", win); + }; + + let get_all = |_| { + let windows = window::all_windows(); + + log::debug!("{:?}", windows); + }; + + let get_current_monitor = |_| { + sycamore::futures::spawn_local(async move { + let monitor = window::current_monitor().await; + + log::debug!("{:?}", monitor); + }); + }; + + let get_primary_monitor = |_| { + sycamore::futures::spawn_local(async move { + let monitor = window::primary_monitor().await; + + log::debug!("{:?}", monitor); + }); + }; + + let get_all_monitors = |_| { + sycamore::futures::spawn_local(async move { + let monitors = window::available_monitors().await.collect::>(); + + log::debug!("{:?}", monitors); + }); + }; + + view! { cx, + div { + button(class="btn",id="get_name",on:click=get_current) { + "Get Current Window" + } + button(class="btn",id="get_version",on:click=get_all) { + "Get All Windows" + } + } + div { + button(class="btn",id="get_tauri_version",on:click=get_current_monitor) { + "Get Current Monitor" + } + button(class="btn",id="get_tauri_version",on:click=get_primary_monitor) { + "Get Primary Monitor" + } + button(class="btn",id="get_tauri_version",on:click=get_all_monitors) { + "Get All Monitors" + } + } + } +} diff --git a/src/lib.rs b/src/lib.rs index 20d4fbd..83deaf5 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -10,6 +10,8 @@ pub mod event; pub mod mocks; #[cfg(feature = "tauri")] pub mod tauri; +#[cfg(feature = "window")] +pub mod window; #[derive(Debug, thiserror::Error)] pub enum Error { diff --git a/src/window.rs b/src/window.rs new file mode 100644 index 0000000..7ca5385 --- /dev/null +++ b/src/window.rs @@ -0,0 +1,744 @@ +use crate::event::Event; +use serde::{de::DeserializeOwned, Serialize}; +use std::fmt::Display; +use wasm_bindgen::{prelude::Closure, JsCast, JsValue}; + +#[derive(Debug, Clone, PartialEq)] +pub enum Theme { + Light, + Dark, +} + +#[derive(Debug, Clone, PartialEq)] +pub enum TitleBarStyle { + Visible, + Transparent, + Overlay, +} + +#[derive(Debug, Clone, PartialEq)] +pub enum UserAttentionType { + Critical = 1, + Informational, +} + +#[derive(Debug, Clone, PartialEq)] +pub enum Position { + Physical(PhysicalPosition), + Logical(LogicalPosition), +} + +#[derive(Debug, Clone, PartialEq)] +pub enum Size { + Physical(PhysicalSize), + Logical(LogicalSize), +} + +#[derive(Debug, Clone, PartialEq)] +pub enum CursorIcon { + Default, + Crosshair, + Hand, + Arrow, + Move, + Text, + Wait, + Help, + Progress, + // something cannot be done + NotAllowed, + ContextMenu, + Cell, + VerticalText, + Alias, + Copy, + NoDrop, + // something can be grabbed + Grab, + /// something is grabbed + Grabbing, + AllScroll, + ZoomIn, + ZoomOut, + // edge is to be moved + EResize, + NResize, + NeResize, + NwResize, + SResize, + SeResize, + SwResize, + WResize, + EwResize, + NsResize, + NeswResize, + NwseResize, + ColResize, + RowResize, +} + +impl Display for CursorIcon { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + CursorIcon::Default => write!(f, "default"), + CursorIcon::Crosshair => write!(f, "crosshair"), + CursorIcon::Hand => write!(f, "hand"), + CursorIcon::Arrow => write!(f, "arrow"), + CursorIcon::Move => write!(f, "move"), + CursorIcon::Text => write!(f, "text"), + CursorIcon::Wait => write!(f, "wait"), + CursorIcon::Help => write!(f, "help"), + CursorIcon::Progress => write!(f, "progress"), + CursorIcon::NotAllowed => write!(f, "notAllowed"), + CursorIcon::ContextMenu => write!(f, "contextMenu"), + CursorIcon::Cell => write!(f, "cell"), + CursorIcon::VerticalText => write!(f, "verticalText"), + CursorIcon::Alias => write!(f, "alias"), + CursorIcon::Copy => write!(f, "copy"), + CursorIcon::NoDrop => write!(f, "noDrop"), + CursorIcon::Grab => write!(f, "grab"), + CursorIcon::Grabbing => write!(f, "grabbing"), + CursorIcon::AllScroll => write!(f, "allScroll"), + CursorIcon::ZoomIn => write!(f, "zoomIn"), + CursorIcon::ZoomOut => write!(f, "zoomOut"), + CursorIcon::EResize => write!(f, "eResize"), + CursorIcon::NResize => write!(f, "nResize"), + CursorIcon::NeResize => write!(f, "neResize"), + CursorIcon::NwResize => write!(f, "nwResize"), + CursorIcon::SResize => write!(f, "sResize"), + CursorIcon::SeResize => write!(f, "seResize"), + CursorIcon::SwResize => write!(f, "swResize"), + CursorIcon::WResize => write!(f, "wResize"), + CursorIcon::EwResize => write!(f, "ewResize"), + CursorIcon::NsResize => write!(f, "nsResize"), + CursorIcon::NeswResize => write!(f, "neswResize"), + CursorIcon::NwseResize => write!(f, "nwseResize"), + CursorIcon::ColResize => write!(f, "colResize"), + CursorIcon::RowResize => write!(f, "rowResize"), + } + } +} + +#[derive(Debug, Clone, PartialEq)] +pub struct WebviewWindow(inner::WebviewWindow); + +impl WebviewWindow { + pub fn new(label: &str, options: ()) -> Self { + Self(inner::WebviewWindow::new(label, options)) + } + + pub fn get_by_label(label: &str) -> Option { + inner::WebviewWindow::getByLabel(label).map(Self) + } + + pub async fn scale_factor(&self) -> f64 { + self.0.scaleFactor().await.as_f64().unwrap() + } + + pub async fn inner_position(&self) -> PhysicalPosition { + PhysicalPosition(self.0.innerPosition().await.unchecked_into()) + } + + pub async fn outer_position(&self) -> PhysicalPosition { + PhysicalPosition(self.0.outerPosition().await.unchecked_into()) + } + + pub async fn inner_size(&self) -> PhysicalSize { + PhysicalSize(self.0.innerSize().await.unchecked_into()) + } + + pub async fn outer_size(&self) -> PhysicalSize { + PhysicalSize(self.0.outerSize().await.unchecked_into()) + } + + pub async fn is_fullscreen(&self) -> bool { + self.0.isFullscreen().await.as_bool().unwrap() + } + + pub async fn is_maximized(&self) -> bool { + self.0.isMaximized().await.as_bool().unwrap() + } + + pub async fn is_decorated(&self) -> bool { + self.0.isDecorated().await.as_bool().unwrap() + } + + pub async fn is_resizable(&self) -> bool { + self.0.isResizable().await.as_bool().unwrap() + } + + pub async fn is_visible(&self) -> bool { + self.0.isVisible().await.as_bool().unwrap() + } + + pub async fn theme(&self) -> Theme { + match self.0.theme().await.as_string().unwrap().as_str() { + "light" => Theme::Light, + "dark" => Theme::Dark, + _ => panic!("Unknown theme"), + } + } + + pub async fn center(&self) { + self.0.center().await; + } + + pub async fn request_user_attention(&self, request_type: UserAttentionType) { + self.0.requestUserAttention(request_type as u32).await; + } + + pub async fn set_resizable(&self, resizable: bool) { + self.0.setResizable(resizable).await; + } + + pub async fn set_title(&self, title: impl AsRef) { + self.0.setTitle(title.as_ref()).await; + } + + pub async fn maximize(&self) { + self.0.maximize().await; + } + + pub async fn unmaximize(&self) { + self.0.unmaximize().await; + } + + pub async fn toggle_maximize(&self) { + self.0.toggleMaximize().await; + } + + pub async fn minimize(&self) { + self.0.minimize().await; + } + + pub async fn unminimize(&self) { + self.0.unminimize().await; + } + + pub async fn show(&self) { + self.0.show().await; + } + + pub async fn hide(&self) { + self.0.hide().await; + } + + pub async fn close(&self) { + self.0.close().await; + } + + pub async fn set_decorations(&self, decorations: bool) { + self.0.setDecorations(decorations).await; + } + + pub async fn set_always_on_top(&self, always_on_top: bool) { + self.0.setAlwaysOnTop(always_on_top).await; + } + + pub async fn set_size(&self, size: Size) { + match size { + Size::Physical(size) => self.0.setSizePhysical(size.0).await, + Size::Logical(size) => self.0.setSizeLogical(size.0).await, + }; + } + + pub async fn set_min_size(&self, size: Option) { + match size { + None => self.0.setMinSizePhysical(None).await, + Some(Size::Physical(size)) => self.0.setMinSizePhysical(Some(size.0)).await, + Some(Size::Logical(size)) => self.0.setMinSizeLogical(Some(size.0)).await, + } + } + + pub async fn set_max_size(&self, size: Option) { + match size { + None => self.0.setMaxSizePhysical(None).await, + Some(Size::Physical(size)) => self.0.setMaxSizePhysical(Some(size.0)).await, + Some(Size::Logical(size)) => self.0.setMaxSizeLogical(Some(size.0)).await, + } + } + + pub async fn set_position(&self, position: Position) { + match position { + Position::Physical(pos) => self.0.setPositionPhysical(pos.0).await, + Position::Logical(pos) => self.0.setPositionLogical(pos.0).await, + } + } + + pub async fn set_fullscreen(&self, fullscreen: bool) { + self.0.setFullscreen(fullscreen).await; + } + + pub async fn set_focus(&self) { + self.0.setFocus().await; + } + + pub async fn set_icon(&self, icon: &[u8]) { + self.0.setIcon(icon).await; + } + + pub async fn set_skip_taskbar(&self, skip: bool) { + self.0.setSkipTaskbar(skip).await; + } + + pub async fn set_cursor_grab(&self, grab: bool) { + self.0.setCursorGrab(grab).await; + } + + pub async fn set_cursor_visible(&self, visible: bool) { + self.0.setCursorVisible(visible).await; + } + + pub async fn set_cursor_icon(&self, icon: CursorIcon) { + self.0.setCursorIcon(&icon.to_string()).await; + } + + pub async fn set_cursor_position(&self, position: Position) { + match position { + Position::Physical(pos) => self.0.setCursorPositionPhysical(pos.0).await, + Position::Logical(pos) => self.0.setCursorPositionLogical(pos.0).await, + } + } + + pub async fn set_ignore_cursor_events(&self, ignore: bool) { + self.0.setIgnoreCursorEvents(ignore).await; + } + + pub async fn start_dragging(&self) { + self.0.startDragging().await; + } + + #[inline(always)] + pub async fn emit(&self, event: &str, payload: &T) { + self.0 + .emit(event, serde_wasm_bindgen::to_value(payload).unwrap()) + .await; + } + + #[inline(always)] + pub async fn listen(&self, event: &str, mut handler: H) -> impl FnOnce() + where + T: DeserializeOwned, + H: FnMut(Event) + 'static, + { + let closure = Closure::::new(move |raw| { + (handler)(serde_wasm_bindgen::from_value(raw).unwrap()) + }); + + let unlisten = self.0.listen(event, &closure).await; + + closure.forget(); + + let unlisten = js_sys::Function::from(unlisten); + move || { + unlisten.call0(&wasm_bindgen::JsValue::NULL).unwrap(); + } + } + + #[inline(always)] + pub async fn once(&self, event: &str, mut handler: H) -> impl FnOnce() + where + T: DeserializeOwned, + H: FnMut(Event) + 'static, + { + let closure = Closure::::new(move |raw| { + (handler)(serde_wasm_bindgen::from_value(raw).unwrap()) + }); + + let unlisten = self.0.once(event, &closure).await; + + closure.forget(); + + let unlisten = js_sys::Function::from(unlisten); + move || { + unlisten.call0(&wasm_bindgen::JsValue::NULL).unwrap(); + } + } +} + +#[derive(Debug, Clone, PartialEq)] +pub struct LogicalPosition(inner::LogicalPosition); + +impl LogicalPosition { + pub fn new(x: u32, y: u32) -> Self { + Self(inner::LogicalPosition::new(x, y)) + } + + pub fn x(&self) -> u32 { + self.0.x() + } + pub fn set_x(&self, x: u32) { + self.0.set_x(x) + } + pub fn y(&self) -> u32 { + self.0.y() + } + pub fn set_y(&self, y: u32) { + self.0.set_y(y) + } +} + +#[derive(Debug, Clone, PartialEq)] +pub struct PhysicalPosition(inner::PhysicalPosition); + +impl PhysicalPosition { + pub fn new(x: u32, y: u32) -> Self { + Self(inner::PhysicalPosition::new(x, y)) + } + + pub fn to_logical(self, scale_factor: u32) -> LogicalPosition { + LogicalPosition(self.0.toLogical(scale_factor)) + } + + pub fn x(&self) -> u32 { + self.0.x() + } + pub fn set_x(&self, x: u32) { + self.0.set_x(x) + } + pub fn y(&self) -> u32 { + self.0.y() + } + pub fn set_y(&self, y: u32) { + self.0.set_y(y) + } +} + +#[derive(Debug, Clone, PartialEq)] +pub struct LogicalSize(inner::LogicalSize); + +impl LogicalSize { + pub fn new(x: u32, y: u32) -> Self { + Self(inner::LogicalSize::new(x, y)) + } + + pub fn width(&self) -> u32 { + self.0.width() + } + pub fn set_width(&self, x: u32) { + self.0.set_width(x) + } + pub fn height(&self) -> u32 { + self.0.height() + } + pub fn set_height(&self, y: u32) { + self.0.set_height(y) + } +} + +#[derive(Debug, Clone, PartialEq)] +pub struct PhysicalSize(inner::PhysicalSize); + +impl PhysicalSize { + pub fn new(x: u32, y: u32) -> Self { + Self(inner::PhysicalSize::new(x, y)) + } + + pub fn to_logical(self, scale_factor: u32) -> LogicalSize { + LogicalSize(self.0.toLogical(scale_factor)) + } + + pub fn width(&self) -> u32 { + self.0.width() + } + pub fn set_width(&self, x: u32) { + self.0.set_width(x) + } + pub fn height(&self) -> u32 { + self.0.height() + } + pub fn set_height(&self, y: u32) { + self.0.set_height(y) + } +} + +#[derive(Debug, Clone, PartialEq)] +pub struct Monitor(JsValue); + +impl Monitor { + pub fn name(&self) -> Option { + let raw = js_sys::Reflect::get(&self.0, &JsValue::from_str("name")).unwrap(); + + raw.as_string() + } + + pub fn size(&self) -> PhysicalSize { + let raw = js_sys::Reflect::get(&self.0, &JsValue::from_str("size")).unwrap(); + + PhysicalSize(raw.unchecked_into()) + } + + pub fn position(&self) -> PhysicalPosition { + let raw = js_sys::Reflect::get(&self.0, &JsValue::from_str("position")).unwrap(); + + PhysicalPosition(raw.unchecked_into()) + } + + pub fn scale_factor(&self) -> u32 { + let raw = js_sys::Reflect::get(&self.0, &JsValue::from_str("size")) + .unwrap() + .as_f64() + .unwrap(); + + raw as u32 + } +} + +pub fn current_window() -> WebviewWindow { + WebviewWindow(inner::getCurrent()) +} + +pub fn all_windows() -> Vec { + inner::getAll().into_iter().map(WebviewWindow).collect() +} + +pub async fn current_monitor() -> Monitor { + Monitor(inner::currentMonitor().await) +} +pub async fn primary_monitor() -> Monitor { + Monitor(inner::primaryMonitor().await) +} + +#[derive(Debug, Clone)] +pub struct AvailableMonitors { + idx: u32, + array: js_sys::Array, +} + +impl Iterator for AvailableMonitors { + type Item = Monitor; + + fn next(&mut self) -> Option { + let raw = self.array.get(self.idx); + + if raw.is_undefined() { + None + } else { + let monitor = Monitor(raw); + self.idx += 1; + + Some(monitor) + } + } +} + +pub async fn available_monitors() -> AvailableMonitors { + AvailableMonitors { + idx: 0, + array: inner::availableMonitors().await.unchecked_into() + } +} + +mod inner { + use wasm_bindgen::{ + prelude::{wasm_bindgen, Closure}, + JsValue, + }; + + #[wasm_bindgen(module = "/dist/window.js")] + extern "C" { + #[derive(Debug, Clone, PartialEq)] + pub type LogicalPosition; + #[wasm_bindgen(constructor)] + pub fn new(x: u32, y: u32) -> LogicalPosition; + #[wasm_bindgen(method, getter)] + pub fn x(this: &LogicalPosition) -> u32; + #[wasm_bindgen(method, setter)] + pub fn set_x(this: &LogicalPosition, x: u32); + #[wasm_bindgen(method, getter)] + pub fn y(this: &LogicalPosition) -> u32; + #[wasm_bindgen(method, setter)] + pub fn set_y(this: &LogicalPosition, y: u32); + } + + #[wasm_bindgen(module = "/dist/window.js")] + extern "C" { + #[derive(Debug, Clone, PartialEq)] + pub type PhysicalPosition; + #[wasm_bindgen(constructor)] + pub fn new(x: u32, y: u32) -> PhysicalPosition; + #[wasm_bindgen(method)] + pub fn toLogical(this: &PhysicalPosition, scaleFactor: u32) -> LogicalPosition; + #[wasm_bindgen(method, getter)] + pub fn x(this: &PhysicalPosition) -> u32; + #[wasm_bindgen(method, setter)] + pub fn set_x(this: &PhysicalPosition, x: u32); + #[wasm_bindgen(method, getter)] + pub fn y(this: &PhysicalPosition) -> u32; + #[wasm_bindgen(method, setter)] + pub fn set_y(this: &PhysicalPosition, y: u32); + } + + #[wasm_bindgen(module = "/dist/window.js")] + extern "C" { + #[derive(Debug, Clone, PartialEq)] + pub type LogicalSize; + #[wasm_bindgen(constructor)] + pub fn new(width: u32, height: u32) -> LogicalSize; + #[wasm_bindgen(method, getter)] + pub fn width(this: &LogicalSize) -> u32; + #[wasm_bindgen(method, setter)] + pub fn set_width(this: &LogicalSize, width: u32); + #[wasm_bindgen(method, getter)] + pub fn height(this: &LogicalSize) -> u32; + #[wasm_bindgen(method, setter)] + pub fn set_height(this: &LogicalSize, height: u32); + } + + #[wasm_bindgen(module = "/dist/window.js")] + extern "C" { + #[derive(Debug, Clone, PartialEq)] + pub type PhysicalSize; + #[wasm_bindgen(constructor)] + pub fn new(width: u32, height: u32) -> PhysicalSize; + #[wasm_bindgen(method)] + pub fn toLogical(this: &PhysicalSize, scaleFactor: u32) -> LogicalSize; + #[wasm_bindgen(method, getter)] + pub fn width(this: &PhysicalSize) -> u32; + #[wasm_bindgen(method, setter)] + pub fn set_width(this: &PhysicalSize, width: u32); + #[wasm_bindgen(method, getter)] + pub fn height(this: &PhysicalSize) -> u32; + #[wasm_bindgen(method, setter)] + pub fn set_height(this: &PhysicalSize, height: u32); + } + + #[wasm_bindgen(module = "/dist/window.js")] + extern "C" { + #[derive(Debug, Clone, PartialEq)] + pub type WebviewWindowHandle; + #[wasm_bindgen(constructor)] + pub fn new(label: &str) -> WebviewWindowHandle; + #[wasm_bindgen(method)] + pub async fn listen( + this: &WebviewWindowHandle, + event: &str, + handler: &Closure, + ) -> JsValue; + #[wasm_bindgen(method)] + pub async fn once( + this: &WebviewWindowHandle, + event: &str, + handler: &Closure, + ) -> JsValue; + #[wasm_bindgen(method)] + pub async fn emit(this: &WebviewWindowHandle, event: &str, payload: JsValue); + } + + #[wasm_bindgen(module = "/dist/window.js")] + extern "C" { + #[wasm_bindgen(extends = WebviewWindowHandle)] + #[derive(Debug, Clone, PartialEq)] + pub type WindowManager; + #[wasm_bindgen(constructor)] + pub fn new(label: &str) -> WindowManager; + #[wasm_bindgen(method)] + pub async fn scaleFactor(this: &WindowManager) -> JsValue; + #[wasm_bindgen(method)] + pub async fn innerPosition(this: &WindowManager) -> JsValue; + #[wasm_bindgen(method)] + pub async fn outerPosition(this: &WindowManager) -> JsValue; + #[wasm_bindgen(method)] + pub async fn innerSize(this: &WindowManager) -> JsValue; + #[wasm_bindgen(method)] + pub async fn outerSize(this: &WindowManager) -> JsValue; + #[wasm_bindgen(method)] + pub async fn isFullscreen(this: &WindowManager) -> JsValue; + #[wasm_bindgen(method)] + pub async fn isMaximized(this: &WindowManager) -> JsValue; + #[wasm_bindgen(method)] + pub async fn isDecorated(this: &WindowManager) -> JsValue; + #[wasm_bindgen(method)] + pub async fn isResizable(this: &WindowManager) -> JsValue; + #[wasm_bindgen(method)] + pub async fn isVisible(this: &WindowManager) -> JsValue; + #[wasm_bindgen(method)] + pub async fn theme(this: &WindowManager) -> JsValue; + #[wasm_bindgen(method)] + pub async fn center(this: &WindowManager); + #[wasm_bindgen(method)] + pub async fn requestUserAttention(this: &WindowManager, requestType: u32); + #[wasm_bindgen(method)] + pub async fn setResizable(this: &WindowManager, resizable: bool); + #[wasm_bindgen(method)] + pub async fn setTitle(this: &WindowManager, title: &str); + #[wasm_bindgen(method)] + pub async fn maximize(this: &WindowManager); + #[wasm_bindgen(method)] + pub async fn unmaximize(this: &WindowManager); + #[wasm_bindgen(method)] + pub async fn toggleMaximize(this: &WindowManager); + #[wasm_bindgen(method)] + pub async fn minimize(this: &WindowManager); + #[wasm_bindgen(method)] + pub async fn unminimize(this: &WindowManager); + #[wasm_bindgen(method)] + pub async fn show(this: &WindowManager); + #[wasm_bindgen(method)] + pub async fn hide(this: &WindowManager); + #[wasm_bindgen(method)] + pub async fn close(this: &WindowManager); + #[wasm_bindgen(method)] + pub async fn setDecorations(this: &WindowManager, decorations: bool); + #[wasm_bindgen(method)] + pub async fn setAlwaysOnTop(this: &WindowManager, alwaysOnTop: bool); + #[wasm_bindgen(method, js_name = setSize)] + pub async fn setSizePhysical(this: &WindowManager, size: PhysicalSize); + #[wasm_bindgen(method, js_name = setSize)] + pub async fn setSizeLogical(this: &WindowManager, size: LogicalSize); + #[wasm_bindgen(method, js_name = setMinSize)] + pub async fn setMinSizePhysical(this: &WindowManager, size: Option); + #[wasm_bindgen(method, js_name = setMinSize)] + pub async fn setMinSizeLogical(this: &WindowManager, size: Option); + #[wasm_bindgen(method, js_name = setMaxSize)] + pub async fn setMaxSizePhysical(this: &WindowManager, size: Option); + #[wasm_bindgen(method, js_name = setMinSize)] + pub async fn setMaxSizeLogical(this: &WindowManager, size: Option); + #[wasm_bindgen(method, js_name = setPosition)] + pub async fn setPositionPhysical(this: &WindowManager, position: PhysicalPosition); + #[wasm_bindgen(method, js_name = setPosition)] + pub async fn setPositionLogical(this: &WindowManager, position: LogicalPosition); + #[wasm_bindgen(method)] + pub async fn setFullscreen(this: &WindowManager, fullscreen: bool); + #[wasm_bindgen(method)] + pub async fn setFocus(this: &WindowManager); + #[wasm_bindgen(method)] + pub async fn setIcon(this: &WindowManager, icon: &[u8]); + #[wasm_bindgen(method)] + pub async fn setSkipTaskbar(this: &WindowManager, skip: bool); + #[wasm_bindgen(method)] + pub async fn setCursorGrab(this: &WindowManager, grab: bool); + #[wasm_bindgen(method)] + pub async fn setCursorVisible(this: &WindowManager, visible: bool); + #[wasm_bindgen(method)] + pub async fn setCursorIcon(this: &WindowManager, icon: &str); + #[wasm_bindgen(method, js_name = setCursorPosition)] + pub async fn setCursorPositionPhysical(this: &WindowManager, position: PhysicalPosition); + #[wasm_bindgen(method, js_name = setCursorPosition)] + pub async fn setCursorPositionLogical(this: &WindowManager, position: LogicalPosition); + #[wasm_bindgen(method)] + pub async fn setIgnoreCursorEvents(this: &WindowManager, ignore: bool); + #[wasm_bindgen(method)] + pub async fn startDragging(this: &WindowManager); + } + + #[wasm_bindgen(module = "/dist/window.js")] + extern "C" { + #[wasm_bindgen(extends = WindowManager)] + #[derive(Debug, Clone, PartialEq)] + pub type WebviewWindow; + #[wasm_bindgen(constructor)] + pub fn new(label: &str, options: ()) -> WebviewWindow; + #[wasm_bindgen(static_method_of = WebviewWindow)] + pub fn getByLabel(label: &str) -> Option; + } + + #[wasm_bindgen(module = "/dist/window.js")] + extern "C" { + pub fn getCurrent() -> WebviewWindow; + pub fn getAll() -> Vec; + pub async fn currentMonitor() -> JsValue; + pub async fn primaryMonitor() -> JsValue; + pub async fn availableMonitors() -> JsValue; + } +} From b3e477ed188f50399978da386cdec8c83245dc1f Mon Sep 17 00:00:00 2001 From: Jonas Kruckenberg Date: Thu, 3 Nov 2022 18:52:06 +0100 Subject: [PATCH 2/6] remove api example --- examples/api/.gitignore | 3 - examples/api/.taurignore | 3 - examples/api/Cargo.toml | 21 --- examples/api/Trunk.toml | 16 --- examples/api/index.html | 12 -- examples/api/public/tauri_logo.png | Bin 2810 -> 0 bytes examples/api/shared/Cargo.toml | 9 -- examples/api/shared/src/lib.rs | 12 -- examples/api/src-tauri/.gitignore | 4 - examples/api/src-tauri/Cargo.toml | 28 ---- examples/api/src-tauri/build.rs | 3 - examples/api/src-tauri/icons/128x128.png | Bin 3512 -> 0 bytes examples/api/src-tauri/icons/128x128@2x.png | Bin 7012 -> 0 bytes examples/api/src-tauri/icons/32x32.png | Bin 974 -> 0 bytes .../api/src-tauri/icons/Square107x107Logo.png | Bin 2863 -> 0 bytes .../api/src-tauri/icons/Square142x142Logo.png | Bin 3858 -> 0 bytes .../api/src-tauri/icons/Square150x150Logo.png | Bin 3966 -> 0 bytes .../api/src-tauri/icons/Square284x284Logo.png | Bin 7737 -> 0 bytes .../api/src-tauri/icons/Square30x30Logo.png | Bin 903 -> 0 bytes .../api/src-tauri/icons/Square310x310Logo.png | Bin 8591 -> 0 bytes .../api/src-tauri/icons/Square44x44Logo.png | Bin 1299 -> 0 bytes .../api/src-tauri/icons/Square71x71Logo.png | Bin 2011 -> 0 bytes .../api/src-tauri/icons/Square89x89Logo.png | Bin 2468 -> 0 bytes examples/api/src-tauri/icons/StoreLogo.png | Bin 1523 -> 0 bytes examples/api/src-tauri/icons/icon.icns | Bin 98451 -> 0 bytes examples/api/src-tauri/icons/icon.ico | Bin 86642 -> 0 bytes examples/api/src-tauri/icons/icon.png | Bin 14183 -> 0 bytes examples/api/src-tauri/src/main.rs | 37 ------ examples/api/src-tauri/tauri.conf.json | 66 ---------- examples/api/src/main.rs | 82 ------------ examples/api/src/views/app.rs | 78 ------------ examples/api/src/views/clipboard.rs | 42 ------ examples/api/src/views/communication.rs | 90 ------------- examples/api/src/views/mod.rs | 33 ----- examples/api/src/views/welcome.rs | 10 -- examples/api/src/views/window.rs | 63 --------- examples/api/style.css | 120 ------------------ 37 files changed, 732 deletions(-) delete mode 100644 examples/api/.gitignore delete mode 100644 examples/api/.taurignore delete mode 100644 examples/api/Cargo.toml delete mode 100644 examples/api/Trunk.toml delete mode 100644 examples/api/index.html delete mode 100644 examples/api/public/tauri_logo.png delete mode 100644 examples/api/shared/Cargo.toml delete mode 100644 examples/api/shared/src/lib.rs delete mode 100644 examples/api/src-tauri/.gitignore delete mode 100644 examples/api/src-tauri/Cargo.toml delete mode 100644 examples/api/src-tauri/build.rs delete mode 100644 examples/api/src-tauri/icons/128x128.png delete mode 100644 examples/api/src-tauri/icons/128x128@2x.png delete mode 100644 examples/api/src-tauri/icons/32x32.png delete mode 100644 examples/api/src-tauri/icons/Square107x107Logo.png delete mode 100644 examples/api/src-tauri/icons/Square142x142Logo.png delete mode 100644 examples/api/src-tauri/icons/Square150x150Logo.png delete mode 100644 examples/api/src-tauri/icons/Square284x284Logo.png delete mode 100644 examples/api/src-tauri/icons/Square30x30Logo.png delete mode 100644 examples/api/src-tauri/icons/Square310x310Logo.png delete mode 100644 examples/api/src-tauri/icons/Square44x44Logo.png delete mode 100644 examples/api/src-tauri/icons/Square71x71Logo.png delete mode 100644 examples/api/src-tauri/icons/Square89x89Logo.png delete mode 100644 examples/api/src-tauri/icons/StoreLogo.png delete mode 100644 examples/api/src-tauri/icons/icon.icns delete mode 100644 examples/api/src-tauri/icons/icon.ico delete mode 100644 examples/api/src-tauri/icons/icon.png delete mode 100644 examples/api/src-tauri/src/main.rs delete mode 100644 examples/api/src-tauri/tauri.conf.json delete mode 100644 examples/api/src/main.rs delete mode 100644 examples/api/src/views/app.rs delete mode 100644 examples/api/src/views/clipboard.rs delete mode 100644 examples/api/src/views/communication.rs delete mode 100644 examples/api/src/views/mod.rs delete mode 100644 examples/api/src/views/welcome.rs delete mode 100644 examples/api/src/views/window.rs delete mode 100644 examples/api/style.css diff --git a/examples/api/.gitignore b/examples/api/.gitignore deleted file mode 100644 index 48c3ca4..0000000 --- a/examples/api/.gitignore +++ /dev/null @@ -1,3 +0,0 @@ -/dist/ -/target/ -/Cargo.lock diff --git a/examples/api/.taurignore b/examples/api/.taurignore deleted file mode 100644 index 1ebdc6d..0000000 --- a/examples/api/.taurignore +++ /dev/null @@ -1,3 +0,0 @@ -/src -/public -/Cargo.toml \ No newline at end of file diff --git a/examples/api/Cargo.toml b/examples/api/Cargo.toml deleted file mode 100644 index 37c7504..0000000 --- a/examples/api/Cargo.toml +++ /dev/null @@ -1,21 +0,0 @@ -[package] -name = "tauri-app-ui" -version = "0.0.0" -edition = "2021" - -# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html -[dependencies] -tauri-sys = { path = "../../", features = ["all"] } -serde = { version = "1.0.140", features = ["derive"] } -sycamore = { git = "https://github.com/sycamore-rs/sycamore", rev = "abd556cbc02047042dad2ebd04405e455a9b11b2", features = ["suspense", "hydrate"] } -sycamore-router = { git = "https://github.com/sycamore-rs/sycamore", rev = "abd556cbc02047042dad2ebd04405e455a9b11b2" } -log = "0.4.17" -wasm-logger = "0.2.0" -gloo-timers = "0.2.4" -shared = { path = "shared" } - -[features] -ssg = ["sycamore/ssr"] - -[workspace] -members = ["src-tauri", "shared"] diff --git a/examples/api/Trunk.toml b/examples/api/Trunk.toml deleted file mode 100644 index 60ac6db..0000000 --- a/examples/api/Trunk.toml +++ /dev/null @@ -1,16 +0,0 @@ -[build] -target = "./index.html" - -[watch] -ignore = ["./src-tauri"] - -[serve] -address = "127.0.0.1" -port = 1420 -open = false - -# [[hooks]] -# # Runs SSG on production builds -# stage = "post_build" -# command = "bash" -# command_arguments = ["-c", "if [[ $TRUNK_PROFILE == \"release\" ]]; then cargo run --release --features ssg -- $TRUNK_STAGING_DIR; fi"] diff --git a/examples/api/index.html b/examples/api/index.html deleted file mode 100644 index fc029e0..0000000 --- a/examples/api/index.html +++ /dev/null @@ -1,12 +0,0 @@ - - - - - Tauri + Yew App - - - - - - - diff --git a/examples/api/public/tauri_logo.png b/examples/api/public/tauri_logo.png deleted file mode 100644 index 2c53b8c4bd721c7346831ba6be581d03a0a4d755..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2810 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 diff --git a/examples/api/shared/Cargo.toml b/examples/api/shared/Cargo.toml deleted file mode 100644 index 92a9d17..0000000 --- a/examples/api/shared/Cargo.toml +++ /dev/null @@ -1,9 +0,0 @@ -[package] -name = "shared" -version = "0.1.0" -edition = "2021" - -# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html - -[dependencies] -serde = { version = "1.0.140", features = ["derive"] } \ No newline at end of file diff --git a/examples/api/shared/src/lib.rs b/examples/api/shared/src/lib.rs deleted file mode 100644 index 1ebbc1d..0000000 --- a/examples/api/shared/src/lib.rs +++ /dev/null @@ -1,12 +0,0 @@ -use serde::{Serialize, Deserialize}; - -#[derive(Debug, Clone, Serialize, Deserialize)] -pub struct Reply<'a> { - pub data: &'a str, -} - -#[derive(Debug, Clone, Serialize, Deserialize)] -pub struct RequestBody<'a> { - pub id: i32, - pub name: &'a str, -} \ No newline at end of file diff --git a/examples/api/src-tauri/.gitignore b/examples/api/src-tauri/.gitignore deleted file mode 100644 index f4dfb82..0000000 --- a/examples/api/src-tauri/.gitignore +++ /dev/null @@ -1,4 +0,0 @@ -# Generated by Cargo -# will have compiled files and executables -/target/ - diff --git a/examples/api/src-tauri/Cargo.toml b/examples/api/src-tauri/Cargo.toml deleted file mode 100644 index ee6ef6f..0000000 --- a/examples/api/src-tauri/Cargo.toml +++ /dev/null @@ -1,28 +0,0 @@ -[package] -name = "tauri-app" -version = "0.0.0" -description = "A Tauri App" -authors = ["you"] -license = "" -repository = "" -edition = "2021" -rust-version = "1.57" - -# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html - -[build-dependencies] -tauri-build = { git = "https://github.com/tauri-apps/tauri", features = [] } - -[dependencies] -serde_json = "1.0" -serde = { version = "1.0", features = ["derive"] } -tauri = { git = "https://github.com/tauri-apps/tauri", features = ["api-all"] } -shared = { path = "../shared" } - -[features] -# by default Tauri runs in production mode -# when `tauri dev` runs it is executed with `cargo run --no-default-features` if `devPath` is an URL -default = [ "custom-protocol" ] -# this feature is used used for production builds where `devPath` points to the filesystem -# DO NOT remove this -custom-protocol = [ "tauri/custom-protocol" ] diff --git a/examples/api/src-tauri/build.rs b/examples/api/src-tauri/build.rs deleted file mode 100644 index d860e1e..0000000 --- a/examples/api/src-tauri/build.rs +++ /dev/null @@ -1,3 +0,0 @@ -fn main() { - tauri_build::build() -} diff --git a/examples/api/src-tauri/icons/128x128.png b/examples/api/src-tauri/icons/128x128.png deleted file mode 100644 index 6be5e50e9b9ae84d9e2ee433f32ef446495eaf3b..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3512 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 diff --git a/examples/api/src-tauri/icons/128x128@2x.png b/examples/api/src-tauri/icons/128x128@2x.png deleted file mode 100644 index e81becee571e96f76aa5667f9324c05e5e7a4479..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 7012 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 Sh@|Ye~|0>}wMPLT8jm@Y!H33Sz}5aFI6 zM9Lzqz|;A*0sGs=2A1uU!1nk2dGF7knQwr99SAFen)x(eCO;F8y2C~0FD1YxRTPcy zPWVxkUYmeuz}Tv?7&Fe-!UE{)ZW)Mb;H)^#eHDv$`dkZGguJz@^MA!ZNGAUqt{|0H zpZ7Ch9S`q5!>R%}>}62!+(T^evyO+ImSo2wpu)su4^3nw5(%)KD%gbSev^*HZZ&3( z#&c@Z0gH|}Ck)w6fh0&NBJ62ib%R}(3@$VFl*_#l2W$wQ-~4RmZZAt5O*^2Q5}Xr8Hy@c`#pM?kc?hFWxRXr*mUfUCXf4ka5DD~ zat6d85COB05l#(P9*cQZ3EC8fVdS~?&vN#rce(aF9@xp80O2{{FBvU+{X>Hoh;xI` z{$e^Nw1y*VbO8wv`8|-m?NwNaKGTGaF{P^JLB^DbOYWIbn%eT`*!^C1H36=O8Z-M> zkD~88ry`eSo`tEBN4>w7OWZwUzlh{WM1m8R6zepqGcGMaV7vWY9b?K4b6~|HVG)ec wi>I@ws#sZo7or4_*4M>7;p5{nr2pZ?Uu4>Krr0kU)&Kwi07*qoM6N<$f)&@lf&c&j diff --git a/examples/api/src-tauri/icons/Square107x107Logo.png b/examples/api/src-tauri/icons/Square107x107Logo.png deleted file mode 100644 index 0ca4f27198838968bd60ed7d371bfa23496b7fe5..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2863 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 Y2S8W#vM)6=T>t<807*qoM6N<$f*y@n<^TWy diff --git a/examples/api/src-tauri/icons/Square284x284Logo.png b/examples/api/src-tauri/icons/Square284x284Logo.png deleted file mode 100644 index c021d2ba76619c08969ab688db3b27f29257aa6f..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 7737 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 diff --git a/examples/api/src-tauri/icons/Square30x30Logo.png b/examples/api/src-tauri/icons/Square30x30Logo.png deleted file mode 100644 index 621970023096ed9f494ba18ace15421a45cd65fa..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 903 zcmV;219<$2P)2 z+CUKPMqaqGiH;zb!R4$B-WXS^YzQr=@UH>k4?*L)&R=zYjBrZenKdc9|JlS$SO*RJ zKt8FSTDAdk1g_WPAO!p^V!AuL;Lm;uQyV;zKq)J3i(;q*;k+pD%f3eltU`PYdy9(k0&%` zuWAPcV6|-y?|?7O1W!KSK}pbk8#~!|FA@(VJkt^V@0lio{afoAeo*f&$W2s6${5!1eKvAGD2$GZwSB98L2ZVS- zKn8ENRkZ*sb!@QugOrQNK3(sy1v%J#m|rpB+h|Nkqa3FRT>74xSs{#&saU2Lf!_Iq zKmuKAESh`gs!fneGWn+nf}l?7jE$HW!Af&vE5=G!QU)U2v&HLIBGXKk4nQx{hsHjL zLPMAo5=*uInFbq7(aa`Y2VX5wCmaeqvECOFv)a>0t>ZaEb*cJccER=BB?KFZhV$c^ znL*l8x*UYZv4WK|j?~Jt6~~F%{pk~z5A*>^M`?r5m9@RJ_x|uEtX(6Vk@Y()MVto* z93wr)%3m%|#OZ~srm>zF(JvDuTq*@;d&^>_BJm5hOU`3FjG70L#Vzv9I?`<7$T@

jU?lMi@tgxr7CqX_r3uw^y4tVU3Pm0sw;|1WSUO%?=bG`*Kmz6u4{#ti;T7AWIBAEh!(Y zz>O01&#X?Ds@L)Sb{CkG#Yz4$3o d@96)?#cz^xWoA}>B$xmI002ovPDHLkV1l3&k#zt7 diff --git a/examples/api/src-tauri/icons/Square310x310Logo.png b/examples/api/src-tauri/icons/Square310x310Logo.png deleted file mode 100644 index f9bc04839491e66c07b16ab03743c0c53b4109cc..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 8591 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 JPDHLkV1lm|RXG3v diff --git a/examples/api/src-tauri/icons/Square71x71Logo.png b/examples/api/src-tauri/icons/Square71x71Logo.png deleted file mode 100644 index 63440d7984936a9caa89275928d8dce97e4d033b..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2011 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∓t$dRJGIadE?vc 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 Kx8Vjl{{H|h@<;Lj diff --git a/examples/api/src-tauri/icons/icon.ico b/examples/api/src-tauri/icons/icon.ico deleted file mode 100644 index b3636e4b22ba65db9061cd60a77b02c92022dfd6..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 86642 zcmeEP2|U!>7oQpXz6;qIyGWagPzg~;i?ooGXpc%o)+~`MC6#O`?P*_Srl`>>O4^Vl zt=7su|8s`v_4?O)M!om+p5N#5ojdpUyUV%foO|y2yFUVfNMI)j3lqRqBrISj5XKP* z1VzP8|30{X1nva{bow>8iG-;V5CAR=-#C~+ST9E;Xn-Gr!ky0h;1D2Lf*4;X82+F5 z^O!~^Jf^7tRQm(w05$`n0FD500O1jY`PTJCTr&uF8&Ctd3%CcU15g0^07(D;)9Adf zstIlhAP-;y5Cn(-CIB#7-_;YEcYcq9pC`~SCax^yT;tqFlpu0SAAgb0M(%>+U?7k~|H%oqaU zG7;{Jz;i$ysD3TnZ-VD-5EkR2olyjs0?__2E-*ZQm7VF#;NSU+_7OmYx`1^UZOBN# zZ~z&=UqaKwI`Y#Ck2VnUWrsY50ipqDyIunt0QGGg8gr?2RTL#iQ3}^>n-k1l{K?P(24g%0NBOjQwp>0N6 zhjzBRS^h3uXS+k@hxlm#X1Zv9Hv0OTvCgXwwP zq#48g-{<`$)9@L955ofX03HIiAkD1kBgDb{vAtuK;{yB_#QPb z7^H|%!06@BiN3iB9Ci78{h)m}hG)EA_Y1zH`^*1Wf4llgsP9;I#3BHLhv)*3H@g5R zlV^Z+P(Cg!<3L6m(}8Vg0JP8Z6)1FRdI6mvlhg2JHsAe^X#fq({sQKWx@-!-`2=vgJA|ipM_2(ARW89@<$pz0wRD0er!Mg=)&?pq^Uuj`CRX?9*x7azbOAK z@H2G-^F}=%gkdm!Y=a>`Q^09J3jk?AHwd1ygZo_)zQ|)8q{l2D{8#x>{=D$a3qS*8 z111CAXbTwW4yLv;z_e*M;Xm3zM*5f!0C|LU zg0Iuw|9`uKynsF=_C>Le(g8pk&cc1r&p*nakv`gza{%N4>RJSp5&Mw;$GgsaI*5=q zmKXbCpZlKhA9*1IxDCMk>j5T!|4WB?1IvT?0BiuDe+(M19t1$Sg}`OV0>fk8pmV72 z*#F7{U_NW0eAu7a2&1HW%{zY}3)Up9h#SY3NF47`W8{X8O(W ze>OhDK0LaB@qi`(hS@cO+Q^{od->yi%maY-6m1cfpQ(>qnED85VcK)M(q-n4ZhYr6 z?DL`?bPNYS@*baIA02u2N7*x;b?F+k<*G9Px4US_gnGiT>6iw<41l`L%)cG}F9P5* zCd}dgCjf>?g|QY9W!Ign^11>c|FRO{UA~Ycj6Ga{hP6N!@P*9aA*6#kz6$UJfa8a) z0PLSLo}&x!1~BPEU4Uop-N_!}GWdt%ozXHBy3E`wDI75VA-wBVTOGd0>2?(2cQ9fd87SHgfKkd{y|RPf7B@l#{7Ukq=937 zOc#Ow3jj#VQ2-6_9>9Fw2LE>h7~|aU=kVuGP^Lf!^3@q|AAsdz=JPEV<>d=;gux{Y zr8fO}CVvtF`Or1iSA;ZI04@NY0crqf2Qbg8fDHgW2v5Q|Kl{S^JB<1Pbg6?E@=*d9 z00sld071yJ+cxHB)Ap;SM`vCXf0#BfB^<>kvv01CC`J_@zV+k|RO1cjR9xrCYoxrEvTxwtwwxwz<|Ttaj%K_NO@n-D#) zNr4^!2~!9r^m2kfBuuAwurYI`<2*$GG7aW4KF?FYzrJ}2WJ=%F$ALZ$^l_k%1AQFm z<3Jw=`Z&D9AVFj7Vcf(hBajw0PLk8I{=n~yu$%I0l1F|_gft6 za?!s75C&KbVeKIv>~A1Tfy;$^S>XP!%94LQ-B@QI(6mS(b1{&Y5y)*h$P4#F-2%J> z;97ngfVrOkM=plL@Ku28fHc5jNOw5wlMyMV>41&U{MYlew-@jM$UKSWi1i%z1sVeU zKu$RT+^g7KS^tq9eEF;u(!{-I7eKdsAg{ro3%svrg3zYu_I6hNtLVeJcZW6<_r{5W z9Kf!t?gQX{w06LkGW)Ckqi#J1q=PO@02+j=XySeC!(Xgr4?*rvXo^_hg@NZ&fcK|B z2DlINuaa|j(yf8~j{!Y)ppOEuSE|n*`~`aO2=*ree>s8Aroiumy+H0?>jvsU2GBPG z=;Qz${R_D8-%ApBNhqbs;@(qPsP93*<4VBSyzfo^a-b9TrmIOkfqmOJ7U{cs#sQQ) zjN@?6E7p1FcYWRy+?(Y6En4vXkrP0-VF^tK#w6-JW59nn7TQmcKkWG@&j((X0=~uP z-hQtH=${GYfcI4T+Jo+@Gt?Wj_aeZ%V30fWU4-5)>+jL`7Rs>(#)^V{I`GFD0J6ru zJp$e{Cnta(-$VKyUw@_h`2Ke!0N-K#V2j;&S(5D06(DAN%k8`()z$2V%`%#|b`*UD>8D~&L zfjyZ4X%7X+0)!wxe4mgDfbZ8~`;2`JoL7(s41@o(;6BPL5AYs<>HR28r~{iIFUbG< z@AQ6yJ^$)kD0}E5;k#wH_VT0k4(-N0KqT;ZG^8y7X~P(Twf+~h*GLnNJ^BG%;~+iM zg$IBi)lFDeAp61^B&;{GM$^Ah34q72ZljHSUI@JXk-0palP!RBya8n3E&I>nZmDB5BQO}=69e2E^yug@xMGa#CiPk&bb{6;AaJ(r}h=s>B2xhYWHEhjXL#L zT%9(7@eZyQ0^+7G~b+gU#t=Xw1ZKfZik4slKJ9O2%+pQ3AyfCw(M=Qv-4dl$%aK>pZ2JOOwN zfOhPg`f#K-+qWO7cwd|$IUdSh^PTd4DRbt393%OH+*zK({SkV9X522Fz`f}Lpc85U z2Po4f;6Xm%%Q??i@N5*^Biy1H{!9}7@wA}qI7a7yvc&_Kvh9w06?mcm_{Yoevk1Vl z0N_knRcUZx3`~Zz1sP}f!rBEn9PB^p%FoKKSEPgG0VqH@3s{gp&Z)SUG4}lad*uJ6 zK)Uz>^@6dsuoB7}0}uy%8SIz-UqsV~ecSl{6xkli)d1*Dy~i-u0J4Bzy8PWC9{V-0 z*AePHSq#dH>(bqc_Dh7pxzb{qHVNdv5z5tF+2eT6r+_v9*2sRm?(d~}!CI3X@R+fO zoD8(s0hVAMoi6GoSrhVtd3{CD)xLeZKTEk#eqiT>f!7yVkUy*kGTy)ZVKPwvpnl;T z`v^!A_m!0Za8DNM81Cyp7yIPcH{S&?g|I)oo`h#o!}+OPa3-cMoSP{J;MVKGIjld- zfPXjv;3wLCZE(u~-L3ywAUFOWt@~Z=E9f4173BS_oB6+h@arKi>__T(KMc=hA3|+~ zb5c9-T=pVBI$!}{Am{{t*O}@6uyp>~?DJ_RAbZCAIIfj;x9!KdvsGm@d9WKjxBXw( z9UNE|d{;sF z_vFHOopqlvmjeBWZs+?gx~d^9E1Z`t?!kNBAXAV(T^aBIz?A#fE}m6h0tf(IQ5`|8 zBf?qzJt=yxi-YYa)J53m!8nWITm1djy=;&_w%I)@Pp9nFFwdkPlzkU%52T?`BIXX-^U=z+^%Y8wxZC4R-LQx=SMZCZEb4{{Hq(rkziK$fgt*zYTa{eX}c zj`x1XI~!fPKn~tVTZnBLOC$}2?{jXZZo}_~g!DlEs0TF=HxwX&x`gA2U+L`|6+@o_;pr6KgrvTE#aox*ecLry)%;_6Z@) zze9vSlt-8R1%ZEO0pH{A*Y|h-$ec@8|6dRC>+XE-*ZF_#$2kC8J7Ad?(1(ZqUmMQr zYy>dBMaYzAPh9-=*ilGV9_2rrTFWv`e`kbF`7_4i`&f|wg~zbBzbE|0vZ0NJej2<_ z%J}~K*Rt$^pA2WYsQ2hy1C&wM9B_a5KMQ3Ccn9c-?3r=e!4B*Ky%IzF(wi@o1=@0u z1@xb~UH^+g_DT@GM@57AMwoNPbK=NWkVa45FZohOY9O5{xE9fq@d&d3Aa4SEn;826 zI2U9MI09gPCy^;vR@^2?%OB(q>x;ct2XOu$&%^_Ht^ir!y3Uup{oem~5ZBSp} zJ1vSD$M^;`GmqZn-i32If%hnXJ8*H${g3#~e1?2qih9H9c>Bw;ceXubDabPwz^V=a z4XOvhe#wDL$bzx|&%ChzHkA4S=JwjPpdP1!9GTy%{+_JAcmEF5e;tSq-{t)DGfDhu zX<gsXSELq@*pp%q)9^DAK#0I_4q!_Cj%`o79|^koZSIofLK5{ zz!RR01i1?r!h1Zdj`M$%fjCcWNd3SL?E-$Q8^7iJ2lf41&pN0Ow|{T!3o>me@YoT+ z%9_k2kO#~i{`cF;d$hq^ou(?_`Ave)BK9R^tr0vGp%v7!Uns5`xJ zEYR5oFven+S&%>4fCmtF5V$|3FZe6yMOR;d2(n)e!1dqm>Od{%jWzBqAJNP9jxo;c zfbXzDeO?N(WOY8~0Q4gz{#)$;?j7rp0ohYnkU!{2M?BaN4(vF4z%Mu@kbVPpa5hq-y7QiTo1TTGr@QImiNF0 z;93lf)79`S&hE1DFA0b9EHGz70zN}uy`2x{-?#=-o5BBc`(04~u`h@=Addz4*F(Gs z5FXlq#=oTeKawcQ4rGY)>a6SuVU7uL?rsk10N8^cA%o?(U{|4E*1-n6RRq@&_!|Mp z1i+eZ#~yHTkDo0-dNAzU#Wws$FRa58s1?`__&~b&o93$w4Xv0I@sVgJ>dOuKzIA%xSp2=P{uhq)S;eUC_{iCq;(R|UHLzPu&RKbX8V`M zyANkVpxmJT;(Nh&dSC<4R>0hV>LEyDa50>n0Q&S(X&yvv0l8!Q+XnA%cU)nC_e>d~ zJ-|Ji3Mhw3)Q3Hy58HsQJ*2*nPIvbT)IiuVm~U^r@Jy&^S_taE6p-VO?9(ZMG?u~m zQ0f7siR%qN0Sz_)Y+t%V1KKH9 zoCkpUn!xbLRB z{lIU9!!;u+U^%4AI5!Obvs{oae)j{nCwBj9IiUX#)PMe-%b)Qcp(Lb31AHs}Z{14( z+2eX5%jN$&BV^Mi;#w@~K!0%e1G>9U@LTd{-oteR&(1R=S?d=t&*cCcU;(_wcJy1k zW%b^3kOQ9k(IeJ&jRE+97VLv|H}8Eg{^RcL^&c66?`?IS6QK%ogN!{oKdJ*bzl`V1 zqF%AYb8Pp!*3ogS$2_;AyFCA1IA}vUrlW2#-U(ufA_AlR2i?KTaa z|4eX{70&5^i#mXI;OjkF%(~qj7v_sqodJZ$`K;N0=&Rwp83}mzGv3)@>I3SL7s|gU z^FoF&7d(nu3v>GI+gXtRIS7m6#(zejJ;=2PzNvtA0P3s^$Sx7U%6_3Q^#bMZ(kXux zmMFpcX+o{Rb~AwmUNhzVJr~DqJ_aBQ)B#p6BbY<7pjP4jutXMUIuBugDfu(`($yyv z279m;WQhARzm#ov{^R~Z_s;KXXfc!RmJ4!+z1gj}_8P_lufHdE=6yWdVMZ~(^MnwV?1SGI!}(@bF0{|cGk_bQ zyYqcaIe*W^ar<~o7xsCwLJlJ=>Lk#`1M&9*zL&?>_m4t*!Pk@ahGhc(q6nx1xQ`#& z131rxyaRLq=6$YR{Gma zzJKjv+mCC7>^~@fIf!2f_&WXX`J-`7`d6<1U+M?W7vF?&Vprb~&+f%DMX;auJw3qh zfy#p2_%fMp{Wqr8b-l0IZU+3WWP#`3lEr<9uM1$bE8QaCt3X|Ghk^SF@U1+)z6axt z4li7P#JmD9J;1YA6hO9~;9dfJYaJQiBQ@=b{E=T+Z@_+HpKBHH9M|){=5crY zZ$S<&c#c<3>mkYy`;CylGoY!PbbJK5r$ShQQ7=Cupr^Wt?*+m4UU4rGtO2V|03-m4 z0L=GHVGfDB>J?1{`;k4$2G?!j-5ep{C5{DHeP0{j=UWEy=SDg7^uo9RY&+rs-O)J= zQw2N^TIFQNqc0DH{Ik)Q`T;3mL*z8_f=#Q9SI&fVi$Pzm7A z<^&n%I70a85buZkUnoO>G=P=4|C^w9xNq#2k>k%I6lD!E$Mb_k;J-Ya+rYu<81QRa zPzS&kumMj808fJf*8r~p*e;+=hBF)KF9B4LyAOmXgWbUQyT49~CBGr{Bg6JXnl_Mj z9iY4Qe>dcf?-8+-Uti!q<^b>?>mu#}lmd4IxDLQ)C(sK!_&)?(c=w|9r}eoZJzO*9 zguD^~-IYDsAI7_YJ?(S+F&F-sr&yPuKPCYDkc0odeqHlta0%py`Zf?y3h1u<(GD2` zeg+A>CJmH7jLYF2XU3QuZ7{wc1!Hsuk9rNAKZ_77FN_;d&vEXcyZgRSN6tcAJX7Ll zkj)VzJmUG@7?dzT}BRtvs|D|2<*eNQulF> zxHp~!@o$qqo^OLZfpU!l_Z@&~4?n{H2LRY_+c6(p$nn{k$*_)4S~= zt`8bf>ygemKr<_Se$yGf0cSyf$l$`c znLqYUMtA9DH5|@2;oc*VJ=(Bhz#ot{IMgtn2fe!*(qze;$lA2271@8aaJ$RF%O z;W^skfL>QzGwK`WSYHw7Jj-I)P!}=*zwCN{cLjp|0L9KaG8@W^^DbZ4gFo`adVa?y z&>tbxquz2s8K7^2?-$Z>UST)j&*m7vF5@fE>2avnnAX4j>KY4*LRqr_U-RP6{J1s} z0k&2c+mnC#!uJEQO@nga9Pcgw_F?|43|~Lr20Y>Ejdty?;IARrfUbVPSm4!*9`FnL z1Re3vACSiOwkLaXenz=akAZefN4_)2(>e$Jgzw^VohZ1Uv!!nXZ28Iio)dbPFRN z{)-p(1-p2Ob?8wK`G~x&1szBRJ;FUU9Pt0Av(ueQCE&aq%t!G+`ePuU!+@UdD?ys` zAsu`t5Yp_OXFvaRCVnHqPCMEG`?Wi8JkY~4lo|C8>r**k69Dyq7x2UVX{_%?ARnlw zxOQa*z&RS+pYg3a-Q9cTkd7suCI4To`(LU8w4*pDfb(8H09N#9jjCVIk=Li7z41Ap*tNu5T-W=$!;5$m+rQyH! zptCQ~j&&>?c#Ly?tn&3+;V~UtTfn)MRgm^X0KUg54}f{3cHEN<=d7U1m{(E+Kc3Yx z3E&GrnPdCj1o&3^tloomioP877;vJ__g%l|0Ms|M1Gx4X1$_EhI>3|>+6A;NINrPm z$OBvioCDco{~gyHiUBVH*sk}aKhMnTTP~jSz8dQNFZ(^v-%IPS@!@$F@Xa;cvx$2I z>H**4<*#<{HI!!w*tq}99M6wvN0%MIws$GWAM4|*3#ScKo77F_p|#1U)Ix~`5(`5 z-Uf85sx!uT|E_myvx$&;OZ-kKf_Id8od%ns0LX*Sl#5_0|}^-3#>?)|}~VObmlQdn`4I zFq3-y*DF*X#eE#;<3Jw=`Z&0DllK&!ua>irA=OR!#{huigfYLykpEG3q4fw4D1dLk#*$?DE zR*-2|eh?M@!Cn8(8*QB-Kl__HQx0Gf*wo1@3e#WPNm)6QBek7>x*W{e1QYHG_SsJl z=qeDUE90iF0#TTReeJ*2NnZdwFaOL8Iz0eH6~IRCQ0RQj@Iw(gnEb$JSVU&|zz;?C zr+1PG_nH2#{J;;)F~R$c>$AU$uHXFrzkAMP5U>a0E6@YFGWgBkN%U{=J2U*v-M zci#H!FYoks$pa*&z_`)TDL)W&XFgr>{4DscijKB|A^0u_{gBz`U??$$pv!^9jH}Cn zP?&y3^+OSwbUp{aKf~g5`56*K7QtP{6@VFl8SL^xOrQ|O)^&jeG=bos{ZKXVVo-rW zx-2MzO7w%Y@cL{tATC}C_zW)~2rm4B7vI|oS7^3&4^870BpDV)RJjwhl(t9ZRT^x0Gu~~X zUyxI9Re%$v?0t%aStR**yJ?DTL7DAhf8%VnRHf9y^ZKv$4?j)S3=oN~a-Sn2RzA$9 zgpFgDM)fm_2t_1F{*eAemo1~SO$B0z#{(X|e}3IG)zYefm^veNfY~s@LGd+H3o--U zC8lnpEjg5yqYyRzO;E-**Rd7i6zUOV`%3ZcRWtZ}5 z?fMJK57(U9a>n%GbdJ_=2f~!`C+qIBZRee7d9qHup+586v+DuMLTowGsa1NL6Zaq7 z`&eD7XoQ}}xdXhJgac6voy zpi9;Tt4U(<3EFv%=8{_VCS-$Q96q}Q8Vwbw6PNKS=CLWAZJ@hJ%Ef zoD=7(_Me)6;DY3$U7aaE$!UW@_hG1(cM!gKX$To%9va(ZaThX za1H;|<*Bl}ZIi1-*4r1H2*21Kowoa$>k;ke&JwQ4hvx>wCVN3h-thM=le9~$IodM} z)t!^}DGN=nENZWOf79;txni!k1kHg^Ug2AJC>3*KuNb{`=kU|ES4&n|Kh&}E%{+q# zZW^D~9^R~~YpV<;5Z;ku6(KACLX7|8PSRnk8-q!j0<(EWO}j$Ta>+IBcV2xDdqJBG z$!IS3?S`yjXK$rQO%L{)mQb%3Svf!TjpLx2w;A&eXiOwdPJG|C-&tyAi7 zkL}||1YH_o-8@Vy>|)C*uMz!U?utEWDUozxw`)lA!!31hj&Cs;P)iRupD}O6#c<_= zqi;%#dYTh9LXJm|9g+*b-S&#TVzX!Ad%c#BZO=*T3a@jPi>2ns@a)M?BJCrvHOCXL z`h+-t;3*4US7tj>PN~#=*o}P)Jy)haF^uBdY{(%zD6h?m-Dmeg>88Duk^2VZM3Ts< z{Y%nm^UX#E+!ii+J|}Xl`6zRdGUeeyGi)bEx$)bNeZC;wz-@bm`iX6gAwDUu_ICIi zYzYo6ZjDb+mrNps$M(C`k$kk7eOqite2(ShlVuS@vB=?Gy{~> zMl@eA_gH%-wM^|ieJ_#Ei1>u}3BS(1#=T|IPn#Vy$B&aaNe|$sdIZfTtUXO>%ILSa z|0CV1ccJyZ`d7yB7;@-`jD40po&V#^lv;O+nbi$;b_&V-NWaF-sdq^Gv+pd)zr#Tr zTsZPd>Qc@DvWuo9gqC^k%)6LpH(T@YX0q;$n3zy=xuN`}t()1F5cZOFCUWZ#){~y_ z&o>U4;zGu><`@gQ7q2 z_z!fXs#_)7RXRns9oQLqYWJ%{J2vGQp(9A7NEZ>KZQ+H;hh5wnHkE^F0)kbgbu zjTq<3DYNI_1TMHJ`isspc(}GDN3Ghza>=X&Y6WxFkHBFy`ZU@#VhaN zY*EAD%C(B##BDQf3hdo@=z!caamxDR%S)xBPH6K~rbhZ*Rv>P&qNUYp(6(``)3)?D zyQpp3&APmg?sIjk4DH8&QJypMGRj^x3 zIL$fMnRl&({pzQ4oU1$=E>0~TG;wcrk#5lX2%5}3pO8Ju{#tQ<7gA@PD?XjEZC=VU zUKbOMD%;VqEjlk0_|`5bDH|!cUK(tA>nJoAYAucJ$xCh&M)q+H|hQ`qXiLU+c^ zYZGc~KMi%Cop<&e-Dd6dk1{|+tZwtvac{gr45|!-TFWLI`k2RZjlOv;;YRGIi7xTc zJJ+o)w2tEr*3+9_E?Rzrq9h@wkStJFs!=^={hKRRde>$o=3 zB)(X~x_v1?i}{N5#{WP5QmPVD$F-j$*C@kJyYS-#c^rCE@hGwCA^lYYtPg zx5_#fJm}vzA!yONXO2S*IkL7bSkF0q{JkRo(_>>jw<>cFeBfQ!bXQ)cSZK9HS*hsC zR*zhDN7F5<{M8Lc-JwYU39j7bcI&?zb;7cx=HL?zO&K=FO4=D*MUq>;G!*%{ioP4(BvZz7cP} zGot0-$HV6e7fm6N4Q#j6nPgb*3Hqq+Q}RhOZoi~+0OUk_w8lNYNWe`q$ErYDLgr%) zu~gkG)V#uq99z7>O*4LuON6olDftlXY;_KA(j?tW1SnOE{Uh@nS?|O!zmZ#;S1Irf zoJLsaJKoARM=L^hk9=rgt8UeJ7i*4CIlh^kI}UR)GNKe0nTYM`xOUYz`Em=PMohBd ztZkwXHQIBWQ$M@(5RO|P6W_Jc@8)hR`Fb>mOQ(0wv?Nm`;5bBt?U$r<6YS4$%{ zu2@1icOZoRiJzLa`OQ)GA%}%xcDu2))o8Eq;s}+^q&;4{uVG_zd|YzJ04uFs$32^F z7%SwRIWuR!-&5gT9lVWf{Uwsw*2wtqI_{^*1kX}guud*-PW<(qoW~Cfr8iHXMJ#=3 z{PtMz{fN0^3cUJP?-a~9?;YbnxbW=MDtU96{>QiIxt0}cvkzsn)jIB2utD+!%_T)Q z{$aUTqs$^tYi|KP@sx^5)>Su1CTgX{i^2#m1C91JZ{NSE#GBV;m>W-4Vm$k<6JhkR zfwMQP3gilC4ctH}3VO$RXxauVl`BM#S*9^2^5#n<-#!eQEz=P5GI%!MakW?HYP=`J zNh;p*eqlTJRMa-jmYbhA+9?A%UKh8t@C82Bt(qNaH2ZQ{MOtxoS!Sf7zY)b-sMS4P zjlA5Ra{$MYuu&N+*AzPVOW!7yaC~SSI6YXF38i>pJR_!ME+x`|xTPpUSvrRx{v5dAsj1FtTr_P(=n zO3=ws=TAjbR#N&0CP;;im#v*pcy8YR91%W45O0SZnObmY? z(HK0Nvn8A=`Se0tt?Rkr8>g>&HlN(U=OQ?8Ix$GT%+z_1=0#3JJ{R@sRaO}*#ubVV zuW%{ow@lIgPOjKo+1Kq9p`umc`24Iu&cbw=c1mPe_|&>n3yf<=x=to+yeX&H`rNf6 zH+Am^YR1b}(rwbRw+R|&p6&>E>mxK$+R&*$MR)#1uIHq^YfEz2!mbUr8M#cY)_2Dtf;-W0m8JLPVMOD(0S?rW57d+RWQq6KT$N4o zPt$o7#j8WI5|*Dk_l<%b`~wY-;Xd^b>F&|TNPd@a6(4NoQA ziIZchPOqAukTNI2-%+62$9%_Y&C}~j>e+N(<;yA1Qle6K8*I7L&!^uqqnO9nHa~V9 zxO&D-A-|wCrdp2^Jl1n=T%DXcOxR)jYV%PlA(?5}z@79tpFMB}# zLV-!!*ch=ukJQ!u8|w*r9s`NhH&Z6&RH`1_IgvPuyiC%*XjA)~C~ET3tfNyaLk&8H zHKv4_oGX?!cFZ59E5*K8g|~j=o>Lc6PjJ$jC+}6G%0q)ET=b+^e%?pE;V$)|8WGht zF%M;)>YYg*P)upx>7ikAw=n5s$%6Hg<82oQf6TTh&<^AoW0b35rgum9B>Rf;t(14r zvm0W(MwB;XAtfg)QJkPZ#9DvioLPk@o^HHA;upEKVU@VS^vhPnDjoCLTuB63O7z@Y zDIa+5Om)kvPf%UE@sg!`hc~ItVpH*vJ5q1CN>+RM+fL{5B{e=UO_WrBRvuqYrsye2 zo;bwjBT(z&bi@p*l+cdHkEXxeR1xEH!_fStQ{|?47pIBrO1@yDFXD6a+Nk(O+4J?8 zb7J?Zy=&et~&cEUfz7%$SQODsZ z;*sNtf@A9T4i>+qVg5e)-KoJ0nnMB-YRYWX+zL#GlQHBZ0zlxmP^Q%74~C?h!cw}CO>#~f1rTZ zJvHgMYa6^4`Mqh&$b7po=sgcGbqC)&&cqG%v&xrBHXAMzZ>_SJJ}*|n>b7R?6=8Xm zYWMv!BTsBo($BlH{;J9%%kxpI+yXTyyK9dthAE9!AG*N#aK8uFYRJ$`BaQKorp75H zxfUD@ugEhY$X+x_(atik&Qh{Yq+J|Q@AXh|uAi9+yXu?3D4$^Em)fHX$D4|XPoFsX z?L3-@Ax(Wzy+gfd^%26z)N=)brlHGx_ths5YW#S|lyJ`6cGP|Ha;<}6+nrUi@4co( zkou`AQ*P`RX>6y^Me|;$kCWOJanSej2THY6sFX^zqoTx0(k_lHxf8sRQs&OZS1zSR ztv-?GJ9oh_6KE$-&$S0oZf~E^I5xCuZcX-ahtWo( zZ8FE{5tkR3R<>F$ihc}3c*PTZo9{Y0+L}DHdU|iYUT&L=;ij}tQ9|4;87VQ%H6jM% z*Ug@jb#%hmfL-y#0ffU=h57;m8!cy<(7Xl;#7ao*Od!Z+5&}Fn?BS2uzuolO&M`Mr zbXE-4*V_ARt@!k9_k<`{D#Vh<`%Yildc{gHBGkP2%x(9iRga|NSNXckTr}#cpYZ(L z!Y9Si2M8~C?Da;i=@%OzsXi-cYP!{n8(grjX37bxTgt!Xo?|RH`Kv9>?cOq{hyk|LDbp zpovGD%GZSw=Lho_D_Zg@2wfO{$yTWUCzETQ``n}hZM1dvh~<~6IFzN+`iTo3d{SMg zTWuONF?IRa#Rm(oSBlP-Y|B`ezFKtNyS!r-uM6Ws2LboA`8My?KOc2&Qml}u#F>3k zyvA&9alY*G7QP*u(#lPR4m%7U$l)?@OI_=UEsJa(58jrrtXyO_0V-+!0!!{NE}vQ`@B$iI(Mrj}b|sJu6B*+8yuoy0$< zUxCm)wQT;82{Fk5H%;RVxD#~9&IM-=1!Tx2>FF=h4Ol$h>lEohT*56O`5jSfJO+mN z>3N3vlS1fg!O$^;dGW1#>xc*j!wP6_Tt!+`2MZsR#7mF5?rk1No z2bbg-?+B{sKT^rg$I+ww?75r?cKngbT)9K7+TNdhLJHkVTCilH`=+S9fq`?!+@#0I zpP+My@7Jz)$?5uLT(;NMJK20guB9*Qm!T^8fxPfagJeytJ~ib<&HHw7J5KK$&rxqZ zcZ@O%i)4=?PBD8Xp;Xm6_SGH_v%n!ir95q=t|Q{>4Xi5z7N~em`EWg>-~5rU-oGJ# zvYE6!jzE_wH8YtoJKA;T-LydEorU$+^%sd#Do2kDUA8E^Sub^n#~Mx^_Jn|r+2xyg zwZ(bj-m#?yoZ)<{n_*3CWXn-7pBCd5Z*N|kwKCU1T-=3Fl32oiX0D?~!2S*Me72k* zw`ofZH}O~#?n+Z&Td!4pE8hF*qbUXn*PP<+P-BZZX53gZ%XTuGiLM9r6ZhKHg=Y$7 zt_x4miPm;bf1tcGFPp?KFo-wOqv(!E`K$x9RGm#@WvT`1jtCB%rI{aZ5~bm;EI72kH%ycfrW_{RPI68S9x*XN@6vVG zQ5GA-)}5Z4o$6edwRC}d{rw4zM`x^QahsZKlyN^dG~|3S=~hb;r_Te875;_wj+GCL z?{zGV)v?+^f2_YXQH!j7NH_MCrdm0BsR*Pz^~QqNniKhBk1klDd1Rj1(z>jd^SDif zjI1MTEpIHh(z`QY`l7utY5u3oN7)8tzZT!FP~n#ydudYP%KBk9M~c1Otzi(EsJxOr zd4JkblWlPpi3g?-ig>N_g^Rb;joMGssFbVz7K0L+ptAvl+vhYu|Zc?F6CpNmArTHHhHU$K}%LdrTZUHPD!u-)RCTQGPER8 z{QX143FlME=M0KlZ#11-eb>}>&55XvWb-2#2DX!}16Rv59+fw%FeaXH3EoaPQ?StEC!GjCy9FbNoQ|yzyGQeAnG5Ik!fz_`^K& z^)3TzCcD|&jM=cUZAk6~ZqE1Y)=rPy`ZcH*S{$|&A0zsp|I-G_fsB{ub*JoM2tQ2L zylt4qisj^MlHR9M6?C5a9gHe_P#SkYJh(l@`3-64b*Y8kw{(f6&5~XMcO!;OHrlgn zUcjef;fBPM118+c7m6XLMprxwx*f5Q-(0>X{nA`T@*IlYJYJWT;xGNPHch0D-_h}o z)9=&f@g}Xe%pOS}S+u{y!Qa9raUECvf&1(}+FbjZS8r$ta27lD=FzsWHvt-zP5qUs zKA0abyKYxHsi?)Y(BUajGBRmmRG>Yt(2%=w#ivh`jUV>2v@k4`FPP*L60|)}{Beh7 zr0=<)<3|Yt#^leHl2oH7Pr98#SRi?G@a9_Cf^(v?E?gCp5P#S~;0c`VGNd-ke95o{ z@{PkOdtc?2B`ErnB=^_xEER6Nm>Bwsr*5`h$(q@3RIF^9IS#0a`|y2`T|Dh#p=;@c z7eoC=s(3fBxj8A2G(6TruHp2#s#4;j zZ|3yA>B49`qee$F+sNgKnG#boZdD)Q<YKP2 zs4Qv7anqe`bdD<^lZ)P8a#8-ByplDJUTtf}CQQ)LsHZfnC^*j+=fQi*p>R+1s?iEV zyzPedue{7F@Q^t3oYBY^r`1|48mkoEN2Tv9ko6CtUY*x6#(T(hg|vkyj}57#z1bGC zmXSSM^~cdSM-F){*KZg(c>SK_icJpIH_rLruCvk$R8cFwJ+lAZiKeBN;&cVRjfVz2 z?{``J^jw>EiPX(98{Ot>i)MzdCz|=kDm9t$6Yj$4$pnsfLp+tB)* z?3)H{DRQbjt#*F=ro*4e#_zVpdh#h!RB~;mRnjNBoPEhL%HguJZd~-t#TLF%MS_#Z zDZCK7+J2z%P~MY0npX6u$@iQHgZLtSh91aYMy%WF{%CxDYMIkOk9t1=e#6W%eOMRJ zcrG1tBYb$$%vfKObD42E-siO^EhLKPFB5+w#8cZb|5$>4+q-nxX-cPalLYQ z1;w>CE0en=Ix$Sfu5$AP?=TO6pz+5@wRKtU+BT7E_DvxEpaHeVfwHwm36dNAt zDPvxVQ397o@1b2L)XcVe^-4%Hn{@Gbt)YOp7bQpZM4V`&y4buTw(acJ_9L~fB=~9% zdAit5(^;!};d6Q0*fRH(MSF*c9!!3yH_3yzrB=lIfO6*5;nAslzHe=(y^%V6HAp_% z*rH)jz{JZ}pWA-OQV90RUa`?g+Ow}EU9EVBn#G9H%qZOv>tQb(YV*!!2 z`TRb=BM}`LneW242kV%-yQ$){Du1-0>nB+8`J#s?+a2P#eDTibr?g;3_+^8DMDyEyDF?+!7U z5Nr6fj#%4Z(9sfcUh|daNY}9qgLp*hxb+5=e6rhaQ@GRA!M@CQb;fw&OhdW?f3dZR zgp}L^LlU3S+mwYGUJsHIkiLlMwpXdz!iHs6)+g)>HG6W1bG@Kz(fXD#*TpHLhbPJI zNm4$x!y~A)#Qfd)W0Q|_AK4uTOHdOUgJk{A+txbgPOEMpJ64_{&YqIg5i?qWKpU%g zx@1vcCP((3i1k%xGWG}7-rhdcUvp}%Lq>k;+#5c-17;4E8_)TUaJnf(PFf&%gV(rK z`VOrZ{n=)Xj~%G~!0zI>@_pl@4rUop=&{tPc_2{-f}~l&c1lRoxV!$cV_#l>ztJ(c zb)r|A+y)t;T~5)S_fKiq2<*<-w>I5fhj?A`72D9QbqQPZvqBJzrhf0`3QU_E(j?x7;L@8t-(q(7`rp@pkrvH6>i_;#Ko(wRPsL zo#Sye)tzVUZsi9HC-18;{W#H{Pk&tOgAIu(3AIZl8{48nhd^r_pFDrjq3xe!mJB*7 zno=$s+;K8)r$V*;%`?87#kzy#9Y!K43t zypQuqTFnsNpz8uu3wLo3fq^-^`ehDo6$3Zy8GPoHy73F8Jtk$NcYk!deXOBWt@=*j zZtdZh%$HQByvh zDKkj0khiI$!IFQ~0ox`A=sUg`<_}>GSY*wdDnvbeYNlxQoiqAQ7fz(fE=vn*4^CaGN?bTK_D##a z_E{z?_j`Js9+okh=os?+;|rf#n9o`gWxSuo_@Hb2E`14&A8 zjEMgh<*?kL>_!QpNp!H;3o^<=5{0JjD}E+upSUpA)}7}-#Y$6HT=h^M`R1woGhNPX z*#(xCNvA0OEg^TBHJc{96WVV_kfbUJA}QWm2)_bsMSl5C9W6(@#{CwIchZS$-k;ZYGPdJDSzC-KM=H0HL13b*21oL3(MEQj{zmO?B8`*HZ(B`{ zS!`E%k5Kc0SarUN>(TTzlUCRU+uu)COLgZjI6!;MZY(CXwQ&T|@#bM-X}^H=IUk;7 z{`XAm39l1syt7&MkhTny=z@%Whb(T z%WnKyiPQ0(E2ZfsS&=pG(=T}j`>iss;7xTt;qAHWZqsbSM#-X`8FYU!fvDZ;2Q4R= zXEqAR<;91hH(4b)c5kn&!Bi65Iw10fm(n%-a<(QjX26N@xiuRr#w7_!C zw6Zj1iHWA^V-(ej9IxoSIIia0ni1{2hJGe~7pEL^rTa^SpFJ zx9X|!z1c73SX5SpiE9L0@g8)va8H`q^GSpu@}~#pPcDDnIDN!^0aFEQoA9TK)p7a9 zkBp4i!NcpA5z%y=y4YH}DL8MYOJlRi;Jadzz05YZlb3VU?oHj)e_phfci!N!#mdj) zP7;*kNZ9N2gzML|%*QFtjd)11bDTRcMJH~}w16DP*{7D| z8n&()SHWA}p6Qp!c1kSf?4!oDB(b>gWsfBlBEx1WW+~g7t-9I3xz2e-v#4bH61(Ni zgzFpIbaU4|SCekvr91=|8bhjf3=o}05T24hutZ?F-zDWRE~x=K=$~?{9Ix))w&O$U z8M0dLMB&EwYMjZ3CZswC!5RdAki2A(u&u^S`>XUErP4OGm!%#S0!3M+eo7L&ietjf zi_MHIVlHdTXtZp;9vg9M`Meu$$JsUN*SSn^4Z4^#Kq!0tpbylb1l1iIWlW9JlZD6R zOKwm|pj|YJJ$Pcv$fx`1D<;+PYiMvj6;?J+k9n9@MKe=(sF-&&s$|1~6~W5WRCW0R zQqSC0E$@0Igk#HfLW%G%2(Gxj4!>QldTRHtF zr4z)>hLPUPm2r)_Tv<8sTtCg{_NpfeQ=K{1#*62rmaX5g$VZXm)+F^~H4Ige1LbqQ`G9?f1|^D=;_W3V&Zdh8?@x!Q&0z6Fs1JE^Oz-|SY=+Opc;YJ*Vu zvZuMuZmX6XESz@L@MeUm?haq0j^hdYZFF_C=W*vu%{3AB=`S()Drfeo(E3c>!t9KB zPOfj3E%(tTei$PEEPq{-?M8}gxnz3$dTGo2?ai$dwZtjTRTnqz=G7)9Wot-$)~4AtqbWl%UF-ZS=7MT=BuV(PN=JZO(iz2yu~XSwZGR?vKQ^camR z;^>vd_65$oEf1Hhc$4fY{d(FNKWe(qiPgev1za$K7NVJOEbf0%KJ@((las1768+s) z%;6YY+HxVl@w@|fO9QNaUkFR`%Xo1%BeRVJ0~-AWd&71#h&QCj>IZ|^ zA8`5j-Eb&ST-kncTEj(IxA`S6Oa_-&OC)nmPp=Iyd&y>P`hcx?S7TkQ3}0#}!E6|R z%&fG5nuM652ZKD7Yi(dzCxJuvn!$xy$7UYEmZ##yqoiC*(`aOv#ixr?oyvtc+n=$Y zHoCO&*r7#MM;h*&9=t%$;X{7Z<+8vst|o2L#Z&#=d|xf|D;{32HP%xnfbS(eILJoX zqSwQLd*aVm5xj`YjwoLf{c!V9e9ggrjsvR8OqamZ z@iC{HUq97rr#GImmX^*KMohw)slZVMf-&x<{rHR)#pZGEv>Uv*e_8B+NnRY`Aw0wcjnWgm z4i!>ko_R;gav3Ey`mWBq9`9Uob{3_r>h#BE$$_Vw4)D}@ve|G7Z_e7X`$?JRN^_xw zk8M}=FFp1W#wzzFUA}VURceQb>m&ljr+k8TOQw;}qG!t`)tdw_4dd5hx1Kyrzs`~K zTCL)gX@mf)4O@LmR?nz>B=uq)$w#i>y-nq_Ylki?^A~&DuS-;xGu_sjyxK-gA2ueX z>BqjS*I=LZT5QyolQ%uox1!y&ZK@rRqbd~!?pe5W~@TCR5E!f0-JN!)8k&=zgD^6*6Av;ORUa<$9WSQj4p+>Q!rnbp*1MHbl+wcce+CCaAD8EHNrX%LdbF_AnjY~B_%9fcdBzP_Gw zrh81kyr%xjCg?Z|-{XE{cU57Jy?$}pzKNoVqU94fqU|abl@~7cU-dqKvT0shg_!Ow zD_i3a8BXSc9m~`b>Xtf$Uzj&xvsqbxmm|X#cpk4hunQKhE`^95ILGgksr)?rJmJ3B z7tFgctx z7#`}v*seB<%c-(I?+I;vH$t1NW6Jx;#pf-vNsjjncFkYIx#@qcoQprx-yg@fF|ugN zHkVv7mzev?Epo|5C>q*?&2%GCa>=FK8d(x4m)x3-klPlLYq?)izN6Usb|ch64??x( z_WS%EzklKP2b}Xb=RD5k^?tpd@8e=e>N6zGj-$7>#TqEe3sjwJ5A|xk2E@VUmR}~_CV^_|G=M2k!(iDUumE&^I{=P=X)xH}?wRWc< z2F;X7-bcjxwF#TbxgR%n#L?`ReoLK-z1PV7ombro33=4Yb-THogZ*?IcY%?6+K#(4 zK@e5r+fYyYRPw!4luvp)%goUr9c;{s8AgGO;k?z@Fvk>hmX#N^FgTC_SD2)3J*)t?D97Ua|a#gP!HZ}h`w4mox{%kWQ(42T_f^)SiQ)z@&f zXk#qycX(ywOkEWlkr7RRX3Vw|JaU1nC3Z&AwbGh>#x^*c4Ji=s(}9VsXbA=y)8pXR z((g4{1*!O1oe|W$J7*{m8EY_H8=Fv(X!hNzDAWBu{Ak3&(TK za&>GY&WBz~?Q)RLdA_%|vnR02S+n;OX96yj&o#)dhO$n}-9mHRxW0&l67`Us%M!%$ z78^2fMaeWD-B-a(iLUPNkh4hBQNms@i{(e>FK^G@iYiLnp@;%Hs??>O9}zMLLh)gX zs;js(+-pwaMQ-9G!Oy>kr=|Ot*!a|t!JcNKEced7R?4MbJnGYIFOvT4f^79U8S>P> zW_*A{0LfZHlLycROBgSVT&TM)7(jcA?62rDT zxL-xiq>`bAEudHqA|ZRliL`pc**ZWW z7a5F8uC1O9K)|a^gF1Wo-PP@BFlE-5qivGFhQVL`Ncm!x2vvLzE3J!PKovkX=<^w;$#|*{-3#-;lz7(NC%ath)OXpeYXaQ>Elip9&N7C5th2!Gy$S zbJuxNuWhVjErkCvrw3*iu}>a=!f}L%Oy)Ne+E!rZN+?)6rep3w`P>y_2pjaik#!D+ zI$%7y@HaK>use5emETNuwjH~aC*rU2j72C0H*^bO@&!m)TefkO;l65964?5mde6ff6;y@+is%x(IOQNL zt{(rXW=OY1r{~9a`86Qq^WnBbRl>d|L`@;ORJj2DP?;w^Ex>+y;XO;HA;X>8&;qUW zGNDPBB=?8g#(a-%QYWC;V$ zFKw+WDK?O!^QcU`$z@`U452q;TGXTjafgXWv@K#b^v13h(Z<9b0PJxFWEd^3OLHm; zw(XQXlT2_PF%#F}5T@+8wo-A|=&^2HmVa(axq$&%DfCB5a8=n`1!|_}tbS@E!ZJ^1 zf#WmjlYIP!jZ)N?u|#3Yi1pLW_=atSAZ*JPfj1+Ws$OG z313h8CQjD5E5DYY*531m^G~Q~8W@ZTfLo1r+wU*x6ot?&aoHDOfRuV$rTM2D$4hlV z{?HdA<8tY0lJU4~CvkF~x?ld7vA0EKn@@q|ZWfrr5)&K@avzS-D)aeii2Hxl{QR$SC}|sBR)4XPFAh@xs+mB}csE@A5$cWq0B-FI AKmY&$ diff --git a/examples/api/src-tauri/icons/icon.png b/examples/api/src-tauri/icons/icon.png deleted file mode 100644 index e1cd2619e0b5ec089cbba5ec7b03ddf2b1dfceb6..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 14183 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

5l#v3A#xI3*z~1~fvo9Q(N^(==!|_FZ z*duZ=+M1~)8E|otX8KNZlr?qels#x_1Xq@9IIw~@9uAREJVH)Xw^}UclF6327}E42 zT)E&?U%TK?(+K7%R!`H5oX0i)4Qn5??Iw3p5J~6_u+aWehY{DSn}3V2p$bgjnAu?o)v@iC254fXeMv50$9YrpU`N?u@QIWs)T?SP|fa}(|9 zqAX+!7`cx=4)cCBg5h~pu(?@9`)aCr#oyz$ld=#RFxYCNZCZls@4v2~*e-t6PEVvV z&bbK3b3wt(Coc!ufAbXXC<**#HQ%J9k`New6iG<5RjtO4XVO?dCvwxD{kJ#tfQr(X zg^NTwF-FwAeS_{V4bfel8l`~NbfrTR2s!G>WduFWxH(t~aK4q=6rEE^$+Uox>gJO2 z{L<;6Q6nHa5#ZEM>H58not!)z(6*_=^~8}jWf*IG$AUKVWOZ4?)GfF z+BM#*wKKmLFD7E~W3U!$IVm$k_k1f&Kz6WV8@55P?r~bcg-Za-!rvW?ns&)KOGT2~ zlkAyqhQj=P$Eg3w#K~}zH@J5bo-BfHjInKSz$@?+Z)NPD4pHj^_Qxmi`UqoTy=`sV zLVxrXGuBr=QRm|}wg75yetQQK4fY3#P_~J}zEfPnb2C4Wo!E(d*(cA;b?7$g2in<( zPn)ghX}nzJPmb6(3Dpeg_GW~Hc}Lt=lgsSZz z!5QXyz7KaR;D`3Ee}d`af{H>WWZ|Io1QI3~4Ll_`g1(cRnhLK73Ro)7zPCd={1W2x zRp%Xlvv4>!<2@}$hz|!V{T}_eHx2xkLl^hQoZTCnsjCl|W_@5Fx2(+j0ogy&Y+;L- z<)G$*CiN7hOm^s!{U>1F7U=iNk{+u~dAC!eDz%=|glFW0jEZU1&o(G_c#wTxUjnG} z#cg3>jEpUi#Mlq@t?Msg_#geK^Lx@DyHWf7=AS5vVyM7YOjvUVCfcpVR<(+5!H?9- zySI6s>o3m&*zr||=wcPGyBkQV`EWJl@bH8qobjOp+sXL*)=&yX)8aAbf~tGv?a2SN zu^Ddo-z?DWk9h9Yz#5p^NU#x~wYSd?H@w@!2Gb4G)6-utEMV~~M85Br5ff(v5O1|T z zIR`9v=XXbK8N1BZV|h34+~1u1oJ_h>7aS*^LOi zS?hm+ec#1L<6bZ!Oc9OG-gV_V$j{5(O1RZD9`g%{h;v>0d zWiz)=`n67_-$k!Qp(dKW6m@Xi_CesKg~LL=e5V3#YN>;l#X) zHz6W=*ucpXy35@nx1)e|M-IcA>?RmWa)fP$3;*?-yraubd*HgRmAxty2ChoMmOJ(z zJKCPRl#%}U=5It0RrpPM-!VH}hd=~)Dgrd$Xa{xl7m@&qyV;7{bKiJt1}0(zWG;nM z*1KXcyD)ss@$q)hg31UNhb@0?Nl9`#klSY~0mVw;&b=%QK~s8IFXc!F5p^a~%zWmV zZJtPB8R=a#DYTy5Z)F|d(vv8Le0cDUfp(A=+8=zftD?-zNk522{i7(|otj9m+yuVX+hY6rRUn6cGGIp1ZdbJid*Uj}>|6O+%M$p(Q32+w2=sfwN14nBnms&GWQT;bYy>aG9 zPr6Cd#uA1P#}T@__%bE|_zq$$Uq0D;)oI(51NepuZw_VsS}Wm3fO?65Ghs-L5Y7GJ zLIb!-G_V};j1QOoJGZuU!{_^uLL^q?67ac`_1g7Ci)<1m$~^foc2@Oz_+n^`6C*Q) z4T02iPh}_YT5x8sN4uk?9(*=IfB@7nLJx4m+z4*1%olhnL{b0QQ?J_k&g=uRR#T@ck<>fO@F?_=pHVa@D;b*RSyCu;(cPAe?GFc~o>pnJbs_ zl1l-I8t{|mTecYcs@j1uvW09EKFp82PJS04Fs+8ys-MS8Kj%a0`K9hOFsr?0KT05_ z-qPfC|ADFn6bo)#`5S)^%6XKt9>$%BPRiU2ACnI78LtlM!3Y|@WCuRmwTvdeR}e|O zoQ_8f>>i3%vce(s;hDMjqMi|dq)o^x#NC#}_V3i1xARk!cH>NLtnx*VG91+hRXb2i z(8Rh(carI}sY2CavhN=3-`7;QH(11wQh zP;d43IbKw1Bs8TPtY$TgJe$}bJ6dRQH}XAxtwrzArUe%5#s*>t*c4ri%riv3((Aa}(}jAR@Z4(p z-St<0$zye=znm-re+QT%YgT0lPQW`C`>bnml$OKpIUb_K)Ln?HtlN7&D? zce9gBWPlhOdWJU%Z$Rp)g}T_;Q-S+@A>VbkYDi-}Xb&x8WhB@;QZD`|oq&vvW6`i`65b&(uy+Zt<<-oGX}plTUIr!V9THGPYbgYYYZ zj~5jMhZ@h}sNarolPDj80vQqXKK3UV90%jX`t-X^Z2HIP%yZi7SW7I*uG-UA1 zVuRN1Z-#@F^j8(GI^$^4?DPv4;ZtL1WdyjrQq$d>ItF4s&Rdc;l6asHjkJ2YfANQ0tp93~R_WJ6W;!Fw6 z`_&T%lm@4jAACAX+oQ?1G)|xS;NylhQw_dgg=$xgY#$BUy?y&%#DFTBJ}oo*y`*WW zh0BBTF|O=ILcEXiIx*WvX?<#QHH=ot+7rnLLWDsQ6n9`7(>}SUD$c_hy|u87|2ehz z!$4Gq)@1SaVZOOIr){?PUr#i=QZXpTP4SE^_HdZ615YT-Mxq zaU=o9m|f2%zQ!`{{bY$e6hmX3)`!B|4Epd^b@RK%3s?=p?RQz&wO;j-(5P1kck$wd zSJ&DfjKN$?vegNGkE)ftChzIhc-&J&UP~)iQS{5IgFrWb(-TpP389q}c`g5_UKr}* zTV`e40XXe8`o2v{SM^gaF{tN~vs1oYEH0ZIG<2|4fWlpe;{Q7v2eV4MT?@pAC#FQ} z1#v^nMVh9F(f8xk1twtl9n%~9=PhY~kse$*zeza6>Y~mucCA-aK#_m8kW$;ho}k)d zef)!x)+xig;L+^Zn@-hLjJ|=MGQgJO48Zh|BVx3qjQpD~&keYzu08*c`6L77$Odq^)ySMSKo~EG>7qO4) zGQ)1PUpjB%VxfNDiDf4Ro1o$&^7Z)mNLab|_7)vaPv5!^CHt3vXwv#|+`R07+H52% zKo%nK#80s-o)YZj?*ITk+}k^g+myi0bp#KfHwslIGiuDjs~yxHx&gptDVWHG=70&V zJ8Io-FR9z~W&kLF(n_>c?3f)cYo6``BMI)wm3jZFbPN8=?HR1B%7>HqNtp?ns~LRX z9I^(_-#Wqs4rYIAzyB*x_rTr;$D0IjmOVaIb*f!eRcm`A$QFiU*E+iYVy(ww*D#+G z4HPQp`u-fa`BDzB*4ZfjHvM8IMi!3!Rv9Ifk3a)bnSGPt_|HayKxwKr8EiZp4ENUM z53~}@bJhH>Z+4qaz_de#z`Nk~-Xj#@`R5upr+J$E_E78H>WPHkEn!|F-Wx92_)~gF z2)F3pQ^!@nTj?i4U^t|f_WD0c>fxtBtXMyIl3x(VyD-sm2;X&fx~*6;rc?rV_gch` zyN$kU`>}KvO#R2AS=Jr7_3Ipox2Z@^{e^GbkT-DuOD$?@^P~b?+CL`B%(rGrZX(XK zB;huyA)r%y72y_VVMa0v_3;!uONHw zoRni;$j1Ra@!^urL#n@$>-xC*WIGo_R5kih{`Gxs4?X65^Z|d%#zxiVbe&$7!wqpB z&Gqq9c!_(*Qp%}ybz$e$eNfD%25@W1%^-Lv!No&Q7eO-*_+I+nyzFbkExed7(pohd zFcaui&L7DXAzjue3 zAncEwaY=bSyTKAntX{Y``Td(kG^niT%yilzTza@SJ?iu5#t=xpcNrHq;5&!j8s6Oy zetM@f_AI0nlI6oafRq+dpX=eD9JgvAw&63Y9DJu}eMQtm%uMgk3K#)+7{ZlVy3fxP zBR(sz&2{V9I!pzKO(qAsz>_xVOOyl^XwC?y4S(8G3sSSj#eFOS0}q)SBw@cO2`27r ze(`We&e5WW?y7A~hhHz4;n*9u=1}rRDJ6V7K~!v*_peughtWU0tpa}h8`F4r1z?lD zN3U_T4#UQb{975_<1b`0`)vi|=5-7rGUbFJ>TCOS;$2XR!cZ|m1HXl4PvaWzU#)Av zV^0!NYg2Yd5~CSM9#DJGNkF{Ab335tD*S3or#<1O%fW*o?Xu^@CP<*c{YpDF|k?t^m$uBbp4Lwi@Baxp9=Mc*(~xK6`g z=hKP^8aedgD#a7mFY}l#Mq+QAZERu0OuxWZS1ULRxwAufv^C?3d%-W=%KJC3-uH}o z1oZPfArJj~@24Pyk@?>uWUms4%sf^D0npR@uxOruAu#d#f3rWINyCbv1WuszHEAz& z=?qL;EJ^}GJt`ml*Cb64NCM3D_Z;&ll82@1V*Vfr;x~{CbpuZ_w~aAeS^5l>0R?!d zOUu`UqI4T!6aN@F4>pDmc_^2GLMq=H1kArrC$v-S;Ly(W+)6v}=fJXt#Kw?r z<4BNZ)kbJ5nvgPW^BF=39{nSI5a0dBXlGZnU!2@8@uC@|B?9ISkRZ)P@>eoY*k`i{ zpIdaL3~cVlGz+YqmT|aE=C-@QkuSOE`e&o-2a`_m#D7^@wTL-hCp^eggtg@r#Kl1# zw4tC;ko=KFA>wgkGS=z*cj@L-#$`K*B|(33f}w1JKLmw^yYL(j>aO0cuko3}1W8{o zrx%w0qh*SnV6qR)#I-k`UGfwvg=!lp*Y)<$?(s5G;XptR`oXMthRorcd&W&C2| z!^L@skGCA-~}Ka^T8SSo0nynP|RU!FKm;e3uRh%sH=JP2(kzg*8>fg z*#_C9z>d<_M#%~*0rduNj`qqMZAAIrbkJN$h+hkbG|IT8OK{Ug*BfV7`67$&?LOS3 zhT3Rfp==4iG-;np#jrT<8R%UC;K~puSgdfHC=_ot5?)jrFH>g5KAHEmwtQHkiiyN6B2g)XX%#m5#`fPyR!RI z5M2-E&!BSvrD+Em(}f*VFd%7AUmA0^Xux{c6R@kes6AJzJ& z$cFLCdjgU*hhG=2ehpu4QV4{1_1}3xN*GT943{@|4Thv)b7D;}$=^aWh^Br?N?865 ze}23(;yHT?oU)V+g#unK^kTnu+&VG#yu?!i1ZS zX#zTt$Y09M-=Rc6Iuhe|Ob~eU*%@fPZN~VrOx>t^1`Q%}NUp)J0DC-ery?iN=fNtg zq7es_@hL>?<+(aOv@b@GpD7&pcXKau3j!2~_)QD3BkTSIY|}(3XJQ?06)6p4G;-;}Y@)~&+B4D(Q#kj~nC@K=65{rb~5fQ?27_$O{UA`h=+ zk-SJ^m5V?CHa5hGtTxIb(OyI-KI(h=_sPXWD{u)Jfy&f{MB0%pYWZKL>oHzz7diuV z|7}09KDCW$bxeIded}%F(v~XTCr-r)5uOjh(AFjgg#6KCwXCfpXOq1yFS3^Z6P|1A z<+TjRjM)9!)l+*g$=V9-@u+q_sGjk)=&553xTvh7zFfhz|Ai$yQkNtPN!M4%ED^8g zosuJv=Y%Lz8R20ju_!X6`D) { - println!("{} {:?}", event, payload); -} - -#[tauri::command] -fn perform_request(endpoint: String, body: RequestBody) -> String { - println!("{} {:?}", endpoint, body); - "message response".into() -} - -fn main() { - tauri::Builder::default() - .invoke_handler(tauri::generate_handler![log_operation, perform_request]) - .on_page_load(|window, _| { - let window_ = window.clone(); - window.listen("js-event", move |event| { - println!("got js-event with message '{:?}'", event.payload()); - let reply = Reply { - data: "something else", - }; - - window_ - .emit("rust-event", Some(reply)) - .expect("failed to emit"); - }); - }) - .run(tauri::generate_context!()) - .expect("error while running tauri application"); -} diff --git a/examples/api/src-tauri/tauri.conf.json b/examples/api/src-tauri/tauri.conf.json deleted file mode 100644 index 15e818e..0000000 --- a/examples/api/src-tauri/tauri.conf.json +++ /dev/null @@ -1,66 +0,0 @@ -{ - "build": { - "beforeDevCommand": "trunk serve", - "beforeBuildCommand": "trunk build --release", - "devPath": "http://localhost:1420", - "distDir": "../dist", - "withGlobalTauri": true - }, - "package": { - "productName": "tauri-app", - "version": "0.0.0" - }, - "tauri": { - "allowlist": { - "all": true - }, - "bundle": { - "active": true, - "category": "DeveloperTool", - "copyright": "", - "deb": { - "depends": [] - }, - "externalBin": [], - "icon": [ - "icons/32x32.png", - "icons/128x128.png", - "icons/128x128@2x.png", - "icons/icon.icns", - "icons/icon.ico" - ], - "identifier": "com.tauri.dev", - "longDescription": "", - "macOS": { - "entitlements": null, - "exceptionDomain": "", - "frameworks": [], - "providerShortName": null, - "signingIdentity": null - }, - "resources": [], - "shortDescription": "", - "targets": "all", - "windows": { - "certificateThumbprint": null, - "digestAlgorithm": "sha256", - "timestampUrl": "" - } - }, - "security": { - "csp": null - }, - "updater": { - "active": false - }, - "windows": [ - { - "fullscreen": false, - "height": 600, - "resizable": true, - "title": "tauri-app", - "width": 800 - } - ] - } -} diff --git a/examples/api/src/main.rs b/examples/api/src/main.rs deleted file mode 100644 index c3f88ef..0000000 --- a/examples/api/src/main.rs +++ /dev/null @@ -1,82 +0,0 @@ -mod views; - -use sycamore::prelude::*; -#[cfg(not(feature = "ssg"))] -use sycamore_router::{Router, HistoryIntegration}; - -#[component] -fn Header(cx: Scope) -> View { - view! { cx, - header(style="display: flex; gap: 1em; margin-bottom: 1em;") { - a(href="/") { - "Welcome" - } - a(href="/app") { - "App" - } - a(href="/clipboard") { - "Clipboard" - } - a(href="/communication") { - "Communication" - } - a(href="/window") { - "Window" - } - } - } -} - -#[cfg(all(not(debug_assertions), not(feature = "ssg")))] -fn main() { - wasm_logger::init(wasm_logger::Config::default()); - - sycamore::hydrate(|cx| view! { cx, - Header - Router( - integration=HistoryIntegration::new(), - view=views::switch - ) - }); -} - -#[cfg(all(debug_assertions, not(feature = "ssg")))] -fn main() { - use sycamore::view; - - wasm_logger::init(wasm_logger::Config::default()); - - sycamore::render(|cx| view! { cx, - Header - Router( - integration=HistoryIntegration::new(), - view=views::switch - ) - }); -} - -#[cfg(feature = "ssg")] -fn main() { - use sycamore_router::StaticRouter; - - let out_dir = std::env::args().nth(1).unwrap(); - - println!("out_dir {}", out_dir); - - let template = std::fs::read_to_string(format!("{}/index.html", out_dir)).unwrap(); - - let html = sycamore::render_to_string(|cx| view! { cx, - Header - StaticRouter( - route=route.clone(), - view=views::switch - ) - }); - - let html = template.replace("\n", &html); - - let path = format!("{}/index.html", out_dir); - - println!("Writing html to file \"{}\"", path); - std::fs::write(path, html).unwrap(); -} diff --git a/examples/api/src/views/app.rs b/examples/api/src/views/app.rs deleted file mode 100644 index 9b04817..0000000 --- a/examples/api/src/views/app.rs +++ /dev/null @@ -1,78 +0,0 @@ -use gloo_timers::callback::Timeout; -use sycamore::prelude::*; -use tauri_sys::app; - -#[component] -pub fn App(cx: Scope) -> View { - let show_app = |_| { - sycamore::futures::spawn_local(async move { - let res = app::hide().await; - - log::debug!("app hide res {:?}", res); - - let timeout = Timeout::new(2_000, move || { - sycamore::futures::spawn_local(async move { - let res = app::show().await; - - log::debug!("app show res {:?}", res); - }); - }); - - timeout.forget(); - }); - }; - - let hide_app = |_| { - sycamore::futures::spawn_local(async move { - let res = app::hide().await; - - log::debug!("app hide res {:?}", res); - }); - }; - - let get_name = |_| { - sycamore::futures::spawn_local(async move { - let res = app::get_name().await; - - log::debug!("app name {:?}", res); - }); - }; - - let get_version = |_| { - sycamore::futures::spawn_local(async move { - let res = app::get_version().await; - - log::debug!("app version {:?}", res); - }); - }; - - let get_tauri_version = |_| { - sycamore::futures::spawn_local(async move { - let res = app::get_tauri_version().await; - - log::debug!("tauri version {:?}", res); - }); - }; - - view! { cx, - div { - button(class="btn",id="get_name",on:click=get_name) { - "Get App Name" - } - button(class="btn",id="get_version",on:click=get_version) { - "Get App Version" - } - button(class="btn",id="get_tauri_version",on:click=get_tauri_version) { - "Get Tauri Version" - } - } - div { - button(class="btn",id="show",title="Hides and shows the app after 2 seconds",on:click=show_app) { - "Show" - } - button(class="btn",id="hide",on:click=hide_app) { - "Hide" - } - } - } -} diff --git a/examples/api/src/views/clipboard.rs b/examples/api/src/views/clipboard.rs deleted file mode 100644 index 1a2093a..0000000 --- a/examples/api/src/views/clipboard.rs +++ /dev/null @@ -1,42 +0,0 @@ -use sycamore::prelude::*; -use tauri_sys::clipboard::{read_text, write_text}; - -#[component] -pub fn Clipboard(cx: Scope) -> View { - let text = create_signal(cx, "clipboard message".to_string()); - - let write = move |_| { - sycamore::futures::spawn_local_scoped(cx, async move { - write_text(&text.get()).await - // .then(() => { - // onMessage('Wrote to the clipboard') - // }) - // .catch(onMessage) - }); - }; - - let read = |_| { - sycamore::futures::spawn_local(async move { - let text = read_text().await; - - log::info!("Read text from clipboard {:?}", text); - // readText() - // .then((contents) => { - // onMessage(`Clipboard contents: ${contents}`) - // }) - // .catch(onMessage) - }); - }; - - view! { cx, - div(class="flex gap-1") { - input(class="grow input",placeholder="Text to write to the clipboard",bind:value=text) - button(class="btn",type="button",on:click=write) { - "Write" - } - button(class="btn",type="button",on:click=read) { - "Read" - } - } - } -} diff --git a/examples/api/src/views/communication.rs b/examples/api/src/views/communication.rs deleted file mode 100644 index 5c0ed4d..0000000 --- a/examples/api/src/views/communication.rs +++ /dev/null @@ -1,90 +0,0 @@ -use serde::{Deserialize, Serialize}; -use sycamore::prelude::*; -use tauri_sys::event::{emit, listen}; -use tauri_sys::tauri::invoke; -use shared::RequestBody; - -#[component] -pub fn Communication<'a, G: Html>(cx: Scope<'a>) -> View { - let unlisten = create_signal::>>(cx, None); - - // on_mount(cx, move || { - - // sycamore::futures::spawn_local_scoped(cx, async move { - // let unlisten_raw = listen::("rust-event", &|reply| log::debug!("got reply {:?}", reply)).await; - - // unlisten.set(Some(Box::new(&unlisten_raw))); - // }); - // }); - - // on_cleanup(cx, || { - // if let Some(unlisten) = unlisten .take().as_deref() { - // (unlisten)() - // } - // }); - - let log = |_| { - #[derive(Serialize)] - struct Payload<'a> { - event: &'a str, - payload: &'a str, - } - - sycamore::futures::spawn_local(async move { - let res = invoke::<_, ()>( - "log_operation", - &Payload { - event: "tauri-click", - payload: "this payload is optional because we used Option in Rust", - }, - ) - .await; - - log::debug!("Emitted event, response {:?}", res); - }); - }; - - let perform_request = |_| { - sycamore::futures::spawn_local(async move { - #[derive(Serialize)] - struct Payload<'a> { - endpoint: &'a str, - body: RequestBody<'a> - } - - let res = invoke::<_, String>( - "perform_request", - &Payload { - endpoint: "dummy endpoint arg", - body: RequestBody { - id: 5, - name: "test", - }, - }, - ) - .await; - - log::debug!("Got reply {:?}", res); - }); - }; - - let emit_event = |_| { - sycamore::futures::spawn_local(async move { - emit("js-event", &"this is the payload string").await; - }); - }; - - view! { cx, - div { - button(class="btn",id="log",on:click=log) { - "Call Log API" - } - button(class="btn",mid="request",on:click=perform_request) { - "Call Request (async) API" - } - button(class="btn",id="event",on:click=emit_event) { - "Send event to Rust" - } - } - } -} diff --git a/examples/api/src/views/mod.rs b/examples/api/src/views/mod.rs deleted file mode 100644 index f735ed2..0000000 --- a/examples/api/src/views/mod.rs +++ /dev/null @@ -1,33 +0,0 @@ -mod app; -mod clipboard; -mod communication; -mod welcome; -mod window; - -use sycamore::view::View; -use sycamore_router::Route; -use sycamore::prelude::*; - -#[derive(Debug, Clone, Route)] -pub enum Page { - #[to("/app")] - App, - #[to("/clipboard")] - Clipboard, - #[to("/communication")] - Communication, - #[to("/window")] - Window, - #[not_found] - NotFound -} - -pub fn switch(cx: Scope, route: &ReadSignal) -> View { - match route.get().as_ref() { - Page::App => app::App(cx), - Page::Clipboard => clipboard::Clipboard(cx), - Page::Communication => communication::Communication(cx), - Page::Window => window::Window(cx), - Page::NotFound => welcome::Welcome(cx) - } -} \ No newline at end of file diff --git a/examples/api/src/views/welcome.rs b/examples/api/src/views/welcome.rs deleted file mode 100644 index 1fffd14..0000000 --- a/examples/api/src/views/welcome.rs +++ /dev/null @@ -1,10 +0,0 @@ -use sycamore::prelude::*; - -#[component] -pub fn Welcome(cx: Scope) -> View { - view! { cx, - h1 { - "Welcome" - } - } -} \ No newline at end of file diff --git a/examples/api/src/views/window.rs b/examples/api/src/views/window.rs deleted file mode 100644 index a8e67e8..0000000 --- a/examples/api/src/views/window.rs +++ /dev/null @@ -1,63 +0,0 @@ -use sycamore::prelude::*; -use tauri_sys::window; - -#[component] -pub fn Window(cx: Scope) -> View { - let get_current = |_| { - let win = window::current_window(); - - log::debug!("{:?}", win); - }; - - let get_all = |_| { - let windows = window::all_windows(); - - log::debug!("{:?}", windows); - }; - - let get_current_monitor = |_| { - sycamore::futures::spawn_local(async move { - let monitor = window::current_monitor().await; - - log::debug!("{:?}", monitor); - }); - }; - - let get_primary_monitor = |_| { - sycamore::futures::spawn_local(async move { - let monitor = window::primary_monitor().await; - - log::debug!("{:?}", monitor); - }); - }; - - let get_all_monitors = |_| { - sycamore::futures::spawn_local(async move { - let monitors = window::available_monitors().await.collect::>(); - - log::debug!("{:?}", monitors); - }); - }; - - view! { cx, - div { - button(class="btn",id="get_name",on:click=get_current) { - "Get Current Window" - } - button(class="btn",id="get_version",on:click=get_all) { - "Get All Windows" - } - } - div { - button(class="btn",id="get_tauri_version",on:click=get_current_monitor) { - "Get Current Monitor" - } - button(class="btn",id="get_tauri_version",on:click=get_primary_monitor) { - "Get Primary Monitor" - } - button(class="btn",id="get_tauri_version",on:click=get_all_monitors) { - "Get All Monitors" - } - } - } -} diff --git a/examples/api/style.css b/examples/api/style.css deleted file mode 100644 index a3fbd74..0000000 --- a/examples/api/style.css +++ /dev/null @@ -1,120 +0,0 @@ -.logo.yew:hover { - filter: drop-shadow(0 0 2em #20a88a); -} -.logo.sycamore { - color: #0000; - font-size: 3rem; - line-height: 1; - font-weight: 800; - -webkit-background-clip: text; - background-clip: text; - background-image: linear-gradient(to right,#fdba74, #f87171); - font-family: Inter,system-ui,sans-serif; -} -.logo.sycamore:hover { - filter: drop-shadow(0 0 2em #f87171); -} - -:root { - font-family: Inter, Avenir, Helvetica, Arial, sans-serif; - font-size: 16px; - line-height: 24px; - font-weight: 400; - - color: #0f0f0f; - background-color: #f6f6f6; - - font-synthesis: none; - text-rendering: optimizeLegibility; - -webkit-font-smoothing: antialiased; - -moz-osx-font-smoothing: grayscale; - -webkit-text-size-adjust: 100%; -} - -.container { - margin: 0; - padding-top: 10vh; - display: flex; - flex-direction: column; - justify-content: center; - text-align: center; -} - -.logo { - height: 6em; - padding: 1.5em; - will-change: filter; - transition: 0.75s; -} - -.logo.tauri:hover { - filter: drop-shadow(0 0 2em #24c8db); -} - -.row { - display: flex; - justify-content: center; - align-items: center; -} - -a { - font-weight: 500; - color: #646cff; - text-decoration: inherit; -} - -a:hover { - color: #535bf2; -} - -h1 { - text-align: center; -} - -input, -button { - border-radius: 8px; - border: 1px solid transparent; - padding: 0.6em 1.2em; - font-size: 1em; - font-weight: 500; - font-family: inherit; - color: #0f0f0f; - background-color: #ffffff; - transition: border-color 0.25s; - box-shadow: 0 2px 2px rgba(0, 0, 0, 0.2); -} - -button { - cursor: pointer; -} - -button:hover { - border-color: #396cd8; -} - -input, -button { - outline: none; -} - -#greet-input { - margin-right: 5px; -} - -@media (prefers-color-scheme: dark) { - :root { - color: #f6f6f6; - background-color: #2f2f2f; - } - - a:hover { - color: #24c8db; - } - - input, - button { - color: #ffffff; - background-color: #0f0f0f98; - } -} From 5db7b4ada12c1d33c028771466a2e4ea300de091 Mon Sep 17 00:00:00 2001 From: Jonas Kruckenberg Date: Thu, 3 Nov 2022 18:52:21 +0100 Subject: [PATCH 3/6] add test fixtures --- examples/test/.gitignore | 1 + examples/test/Cargo.lock | 3894 +++++++++++++++++ examples/test/Cargo.toml | 17 + examples/test/Trunk.toml | 10 + examples/test/dist/index.html | 35 + .../tauri-sys-91bd50ded94e0ed7/dist/app.js | 91 + .../dist/clipboard.js | 66 + .../tauri-sys-91bd50ded94e0ed7/dist/event.js | 123 + .../tauri-sys-91bd50ded94e0ed7/dist/mocks.js | 30 + .../dist/process.js | 65 + .../tauri-sys-91bd50ded94e0ed7/dist/tauri.js | 46 + .../tauri-sys-91bd50ded94e0ed7/dist/window.js | 1004 +++++ .../tauri-sys-test-ui-3eb704384493bbf2.js | 644 +++ ...tauri-sys-test-ui-3eb704384493bbf2_bg.wasm | Bin 0 -> 1678833 bytes examples/test/index.html | 7 + examples/test/src-tauri/.gitignore | 4 + examples/test/src-tauri/Cargo.toml | 27 + examples/test/src-tauri/build.rs | 3 + examples/test/src-tauri/ci.tauri.conf.json | 6 + examples/test/src-tauri/icons/128x128.png | Bin 0 -> 3512 bytes examples/test/src-tauri/icons/128x128@2x.png | Bin 0 -> 7012 bytes examples/test/src-tauri/icons/32x32.png | Bin 0 -> 974 bytes .../src-tauri/icons/Square107x107Logo.png | Bin 0 -> 2863 bytes .../src-tauri/icons/Square142x142Logo.png | Bin 0 -> 3858 bytes .../src-tauri/icons/Square150x150Logo.png | Bin 0 -> 3966 bytes .../src-tauri/icons/Square284x284Logo.png | Bin 0 -> 7737 bytes .../test/src-tauri/icons/Square30x30Logo.png | Bin 0 -> 903 bytes .../src-tauri/icons/Square310x310Logo.png | Bin 0 -> 8591 bytes .../test/src-tauri/icons/Square44x44Logo.png | Bin 0 -> 1299 bytes .../test/src-tauri/icons/Square71x71Logo.png | Bin 0 -> 2011 bytes .../test/src-tauri/icons/Square89x89Logo.png | Bin 0 -> 2468 bytes examples/test/src-tauri/icons/StoreLogo.png | Bin 0 -> 1523 bytes examples/test/src-tauri/icons/icon.icns | Bin 0 -> 98451 bytes examples/test/src-tauri/icons/icon.ico | Bin 0 -> 86642 bytes examples/test/src-tauri/icons/icon.png | Bin 0 -> 14183 bytes examples/test/src-tauri/src/main.rs | 38 + examples/test/src-tauri/tauri.conf.json | 66 + examples/test/src/app.rs | 34 + examples/test/src/clipboard.rs | 12 + examples/test/src/event.rs | 10 + examples/test/src/main.rs | 86 + examples/test/src/window.rs | 13 + 42 files changed, 6332 insertions(+) create mode 100644 examples/test/.gitignore create mode 100644 examples/test/Cargo.lock create mode 100644 examples/test/Cargo.toml create mode 100644 examples/test/Trunk.toml create mode 100644 examples/test/dist/index.html create mode 100644 examples/test/dist/snippets/tauri-sys-91bd50ded94e0ed7/dist/app.js create mode 100644 examples/test/dist/snippets/tauri-sys-91bd50ded94e0ed7/dist/clipboard.js create mode 100644 examples/test/dist/snippets/tauri-sys-91bd50ded94e0ed7/dist/event.js create mode 100644 examples/test/dist/snippets/tauri-sys-91bd50ded94e0ed7/dist/mocks.js create mode 100644 examples/test/dist/snippets/tauri-sys-91bd50ded94e0ed7/dist/process.js create mode 100644 examples/test/dist/snippets/tauri-sys-91bd50ded94e0ed7/dist/tauri.js create mode 100644 examples/test/dist/snippets/tauri-sys-91bd50ded94e0ed7/dist/window.js create mode 100644 examples/test/dist/tauri-sys-test-ui-3eb704384493bbf2.js create mode 100644 examples/test/dist/tauri-sys-test-ui-3eb704384493bbf2_bg.wasm create mode 100644 examples/test/index.html create mode 100644 examples/test/src-tauri/.gitignore create mode 100644 examples/test/src-tauri/Cargo.toml create mode 100644 examples/test/src-tauri/build.rs create mode 100644 examples/test/src-tauri/ci.tauri.conf.json create mode 100644 examples/test/src-tauri/icons/128x128.png create mode 100644 examples/test/src-tauri/icons/128x128@2x.png create mode 100644 examples/test/src-tauri/icons/32x32.png create mode 100644 examples/test/src-tauri/icons/Square107x107Logo.png create mode 100644 examples/test/src-tauri/icons/Square142x142Logo.png create mode 100644 examples/test/src-tauri/icons/Square150x150Logo.png create mode 100644 examples/test/src-tauri/icons/Square284x284Logo.png create mode 100644 examples/test/src-tauri/icons/Square30x30Logo.png create mode 100644 examples/test/src-tauri/icons/Square310x310Logo.png create mode 100644 examples/test/src-tauri/icons/Square44x44Logo.png create mode 100644 examples/test/src-tauri/icons/Square71x71Logo.png create mode 100644 examples/test/src-tauri/icons/Square89x89Logo.png create mode 100644 examples/test/src-tauri/icons/StoreLogo.png create mode 100644 examples/test/src-tauri/icons/icon.icns create mode 100644 examples/test/src-tauri/icons/icon.ico create mode 100644 examples/test/src-tauri/icons/icon.png create mode 100644 examples/test/src-tauri/src/main.rs create mode 100644 examples/test/src-tauri/tauri.conf.json create mode 100644 examples/test/src/app.rs create mode 100644 examples/test/src/clipboard.rs create mode 100644 examples/test/src/event.rs create mode 100644 examples/test/src/main.rs create mode 100644 examples/test/src/window.rs diff --git a/examples/test/.gitignore b/examples/test/.gitignore new file mode 100644 index 0000000..1de5659 --- /dev/null +++ b/examples/test/.gitignore @@ -0,0 +1 @@ +target \ No newline at end of file diff --git a/examples/test/Cargo.lock b/examples/test/Cargo.lock new file mode 100644 index 0000000..88aadaf --- /dev/null +++ b/examples/test/Cargo.lock @@ -0,0 +1,3894 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 3 + +[[package]] +name = "adler" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe" + +[[package]] +name = "adler32" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aae1277d39aeec15cb388266ecc24b11c80469deae6067e17a1a7aa9e5c1f234" + +[[package]] +name = "ahash" +version = "0.7.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fcb51a0695d8f838b1ee009b3fbf66bda078cd64590202a864a8f3e8c4315c47" +dependencies = [ + "getrandom 0.2.8", + "once_cell", + "version_check", +] + +[[package]] +name = "aho-corasick" +version = "0.7.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b4f55bd91a0978cbfd91c457a164bab8b4001c833b7f323132c0a4e1922dd44e" +dependencies = [ + "memchr", +] + +[[package]] +name = "alloc-no-stdlib" +version = "2.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cc7bb162ec39d46ab1ca8c77bf72e890535becd1751bb45f64c597edb4c8c6b3" + +[[package]] +name = "alloc-stdlib" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "94fb8275041c72129eb51b7d0322c29b8387a0386127718b096429201a5d6ece" +dependencies = [ + "alloc-no-stdlib", +] + +[[package]] +name = "anyhow" +version = "1.0.66" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "216261ddc8289130e551ddcd5ce8a064710c0d064a4d2895c67151c92b5443f6" + +[[package]] +name = "atk" +version = "0.15.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2c3d816ce6f0e2909a96830d6911c2aff044370b1ef92d7f267b43bae5addedd" +dependencies = [ + "atk-sys", + "bitflags", + "glib", + "libc", +] + +[[package]] +name = "atk-sys" +version = "0.15.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "58aeb089fb698e06db8089971c7ee317ab9644bade33383f63631437b03aafb6" +dependencies = [ + "glib-sys", + "gobject-sys", + "libc", + "system-deps 6.0.3", +] + +[[package]] +name = "attohttpc" +version = "0.22.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fcf00bc6d5abb29b5f97e3c61a90b6d3caa12f3faf897d4a3e3607c050a35a7" +dependencies = [ + "flate2", + "http", + "log", + "native-tls", + "serde", + "serde_json", + "serde_urlencoded", + "url", +] + +[[package]] +name = "autocfg" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa" + +[[package]] +name = "base64" +version = "0.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8" + +[[package]] +name = "bitflags" +version = "1.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" + +[[package]] +name = "block" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0d8c1fef690941d3e7788d328517591fecc684c084084702d6ff1641e993699a" + +[[package]] +name = "block-buffer" +version = "0.10.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "69cce20737498f97b993470a6e536b8523f0af7892a4f928cceb1ac5e52ebe7e" +dependencies = [ + "generic-array", +] + +[[package]] +name = "brotli" +version = "3.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a1a0b1dbcc8ae29329621f8d4f0d835787c1c38bb1401979b49d13b0b305ff68" +dependencies = [ + "alloc-no-stdlib", + "alloc-stdlib", + "brotli-decompressor", +] + +[[package]] +name = "brotli-decompressor" +version = "2.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "59ad2d4653bf5ca36ae797b1f4bb4dbddb60ce49ca4aed8a2ce4829f60425b80" +dependencies = [ + "alloc-no-stdlib", + "alloc-stdlib", +] + +[[package]] +name = "bstr" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ba3569f383e8f1598449f1a423e72e99569137b47740b1da11ef19af3d5c3223" +dependencies = [ + "memchr", +] + +[[package]] +name = "bumpalo" +version = "3.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "572f695136211188308f16ad2ca5c851a712c464060ae6974944458eb83880ba" + +[[package]] +name = "bytemuck" +version = "1.12.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5aec14f5d4e6e3f927cd0c81f72e5710d95ee9019fbeb4b3021193867491bfd8" + +[[package]] +name = "byteorder" +version = "1.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610" + +[[package]] +name = "bytes" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec8a7b6a70fde80372154c65702f00a0f56f3e1c36abbc6c440484be248856db" + +[[package]] +name = "cairo-rs" +version = "0.15.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c76ee391b03d35510d9fa917357c7f1855bd9a6659c95a1b392e33f49b3369bc" +dependencies = [ + "bitflags", + "cairo-sys-rs", + "glib", + "libc", + "thiserror", +] + +[[package]] +name = "cairo-sys-rs" +version = "0.15.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3c55d429bef56ac9172d25fecb85dc8068307d17acd74b377866b7a1ef25d3c8" +dependencies = [ + "glib-sys", + "libc", + "system-deps 6.0.3", +] + +[[package]] +name = "cargo_toml" +version = "0.11.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e72c3ff59e3b7d24630206bb63a73af65da4ed5df1f76ee84dfafb9fee2ba60e" +dependencies = [ + "serde", + "serde_derive", + "toml", +] + +[[package]] +name = "cc" +version = "1.0.74" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "581f5dba903aac52ea3feb5ec4810848460ee833876f1f9b0fdeab1f19091574" + +[[package]] +name = "cesu8" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6d43a04d8753f35258c91f8ec639f792891f748a1edbd759cf1dcea3382ad83c" + +[[package]] +name = "cfb" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "74f89d248799e3f15f91b70917f65381062a01bb8e222700ea0e5a7ff9785f9c" +dependencies = [ + "byteorder", + "uuid 0.8.2", +] + +[[package]] +name = "cfg-expr" +version = "0.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3431df59f28accaf4cb4eed4a9acc66bea3f3c3753aa6cdc2f024174ef232af7" +dependencies = [ + "smallvec", +] + +[[package]] +name = "cfg-expr" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b0357a6402b295ca3a86bc148e84df46c02e41f41fef186bda662557ef6328aa" +dependencies = [ + "smallvec", +] + +[[package]] +name = "cfg-if" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" + +[[package]] +name = "cocoa" +version = "0.24.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f425db7937052c684daec3bd6375c8abe2d146dca4b8b143d6db777c39138f3a" +dependencies = [ + "bitflags", + "block", + "cocoa-foundation", + "core-foundation", + "core-graphics", + "foreign-types", + "libc", + "objc", +] + +[[package]] +name = "cocoa-foundation" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7ade49b65d560ca58c403a479bb396592b155c0185eada742ee323d1d68d6318" +dependencies = [ + "bitflags", + "block", + "core-foundation", + "core-graphics-types", + "foreign-types", + "libc", + "objc", +] + +[[package]] +name = "color_quant" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3d7b894f5411737b7867f4827955924d7c254fc9f4d91a6aad6b097804b1018b" + +[[package]] +name = "combine" +version = "4.6.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "35ed6e9d84f0b51a7f52daf1c7d71dd136fd7a3f41a8462b8cdb8c78d920fad4" +dependencies = [ + "bytes", + "memchr", +] + +[[package]] +name = "console_error_panic_hook" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a06aeb73f470f66dcdbf7223caeebb85984942f22f1adb2a088cf9668146bbbc" +dependencies = [ + "cfg-if", + "wasm-bindgen", +] + +[[package]] +name = "convert_case" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6245d59a3e82a7fc217c5828a6692dbc6dfb63a0c8c90495621f7b9d79704a0e" + +[[package]] +name = "core-foundation" +version = "0.9.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "194a7a9e6de53fa55116934067c844d9d749312f75c6f6d0980e8c252f8c2146" +dependencies = [ + "core-foundation-sys", + "libc", +] + +[[package]] +name = "core-foundation-sys" +version = "0.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5827cebf4670468b8772dd191856768aedcb1b0278a04f989f7766351917b9dc" + +[[package]] +name = "core-graphics" +version = "0.22.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2581bbab3b8ffc6fcbd550bf46c355135d16e9ff2a6ea032ad6b9bf1d7efe4fb" +dependencies = [ + "bitflags", + "core-foundation", + "core-graphics-types", + "foreign-types", + "libc", +] + +[[package]] +name = "core-graphics-types" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3a68b68b3446082644c91ac778bf50cd4104bfb002b5a6a7c44cca5a2c70788b" +dependencies = [ + "bitflags", + "core-foundation", + "foreign-types", + "libc", +] + +[[package]] +name = "cpufeatures" +version = "0.2.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "28d997bd5e24a5928dd43e46dc529867e207907fe0b239c3477d924f7f2ca320" +dependencies = [ + "libc", +] + +[[package]] +name = "crc32fast" +version = "1.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b540bd8bc810d3885c6ea91e2018302f68baba2129ab3e88f32389ee9370880d" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "crossbeam-channel" +version = "0.5.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c2dd04ddaf88237dc3b8d8f9a3c1004b506b54b3313403944054d23c0870c521" +dependencies = [ + "cfg-if", + "crossbeam-utils", +] + +[[package]] +name = "crossbeam-utils" +version = "0.8.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "edbafec5fa1f196ca66527c1b12c2ec4745ca14b50f1ad8f9f6f720b55d11fac" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "crypto-common" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3" +dependencies = [ + "generic-array", + "typenum", +] + +[[package]] +name = "cssparser" +version = "0.27.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "754b69d351cdc2d8ee09ae203db831e005560fc6030da058f86ad60c92a9cb0a" +dependencies = [ + "cssparser-macros", + "dtoa-short", + "itoa 0.4.8", + "matches", + "phf 0.8.0", + "proc-macro2", + "quote", + "smallvec", + "syn", +] + +[[package]] +name = "cssparser-macros" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dfae75de57f2b2e85e8768c3ea840fd159c8f33e2b6522c7835b7abac81be16e" +dependencies = [ + "quote", + "syn", +] + +[[package]] +name = "ctor" +version = "0.1.26" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6d2301688392eb071b0bf1a37be05c469d3cc4dbbd95df672fe28ab021e6a096" +dependencies = [ + "quote", + "syn", +] + +[[package]] +name = "cty" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b365fabc795046672053e29c954733ec3b05e4be654ab130fe8f1f94d7051f35" + +[[package]] +name = "darling" +version = "0.13.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a01d95850c592940db9b8194bc39f4bc0e89dee5c4265e4b1807c34a9aba453c" +dependencies = [ + "darling_core", + "darling_macro", +] + +[[package]] +name = "darling_core" +version = "0.13.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "859d65a907b6852c9361e3185c862aae7fafd2887876799fa55f5f99dc40d610" +dependencies = [ + "fnv", + "ident_case", + "proc-macro2", + "quote", + "strsim", + "syn", +] + +[[package]] +name = "darling_macro" +version = "0.13.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9c972679f83bdf9c42bd905396b6c3588a843a17f0f16dfcfa3e2c5d57441835" +dependencies = [ + "darling_core", + "quote", + "syn", +] + +[[package]] +name = "dbus" +version = "0.9.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6f8bcdd56d2e5c4ed26a529c5a9029f5db8290d433497506f958eae3be148eb6" +dependencies = [ + "libc", + "libdbus-sys", + "winapi", +] + +[[package]] +name = "deflate" +version = "0.7.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "707b6a7b384888a70c8d2e8650b3e60170dfc6a67bb4aa67b6dfca57af4bedb4" +dependencies = [ + "adler32", + "byteorder", +] + +[[package]] +name = "derive_more" +version = "0.99.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4fb810d30a7c1953f91334de7244731fc3f3c10d7fe163338a35b9f640960321" +dependencies = [ + "convert_case", + "proc-macro2", + "quote", + "rustc_version 0.4.0", + "syn", +] + +[[package]] +name = "digest" +version = "0.10.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "adfbc57365a37acbd2ebf2b64d7e69bb766e2fea813521ed536f5d0520dcf86c" +dependencies = [ + "block-buffer", + "crypto-common", +] + +[[package]] +name = "dirs-next" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b98cf8ebf19c3d1b223e151f99a4f9f0690dca41414773390fc824184ac833e1" +dependencies = [ + "cfg-if", + "dirs-sys-next", +] + +[[package]] +name = "dirs-sys-next" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4ebda144c4fe02d1f7ea1a7d9641b6fc6b580adcfa024ae48797ecdeb6825b4d" +dependencies = [ + "libc", + "redox_users", + "winapi", +] + +[[package]] +name = "dispatch" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bd0c93bb4b0c6d9b77f4435b0ae98c24d17f1c45b2ff844c6151a07256ca923b" + +[[package]] +name = "dtoa" +version = "0.4.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "56899898ce76aaf4a0f24d914c97ea6ed976d42fec6ad33fcbb0a1103e07b2b0" + +[[package]] +name = "dtoa-short" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bde03329ae10e79ede66c9ce4dc930aa8599043b0743008548680f25b91502d6" +dependencies = [ + "dtoa", +] + +[[package]] +name = "embed_plist" +version = "1.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4ef6b89e5b37196644d8796de5268852ff179b44e96276cf4290264843743bb7" + +[[package]] +name = "encoding_rs" +version = "0.8.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9852635589dc9f9ea1b6fe9f05b50ef208c85c834a562f0c6abb1c475736ec2b" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "fastrand" +version = "1.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a7a407cfaa3385c4ae6b23e84623d48c2798d06e3e6a1878f7f59f17b3f86499" +dependencies = [ + "instant", +] + +[[package]] +name = "field-offset" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e1c54951450cbd39f3dbcf1005ac413b49487dabf18a720ad2383eccfeffb92" +dependencies = [ + "memoffset", + "rustc_version 0.3.3", +] + +[[package]] +name = "filetime" +version = "0.2.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4b9663d381d07ae25dc88dbdf27df458faa83a9b25336bcac83d5e452b5fc9d3" +dependencies = [ + "cfg-if", + "libc", + "redox_syscall", + "windows-sys 0.42.0", +] + +[[package]] +name = "flate2" +version = "1.0.24" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f82b0f4c27ad9f8bfd1f3208d882da2b09c301bc1c828fd3a00d0216d2fbbff6" +dependencies = [ + "crc32fast", + "miniz_oxide 0.5.4", +] + +[[package]] +name = "fnv" +version = "1.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1" + +[[package]] +name = "foreign-types" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1" +dependencies = [ + "foreign-types-shared", +] + +[[package]] +name = "foreign-types-shared" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b" + +[[package]] +name = "form_urlencoded" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a9c384f161156f5260c24a097c56119f9be8c798586aecc13afbcbe7b7e26bf8" +dependencies = [ + "percent-encoding", +] + +[[package]] +name = "futf" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "df420e2e84819663797d1ec6544b13c5be84629e7bb00dc960d6917db2987843" +dependencies = [ + "mac", + "new_debug_unreachable", +] + +[[package]] +name = "futures" +version = "0.3.25" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "38390104763dc37a5145a53c29c63c1290b5d316d6086ec32c293f6736051bb0" +dependencies = [ + "futures-channel", + "futures-core", + "futures-executor", + "futures-io", + "futures-sink", + "futures-task", + "futures-util", +] + +[[package]] +name = "futures-channel" +version = "0.3.25" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "52ba265a92256105f45b719605a571ffe2d1f0fea3807304b522c1d778f79eed" +dependencies = [ + "futures-core", + "futures-sink", +] + +[[package]] +name = "futures-core" +version = "0.3.25" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "04909a7a7e4633ae6c4a9ab280aeb86da1236243a77b694a49eacd659a4bd3ac" + +[[package]] +name = "futures-executor" +version = "0.3.25" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7acc85df6714c176ab5edf386123fafe217be88c0840ec11f199441134a074e2" +dependencies = [ + "futures-core", + "futures-task", + "futures-util", +] + +[[package]] +name = "futures-io" +version = "0.3.25" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "00f5fb52a06bdcadeb54e8d3671f8888a39697dcb0b81b23b55174030427f4eb" + +[[package]] +name = "futures-macro" +version = "0.3.25" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bdfb8ce053d86b91919aad980c220b1fb8401a9394410e1c289ed7e66b61835d" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "futures-sink" +version = "0.3.25" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "39c15cf1a4aa79df40f1bb462fb39676d0ad9e366c2a33b590d7c66f4f81fcf9" + +[[package]] +name = "futures-task" +version = "0.3.25" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2ffb393ac5d9a6eaa9d3fdf37ae2776656b706e200c8e16b1bdb227f5198e6ea" + +[[package]] +name = "futures-util" +version = "0.3.25" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "197676987abd2f9cadff84926f410af1c183608d36641465df73ae8211dc65d6" +dependencies = [ + "futures-channel", + "futures-core", + "futures-io", + "futures-macro", + "futures-sink", + "futures-task", + "memchr", + "pin-project-lite", + "pin-utils", + "slab", +] + +[[package]] +name = "fxhash" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c31b6d751ae2c7f11320402d34e41349dd1016f8d5d45e48c4312bc8625af50c" +dependencies = [ + "byteorder", +] + +[[package]] +name = "gdk" +version = "0.15.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a6e05c1f572ab0e1f15be94217f0dc29088c248b14f792a5ff0af0d84bcda9e8" +dependencies = [ + "bitflags", + "cairo-rs", + "gdk-pixbuf", + "gdk-sys", + "gio", + "glib", + "libc", + "pango", +] + +[[package]] +name = "gdk-pixbuf" +version = "0.15.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ad38dd9cc8b099cceecdf41375bb6d481b1b5a7cd5cd603e10a69a9383f8619a" +dependencies = [ + "bitflags", + "gdk-pixbuf-sys", + "gio", + "glib", + "libc", +] + +[[package]] +name = "gdk-pixbuf-sys" +version = "0.15.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "140b2f5378256527150350a8346dbdb08fadc13453a7a2d73aecd5fab3c402a7" +dependencies = [ + "gio-sys", + "glib-sys", + "gobject-sys", + "libc", + "system-deps 6.0.3", +] + +[[package]] +name = "gdk-sys" +version = "0.15.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32e7a08c1e8f06f4177fb7e51a777b8c1689f743a7bc11ea91d44d2226073a88" +dependencies = [ + "cairo-sys-rs", + "gdk-pixbuf-sys", + "gio-sys", + "glib-sys", + "gobject-sys", + "libc", + "pango-sys", + "pkg-config", + "system-deps 6.0.3", +] + +[[package]] +name = "gdkx11-sys" +version = "0.15.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b4b7f8c7a84b407aa9b143877e267e848ff34106578b64d1e0a24bf550716178" +dependencies = [ + "gdk-sys", + "glib-sys", + "libc", + "system-deps 6.0.3", + "x11", +] + +[[package]] +name = "generator" +version = "0.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cc184cace1cea8335047a471cc1da80f18acf8a76f3bab2028d499e328948ec7" +dependencies = [ + "cc", + "libc", + "log", + "rustversion", + "windows 0.32.0", +] + +[[package]] +name = "generic-array" +version = "0.14.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bff49e947297f3312447abdca79f45f4738097cc82b06e72054d2223f601f1b9" +dependencies = [ + "typenum", + "version_check", +] + +[[package]] +name = "getrandom" +version = "0.1.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8fc3cb4d91f53b50155bdcfd23f6a4c39ae1969c2ae85982b135750cccaf5fce" +dependencies = [ + "cfg-if", + "libc", + "wasi 0.9.0+wasi-snapshot-preview1", +] + +[[package]] +name = "getrandom" +version = "0.2.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c05aeb6a22b8f62540c194aac980f2115af067bfe15a0734d7277a768d396b31" +dependencies = [ + "cfg-if", + "libc", + "wasi 0.11.0+wasi-snapshot-preview1", +] + +[[package]] +name = "gio" +version = "0.15.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "68fdbc90312d462781a395f7a16d96a2b379bb6ef8cd6310a2df272771c4283b" +dependencies = [ + "bitflags", + "futures-channel", + "futures-core", + "futures-io", + "gio-sys", + "glib", + "libc", + "once_cell", + "thiserror", +] + +[[package]] +name = "gio-sys" +version = "0.15.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32157a475271e2c4a023382e9cab31c4584ee30a97da41d3c4e9fdd605abcf8d" +dependencies = [ + "glib-sys", + "gobject-sys", + "libc", + "system-deps 6.0.3", + "winapi", +] + +[[package]] +name = "glib" +version = "0.15.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "edb0306fbad0ab5428b0ca674a23893db909a98582969c9b537be4ced78c505d" +dependencies = [ + "bitflags", + "futures-channel", + "futures-core", + "futures-executor", + "futures-task", + "glib-macros", + "glib-sys", + "gobject-sys", + "libc", + "once_cell", + "smallvec", + "thiserror", +] + +[[package]] +name = "glib-macros" +version = "0.15.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "25a68131a662b04931e71891fb14aaf65ee4b44d08e8abc10f49e77418c86c64" +dependencies = [ + "anyhow", + "heck 0.4.0", + "proc-macro-crate", + "proc-macro-error", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "glib-sys" +version = "0.15.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ef4b192f8e65e9cf76cbf4ea71fa8e3be4a0e18ffe3d68b8da6836974cc5bad4" +dependencies = [ + "libc", + "system-deps 6.0.3", +] + +[[package]] +name = "glob" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b919933a397b79c37e33b77bb2aa3dc8eb6e165ad809e58ff75bc7db2e34574" + +[[package]] +name = "globset" +version = "0.4.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0a1e17342619edbc21a964c2afbeb6c820c6a2560032872f397bb97ea127bd0a" +dependencies = [ + "aho-corasick", + "bstr", + "fnv", + "log", + "regex", +] + +[[package]] +name = "gobject-sys" +version = "0.15.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0d57ce44246becd17153bd035ab4d32cfee096a657fc01f2231c9278378d1e0a" +dependencies = [ + "glib-sys", + "libc", + "system-deps 6.0.3", +] + +[[package]] +name = "gtk" +version = "0.15.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "92e3004a2d5d6d8b5057d2b57b3712c9529b62e82c77f25c1fecde1fd5c23bd0" +dependencies = [ + "atk", + "bitflags", + "cairo-rs", + "field-offset", + "futures-channel", + "gdk", + "gdk-pixbuf", + "gio", + "glib", + "gtk-sys", + "gtk3-macros", + "libc", + "once_cell", + "pango", + "pkg-config", +] + +[[package]] +name = "gtk-sys" +version = "0.15.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d5bc2f0587cba247f60246a0ca11fe25fb733eabc3de12d1965fc07efab87c84" +dependencies = [ + "atk-sys", + "cairo-sys-rs", + "gdk-pixbuf-sys", + "gdk-sys", + "gio-sys", + "glib-sys", + "gobject-sys", + "libc", + "pango-sys", + "system-deps 6.0.3", +] + +[[package]] +name = "gtk3-macros" +version = "0.15.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "24f518afe90c23fba585b2d7697856f9e6a7bbc62f65588035e66f6afb01a2e9" +dependencies = [ + "anyhow", + "proc-macro-crate", + "proc-macro-error", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "hashbrown" +version = "0.12.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888" + +[[package]] +name = "heck" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6d621efb26863f0e9924c6ac577e8275e5e6b77455db64ffa6c65c904e9e132c" +dependencies = [ + "unicode-segmentation", +] + +[[package]] +name = "heck" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2540771e65fc8cb83cd6e8a237f70c319bd5c29f78ed1084ba5d50eeac86f7f9" + +[[package]] +name = "hermit-abi" +version = "0.1.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33" +dependencies = [ + "libc", +] + +[[package]] +name = "html-escape" +version = "0.2.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "15315cfa9503e9aa85a477138eff76a1b203a430703548052c330b69d8d8c205" +dependencies = [ + "utf8-width", +] + +[[package]] +name = "html5ever" +version = "0.25.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e5c13fb08e5d4dfc151ee5e88bae63f7773d61852f3bdc73c9f4b9e1bde03148" +dependencies = [ + "log", + "mac", + "markup5ever", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "http" +version = "0.2.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "75f43d41e26995c17e71ee126451dd3941010b0514a81a9d11f3b341debc2399" +dependencies = [ + "bytes", + "fnv", + "itoa 1.0.4", +] + +[[package]] +name = "http-range" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "21dec9db110f5f872ed9699c3ecf50cf16f423502706ba5c72462e28d3157573" + +[[package]] +name = "ico" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6a4b3331534254a9b64095ae60d3dc2a8225a7a70229cd5888be127cdc1f6804" +dependencies = [ + "byteorder", + "png 0.11.0", +] + +[[package]] +name = "ident_case" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39" + +[[package]] +name = "idna" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e14ddfc70884202db2244c223200c204c2bda1bc6e0998d11b5e024d657209e6" +dependencies = [ + "unicode-bidi", + "unicode-normalization", +] + +[[package]] +name = "ignore" +version = "0.4.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "713f1b139373f96a2e0ce3ac931cd01ee973c3c5dd7c40c0c2efe96ad2b6751d" +dependencies = [ + "crossbeam-utils", + "globset", + "lazy_static", + "log", + "memchr", + "regex", + "same-file", + "thread_local", + "walkdir", + "winapi-util", +] + +[[package]] +name = "image" +version = "0.24.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bd8e4fb07cf672b1642304e731ef8a6a4c7891d67bb4fd4f5ce58cd6ed86803c" +dependencies = [ + "bytemuck", + "byteorder", + "color_quant", + "num-rational", + "num-traits", +] + +[[package]] +name = "indexmap" +version = "1.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "10a35a97730320ffe8e2d410b5d3b69279b98d2c14bdb8b70ea89ecf7888d41e" +dependencies = [ + "autocfg", + "hashbrown", +] + +[[package]] +name = "infer" +version = "0.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "20b2b533137b9cad970793453d4f921c2e91312a6d88b1085c07bc15fc51bb3b" +dependencies = [ + "cfb", +] + +[[package]] +name = "inflate" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f5f9f47468e9a76a6452271efadc88fe865a82be91fe75e6c0c57b87ccea59d4" +dependencies = [ + "adler32", +] + +[[package]] +name = "instant" +version = "0.1.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7a5bbe824c507c5da5956355e86a746d82e0e1464f65d862cc5e71da70e94b2c" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "itoa" +version = "0.4.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b71991ff56294aa922b450139ee08b3bfc70982c6b2c7562771375cf73542dd4" + +[[package]] +name = "itoa" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4217ad341ebadf8d8e724e264f13e593e0648f5b3e94b3896a5df283be015ecc" + +[[package]] +name = "javascriptcore-rs" +version = "0.16.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bf053e7843f2812ff03ef5afe34bb9c06ffee120385caad4f6b9967fcd37d41c" +dependencies = [ + "bitflags", + "glib", + "javascriptcore-rs-sys", +] + +[[package]] +name = "javascriptcore-rs-sys" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "905fbb87419c5cde6e3269537e4ea7d46431f3008c5d057e915ef3f115e7793c" +dependencies = [ + "glib-sys", + "gobject-sys", + "libc", + "system-deps 5.0.0", +] + +[[package]] +name = "jni" +version = "0.19.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c6df18c2e3db7e453d3c6ac5b3e9d5182664d28788126d39b91f2d1e22b017ec" +dependencies = [ + "cesu8", + "combine", + "jni-sys", + "log", + "thiserror", + "walkdir", +] + +[[package]] +name = "jni-sys" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8eaf4bc02d17cbdd7ff4c7438cafcdf7fb9a4613313ad11b4f8fefe7d3fa0130" + +[[package]] +name = "js-sys" +version = "0.3.60" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "49409df3e3bf0856b916e2ceaca09ee28e6871cf7d9ce97a692cacfdb2a25a47" +dependencies = [ + "wasm-bindgen", +] + +[[package]] +name = "json-patch" +version = "0.2.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f995a3c8f2bc3dd52a18a583e90f9ec109c047fa1603a853e46bcda14d2e279d" +dependencies = [ + "serde", + "serde_json", + "treediff", +] + +[[package]] +name = "kuchiki" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1ea8e9c6e031377cff82ee3001dc8026cdf431ed4e2e6b51f98ab8c73484a358" +dependencies = [ + "cssparser", + "html5ever", + "matches", + "selectors", +] + +[[package]] +name = "lazy_static" +version = "1.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646" + +[[package]] +name = "libc" +version = "0.2.137" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fc7fcc620a3bff7cdd7a365be3376c97191aeaccc2a603e600951e452615bf89" + +[[package]] +name = "libdbus-sys" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c185b5b7ad900923ef3a8ff594083d4d9b5aea80bb4f32b8342363138c0d456b" +dependencies = [ + "pkg-config", +] + +[[package]] +name = "line-wrap" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f30344350a2a51da54c1d53be93fade8a237e545dbcc4bdbe635413f2117cab9" +dependencies = [ + "safemem", +] + +[[package]] +name = "lock_api" +version = "0.4.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "435011366fe56583b16cf956f9df0095b405b82d76425bc8981c0e22e60ec4df" +dependencies = [ + "autocfg", + "scopeguard", +] + +[[package]] +name = "log" +version = "0.4.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "abb12e687cfb44aa40f41fc3978ef76448f9b6038cad6aef4259d3c095a2382e" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "loom" +version = "0.5.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ff50ecb28bb86013e935fb6683ab1f6d3a20016f123c76fd4c27470076ac30f5" +dependencies = [ + "cfg-if", + "generator", + "scoped-tls", + "serde", + "serde_json", + "tracing", + "tracing-subscriber", +] + +[[package]] +name = "mac" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c41e0c4fef86961ac6d6f8a82609f55f31b05e4fce149ac5710e439df7619ba4" + +[[package]] +name = "mac-notification-sys" +version = "0.5.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3e72d50edb17756489e79d52eb146927bec8eba9dd48faadf9ef08bca3791ad5" +dependencies = [ + "cc", + "dirs-next", + "objc-foundation", + "objc_id", + "time", +] + +[[package]] +name = "malloc_buf" +version = "0.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "62bb907fe88d54d8d9ce32a3cceab4218ed2f6b7d35617cafe9adf84e43919cb" +dependencies = [ + "libc", +] + +[[package]] +name = "markup5ever" +version = "0.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a24f40fb03852d1cdd84330cddcaf98e9ec08a7b7768e952fad3b4cf048ec8fd" +dependencies = [ + "log", + "phf 0.8.0", + "phf_codegen", + "string_cache", + "string_cache_codegen", + "tendril", +] + +[[package]] +name = "matchers" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8263075bb86c5a1b1427b5ae862e8889656f126e9f77c484496e8b47cf5c5558" +dependencies = [ + "regex-automata", +] + +[[package]] +name = "matches" +version = "0.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a3e378b66a060d48947b590737b30a1be76706c8dd7b8ba0f2fe3989c68a853f" + +[[package]] +name = "memchr" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d" + +[[package]] +name = "memoffset" +version = "0.6.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5aa361d4faea93603064a027415f07bd8e1d5c88c9fbf68bf56a285428fd79ce" +dependencies = [ + "autocfg", +] + +[[package]] +name = "miniz_oxide" +version = "0.5.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "96590ba8f175222643a85693f33d26e9c8a015f599c216509b1a6894af675d34" +dependencies = [ + "adler", +] + +[[package]] +name = "miniz_oxide" +version = "0.6.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b275950c28b37e794e8c55d88aeb5e139d0ce23fdbbeda68f8d7174abdf9e8fa" +dependencies = [ + "adler", +] + +[[package]] +name = "native-tls" +version = "0.2.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "07226173c32f2926027b63cce4bcd8076c3552846cbe7925f3aaffeac0a3b92e" +dependencies = [ + "lazy_static", + "libc", + "log", + "openssl", + "openssl-probe", + "openssl-sys", + "schannel", + "security-framework", + "security-framework-sys", + "tempfile", +] + +[[package]] +name = "ndk" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2032c77e030ddee34a6787a64166008da93f6a352b629261d0fee232b8742dd4" +dependencies = [ + "bitflags", + "jni-sys", + "ndk-sys", + "num_enum", + "thiserror", +] + +[[package]] +name = "ndk-context" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "27b02d87554356db9e9a873add8782d4ea6e3e58ea071a9adb9a2e8ddb884a8b" + +[[package]] +name = "ndk-sys" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6e5a6ae77c8ee183dcbbba6150e2e6b9f3f4196a7666c02a715a95692ec1fa97" +dependencies = [ + "jni-sys", +] + +[[package]] +name = "new_debug_unreachable" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e4a24736216ec316047a1fc4252e27dabb04218aa4a3f37c6e7ddbf1f9782b54" + +[[package]] +name = "nodrop" +version = "0.1.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72ef4a56884ca558e5ddb05a1d1e7e1bfd9a68d9ed024c21704cc98872dae1bb" + +[[package]] +name = "notify-rust" +version = "4.5.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "368e89ea58df747ce88be669ae44e79783c1d30bfd540ad0fc520b3f41f0b3b0" +dependencies = [ + "dbus", + "mac-notification-sys", + "tauri-winrt-notification", +] + +[[package]] +name = "nu-ansi-term" +version = "0.46.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "77a8165726e8236064dbb45459242600304b42a5ea24ee2948e18e023bf7ba84" +dependencies = [ + "overload", + "winapi", +] + +[[package]] +name = "num-integer" +version = "0.1.45" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "225d3389fb3509a24c93f5c29eb6bde2586b98d9f016636dff58d7c6f7569cd9" +dependencies = [ + "autocfg", + "num-traits", +] + +[[package]] +name = "num-iter" +version = "0.1.43" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7d03e6c028c5dc5cac6e2dec0efda81fc887605bb3d884578bb6d6bf7514e252" +dependencies = [ + "autocfg", + "num-integer", + "num-traits", +] + +[[package]] +name = "num-rational" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0638a1c9d0a3c0914158145bc76cff373a75a627e6ecbfb71cbe6f453a5a19b0" +dependencies = [ + "autocfg", + "num-integer", + "num-traits", +] + +[[package]] +name = "num-traits" +version = "0.2.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd" +dependencies = [ + "autocfg", +] + +[[package]] +name = "num_cpus" +version = "1.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "19e64526ebdee182341572e50e9ad03965aa510cd94427a4549448f285e957a1" +dependencies = [ + "hermit-abi", + "libc", +] + +[[package]] +name = "num_enum" +version = "0.5.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf5395665662ef45796a4ff5486c5d41d29e0c09640af4c5f17fd94ee2c119c9" +dependencies = [ + "num_enum_derive", +] + +[[package]] +name = "num_enum_derive" +version = "0.5.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3b0498641e53dd6ac1a4f22547548caa6864cc4933784319cd1775271c5a46ce" +dependencies = [ + "proc-macro-crate", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "num_threads" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2819ce041d2ee131036f4fc9d6ae7ae125a3a40e97ba64d04fe799ad9dabbb44" +dependencies = [ + "libc", +] + +[[package]] +name = "objc" +version = "0.2.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "915b1b472bc21c53464d6c8461c9d3af805ba1ef837e1cac254428f4a77177b1" +dependencies = [ + "malloc_buf", + "objc_exception", +] + +[[package]] +name = "objc-foundation" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1add1b659e36c9607c7aab864a76c7a4c2760cd0cd2e120f3fb8b952c7e22bf9" +dependencies = [ + "block", + "objc", + "objc_id", +] + +[[package]] +name = "objc_exception" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ad970fb455818ad6cba4c122ad012fae53ae8b4795f86378bce65e4f6bab2ca4" +dependencies = [ + "cc", +] + +[[package]] +name = "objc_id" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c92d4ddb4bd7b50d730c215ff871754d0da6b2178849f8a2a2ab69712d0c073b" +dependencies = [ + "objc", +] + +[[package]] +name = "once_cell" +version = "1.16.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "86f0b0d4bf799edbc74508c1e8bf170ff5f41238e5f8225603ca7caaae2b7860" + +[[package]] +name = "open" +version = "3.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b4a3100141f1733ea40b53381b0ae3117330735ef22309a190ac57b9576ea716" +dependencies = [ + "pathdiff", + "windows-sys 0.36.1", +] + +[[package]] +name = "openssl" +version = "0.10.42" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "12fc0523e3bd51a692c8850d075d74dc062ccf251c0110668cbd921917118a13" +dependencies = [ + "bitflags", + "cfg-if", + "foreign-types", + "libc", + "once_cell", + "openssl-macros", + "openssl-sys", +] + +[[package]] +name = "openssl-macros" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b501e44f11665960c7e7fcf062c7d96a14ade4aa98116c004b2e37b5be7d736c" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "openssl-probe" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ff011a302c396a5197692431fc1948019154afc178baf7d8e37367442a4601cf" + +[[package]] +name = "openssl-sys" +version = "0.9.77" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b03b84c3b2d099b81f0953422b4d4ad58761589d0229b5506356afca05a3670a" +dependencies = [ + "autocfg", + "cc", + "libc", + "pkg-config", + "vcpkg", +] + +[[package]] +name = "os_info" +version = "3.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c4750134fb6a5d49afc80777394ad5d95b04bc12068c6abb92fae8f43817270f" +dependencies = [ + "log", + "serde", + "winapi", +] + +[[package]] +name = "os_pipe" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0dceb7e43f59c35ee1548045b2c72945a5a3bb6ce6d6f07cdc13dc8f6bc4930a" +dependencies = [ + "libc", + "winapi", +] + +[[package]] +name = "overload" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39" + +[[package]] +name = "pango" +version = "0.15.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "22e4045548659aee5313bde6c582b0d83a627b7904dd20dc2d9ef0895d414e4f" +dependencies = [ + "bitflags", + "glib", + "libc", + "once_cell", + "pango-sys", +] + +[[package]] +name = "pango-sys" +version = "0.15.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d2a00081cde4661982ed91d80ef437c20eacaf6aa1a5962c0279ae194662c3aa" +dependencies = [ + "glib-sys", + "gobject-sys", + "libc", + "system-deps 6.0.3", +] + +[[package]] +name = "parking_lot" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3742b2c103b9f06bc9fff0a37ff4912935851bee6d36f3c02bcc755bcfec228f" +dependencies = [ + "lock_api", + "parking_lot_core", +] + +[[package]] +name = "parking_lot_core" +version = "0.9.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4dc9e0dc2adc1c69d09143aff38d3d30c5c3f0df0dad82e6d25547af174ebec0" +dependencies = [ + "cfg-if", + "libc", + "redox_syscall", + "smallvec", + "windows-sys 0.42.0", +] + +[[package]] +name = "paste" +version = "1.0.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b1de2e551fb905ac83f73f7aedf2f0cb4a0da7e35efa24a202a936269f1f18e1" + +[[package]] +name = "pathdiff" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8835116a5c179084a830efb3adc117ab007512b535bc1a21c991d3b32a6b44dd" + +[[package]] +name = "percent-encoding" +version = "2.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "478c572c3d73181ff3c2539045f6eb99e5491218eae919370993b890cdbdd98e" + +[[package]] +name = "pest" +version = "2.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dbc7bc69c062e492337d74d59b120c274fd3d261b6bf6d3207d499b4b379c41a" +dependencies = [ + "thiserror", + "ucd-trie", +] + +[[package]] +name = "phf" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3dfb61232e34fcb633f43d12c58f83c1df82962dcdfa565a4e866ffc17dafe12" +dependencies = [ + "phf_macros 0.8.0", + "phf_shared 0.8.0", + "proc-macro-hack", +] + +[[package]] +name = "phf" +version = "0.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fabbf1ead8a5bcbc20f5f8b939ee3f5b0f6f281b6ad3468b84656b658b455259" +dependencies = [ + "phf_macros 0.10.0", + "phf_shared 0.10.0", + "proc-macro-hack", +] + +[[package]] +name = "phf_codegen" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cbffee61585b0411840d3ece935cce9cb6321f01c45477d30066498cd5e1a815" +dependencies = [ + "phf_generator 0.8.0", + "phf_shared 0.8.0", +] + +[[package]] +name = "phf_generator" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "17367f0cc86f2d25802b2c26ee58a7b23faeccf78a396094c13dced0d0182526" +dependencies = [ + "phf_shared 0.8.0", + "rand 0.7.3", +] + +[[package]] +name = "phf_generator" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5d5285893bb5eb82e6aaf5d59ee909a06a16737a8970984dd7746ba9283498d6" +dependencies = [ + "phf_shared 0.10.0", + "rand 0.8.5", +] + +[[package]] +name = "phf_macros" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7f6fde18ff429ffc8fe78e2bf7f8b7a5a5a6e2a8b58bc5a9ac69198bbda9189c" +dependencies = [ + "phf_generator 0.8.0", + "phf_shared 0.8.0", + "proc-macro-hack", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "phf_macros" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "58fdf3184dd560f160dd73922bea2d5cd6e8f064bf4b13110abd81b03697b4e0" +dependencies = [ + "phf_generator 0.10.0", + "phf_shared 0.10.0", + "proc-macro-hack", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "phf_shared" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c00cf8b9eafe68dde5e9eaa2cef8ee84a9336a47d566ec55ca16589633b65af7" +dependencies = [ + "siphasher", +] + +[[package]] +name = "phf_shared" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6796ad771acdc0123d2a88dc428b5e38ef24456743ddb1744ed628f9815c096" +dependencies = [ + "siphasher", +] + +[[package]] +name = "pin-project-lite" +version = "0.2.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e0a7ae3ac2f1173085d398531c705756c94a4c56843785df85a60c1a0afac116" + +[[package]] +name = "pin-utils" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184" + +[[package]] +name = "pkg-config" +version = "0.3.26" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ac9a59f73473f1b8d852421e59e64809f025994837ef743615c6d0c5b305160" + +[[package]] +name = "plist" +version = "1.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bd39bc6cdc9355ad1dc5eeedefee696bb35c34caf21768741e81826c0bbd7225" +dependencies = [ + "base64", + "indexmap", + "line-wrap", + "serde", + "time", + "xml-rs", +] + +[[package]] +name = "png" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0b0cabbbd20c2d7f06dbf015e06aad59b6ca3d9ed14848783e98af9aaf19925" +dependencies = [ + "bitflags", + "deflate", + "inflate", + "num-iter", +] + +[[package]] +name = "png" +version = "0.17.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5d708eaf860a19b19ce538740d2b4bdeeb8337fa53f7738455e706623ad5c638" +dependencies = [ + "bitflags", + "crc32fast", + "flate2", + "miniz_oxide 0.6.2", +] + +[[package]] +name = "ppv-lite86" +version = "0.2.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eb9f9e6e233e5c4a35559a617bf40a4ec447db2e84c20b55a6f83167b7e57872" + +[[package]] +name = "precomputed-hash" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c" + +[[package]] +name = "proc-macro-crate" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eda0fc3b0fb7c975631757e14d9049da17374063edb6ebbcbc54d880d4fe94e9" +dependencies = [ + "once_cell", + "thiserror", + "toml", +] + +[[package]] +name = "proc-macro-error" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c" +dependencies = [ + "proc-macro-error-attr", + "proc-macro2", + "quote", + "syn", + "version_check", +] + +[[package]] +name = "proc-macro-error-attr" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869" +dependencies = [ + "proc-macro2", + "quote", + "version_check", +] + +[[package]] +name = "proc-macro-hack" +version = "0.5.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dbf0c48bc1d91375ae5c3cd81e3722dff1abcf81a30960240640d223f59fe0e5" + +[[package]] +name = "proc-macro2" +version = "1.0.47" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5ea3d908b0e36316caf9e9e2c4625cdde190a7e6f440d794667ed17a1855e725" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quick-xml" +version = "0.23.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "11bafc859c6815fbaffbbbf4229ecb767ac913fecb27f9ad4343662e9ef099ea" +dependencies = [ + "memchr", +] + +[[package]] +name = "quote" +version = "1.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bbe448f377a7d6961e30f5955f9b8d106c3f5e449d493ee1b125c1d43c2b5179" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "rand" +version = "0.7.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6a6b1679d49b24bbfe0c803429aa1874472f50d9b363131f0e89fc356b544d03" +dependencies = [ + "getrandom 0.1.16", + "libc", + "rand_chacha 0.2.2", + "rand_core 0.5.1", + "rand_hc", + "rand_pcg", +] + +[[package]] +name = "rand" +version = "0.8.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404" +dependencies = [ + "libc", + "rand_chacha 0.3.1", + "rand_core 0.6.4", +] + +[[package]] +name = "rand_chacha" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f4c8ed856279c9737206bf725bf36935d8666ead7aa69b52be55af369d193402" +dependencies = [ + "ppv-lite86", + "rand_core 0.5.1", +] + +[[package]] +name = "rand_chacha" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88" +dependencies = [ + "ppv-lite86", + "rand_core 0.6.4", +] + +[[package]] +name = "rand_core" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "90bde5296fc891b0cef12a6d03ddccc162ce7b2aff54160af9338f8d40df6d19" +dependencies = [ + "getrandom 0.1.16", +] + +[[package]] +name = "rand_core" +version = "0.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c" +dependencies = [ + "getrandom 0.2.8", +] + +[[package]] +name = "rand_hc" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ca3129af7b92a17112d59ad498c6f81eaf463253766b90396d39ea7a39d6613c" +dependencies = [ + "rand_core 0.5.1", +] + +[[package]] +name = "rand_pcg" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "16abd0c1b639e9eb4d7c50c0b8100b0d0f849be2349829c740fe8e6eb4816429" +dependencies = [ + "rand_core 0.5.1", +] + +[[package]] +name = "raw-window-handle" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed7e3d950b66e19e0c372f3fa3fbbcf85b1746b571f74e0c2af6042a5c93420a" +dependencies = [ + "cty", +] + +[[package]] +name = "redox_syscall" +version = "0.2.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fb5a58c1855b4b6819d59012155603f0b22ad30cad752600aadfcb695265519a" +dependencies = [ + "bitflags", +] + +[[package]] +name = "redox_users" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b033d837a7cf162d7993aded9304e30a83213c648b6e389db233191f891e5c2b" +dependencies = [ + "getrandom 0.2.8", + "redox_syscall", + "thiserror", +] + +[[package]] +name = "regex" +version = "1.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4c4eb3267174b8c6c2f654116623910a0fef09c4753f8dd83db29c48a0df988b" +dependencies = [ + "aho-corasick", + "memchr", + "regex-syntax", +] + +[[package]] +name = "regex-automata" +version = "0.1.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132" +dependencies = [ + "regex-syntax", +] + +[[package]] +name = "regex-syntax" +version = "0.6.27" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a3f87b73ce11b1619a3c6332f45341e0047173771e8b8b73f87bfeefb7b56244" + +[[package]] +name = "remove_dir_all" +version = "0.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3acd125665422973a33ac9d3dd2df85edad0f4ae9b00dafb1a05e43a9f5ef8e7" +dependencies = [ + "winapi", +] + +[[package]] +name = "rfd" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0149778bd99b6959285b0933288206090c50e2327f47a9c463bfdbf45c8823ea" +dependencies = [ + "block", + "dispatch", + "glib-sys", + "gobject-sys", + "gtk-sys", + "js-sys", + "lazy_static", + "log", + "objc", + "objc-foundation", + "objc_id", + "raw-window-handle", + "wasm-bindgen", + "wasm-bindgen-futures", + "web-sys", + "windows 0.37.0", +] + +[[package]] +name = "rustc_version" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0dfe2087c51c460008730de8b57e6a320782fbfb312e1f4d520e6c6fae155ee" +dependencies = [ + "semver 0.11.0", +] + +[[package]] +name = "rustc_version" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366" +dependencies = [ + "semver 1.0.14", +] + +[[package]] +name = "rustversion" +version = "1.0.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "97477e48b4cf8603ad5f7aaf897467cf42ab4218a38ef76fb14c2d6773a6d6a8" + +[[package]] +name = "ryu" +version = "1.0.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4501abdff3ae82a1c1b477a17252eb69cee9e66eb915c1abaa4f44d873df9f09" + +[[package]] +name = "safemem" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ef703b7cb59335eae2eb93ceb664c0eb7ea6bf567079d843e09420219668e072" + +[[package]] +name = "same-file" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502" +dependencies = [ + "winapi-util", +] + +[[package]] +name = "schannel" +version = "0.1.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "88d6731146462ea25d9244b2ed5fd1d716d25c52e4d54aa4fb0f3c4e9854dbe2" +dependencies = [ + "lazy_static", + "windows-sys 0.36.1", +] + +[[package]] +name = "scoped-tls" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e1cf6437eb19a8f4a6cc0f7dca544973b0b78843adbfeb3683d1a94a0024a294" + +[[package]] +name = "scopeguard" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd" + +[[package]] +name = "security-framework" +version = "2.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2bc1bb97804af6631813c55739f771071e0f2ed33ee20b68c86ec505d906356c" +dependencies = [ + "bitflags", + "core-foundation", + "core-foundation-sys", + "libc", + "security-framework-sys", +] + +[[package]] +name = "security-framework-sys" +version = "2.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0160a13a177a45bfb43ce71c01580998474f556ad854dcbca936dd2841a5c556" +dependencies = [ + "core-foundation-sys", + "libc", +] + +[[package]] +name = "selectors" +version = "0.22.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "df320f1889ac4ba6bc0cdc9c9af7af4bd64bb927bccdf32d81140dc1f9be12fe" +dependencies = [ + "bitflags", + "cssparser", + "derive_more", + "fxhash", + "log", + "matches", + "phf 0.8.0", + "phf_codegen", + "precomputed-hash", + "servo_arc", + "smallvec", + "thin-slice", +] + +[[package]] +name = "semver" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f301af10236f6df4160f7c3f04eec6dbc70ace82d23326abad5edee88801c6b6" +dependencies = [ + "semver-parser", +] + +[[package]] +name = "semver" +version = "1.0.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e25dfac463d778e353db5be2449d1cce89bd6fd23c9f1ea21310ce6e5a1b29c4" +dependencies = [ + "serde", +] + +[[package]] +name = "semver-parser" +version = "0.10.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "00b0bef5b7f9e0df16536d3961cfb6e84331c065b4066afb39768d0e319411f7" +dependencies = [ + "pest", +] + +[[package]] +name = "serde" +version = "1.0.147" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d193d69bae983fc11a79df82342761dfbf28a99fc8d203dca4c3c1b590948965" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde-wasm-bindgen" +version = "0.4.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e3b4c031cd0d9014307d82b8abf653c0290fbdaeb4c02d00c63cf52f728628bf" +dependencies = [ + "js-sys", + "serde", + "wasm-bindgen", +] + +[[package]] +name = "serde_derive" +version = "1.0.147" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4f1d362ca8fc9c3e3a7484440752472d68a6caa98f1ab81d99b5dfe517cec852" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "serde_json" +version = "1.0.87" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ce777b7b150d76b9cf60d28b55f5847135a003f7d7350c6be7a773508ce7d45" +dependencies = [ + "itoa 1.0.4", + "ryu", + "serde", +] + +[[package]] +name = "serde_repr" +version = "0.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fe39d9fbb0ebf5eb2c7cb7e2a47e4f462fad1379f1166b8ae49ad9eae89a7ca" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "serde_urlencoded" +version = "0.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd" +dependencies = [ + "form_urlencoded", + "itoa 1.0.4", + "ryu", + "serde", +] + +[[package]] +name = "serde_with" +version = "1.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "678b5a069e50bf00ecd22d0cd8ddf7c236f68581b03db652061ed5eb13a312ff" +dependencies = [ + "serde", + "serde_with_macros", +] + +[[package]] +name = "serde_with_macros" +version = "1.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e182d6ec6f05393cc0e5ed1bf81ad6db3a8feedf8ee515ecdd369809bcce8082" +dependencies = [ + "darling", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "serialize-to-javascript" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c9823f2d3b6a81d98228151fdeaf848206a7855a7a042bbf9bf870449a66cafb" +dependencies = [ + "serde", + "serde_json", + "serialize-to-javascript-impl", +] + +[[package]] +name = "serialize-to-javascript-impl" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "74064874e9f6a15f04c1f3cb627902d0e6b410abbf36668afa873c61889f1763" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "servo_arc" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d98238b800e0d1576d8b6e3de32827c2d74bee68bb97748dcf5071fb53965432" +dependencies = [ + "nodrop", + "stable_deref_trait", +] + +[[package]] +name = "sha2" +version = "0.10.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "82e6b795fe2e3b1e845bafcb27aa35405c4d47cdfc92af5fc8d3002f76cebdc0" +dependencies = [ + "cfg-if", + "cpufeatures", + "digest", +] + +[[package]] +name = "sharded-slab" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "900fba806f70c630b0a382d0d825e17a0f19fcd059a2ade1ff237bcddf446b31" +dependencies = [ + "lazy_static", +] + +[[package]] +name = "shared_child" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b0d94659ad3c2137fef23ae75b03d5241d633f8acded53d672decfa0e6e0caef" +dependencies = [ + "libc", + "winapi", +] + +[[package]] +name = "siphasher" +version = "0.3.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7bd3e3206899af3f8b12af284fafc038cc1dc2b41d1b89dd17297221c5d225de" + +[[package]] +name = "slab" +version = "0.4.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4614a76b2a8be0058caa9dbbaf66d988527d86d003c11a94fbd335d7661edcef" +dependencies = [ + "autocfg", +] + +[[package]] +name = "slotmap" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e1e08e261d0e8f5c43123b7adf3e4ca1690d655377ac93a03b2c9d3e98de1342" +dependencies = [ + "version_check", +] + +[[package]] +name = "smallvec" +version = "1.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a507befe795404456341dfab10cef66ead4c041f62b8b11bbb92bffe5d0953e0" + +[[package]] +name = "soup2" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b2b4d76501d8ba387cf0fefbe055c3e0a59891d09f0f995ae4e4b16f6b60f3c0" +dependencies = [ + "bitflags", + "gio", + "glib", + "libc", + "once_cell", + "soup2-sys", +] + +[[package]] +name = "soup2-sys" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "009ef427103fcb17f802871647a7fa6c60cbb654b4c4e4c0ac60a31c5f6dc9cf" +dependencies = [ + "bitflags", + "gio-sys", + "glib-sys", + "gobject-sys", + "libc", + "system-deps 5.0.0", +] + +[[package]] +name = "stable_deref_trait" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3" + +[[package]] +name = "state" +version = "0.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dbe866e1e51e8260c9eed836a042a5e7f6726bb2b411dffeaa712e19c388f23b" +dependencies = [ + "loom", +] + +[[package]] +name = "string_cache" +version = "0.8.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "213494b7a2b503146286049378ce02b482200519accc31872ee8be91fa820a08" +dependencies = [ + "new_debug_unreachable", + "once_cell", + "parking_lot", + "phf_shared 0.10.0", + "precomputed-hash", + "serde", +] + +[[package]] +name = "string_cache_codegen" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6bb30289b722be4ff74a408c3cc27edeaad656e06cb1fe8fa9231fa59c728988" +dependencies = [ + "phf_generator 0.10.0", + "phf_shared 0.10.0", + "proc-macro2", + "quote", +] + +[[package]] +name = "strsim" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623" + +[[package]] +name = "strum" +version = "0.22.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f7ac893c7d471c8a21f31cfe213ec4f6d9afeed25537c772e08ef3f005f8729e" +dependencies = [ + "strum_macros", +] + +[[package]] +name = "strum_macros" +version = "0.22.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "339f799d8b549e3744c7ac7feb216383e4005d94bdb22561b3ab8f3b808ae9fb" +dependencies = [ + "heck 0.3.3", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "sycamore" +version = "0.8.2" +source = "git+https://github.com/sycamore-rs/sycamore?rev=abd556cbc02047042dad2ebd04405e455a9b11b2#abd556cbc02047042dad2ebd04405e455a9b11b2" +dependencies = [ + "ahash", + "futures", + "indexmap", + "js-sys", + "paste", + "sycamore-core", + "sycamore-futures", + "sycamore-macro", + "sycamore-reactive", + "sycamore-web", + "wasm-bindgen", + "wasm-bindgen-futures", + "web-sys", +] + +[[package]] +name = "sycamore-core" +version = "0.8.2" +source = "git+https://github.com/sycamore-rs/sycamore?rev=abd556cbc02047042dad2ebd04405e455a9b11b2#abd556cbc02047042dad2ebd04405e455a9b11b2" +dependencies = [ + "ahash", + "sycamore-reactive", +] + +[[package]] +name = "sycamore-futures" +version = "0.8.0" +source = "git+https://github.com/sycamore-rs/sycamore?rev=abd556cbc02047042dad2ebd04405e455a9b11b2#abd556cbc02047042dad2ebd04405e455a9b11b2" +dependencies = [ + "futures", + "sycamore-reactive", + "tokio", + "wasm-bindgen-futures", +] + +[[package]] +name = "sycamore-macro" +version = "0.8.2" +source = "git+https://github.com/sycamore-rs/sycamore?rev=abd556cbc02047042dad2ebd04405e455a9b11b2#abd556cbc02047042dad2ebd04405e455a9b11b2" +dependencies = [ + "once_cell", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "sycamore-reactive" +version = "0.8.1" +source = "git+https://github.com/sycamore-rs/sycamore?rev=abd556cbc02047042dad2ebd04405e455a9b11b2#abd556cbc02047042dad2ebd04405e455a9b11b2" +dependencies = [ + "ahash", + "bumpalo", + "indexmap", + "slotmap", + "smallvec", +] + +[[package]] +name = "sycamore-web" +version = "0.8.2" +source = "git+https://github.com/sycamore-rs/sycamore?rev=abd556cbc02047042dad2ebd04405e455a9b11b2#abd556cbc02047042dad2ebd04405e455a9b11b2" +dependencies = [ + "html-escape", + "indexmap", + "js-sys", + "once_cell", + "sycamore-core", + "sycamore-reactive", + "wasm-bindgen", + "web-sys", +] + +[[package]] +name = "syn" +version = "1.0.103" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a864042229133ada95abf3b54fdc62ef5ccabe9515b64717bcb9a1919e59445d" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "system-deps" +version = "5.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "18db855554db7bd0e73e06cf7ba3df39f97812cb11d3f75e71c39bf45171797e" +dependencies = [ + "cfg-expr 0.9.1", + "heck 0.3.3", + "pkg-config", + "toml", + "version-compare 0.0.11", +] + +[[package]] +name = "system-deps" +version = "6.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2955b1fe31e1fa2fbd1976b71cc69a606d7d4da16f6de3333d0c92d51419aeff" +dependencies = [ + "cfg-expr 0.11.0", + "heck 0.4.0", + "pkg-config", + "toml", + "version-compare 0.1.0", +] + +[[package]] +name = "tao" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "43336f5d1793543ba96e2a1e75f3a5c7dcd592743be06a0ab3a190f4fcb4b934" +dependencies = [ + "bitflags", + "cairo-rs", + "cc", + "cocoa", + "core-foundation", + "core-graphics", + "crossbeam-channel", + "dispatch", + "gdk", + "gdk-pixbuf", + "gdk-sys", + "gdkx11-sys", + "gio", + "glib", + "glib-sys", + "gtk", + "image", + "instant", + "jni", + "lazy_static", + "libc", + "log", + "ndk", + "ndk-context", + "ndk-sys", + "objc", + "once_cell", + "parking_lot", + "paste", + "png 0.17.7", + "raw-window-handle", + "scopeguard", + "serde", + "unicode-segmentation", + "uuid 1.2.1", + "windows 0.39.0", + "windows-implement", + "x11-dl", +] + +[[package]] +name = "tar" +version = "0.4.38" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4b55807c0344e1e6c04d7c965f5289c39a8d94ae23ed5c0b57aabac549f871c6" +dependencies = [ + "filetime", + "libc", + "xattr", +] + +[[package]] +name = "tauri" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "efbf22abd61d95ca9b2becd77f9db4c093892f73e8a07d21d8b0b2bf71a7bcea" +dependencies = [ + "anyhow", + "attohttpc", + "cocoa", + "dirs-next", + "embed_plist", + "encoding_rs", + "flate2", + "futures-util", + "glib", + "glob", + "gtk", + "heck 0.4.0", + "http", + "ignore", + "notify-rust", + "objc", + "once_cell", + "open", + "os_info", + "os_pipe", + "percent-encoding", + "rand 0.8.5", + "raw-window-handle", + "regex", + "rfd", + "semver 1.0.14", + "serde", + "serde_json", + "serde_repr", + "serialize-to-javascript", + "shared_child", + "state", + "tar", + "tauri-macros", + "tauri-runtime", + "tauri-runtime-wry", + "tauri-utils", + "tempfile", + "thiserror", + "tokio", + "url", + "uuid 1.2.1", + "webkit2gtk", + "webview2-com", + "windows 0.39.0", +] + +[[package]] +name = "tauri-build" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0991fb306849897439dbd4a72e4cbed2413e2eb26cb4b3ba220b94edba8b4b88" +dependencies = [ + "anyhow", + "cargo_toml", + "heck 0.4.0", + "json-patch", + "semver 1.0.14", + "serde_json", + "tauri-utils", + "winres", +] + +[[package]] +name = "tauri-codegen" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "356fa253e40ae4d6ff02075011f2f2bb4066f5c9d8c1e16ca6912d7b75903ba6" +dependencies = [ + "base64", + "brotli", + "ico", + "json-patch", + "plist", + "png 0.17.7", + "proc-macro2", + "quote", + "regex", + "semver 1.0.14", + "serde", + "serde_json", + "sha2", + "tauri-utils", + "thiserror", + "time", + "uuid 1.2.1", + "walkdir", +] + +[[package]] +name = "tauri-macros" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6051fd6940ddb22af452340d03c66a3e2f5d72e0788d4081d91e31528ccdc4d" +dependencies = [ + "heck 0.4.0", + "proc-macro2", + "quote", + "syn", + "tauri-codegen", + "tauri-utils", +] + +[[package]] +name = "tauri-runtime" +version = "0.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d49439a5ea47f474572b854972f42eda2e02a470be5ca9609cc83bb66945abe2" +dependencies = [ + "gtk", + "http", + "http-range", + "infer", + "rand 0.8.5", + "raw-window-handle", + "serde", + "serde_json", + "tauri-utils", + "thiserror", + "uuid 1.2.1", + "webview2-com", + "windows 0.39.0", +] + +[[package]] +name = "tauri-runtime-wry" +version = "0.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "28dce920995fd49907aa9bea7249ed1771454f11f7611924c920a1f75fb614d4" +dependencies = [ + "cocoa", + "gtk", + "percent-encoding", + "rand 0.8.5", + "raw-window-handle", + "tauri-runtime", + "tauri-utils", + "uuid 1.2.1", + "webkit2gtk", + "webview2-com", + "windows 0.39.0", + "wry", +] + +[[package]] +name = "tauri-sys" +version = "0.1.0" +dependencies = [ + "js-sys", + "semver 1.0.14", + "serde", + "serde-wasm-bindgen", + "thiserror", + "url", + "wasm-bindgen", + "wasm-bindgen-futures", +] + +[[package]] +name = "tauri-sys-test" +version = "0.0.0" +dependencies = [ + "serde", + "serde_json", + "tauri", + "tauri-build", +] + +[[package]] +name = "tauri-sys-test-ui" +version = "0.0.0" +dependencies = [ + "anyhow", + "console_error_panic_hook", + "futures-util", + "serde", + "sycamore", + "tauri-sys", + "wasm-bindgen-futures", +] + +[[package]] +name = "tauri-utils" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e8fdae6f29cef959809a3c3afef510c5b715a446a597ab8b791497585363f39" +dependencies = [ + "brotli", + "ctor", + "glob", + "heck 0.4.0", + "html5ever", + "json-patch", + "kuchiki", + "memchr", + "phf 0.10.1", + "proc-macro2", + "quote", + "semver 1.0.14", + "serde", + "serde_json", + "serde_with", + "thiserror", + "url", + "walkdir", + "windows 0.39.0", +] + +[[package]] +name = "tauri-winrt-notification" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c58de036c4d2e20717024de2a3c4bf56c301f07b21bc8ef9b57189fce06f1f3b" +dependencies = [ + "quick-xml", + "strum", + "windows 0.39.0", +] + +[[package]] +name = "tempfile" +version = "3.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5cdb1ef4eaeeaddc8fbd371e5017057064af0911902ef36b39801f67cc6d79e4" +dependencies = [ + "cfg-if", + "fastrand", + "libc", + "redox_syscall", + "remove_dir_all", + "winapi", +] + +[[package]] +name = "tendril" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d24a120c5fc464a3458240ee02c299ebcb9d67b5249c8848b09d639dca8d7bb0" +dependencies = [ + "futf", + "mac", + "utf-8", +] + +[[package]] +name = "thin-slice" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8eaa81235c7058867fa8c0e7314f33dcce9c215f535d1913822a2b3f5e289f3c" + +[[package]] +name = "thiserror" +version = "1.0.37" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "10deb33631e3c9018b9baf9dcbbc4f737320d2b576bac10f6aefa048fa407e3e" +dependencies = [ + "thiserror-impl", +] + +[[package]] +name = "thiserror-impl" +version = "1.0.37" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "982d17546b47146b28f7c22e3d08465f6b8903d0ea13c1660d9d84a6e7adcdbb" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "thread_local" +version = "1.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5516c27b78311c50bf42c071425c560ac799b11c30b31f87e3081965fe5e0180" +dependencies = [ + "once_cell", +] + +[[package]] +name = "time" +version = "0.3.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0fab5c8b9980850e06d92ddbe3ab839c062c801f3927c0fb8abd6fc8e918fbca" +dependencies = [ + "itoa 1.0.4", + "libc", + "num_threads", + "serde", + "time-core", + "time-macros", +] + +[[package]] +name = "time-core" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2e153e1f1acaef8acc537e68b44906d2db6436e2b35ac2c6b42640fff91f00fd" + +[[package]] +name = "time-macros" +version = "0.2.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "65bb801831d812c562ae7d2bfb531f26e66e4e1f6b17307ba4149c5064710e5b" +dependencies = [ + "time-core", +] + +[[package]] +name = "tinyvec" +version = "1.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "87cc5ceb3875bb20c2890005a4e226a4651264a5c75edb2421b52861a0a0cb50" +dependencies = [ + "tinyvec_macros", +] + +[[package]] +name = "tinyvec_macros" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cda74da7e1a664f795bb1f8a87ec406fb89a02522cf6e50620d016add6dbbf5c" + +[[package]] +name = "tokio" +version = "1.21.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a9e03c497dc955702ba729190dc4aac6f2a0ce97f913e5b1b5912fc5039d9099" +dependencies = [ + "autocfg", + "bytes", + "memchr", + "num_cpus", + "pin-project-lite", +] + +[[package]] +name = "toml" +version = "0.5.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8d82e1a7758622a465f8cee077614c73484dac5b836c02ff6a40d5d1010324d7" +dependencies = [ + "serde", +] + +[[package]] +name = "tracing" +version = "0.1.37" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8ce8c33a8d48bd45d624a6e523445fd21ec13d3653cd51f681abf67418f54eb8" +dependencies = [ + "cfg-if", + "pin-project-lite", + "tracing-attributes", + "tracing-core", +] + +[[package]] +name = "tracing-attributes" +version = "0.1.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4017f8f45139870ca7e672686113917c71c7a6e02d4924eda67186083c03081a" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "tracing-core" +version = "0.1.30" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "24eb03ba0eab1fd845050058ce5e616558e8f8d8fca633e6b163fe25c797213a" +dependencies = [ + "once_cell", + "valuable", +] + +[[package]] +name = "tracing-log" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "78ddad33d2d10b1ed7eb9d1f518a5674713876e97e5bb9b7345a7984fbb4f922" +dependencies = [ + "lazy_static", + "log", + "tracing-core", +] + +[[package]] +name = "tracing-subscriber" +version = "0.3.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a6176eae26dd70d0c919749377897b54a9276bd7061339665dd68777926b5a70" +dependencies = [ + "matchers", + "nu-ansi-term", + "once_cell", + "regex", + "sharded-slab", + "smallvec", + "thread_local", + "tracing", + "tracing-core", + "tracing-log", +] + +[[package]] +name = "treediff" +version = "3.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "761e8d5ad7ce14bb82b7e61ccc0ca961005a275a060b9644a2431aa11553c2ff" +dependencies = [ + "serde_json", +] + +[[package]] +name = "typenum" +version = "1.15.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dcf81ac59edc17cc8697ff311e8f5ef2d99fcbd9817b34cec66f90b6c3dfd987" + +[[package]] +name = "ucd-trie" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9e79c4d996edb816c91e4308506774452e55e95c3c9de07b6729e17e15a5ef81" + +[[package]] +name = "unicode-bidi" +version = "0.3.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "099b7128301d285f79ddd55b9a83d5e6b9e97c92e0ea0daebee7263e932de992" + +[[package]] +name = "unicode-ident" +version = "1.0.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ceab39d59e4c9499d4e5a8ee0e2735b891bb7308ac83dfb4e80cad195c9f6f3" + +[[package]] +name = "unicode-normalization" +version = "0.1.22" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c5713f0fc4b5db668a2ac63cdb7bb4469d8c9fed047b1d0292cc7b0ce2ba921" +dependencies = [ + "tinyvec", +] + +[[package]] +name = "unicode-segmentation" +version = "1.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0fdbf052a0783de01e944a6ce7a8cb939e295b1e7be835a1112c3b9a7f047a5a" + +[[package]] +name = "url" +version = "2.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0d68c799ae75762b8c3fe375feb6600ef5602c883c5d21eb51c09f22b83c4643" +dependencies = [ + "form_urlencoded", + "idna", + "percent-encoding", + "serde", +] + +[[package]] +name = "utf-8" +version = "0.7.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9" + +[[package]] +name = "utf8-width" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5190c9442dcdaf0ddd50f37420417d219ae5261bbf5db120d0f9bab996c9cba1" + +[[package]] +name = "uuid" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bc5cf98d8186244414c848017f0e2676b3fcb46807f6668a97dfe67359a3c4b7" + +[[package]] +name = "uuid" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "feb41e78f93363bb2df8b0e86a2ca30eed7806ea16ea0c790d757cf93f79be83" +dependencies = [ + "getrandom 0.2.8", +] + +[[package]] +name = "valuable" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "830b7e5d4d90034032940e4ace0d9a9a057e7a45cd94e6c007832e39edb82f6d" + +[[package]] +name = "vcpkg" +version = "0.2.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426" + +[[package]] +name = "version-compare" +version = "0.0.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1c18c859eead79d8b95d09e4678566e8d70105c4e7b251f707a03df32442661b" + +[[package]] +name = "version-compare" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fe88247b92c1df6b6de80ddc290f3976dbdf2f5f5d3fd049a9fb598c6dd5ca73" + +[[package]] +name = "version_check" +version = "0.9.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f" + +[[package]] +name = "walkdir" +version = "2.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "808cf2735cd4b6866113f648b791c6adc5714537bc222d9347bb203386ffda56" +dependencies = [ + "same-file", + "winapi", + "winapi-util", +] + +[[package]] +name = "wasi" +version = "0.9.0+wasi-snapshot-preview1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cccddf32554fecc6acb585f82a32a72e28b48f8c4c1883ddfeeeaa96f7d8e519" + +[[package]] +name = "wasi" +version = "0.11.0+wasi-snapshot-preview1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423" + +[[package]] +name = "wasm-bindgen" +version = "0.2.83" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eaf9f5aceeec8be17c128b2e93e031fb8a4d469bb9c4ae2d7dc1888b26887268" +dependencies = [ + "cfg-if", + "serde_json", + "wasm-bindgen-macro", +] + +[[package]] +name = "wasm-bindgen-backend" +version = "0.2.83" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4c8ffb332579b0557b52d268b91feab8df3615f265d5270fec2a8c95b17c1142" +dependencies = [ + "bumpalo", + "log", + "once_cell", + "proc-macro2", + "quote", + "syn", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-futures" +version = "0.4.33" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "23639446165ca5a5de86ae1d8896b737ae80319560fbaa4c2887b7da6e7ebd7d" +dependencies = [ + "cfg-if", + "js-sys", + "wasm-bindgen", + "web-sys", +] + +[[package]] +name = "wasm-bindgen-macro" +version = "0.2.83" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "052be0f94026e6cbc75cdefc9bae13fd6052cdcaf532fa6c45e7ae33a1e6c810" +dependencies = [ + "quote", + "wasm-bindgen-macro-support", +] + +[[package]] +name = "wasm-bindgen-macro-support" +version = "0.2.83" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "07bc0c051dc5f23e307b13285f9d75df86bfdf816c5721e573dec1f9b8aa193c" +dependencies = [ + "proc-macro2", + "quote", + "syn", + "wasm-bindgen-backend", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-shared" +version = "0.2.83" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1c38c045535d93ec4f0b4defec448e4291638ee608530863b1e2ba115d4fff7f" + +[[package]] +name = "web-sys" +version = "0.3.60" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bcda906d8be16e728fd5adc5b729afad4e444e106ab28cd1c7256e54fa61510f" +dependencies = [ + "js-sys", + "wasm-bindgen", +] + +[[package]] +name = "webkit2gtk" +version = "0.18.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8f859735e4a452aeb28c6c56a852967a8a76c8eb1cc32dbf931ad28a13d6370" +dependencies = [ + "bitflags", + "cairo-rs", + "gdk", + "gdk-sys", + "gio", + "gio-sys", + "glib", + "glib-sys", + "gobject-sys", + "gtk", + "gtk-sys", + "javascriptcore-rs", + "libc", + "once_cell", + "soup2", + "webkit2gtk-sys", +] + +[[package]] +name = "webkit2gtk-sys" +version = "0.18.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4d76ca6ecc47aeba01ec61e480139dda143796abcae6f83bcddf50d6b5b1dcf3" +dependencies = [ + "atk-sys", + "bitflags", + "cairo-sys-rs", + "gdk-pixbuf-sys", + "gdk-sys", + "gio-sys", + "glib-sys", + "gobject-sys", + "gtk-sys", + "javascriptcore-rs-sys", + "libc", + "pango-sys", + "pkg-config", + "soup2-sys", + "system-deps 6.0.3", +] + +[[package]] +name = "webview2-com" +version = "0.19.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b4a769c9f1a64a8734bde70caafac2b96cada12cd4aefa49196b3a386b8b4178" +dependencies = [ + "webview2-com-macros", + "webview2-com-sys", + "windows 0.39.0", + "windows-implement", +] + +[[package]] +name = "webview2-com-macros" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eaebe196c01691db62e9e4ca52c5ef1e4fd837dcae27dae3ada599b5a8fd05ac" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "webview2-com-sys" +version = "0.19.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aac48ef20ddf657755fdcda8dfed2a7b4fc7e4581acce6fe9b88c3d64f29dee7" +dependencies = [ + "regex", + "serde", + "serde_json", + "thiserror", + "windows 0.39.0", + "windows-bindgen", + "windows-metadata", +] + +[[package]] +name = "winapi" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" +dependencies = [ + "winapi-i686-pc-windows-gnu", + "winapi-x86_64-pc-windows-gnu", +] + +[[package]] +name = "winapi-i686-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" + +[[package]] +name = "winapi-util" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178" +dependencies = [ + "winapi", +] + +[[package]] +name = "winapi-x86_64-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" + +[[package]] +name = "windows" +version = "0.32.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fbedf6db9096bc2364adce0ae0aa636dcd89f3c3f2cd67947062aaf0ca2a10ec" +dependencies = [ + "windows_aarch64_msvc 0.32.0", + "windows_i686_gnu 0.32.0", + "windows_i686_msvc 0.32.0", + "windows_x86_64_gnu 0.32.0", + "windows_x86_64_msvc 0.32.0", +] + +[[package]] +name = "windows" +version = "0.37.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "57b543186b344cc61c85b5aab0d2e3adf4e0f99bc076eff9aa5927bcc0b8a647" +dependencies = [ + "windows_aarch64_msvc 0.37.0", + "windows_i686_gnu 0.37.0", + "windows_i686_msvc 0.37.0", + "windows_x86_64_gnu 0.37.0", + "windows_x86_64_msvc 0.37.0", +] + +[[package]] +name = "windows" +version = "0.39.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f1c4bd0a50ac6020f65184721f758dba47bb9fbc2133df715ec74a237b26794a" +dependencies = [ + "windows-implement", + "windows_aarch64_msvc 0.39.0", + "windows_i686_gnu 0.39.0", + "windows_i686_msvc 0.39.0", + "windows_x86_64_gnu 0.39.0", + "windows_x86_64_msvc 0.39.0", +] + +[[package]] +name = "windows-bindgen" +version = "0.39.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "68003dbd0e38abc0fb85b939240f4bce37c43a5981d3df37ccbaaa981b47cb41" +dependencies = [ + "windows-metadata", + "windows-tokens", +] + +[[package]] +name = "windows-implement" +version = "0.39.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ba01f98f509cb5dc05f4e5fc95e535f78260f15fea8fe1a8abdd08f774f1cee7" +dependencies = [ + "syn", + "windows-tokens", +] + +[[package]] +name = "windows-metadata" +version = "0.39.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9ee5e275231f07c6e240d14f34e1b635bf1faa1c76c57cfd59a5cdb9848e4278" + +[[package]] +name = "windows-sys" +version = "0.36.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ea04155a16a59f9eab786fe12a4a450e75cdb175f9e0d80da1e17db09f55b8d2" +dependencies = [ + "windows_aarch64_msvc 0.36.1", + "windows_i686_gnu 0.36.1", + "windows_i686_msvc 0.36.1", + "windows_x86_64_gnu 0.36.1", + "windows_x86_64_msvc 0.36.1", +] + +[[package]] +name = "windows-sys" +version = "0.42.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5a3e1820f08b8513f676f7ab6c1f99ff312fb97b553d30ff4dd86f9f15728aa7" +dependencies = [ + "windows_aarch64_gnullvm", + "windows_aarch64_msvc 0.42.0", + "windows_i686_gnu 0.42.0", + "windows_i686_msvc 0.42.0", + "windows_x86_64_gnu 0.42.0", + "windows_x86_64_gnullvm", + "windows_x86_64_msvc 0.42.0", +] + +[[package]] +name = "windows-tokens" +version = "0.39.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f838de2fe15fe6bac988e74b798f26499a8b21a9d97edec321e79b28d1d7f597" + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.42.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41d2aa71f6f0cbe00ae5167d90ef3cfe66527d6f613ca78ac8024c3ccab9a19e" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.32.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d8e92753b1c443191654ec532f14c199742964a061be25d77d7a96f09db20bf5" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.36.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9bb8c3fd39ade2d67e9874ac4f3db21f0d710bee00fe7cab16949ec184eeaa47" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.37.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2623277cb2d1c216ba3b578c0f3cf9cdebeddb6e66b1b218bb33596ea7769c3a" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.39.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec7711666096bd4096ffa835238905bb33fb87267910e154b18b44eaabb340f2" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.42.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dd0f252f5a35cac83d6311b2e795981f5ee6e67eb1f9a7f64eb4500fbc4dcdb4" + +[[package]] +name = "windows_i686_gnu" +version = "0.32.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6a711c68811799e017b6038e0922cb27a5e2f43a2ddb609fe0b6f3eeda9de615" + +[[package]] +name = "windows_i686_gnu" +version = "0.36.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "180e6ccf01daf4c426b846dfc66db1fc518f074baa793aa7d9b9aaeffad6a3b6" + +[[package]] +name = "windows_i686_gnu" +version = "0.37.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d3925fd0b0b804730d44d4b6278c50f9699703ec49bcd628020f46f4ba07d9e1" + +[[package]] +name = "windows_i686_gnu" +version = "0.39.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "763fc57100a5f7042e3057e7e8d9bdd7860d330070251a73d003563a3bb49e1b" + +[[package]] +name = "windows_i686_gnu" +version = "0.42.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fbeae19f6716841636c28d695375df17562ca208b2b7d0dc47635a50ae6c5de7" + +[[package]] +name = "windows_i686_msvc" +version = "0.32.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "146c11bb1a02615db74680b32a68e2d61f553cc24c4eb5b4ca10311740e44172" + +[[package]] +name = "windows_i686_msvc" +version = "0.36.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e2e7917148b2812d1eeafaeb22a97e4813dfa60a3f8f78ebe204bcc88f12f024" + +[[package]] +name = "windows_i686_msvc" +version = "0.37.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ce907ac74fe331b524c1298683efbf598bb031bc84d5e274db2083696d07c57c" + +[[package]] +name = "windows_i686_msvc" +version = "0.39.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7bc7cbfe58828921e10a9f446fcaaf649204dcfe6c1ddd712c5eebae6bda1106" + +[[package]] +name = "windows_i686_msvc" +version = "0.42.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "84c12f65daa39dd2babe6e442988fc329d6243fdce47d7d2d155b8d874862246" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.32.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c912b12f7454c6620635bbff3450962753834be2a594819bd5e945af18ec64bc" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.36.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4dcd171b8776c41b97521e5da127a2d86ad280114807d0b2ab1e462bc764d9e1" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.37.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2babfba0828f2e6b32457d5341427dcbb577ceef556273229959ac23a10af33d" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.39.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6868c165637d653ae1e8dc4d82c25d4f97dd6605eaa8d784b5c6e0ab2a252b65" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.42.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bf7b1b21b5362cbc318f686150e5bcea75ecedc74dd157d874d754a2ca44b0ed" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.42.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09d525d2ba30eeb3297665bd434a54297e4170c7f1a44cad4ef58095b4cd2028" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.32.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "504a2476202769977a040c6364301a3f65d0cc9e3fb08600b2bda150a0488316" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.36.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c811ca4a8c853ef420abd8592ba53ddbbac90410fab6903b3e79972a631f7680" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.37.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f4dd6dc7df2d84cf7b33822ed5b86318fb1781948e9663bacd047fc9dd52259d" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.39.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5e4d40883ae9cae962787ca76ba76390ffa29214667a111db9e0a1ad8377e809" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.42.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f40009d85759725a34da6d89a94e63d7bdc50a862acf0dbc7c8e488f1edcb6f5" + +[[package]] +name = "winres" +version = "0.1.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b68db261ef59e9e52806f688020631e987592bd83619edccda9c47d42cde4f6c" +dependencies = [ + "toml", +] + +[[package]] +name = "wry" +version = "0.21.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ff5c1352b4266fdf92c63479d2f58ab4cd29dc4e78fbc1b62011ed1227926945" +dependencies = [ + "base64", + "block", + "cocoa", + "core-graphics", + "crossbeam-channel", + "gdk", + "gio", + "glib", + "gtk", + "html5ever", + "http", + "kuchiki", + "libc", + "log", + "objc", + "objc_id", + "once_cell", + "serde", + "serde_json", + "sha2", + "tao", + "thiserror", + "url", + "webkit2gtk", + "webkit2gtk-sys", + "webview2-com", + "windows 0.39.0", + "windows-implement", +] + +[[package]] +name = "x11" +version = "2.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f7ae97874a928d821b061fce3d1fc52f08071dd53c89a6102bc06efcac3b2908" +dependencies = [ + "libc", + "pkg-config", +] + +[[package]] +name = "x11-dl" +version = "2.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c83627bc137605acc00bb399c7b908ef460b621fc37c953db2b09f88c449ea6" +dependencies = [ + "lazy_static", + "libc", + "pkg-config", +] + +[[package]] +name = "xattr" +version = "0.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6d1526bbe5aaeb5eb06885f4d987bcdfa5e23187055de9b83fe00156a821fabc" +dependencies = [ + "libc", +] + +[[package]] +name = "xml-rs" +version = "0.8.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d2d7d3948613f75c98fd9328cfdcc45acc4d360655289d0a7d4ec931392200a3" diff --git a/examples/test/Cargo.toml b/examples/test/Cargo.toml new file mode 100644 index 0000000..2c74dba --- /dev/null +++ b/examples/test/Cargo.toml @@ -0,0 +1,17 @@ +[package] +name = "tauri-sys-test-ui" +version = "0.0.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html +[dependencies] +tauri-sys = { path = "../../", features = ["all"] } +sycamore = { git = "https://github.com/sycamore-rs/sycamore", rev = "abd556cbc02047042dad2ebd04405e455a9b11b2", features = ["suspense"] } +anyhow = "1.0.66" +console_error_panic_hook = "0.1.7" +wasm-bindgen-futures = "0.4.32" +futures-util = "0.3.25" +serde = { version = "1.0.147", features = ["derive"] } + +[features] +ci = [] diff --git a/examples/test/Trunk.toml b/examples/test/Trunk.toml new file mode 100644 index 0000000..856f3d2 --- /dev/null +++ b/examples/test/Trunk.toml @@ -0,0 +1,10 @@ +[build] +target = "./index.html" + +[watch] +ignore = ["./src-tauri"] + +[serve] +address = "127.0.0.1" +port = 1420 +open = false \ No newline at end of file diff --git a/examples/test/dist/index.html b/examples/test/dist/index.html new file mode 100644 index 0000000..6f47821 --- /dev/null +++ b/examples/test/dist/index.html @@ -0,0 +1,35 @@ + + + Tauri + Yew App + + + + + \ No newline at end of file diff --git a/examples/test/dist/snippets/tauri-sys-91bd50ded94e0ed7/dist/app.js b/examples/test/dist/snippets/tauri-sys-91bd50ded94e0ed7/dist/app.js new file mode 100644 index 0000000..6b66a23 --- /dev/null +++ b/examples/test/dist/snippets/tauri-sys-91bd50ded94e0ed7/dist/app.js @@ -0,0 +1,91 @@ +// tauri/tooling/api/src/tauri.ts +function uid() { + return window.crypto.getRandomValues(new Uint32Array(1))[0]; +} +function transformCallback(callback, once = false) { + const identifier = uid(); + const prop = `_${identifier}`; + Object.defineProperty(window, prop, { + value: (result) => { + if (once) { + Reflect.deleteProperty(window, prop); + } + return callback?.(result); + }, + writable: false, + configurable: true + }); + return identifier; +} +async function invoke(cmd, args = {}) { + return new Promise((resolve, reject) => { + const callback = transformCallback((e) => { + resolve(e); + Reflect.deleteProperty(window, `_${error}`); + }, true); + const error = transformCallback((e) => { + reject(e); + Reflect.deleteProperty(window, `_${callback}`); + }, true); + window.__TAURI_IPC__({ + cmd, + callback, + error, + ...args + }); + }); +} + +// tauri/tooling/api/src/helpers/tauri.ts +async function invokeTauriCommand(command) { + return invoke("tauri", command); +} + +// tauri/tooling/api/src/app.ts +async function getVersion() { + return invokeTauriCommand({ + __tauriModule: "App", + message: { + cmd: "getAppVersion" + } + }); +} +async function getName() { + return invokeTauriCommand({ + __tauriModule: "App", + message: { + cmd: "getAppName" + } + }); +} +async function getTauriVersion() { + return invokeTauriCommand({ + __tauriModule: "App", + message: { + cmd: "getTauriVersion" + } + }); +} +async function show() { + return invokeTauriCommand({ + __tauriModule: "App", + message: { + cmd: "show" + } + }); +} +async function hide() { + return invokeTauriCommand({ + __tauriModule: "App", + message: { + cmd: "hide" + } + }); +} +export { + getName, + getTauriVersion, + getVersion, + hide, + show +}; diff --git a/examples/test/dist/snippets/tauri-sys-91bd50ded94e0ed7/dist/clipboard.js b/examples/test/dist/snippets/tauri-sys-91bd50ded94e0ed7/dist/clipboard.js new file mode 100644 index 0000000..16bd040 --- /dev/null +++ b/examples/test/dist/snippets/tauri-sys-91bd50ded94e0ed7/dist/clipboard.js @@ -0,0 +1,66 @@ +// tauri/tooling/api/src/tauri.ts +function uid() { + return window.crypto.getRandomValues(new Uint32Array(1))[0]; +} +function transformCallback(callback, once = false) { + const identifier = uid(); + const prop = `_${identifier}`; + Object.defineProperty(window, prop, { + value: (result) => { + if (once) { + Reflect.deleteProperty(window, prop); + } + return callback?.(result); + }, + writable: false, + configurable: true + }); + return identifier; +} +async function invoke(cmd, args = {}) { + return new Promise((resolve, reject) => { + const callback = transformCallback((e) => { + resolve(e); + Reflect.deleteProperty(window, `_${error}`); + }, true); + const error = transformCallback((e) => { + reject(e); + Reflect.deleteProperty(window, `_${callback}`); + }, true); + window.__TAURI_IPC__({ + cmd, + callback, + error, + ...args + }); + }); +} + +// tauri/tooling/api/src/helpers/tauri.ts +async function invokeTauriCommand(command) { + return invoke("tauri", command); +} + +// tauri/tooling/api/src/clipboard.ts +async function writeText(text) { + return invokeTauriCommand({ + __tauriModule: "Clipboard", + message: { + cmd: "writeText", + data: text + } + }); +} +async function readText() { + return invokeTauriCommand({ + __tauriModule: "Clipboard", + message: { + cmd: "readText", + data: null + } + }); +} +export { + readText, + writeText +}; diff --git a/examples/test/dist/snippets/tauri-sys-91bd50ded94e0ed7/dist/event.js b/examples/test/dist/snippets/tauri-sys-91bd50ded94e0ed7/dist/event.js new file mode 100644 index 0000000..934f20b --- /dev/null +++ b/examples/test/dist/snippets/tauri-sys-91bd50ded94e0ed7/dist/event.js @@ -0,0 +1,123 @@ +// tauri/tooling/api/src/tauri.ts +function uid() { + return window.crypto.getRandomValues(new Uint32Array(1))[0]; +} +function transformCallback(callback, once3 = false) { + const identifier = uid(); + const prop = `_${identifier}`; + Object.defineProperty(window, prop, { + value: (result) => { + if (once3) { + Reflect.deleteProperty(window, prop); + } + return callback?.(result); + }, + writable: false, + configurable: true + }); + return identifier; +} +async function invoke(cmd, args = {}) { + return new Promise((resolve, reject) => { + const callback = transformCallback((e) => { + resolve(e); + Reflect.deleteProperty(window, `_${error}`); + }, true); + const error = transformCallback((e) => { + reject(e); + Reflect.deleteProperty(window, `_${callback}`); + }, true); + window.__TAURI_IPC__({ + cmd, + callback, + error, + ...args + }); + }); +} + +// tauri/tooling/api/src/helpers/tauri.ts +async function invokeTauriCommand(command) { + return invoke("tauri", command); +} + +// tauri/tooling/api/src/helpers/event.ts +async function _unlisten(event, eventId) { + return invokeTauriCommand({ + __tauriModule: "Event", + message: { + cmd: "unlisten", + event, + eventId + } + }); +} +async function emit(event, windowLabel, payload) { + await invokeTauriCommand({ + __tauriModule: "Event", + message: { + cmd: "emit", + event, + windowLabel, + payload + } + }); +} +async function listen(event, windowLabel, handler) { + return invokeTauriCommand({ + __tauriModule: "Event", + message: { + cmd: "listen", + event, + windowLabel, + handler: transformCallback(handler) + } + }).then((eventId) => { + return async () => _unlisten(event, eventId); + }); +} +async function once(event, windowLabel, handler) { + return listen(event, windowLabel, (eventData) => { + handler(eventData); + _unlisten(event, eventData.id).catch(() => { + }); + }); +} + +// tauri/tooling/api/src/event.ts +var TauriEvent = /* @__PURE__ */ ((TauriEvent2) => { + TauriEvent2["WINDOW_RESIZED"] = "tauri://resize"; + TauriEvent2["WINDOW_MOVED"] = "tauri://move"; + TauriEvent2["WINDOW_CLOSE_REQUESTED"] = "tauri://close-requested"; + TauriEvent2["WINDOW_CREATED"] = "tauri://window-created"; + TauriEvent2["WINDOW_DESTROYED"] = "tauri://destroyed"; + TauriEvent2["WINDOW_FOCUS"] = "tauri://focus"; + TauriEvent2["WINDOW_BLUR"] = "tauri://blur"; + TauriEvent2["WINDOW_SCALE_FACTOR_CHANGED"] = "tauri://scale-change"; + TauriEvent2["WINDOW_THEME_CHANGED"] = "tauri://theme-changed"; + TauriEvent2["WINDOW_FILE_DROP"] = "tauri://file-drop"; + TauriEvent2["WINDOW_FILE_DROP_HOVER"] = "tauri://file-drop-hover"; + TauriEvent2["WINDOW_FILE_DROP_CANCELLED"] = "tauri://file-drop-cancelled"; + TauriEvent2["MENU"] = "tauri://menu"; + TauriEvent2["CHECK_UPDATE"] = "tauri://update"; + TauriEvent2["UPDATE_AVAILABLE"] = "tauri://update-available"; + TauriEvent2["INSTALL_UPDATE"] = "tauri://update-install"; + TauriEvent2["STATUS_UPDATE"] = "tauri://update-status"; + TauriEvent2["DOWNLOAD_PROGRESS"] = "tauri://update-download-progress"; + return TauriEvent2; +})(TauriEvent || {}); +async function listen2(event, handler) { + return listen(event, null, handler); +} +async function once2(event, handler) { + return once(event, null, handler); +} +async function emit2(event, payload) { + return emit(event, void 0, payload); +} +export { + TauriEvent, + emit2 as emit, + listen2 as listen, + once2 as once +}; diff --git a/examples/test/dist/snippets/tauri-sys-91bd50ded94e0ed7/dist/mocks.js b/examples/test/dist/snippets/tauri-sys-91bd50ded94e0ed7/dist/mocks.js new file mode 100644 index 0000000..4342d8f --- /dev/null +++ b/examples/test/dist/snippets/tauri-sys-91bd50ded94e0ed7/dist/mocks.js @@ -0,0 +1,30 @@ +// tauri/tooling/api/src/mocks.ts +function mockIPC(cb) { + window.__TAURI_IPC__ = async ({ + cmd, + callback, + error, + ...args + }) => { + try { + window[`_${callback}`](await cb(cmd, args)); + } catch (err) { + window[`_${error}`](err); + } + }; +} +function mockWindows(current, ...additionalWindows) { + window.__TAURI_METADATA__ = { + __windows: [current, ...additionalWindows].map((label) => ({ label })), + __currentWindow: { label: current } + }; +} +function clearMocks() { + delete window.__TAURI_IPC__; + delete window.__TAURI_METADATA__; +} +export { + clearMocks, + mockIPC, + mockWindows +}; diff --git a/examples/test/dist/snippets/tauri-sys-91bd50ded94e0ed7/dist/process.js b/examples/test/dist/snippets/tauri-sys-91bd50ded94e0ed7/dist/process.js new file mode 100644 index 0000000..9356313 --- /dev/null +++ b/examples/test/dist/snippets/tauri-sys-91bd50ded94e0ed7/dist/process.js @@ -0,0 +1,65 @@ +// tauri/tooling/api/src/tauri.ts +function uid() { + return window.crypto.getRandomValues(new Uint32Array(1))[0]; +} +function transformCallback(callback, once = false) { + const identifier = uid(); + const prop = `_${identifier}`; + Object.defineProperty(window, prop, { + value: (result) => { + if (once) { + Reflect.deleteProperty(window, prop); + } + return callback?.(result); + }, + writable: false, + configurable: true + }); + return identifier; +} +async function invoke(cmd, args = {}) { + return new Promise((resolve, reject) => { + const callback = transformCallback((e) => { + resolve(e); + Reflect.deleteProperty(window, `_${error}`); + }, true); + const error = transformCallback((e) => { + reject(e); + Reflect.deleteProperty(window, `_${callback}`); + }, true); + window.__TAURI_IPC__({ + cmd, + callback, + error, + ...args + }); + }); +} + +// tauri/tooling/api/src/helpers/tauri.ts +async function invokeTauriCommand(command) { + return invoke("tauri", command); +} + +// tauri/tooling/api/src/process.ts +async function exit(exitCode = 0) { + return invokeTauriCommand({ + __tauriModule: "Process", + message: { + cmd: "exit", + exitCode + } + }); +} +async function relaunch() { + return invokeTauriCommand({ + __tauriModule: "Process", + message: { + cmd: "relaunch" + } + }); +} +export { + exit, + relaunch +}; diff --git a/examples/test/dist/snippets/tauri-sys-91bd50ded94e0ed7/dist/tauri.js b/examples/test/dist/snippets/tauri-sys-91bd50ded94e0ed7/dist/tauri.js new file mode 100644 index 0000000..5360e6f --- /dev/null +++ b/examples/test/dist/snippets/tauri-sys-91bd50ded94e0ed7/dist/tauri.js @@ -0,0 +1,46 @@ +// tauri/tooling/api/src/tauri.ts +function uid() { + return window.crypto.getRandomValues(new Uint32Array(1))[0]; +} +function transformCallback(callback, once = false) { + const identifier = uid(); + const prop = `_${identifier}`; + Object.defineProperty(window, prop, { + value: (result) => { + if (once) { + Reflect.deleteProperty(window, prop); + } + return callback?.(result); + }, + writable: false, + configurable: true + }); + return identifier; +} +async function invoke(cmd, args = {}) { + return new Promise((resolve, reject) => { + const callback = transformCallback((e) => { + resolve(e); + Reflect.deleteProperty(window, `_${error}`); + }, true); + const error = transformCallback((e) => { + reject(e); + Reflect.deleteProperty(window, `_${callback}`); + }, true); + window.__TAURI_IPC__({ + cmd, + callback, + error, + ...args + }); + }); +} +function convertFileSrc(filePath, protocol = "asset") { + const path = encodeURIComponent(filePath); + return navigator.userAgent.includes("Windows") ? `https://${protocol}.localhost/${path}` : `${protocol}://localhost/${path}`; +} +export { + convertFileSrc, + invoke, + transformCallback +}; diff --git a/examples/test/dist/snippets/tauri-sys-91bd50ded94e0ed7/dist/window.js b/examples/test/dist/snippets/tauri-sys-91bd50ded94e0ed7/dist/window.js new file mode 100644 index 0000000..e0b637b --- /dev/null +++ b/examples/test/dist/snippets/tauri-sys-91bd50ded94e0ed7/dist/window.js @@ -0,0 +1,1004 @@ +// tauri/tooling/api/src/tauri.ts +function uid() { + return window.crypto.getRandomValues(new Uint32Array(1))[0]; +} +function transformCallback(callback, once2 = false) { + const identifier = uid(); + const prop = `_${identifier}`; + Object.defineProperty(window, prop, { + value: (result) => { + if (once2) { + Reflect.deleteProperty(window, prop); + } + return callback?.(result); + }, + writable: false, + configurable: true + }); + return identifier; +} +async function invoke(cmd, args = {}) { + return new Promise((resolve, reject) => { + const callback = transformCallback((e) => { + resolve(e); + Reflect.deleteProperty(window, `_${error}`); + }, true); + const error = transformCallback((e) => { + reject(e); + Reflect.deleteProperty(window, `_${callback}`); + }, true); + window.__TAURI_IPC__({ + cmd, + callback, + error, + ...args + }); + }); +} + +// tauri/tooling/api/src/helpers/tauri.ts +async function invokeTauriCommand(command) { + return invoke("tauri", command); +} + +// tauri/tooling/api/src/helpers/event.ts +async function _unlisten(event, eventId) { + return invokeTauriCommand({ + __tauriModule: "Event", + message: { + cmd: "unlisten", + event, + eventId + } + }); +} +async function emit(event, windowLabel, payload) { + await invokeTauriCommand({ + __tauriModule: "Event", + message: { + cmd: "emit", + event, + windowLabel, + payload + } + }); +} +async function listen(event, windowLabel, handler) { + return invokeTauriCommand({ + __tauriModule: "Event", + message: { + cmd: "listen", + event, + windowLabel, + handler: transformCallback(handler) + } + }).then((eventId) => { + return async () => _unlisten(event, eventId); + }); +} +async function once(event, windowLabel, handler) { + return listen(event, windowLabel, (eventData) => { + handler(eventData); + _unlisten(event, eventData.id).catch(() => { + }); + }); +} + +// tauri/tooling/api/src/window.ts +var LogicalSize = class { + constructor(width, height) { + this.type = "Logical"; + this.width = width; + this.height = height; + } +}; +var PhysicalSize = class { + constructor(width, height) { + this.type = "Physical"; + this.width = width; + this.height = height; + } + toLogical(scaleFactor) { + return new LogicalSize(this.width / scaleFactor, this.height / scaleFactor); + } +}; +var LogicalPosition = class { + constructor(x, y) { + this.type = "Logical"; + this.x = x; + this.y = y; + } +}; +var PhysicalPosition = class { + constructor(x, y) { + this.type = "Physical"; + this.x = x; + this.y = y; + } + toLogical(scaleFactor) { + return new LogicalPosition(this.x / scaleFactor, this.y / scaleFactor); + } +}; +var UserAttentionType = /* @__PURE__ */ ((UserAttentionType2) => { + UserAttentionType2[UserAttentionType2["Critical"] = 1] = "Critical"; + UserAttentionType2[UserAttentionType2["Informational"] = 2] = "Informational"; + return UserAttentionType2; +})(UserAttentionType || {}); +function getCurrent() { + return new WebviewWindow(window.__TAURI_METADATA__.__currentWindow.label, { + skip: true + }); +} +function getAll() { + return window.__TAURI_METADATA__.__windows.map( + (w) => new WebviewWindow(w.label, { + skip: true + }) + ); +} +var localTauriEvents = ["tauri://created", "tauri://error"]; +var WebviewWindowHandle = class { + constructor(label) { + this.label = label; + this.listeners = /* @__PURE__ */ Object.create(null); + } + async listen(event, handler) { + if (this._handleTauriEvent(event, handler)) { + return Promise.resolve(() => { + const listeners = this.listeners[event]; + listeners.splice(listeners.indexOf(handler), 1); + }); + } + return listen(event, this.label, handler); + } + async once(event, handler) { + if (this._handleTauriEvent(event, handler)) { + return Promise.resolve(() => { + const listeners = this.listeners[event]; + listeners.splice(listeners.indexOf(handler), 1); + }); + } + return once(event, this.label, handler); + } + async emit(event, payload) { + if (localTauriEvents.includes(event)) { + for (const handler of this.listeners[event] || []) { + handler({ event, id: -1, windowLabel: this.label, payload }); + } + return Promise.resolve(); + } + return emit(event, this.label, payload); + } + _handleTauriEvent(event, handler) { + if (localTauriEvents.includes(event)) { + if (!(event in this.listeners)) { + this.listeners[event] = [handler]; + } else { + this.listeners[event].push(handler); + } + return true; + } + return false; + } +}; +var WindowManager = class extends WebviewWindowHandle { + async scaleFactor() { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "scaleFactor" + } + } + } + }); + } + async innerPosition() { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "innerPosition" + } + } + } + }).then(({ x, y }) => new PhysicalPosition(x, y)); + } + async outerPosition() { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "outerPosition" + } + } + } + }).then(({ x, y }) => new PhysicalPosition(x, y)); + } + async innerSize() { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "innerSize" + } + } + } + }).then(({ width, height }) => new PhysicalSize(width, height)); + } + async outerSize() { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "outerSize" + } + } + } + }).then(({ width, height }) => new PhysicalSize(width, height)); + } + async isFullscreen() { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "isFullscreen" + } + } + } + }); + } + async isMaximized() { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "isMaximized" + } + } + } + }); + } + async isDecorated() { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "isDecorated" + } + } + } + }); + } + async isResizable() { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "isResizable" + } + } + } + }); + } + async isVisible() { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "isVisible" + } + } + } + }); + } + async theme() { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "theme" + } + } + } + }); + } + async center() { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "center" + } + } + } + }); + } + async requestUserAttention(requestType) { + let requestType_ = null; + if (requestType) { + if (requestType === 1 /* Critical */) { + requestType_ = { type: "Critical" }; + } else { + requestType_ = { type: "Informational" }; + } + } + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "requestUserAttention", + payload: requestType_ + } + } + } + }); + } + async setResizable(resizable) { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "setResizable", + payload: resizable + } + } + } + }); + } + async setTitle(title) { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "setTitle", + payload: title + } + } + } + }); + } + async maximize() { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "maximize" + } + } + } + }); + } + async unmaximize() { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "unmaximize" + } + } + } + }); + } + async toggleMaximize() { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "toggleMaximize" + } + } + } + }); + } + async minimize() { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "minimize" + } + } + } + }); + } + async unminimize() { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "unminimize" + } + } + } + }); + } + async show() { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "show" + } + } + } + }); + } + async hide() { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "hide" + } + } + } + }); + } + async close() { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "close" + } + } + } + }); + } + async setDecorations(decorations) { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "setDecorations", + payload: decorations + } + } + } + }); + } + async setAlwaysOnTop(alwaysOnTop) { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "setAlwaysOnTop", + payload: alwaysOnTop + } + } + } + }); + } + async setSize(size) { + if (!size || size.type !== "Logical" && size.type !== "Physical") { + throw new Error( + "the `size` argument must be either a LogicalSize or a PhysicalSize instance" + ); + } + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "setSize", + payload: { + type: size.type, + data: { + width: size.width, + height: size.height + } + } + } + } + } + }); + } + async setMinSize(size) { + if (size && size.type !== "Logical" && size.type !== "Physical") { + throw new Error( + "the `size` argument must be either a LogicalSize or a PhysicalSize instance" + ); + } + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "setMinSize", + payload: size ? { + type: size.type, + data: { + width: size.width, + height: size.height + } + } : null + } + } + } + }); + } + async setMaxSize(size) { + if (size && size.type !== "Logical" && size.type !== "Physical") { + throw new Error( + "the `size` argument must be either a LogicalSize or a PhysicalSize instance" + ); + } + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "setMaxSize", + payload: size ? { + type: size.type, + data: { + width: size.width, + height: size.height + } + } : null + } + } + } + }); + } + async setPosition(position) { + if (!position || position.type !== "Logical" && position.type !== "Physical") { + throw new Error( + "the `position` argument must be either a LogicalPosition or a PhysicalPosition instance" + ); + } + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "setPosition", + payload: { + type: position.type, + data: { + x: position.x, + y: position.y + } + } + } + } + } + }); + } + async setFullscreen(fullscreen) { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "setFullscreen", + payload: fullscreen + } + } + } + }); + } + async setFocus() { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "setFocus" + } + } + } + }); + } + async setIcon(icon) { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "setIcon", + payload: { + icon: typeof icon === "string" ? icon : Array.from(icon) + } + } + } + } + }); + } + async setSkipTaskbar(skip) { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "setSkipTaskbar", + payload: skip + } + } + } + }); + } + async setCursorGrab(grab) { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "setCursorGrab", + payload: grab + } + } + } + }); + } + async setCursorVisible(visible) { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "setCursorVisible", + payload: visible + } + } + } + }); + } + async setCursorIcon(icon) { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "setCursorIcon", + payload: icon + } + } + } + }); + } + async setCursorPosition(position) { + if (!position || position.type !== "Logical" && position.type !== "Physical") { + throw new Error( + "the `position` argument must be either a LogicalPosition or a PhysicalPosition instance" + ); + } + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "setCursorPosition", + payload: { + type: position.type, + data: { + x: position.x, + y: position.y + } + } + } + } + } + }); + } + async setIgnoreCursorEvents(ignore) { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "setIgnoreCursorEvents", + payload: ignore + } + } + } + }); + } + async startDragging() { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + label: this.label, + cmd: { + type: "startDragging" + } + } + } + }); + } + async onResized(handler) { + return this.listen("tauri://resize" /* WINDOW_RESIZED */, handler); + } + async onMoved(handler) { + return this.listen("tauri://move" /* WINDOW_MOVED */, handler); + } + async onCloseRequested(handler) { + return this.listen("tauri://close-requested" /* WINDOW_CLOSE_REQUESTED */, (event) => { + const evt = new CloseRequestedEvent(event); + void Promise.resolve(handler(evt)).then(() => { + if (!evt.isPreventDefault()) { + return this.close(); + } + }); + }); + } + async onFocusChanged(handler) { + const unlistenFocus = await this.listen( + "tauri://focus" /* WINDOW_FOCUS */, + (event) => { + handler({ ...event, payload: true }); + } + ); + const unlistenBlur = await this.listen( + "tauri://blur" /* WINDOW_BLUR */, + (event) => { + handler({ ...event, payload: false }); + } + ); + return () => { + unlistenFocus(); + unlistenBlur(); + }; + } + async onScaleChanged(handler) { + return this.listen( + "tauri://scale-change" /* WINDOW_SCALE_FACTOR_CHANGED */, + handler + ); + } + async onMenuClicked(handler) { + return this.listen("tauri://menu" /* MENU */, handler); + } + async onFileDropEvent(handler) { + const unlistenFileDrop = await this.listen( + "tauri://file-drop" /* WINDOW_FILE_DROP */, + (event) => { + handler({ ...event, payload: { type: "drop", paths: event.payload } }); + } + ); + const unlistenFileHover = await this.listen( + "tauri://file-drop-hover" /* WINDOW_FILE_DROP_HOVER */, + (event) => { + handler({ ...event, payload: { type: "hover", paths: event.payload } }); + } + ); + const unlistenCancel = await this.listen( + "tauri://file-drop-cancelled" /* WINDOW_FILE_DROP_CANCELLED */, + (event) => { + handler({ ...event, payload: { type: "cancel" } }); + } + ); + return () => { + unlistenFileDrop(); + unlistenFileHover(); + unlistenCancel(); + }; + } + async onThemeChanged(handler) { + return this.listen("tauri://theme-changed" /* WINDOW_THEME_CHANGED */, handler); + } +}; +var CloseRequestedEvent = class { + constructor(event) { + this._preventDefault = false; + this.event = event.event; + this.windowLabel = event.windowLabel; + this.id = event.id; + } + preventDefault() { + this._preventDefault = true; + } + isPreventDefault() { + return this._preventDefault; + } +}; +var WebviewWindow = class extends WindowManager { + constructor(label, options = {}) { + super(label); + if (!options?.skip) { + invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "createWebview", + data: { + options: { + label, + ...options + } + } + } + }).then(async () => this.emit("tauri://created")).catch(async (e) => this.emit("tauri://error", e)); + } + } + static getByLabel(label) { + if (getAll().some((w) => w.label === label)) { + return new WebviewWindow(label, { skip: true }); + } + return null; + } +}; +var appWindow; +if ("__TAURI_METADATA__" in window) { + appWindow = new WebviewWindow( + window.__TAURI_METADATA__.__currentWindow.label, + { + skip: true + } + ); +} else { + console.warn( + `Could not find "window.__TAURI_METADATA__". The "appWindow" value will reference the "main" window label. +Note that this is not an issue if running this frontend on a browser instead of a Tauri window.` + ); + appWindow = new WebviewWindow("main", { + skip: true + }); +} +function mapMonitor(m) { + return m === null ? null : { + name: m.name, + scaleFactor: m.scaleFactor, + position: new PhysicalPosition(m.position.x, m.position.y), + size: new PhysicalSize(m.size.width, m.size.height) + }; +} +async function currentMonitor() { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + cmd: { + type: "currentMonitor" + } + } + } + }).then(mapMonitor); +} +async function primaryMonitor() { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + cmd: { + type: "primaryMonitor" + } + } + } + }).then(mapMonitor); +} +async function availableMonitors() { + return invokeTauriCommand({ + __tauriModule: "Window", + message: { + cmd: "manage", + data: { + cmd: { + type: "availableMonitors" + } + } + } + }).then((ms) => ms.map(mapMonitor)); +} +export { + CloseRequestedEvent, + LogicalPosition, + LogicalSize, + PhysicalPosition, + PhysicalSize, + UserAttentionType, + WebviewWindow, + WebviewWindowHandle, + WindowManager, + appWindow, + availableMonitors, + currentMonitor, + getAll, + getCurrent, + primaryMonitor +}; diff --git a/examples/test/dist/tauri-sys-test-ui-3eb704384493bbf2.js b/examples/test/dist/tauri-sys-test-ui-3eb704384493bbf2.js new file mode 100644 index 0000000..055ec6b --- /dev/null +++ b/examples/test/dist/tauri-sys-test-ui-3eb704384493bbf2.js @@ -0,0 +1,644 @@ +import { getName, getTauriVersion, getVersion } from './snippets/tauri-sys-91bd50ded94e0ed7/dist/app.js'; +import { readText, writeText } from './snippets/tauri-sys-91bd50ded94e0ed7/dist/clipboard.js'; +import { emit } from './snippets/tauri-sys-91bd50ded94e0ed7/dist/event.js'; +import { invoke } from './snippets/tauri-sys-91bd50ded94e0ed7/dist/tauri.js'; + +let wasm; + +const heap = new Array(32).fill(undefined); + +heap.push(undefined, null, true, false); + +function getObject(idx) { return heap[idx]; } + +let WASM_VECTOR_LEN = 0; + +let cachedUint8Memory0 = new Uint8Array(); + +function getUint8Memory0() { + if (cachedUint8Memory0.byteLength === 0) { + cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer); + } + return cachedUint8Memory0; +} + +const cachedTextEncoder = new TextEncoder('utf-8'); + +const encodeString = (typeof cachedTextEncoder.encodeInto === 'function' + ? function (arg, view) { + return cachedTextEncoder.encodeInto(arg, view); +} + : function (arg, view) { + const buf = cachedTextEncoder.encode(arg); + view.set(buf); + return { + read: arg.length, + written: buf.length + }; +}); + +function passStringToWasm0(arg, malloc, realloc) { + + if (realloc === undefined) { + const buf = cachedTextEncoder.encode(arg); + const ptr = malloc(buf.length); + getUint8Memory0().subarray(ptr, ptr + buf.length).set(buf); + WASM_VECTOR_LEN = buf.length; + return ptr; + } + + let len = arg.length; + let ptr = malloc(len); + + const mem = getUint8Memory0(); + + let offset = 0; + + for (; offset < len; offset++) { + const code = arg.charCodeAt(offset); + if (code > 0x7F) break; + mem[ptr + offset] = code; + } + + if (offset !== len) { + if (offset !== 0) { + arg = arg.slice(offset); + } + ptr = realloc(ptr, len, len = offset + arg.length * 3); + const view = getUint8Memory0().subarray(ptr + offset, ptr + len); + const ret = encodeString(arg, view); + + offset += ret.written; + } + + WASM_VECTOR_LEN = offset; + return ptr; +} + +function isLikeNone(x) { + return x === undefined || x === null; +} + +let cachedInt32Memory0 = new Int32Array(); + +function getInt32Memory0() { + if (cachedInt32Memory0.byteLength === 0) { + cachedInt32Memory0 = new Int32Array(wasm.memory.buffer); + } + return cachedInt32Memory0; +} + +let heap_next = heap.length; + +function addHeapObject(obj) { + if (heap_next === heap.length) heap.push(heap.length + 1); + const idx = heap_next; + heap_next = heap[idx]; + + heap[idx] = obj; + return idx; +} + +const cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }); + +cachedTextDecoder.decode(); + +function getStringFromWasm0(ptr, len) { + return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len)); +} + +let cachedFloat64Memory0 = new Float64Array(); + +function getFloat64Memory0() { + if (cachedFloat64Memory0.byteLength === 0) { + cachedFloat64Memory0 = new Float64Array(wasm.memory.buffer); + } + return cachedFloat64Memory0; +} + +function dropObject(idx) { + if (idx < 36) return; + heap[idx] = heap_next; + heap_next = idx; +} + +function takeObject(idx) { + const ret = getObject(idx); + dropObject(idx); + return ret; +} + +function debugString(val) { + // primitive types + const type = typeof val; + if (type == 'number' || type == 'boolean' || val == null) { + return `${val}`; + } + if (type == 'string') { + return `"${val}"`; + } + if (type == 'symbol') { + const description = val.description; + if (description == null) { + return 'Symbol'; + } else { + return `Symbol(${description})`; + } + } + if (type == 'function') { + const name = val.name; + if (typeof name == 'string' && name.length > 0) { + return `Function(${name})`; + } else { + return 'Function'; + } + } + // objects + if (Array.isArray(val)) { + const length = val.length; + let debug = '['; + if (length > 0) { + debug += debugString(val[0]); + } + for(let i = 1; i < length; i++) { + debug += ', ' + debugString(val[i]); + } + debug += ']'; + return debug; + } + // Test for built-in + const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val)); + let className; + if (builtInMatches.length > 1) { + className = builtInMatches[1]; + } else { + // Failed to match the standard '[object ClassName]' + return toString.call(val); + } + if (className == 'Object') { + // we're a user defined class or Object + // JSON.stringify avoids problems with cycles, and is generally much + // easier than looping through ownProperties of `val`. + try { + return 'Object(' + JSON.stringify(val) + ')'; + } catch (_) { + return 'Object'; + } + } + // errors + if (val instanceof Error) { + return `${val.name}: ${val.message}\n${val.stack}`; + } + // TODO we could test for more things here, like `Set`s and `Map`s. + return className; +} + +function makeMutClosure(arg0, arg1, dtor, f) { + const state = { a: arg0, b: arg1, cnt: 1, dtor }; + const real = (...args) => { + // First up with a closure we increment the internal reference + // count. This ensures that the Rust closure environment won't + // be deallocated while we're invoking it. + state.cnt++; + const a = state.a; + state.a = 0; + try { + return f(a, state.b, ...args); + } finally { + if (--state.cnt === 0) { + wasm.__wbindgen_export_2.get(state.dtor)(a, state.b); + + } else { + state.a = a; + } + } + }; + real.original = state; + + return real; +} +function __wbg_adapter_28(arg0, arg1, arg2) { + wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h45f286b32445b0b2(arg0, arg1, addHeapObject(arg2)); +} + +function getCachedStringFromWasm0(ptr, len) { + if (ptr === 0) { + return getObject(len); + } else { + return getStringFromWasm0(ptr, len); + } +} + +function handleError(f, args) { + try { + return f.apply(this, args); + } catch (e) { + wasm.__wbindgen_exn_store(addHeapObject(e)); + } +} + +async function load(module, imports) { + if (typeof Response === 'function' && module instanceof Response) { + if (typeof WebAssembly.instantiateStreaming === 'function') { + try { + return await WebAssembly.instantiateStreaming(module, imports); + + } catch (e) { + if (module.headers.get('Content-Type') != 'application/wasm') { + console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e); + + } else { + throw e; + } + } + } + + const bytes = await module.arrayBuffer(); + return await WebAssembly.instantiate(bytes, imports); + + } else { + const instance = await WebAssembly.instantiate(module, imports); + + if (instance instanceof WebAssembly.Instance) { + return { instance, module }; + + } else { + return instance; + } + } +} + +function getImports() { + const imports = {}; + imports.wbg = {}; + imports.wbg.__wbg_readText_d6aa69a1d055ebfb = function() { + const ret = readText(); + return addHeapObject(ret); + }; + imports.wbg.__wbg_writeText_98a927b6ebdc847f = function(arg0, arg1) { + var v0 = getCachedStringFromWasm0(arg0, arg1); + const ret = writeText(v0); + return addHeapObject(ret); + }; + imports.wbg.__wbg_invoke_575077e3d547074e = function() { return handleError(function (arg0, arg1, arg2) { + var v0 = getCachedStringFromWasm0(arg0, arg1); + const ret = invoke(v0, takeObject(arg2)); + return addHeapObject(ret); + }, arguments) }; + imports.wbg.__wbg_getVersion_13e166788d7097c8 = function() { + const ret = getVersion(); + return addHeapObject(ret); + }; + imports.wbg.__wbg_getTauriVersion_62b3cf54af008ea9 = function() { + const ret = getTauriVersion(); + return addHeapObject(ret); + }; + imports.wbg.__wbg_getName_d3872e5e2b652485 = function() { + const ret = getName(); + return addHeapObject(ret); + }; + imports.wbg.__wbg_emit_128d56f37ce5403a = function(arg0, arg1, arg2) { + var v0 = getCachedStringFromWasm0(arg0, arg1); + const ret = emit(v0, takeObject(arg2)); + return addHeapObject(ret); + }; + imports.wbg.__wbindgen_boolean_get = function(arg0) { + const v = getObject(arg0); + const ret = typeof(v) === 'boolean' ? (v ? 1 : 0) : 2; + return ret; + }; + imports.wbg.__wbindgen_string_get = function(arg0, arg1) { + const obj = getObject(arg1); + const ret = typeof(obj) === 'string' ? obj : undefined; + var ptr0 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + var len0 = WASM_VECTOR_LEN; + getInt32Memory0()[arg0 / 4 + 1] = len0; + getInt32Memory0()[arg0 / 4 + 0] = ptr0; + }; + imports.wbg.__wbindgen_object_clone_ref = function(arg0) { + const ret = getObject(arg0); + return addHeapObject(ret); + }; + imports.wbg.__wbg_nodeId_bbf0efafa303e805 = function(arg0, arg1) { + const ret = getObject(arg1).$$$nodeId; + getInt32Memory0()[arg0 / 4 + 1] = isLikeNone(ret) ? 0 : ret; + getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret); + }; + imports.wbg.__wbg_setnodeId_433ef8ed15bd1612 = function(arg0, arg1) { + getObject(arg0).$$$nodeId = arg1 >>> 0; + }; + imports.wbg.__wbg_createTextNode_a7d5f5b956acda97 = function(arg0, arg1) { + const ret = getObject(arg0).createTextNode(arg1); + return addHeapObject(ret); + }; + imports.wbg.__wbindgen_string_new = function(arg0, arg1) { + const ret = getStringFromWasm0(arg0, arg1); + return addHeapObject(ret); + }; + imports.wbg.__wbg_instanceof_Window_acc97ff9f5d2c7b4 = function(arg0) { + let result; + try { + result = getObject(arg0) instanceof Window; + } catch { + result = false; + } + const ret = result; + return ret; + }; + imports.wbg.__wbg_document_3ead31dbcad65886 = function(arg0) { + const ret = getObject(arg0).document; + return isLikeNone(ret) ? 0 : addHeapObject(ret); + }; + imports.wbg.__wbg_body_3cb4b4042b9a632b = function(arg0) { + const ret = getObject(arg0).body; + return isLikeNone(ret) ? 0 : addHeapObject(ret); + }; + imports.wbg.__wbg_createComment_0df3a4d0d91032e7 = function(arg0, arg1, arg2) { + var v0 = getCachedStringFromWasm0(arg1, arg2); + const ret = getObject(arg0).createComment(v0); + return addHeapObject(ret); + }; + imports.wbg.__wbg_createElement_976dbb84fe1661b5 = function() { return handleError(function (arg0, arg1, arg2) { + var v0 = getCachedStringFromWasm0(arg1, arg2); + const ret = getObject(arg0).createElement(v0); + return addHeapObject(ret); + }, arguments) }; + imports.wbg.__wbg_createElementNS_1561aca8ee3693c0 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) { + var v0 = getCachedStringFromWasm0(arg1, arg2); + var v1 = getCachedStringFromWasm0(arg3, arg4); + const ret = getObject(arg0).createElementNS(v0, v1); + return addHeapObject(ret); + }, arguments) }; + imports.wbg.__wbg_createTextNode_300f845fab76642f = function(arg0, arg1, arg2) { + var v0 = getCachedStringFromWasm0(arg1, arg2); + const ret = getObject(arg0).createTextNode(v0); + return addHeapObject(ret); + }; + imports.wbg.__wbg_instanceof_Comment_1758f7164ca9ea81 = function(arg0) { + let result; + try { + result = getObject(arg0) instanceof Comment; + } catch { + result = false; + } + const ret = result; + return ret; + }; + imports.wbg.__wbg_instanceof_Text_6855016c7825859b = function(arg0) { + let result; + try { + result = getObject(arg0) instanceof Text; + } catch { + result = false; + } + const ret = result; + return ret; + }; + imports.wbg.__wbg_instanceof_Element_33bd126d58f2021b = function(arg0) { + let result; + try { + result = getObject(arg0) instanceof Element; + } catch { + result = false; + } + const ret = result; + return ret; + }; + imports.wbg.__wbg_outerHTML_bf662bdff92e5910 = function(arg0, arg1) { + const ret = getObject(arg1).outerHTML; + const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + getInt32Memory0()[arg0 / 4 + 1] = len0; + getInt32Memory0()[arg0 / 4 + 0] = ptr0; + }; + imports.wbg.__wbg_parentNode_e397bbbe28be7b28 = function(arg0) { + const ret = getObject(arg0).parentNode; + return isLikeNone(ret) ? 0 : addHeapObject(ret); + }; + imports.wbg.__wbg_nextSibling_62338ec2a05607b4 = function(arg0) { + const ret = getObject(arg0).nextSibling; + return isLikeNone(ret) ? 0 : addHeapObject(ret); + }; + imports.wbg.__wbg_textContent_77bd294928962f93 = function(arg0, arg1) { + const ret = getObject(arg1).textContent; + var ptr0 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + var len0 = WASM_VECTOR_LEN; + getInt32Memory0()[arg0 / 4 + 1] = len0; + getInt32Memory0()[arg0 / 4 + 0] = ptr0; + }; + imports.wbg.__wbg_settextContent_538ceb17614272d8 = function(arg0, arg1, arg2) { + var v0 = getCachedStringFromWasm0(arg1, arg2); + getObject(arg0).textContent = v0; + }; + imports.wbg.__wbg_appendChild_e513ef0e5098dfdd = function() { return handleError(function (arg0, arg1) { + const ret = getObject(arg0).appendChild(getObject(arg1)); + return addHeapObject(ret); + }, arguments) }; + imports.wbg.__wbg_insertBefore_9f2d2defb9471006 = function() { return handleError(function (arg0, arg1, arg2) { + const ret = getObject(arg0).insertBefore(getObject(arg1), getObject(arg2)); + return addHeapObject(ret); + }, arguments) }; + imports.wbg.__wbg_removeChild_6751e9ca5d9aaf00 = function() { return handleError(function (arg0, arg1) { + const ret = getObject(arg0).removeChild(getObject(arg1)); + return addHeapObject(ret); + }, arguments) }; + imports.wbg.__wbg_replaceChild_4793d6269c04dd25 = function() { return handleError(function (arg0, arg1, arg2) { + const ret = getObject(arg0).replaceChild(getObject(arg1), getObject(arg2)); + return addHeapObject(ret); + }, arguments) }; + imports.wbg.__wbindgen_is_undefined = function(arg0) { + const ret = getObject(arg0) === undefined; + return ret; + }; + imports.wbg.__wbindgen_number_get = function(arg0, arg1) { + const obj = getObject(arg1); + const ret = typeof(obj) === 'number' ? obj : undefined; + getFloat64Memory0()[arg0 / 8 + 1] = isLikeNone(ret) ? 0 : ret; + getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret); + }; + imports.wbg.__wbindgen_error_new = function(arg0, arg1) { + const ret = new Error(getStringFromWasm0(arg0, arg1)); + return addHeapObject(ret); + }; + imports.wbg.__wbindgen_jsval_loose_eq = function(arg0, arg1) { + const ret = getObject(arg0) == getObject(arg1); + return ret; + }; + imports.wbg.__wbindgen_cb_drop = function(arg0) { + const obj = takeObject(arg0).original; + if (obj.cnt-- == 1) { + obj.a = 0; + return true; + } + const ret = false; + return ret; + }; + imports.wbg.__wbg_instanceof_ArrayBuffer_e5e48f4762c5610b = function(arg0) { + let result; + try { + result = getObject(arg0) instanceof ArrayBuffer; + } catch { + result = false; + } + const ret = result; + return ret; + }; + imports.wbg.__wbg_newnoargs_b5b063fc6c2f0376 = function(arg0, arg1) { + var v0 = getCachedStringFromWasm0(arg0, arg1); + const ret = new Function(v0); + return addHeapObject(ret); + }; + imports.wbg.__wbg_call_97ae9d8645dc388b = function() { return handleError(function (arg0, arg1) { + const ret = getObject(arg0).call(getObject(arg1)); + return addHeapObject(ret); + }, arguments) }; + imports.wbg.__wbg_is_40a66842732708e7 = function(arg0, arg1) { + const ret = Object.is(getObject(arg0), getObject(arg1)); + return ret; + }; + imports.wbg.__wbg_toString_7be108a12ef03bc2 = function(arg0) { + const ret = getObject(arg0).toString(); + return addHeapObject(ret); + }; + imports.wbg.__wbg_resolve_99fe17964f31ffc0 = function(arg0) { + const ret = Promise.resolve(getObject(arg0)); + return addHeapObject(ret); + }; + imports.wbg.__wbg_then_11f7a54d67b4bfad = function(arg0, arg1) { + const ret = getObject(arg0).then(getObject(arg1)); + return addHeapObject(ret); + }; + imports.wbg.__wbg_then_cedad20fbbd9418a = function(arg0, arg1, arg2) { + const ret = getObject(arg0).then(getObject(arg1), getObject(arg2)); + return addHeapObject(ret); + }; + imports.wbg.__wbg_globalThis_7f206bda628d5286 = function() { return handleError(function () { + const ret = globalThis.globalThis; + return addHeapObject(ret); + }, arguments) }; + imports.wbg.__wbg_self_6d479506f72c6a71 = function() { return handleError(function () { + const ret = self.self; + return addHeapObject(ret); + }, arguments) }; + imports.wbg.__wbg_window_f2557cc78490aceb = function() { return handleError(function () { + const ret = window.window; + return addHeapObject(ret); + }, arguments) }; + imports.wbg.__wbg_global_ba75c50d1cf384f4 = function() { return handleError(function () { + const ret = global.global; + return addHeapObject(ret); + }, arguments) }; + imports.wbg.__wbg_instanceof_Uint8Array_971eeda69eb75003 = function(arg0) { + let result; + try { + result = getObject(arg0) instanceof Uint8Array; + } catch { + result = false; + } + const ret = result; + return ret; + }; + imports.wbg.__wbg_new_8c3f0052272a457a = function(arg0) { + const ret = new Uint8Array(getObject(arg0)); + return addHeapObject(ret); + }; + imports.wbg.__wbg_length_9e1ae1900cb0fbd5 = function(arg0) { + const ret = getObject(arg0).length; + return ret; + }; + imports.wbg.__wbg_set_83db9690f9353e79 = function(arg0, arg1, arg2) { + getObject(arg0).set(getObject(arg1), arg2 >>> 0); + }; + imports.wbg.__wbg_buffer_3f3d764d4747d564 = function(arg0) { + const ret = getObject(arg0).buffer; + return addHeapObject(ret); + }; + imports.wbg.__wbg_error_f851667af71bcfc6 = function(arg0, arg1) { + var v0 = getCachedStringFromWasm0(arg0, arg1); + if (arg0 !== 0) { wasm.__wbindgen_free(arg0, arg1); } + console.error(v0); +}; +imports.wbg.__wbg_new_abda76e883ba8a5f = function() { + const ret = new Error(); + return addHeapObject(ret); +}; +imports.wbg.__wbg_stack_658279fe44541cf6 = function(arg0, arg1) { + const ret = getObject(arg1).stack; + const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + getInt32Memory0()[arg0 / 4 + 1] = len0; + getInt32Memory0()[arg0 / 4 + 0] = ptr0; +}; +imports.wbg.__wbindgen_debug_string = function(arg0, arg1) { + const ret = debugString(getObject(arg1)); + const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + getInt32Memory0()[arg0 / 4 + 1] = len0; + getInt32Memory0()[arg0 / 4 + 0] = ptr0; +}; +imports.wbg.__wbindgen_object_drop_ref = function(arg0) { + takeObject(arg0); +}; +imports.wbg.__wbindgen_throw = function(arg0, arg1) { + throw new Error(getStringFromWasm0(arg0, arg1)); +}; +imports.wbg.__wbindgen_memory = function() { + const ret = wasm.memory; + return addHeapObject(ret); +}; +imports.wbg.__wbindgen_closure_wrapper5822 = function(arg0, arg1, arg2) { + const ret = makeMutClosure(arg0, arg1, 295, __wbg_adapter_28); + return addHeapObject(ret); +}; + +return imports; +} + +function initMemory(imports, maybe_memory) { + +} + +function finalizeInit(instance, module) { + wasm = instance.exports; + init.__wbindgen_wasm_module = module; + cachedFloat64Memory0 = new Float64Array(); + cachedInt32Memory0 = new Int32Array(); + cachedUint8Memory0 = new Uint8Array(); + + wasm.__wbindgen_start(); + return wasm; +} + +function initSync(module) { + const imports = getImports(); + + initMemory(imports); + + if (!(module instanceof WebAssembly.Module)) { + module = new WebAssembly.Module(module); + } + + const instance = new WebAssembly.Instance(module, imports); + + return finalizeInit(instance, module); +} + +async function init(input) { + if (typeof input === 'undefined') { + input = new URL('tauri-sys-test-ui-3eb704384493bbf2_bg.wasm', import.meta.url); + } + const imports = getImports(); + + if (typeof input === 'string' || (typeof Request === 'function' && input instanceof Request) || (typeof URL === 'function' && input instanceof URL)) { + input = fetch(input); + } + + initMemory(imports); + + const { instance, module } = await load(await input, imports); + + return finalizeInit(instance, module); +} + +export { initSync } +export default init; diff --git a/examples/test/dist/tauri-sys-test-ui-3eb704384493bbf2_bg.wasm b/examples/test/dist/tauri-sys-test-ui-3eb704384493bbf2_bg.wasm new file mode 100644 index 0000000000000000000000000000000000000000..f24c56af065b98743781d7da34eb1811ba19eaf7 GIT binary patch literal 1678833 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 z _YsjAefq>@xpm1ONxuT!t2LIR2D{Mu{=1{mPbdxyXK;UA819TmnMT@9D^ zj%#G?%HSVz4qSgG1pvke&=_(|5+iZD|Hw1*ZDp01^bvipT`reog#Ix84Wl9%G~#~ zQ8G)G{Yg{WcheNdYMAWCPnF^}w#f|Qm>by`53o%g=aq-VvBDUrl%VtFmE)wqYd4|f zLsx635LKd;)p8;GPh2V#iuuW+W1DU39*p+&sCV7FOE2i5^U}f}{`WM#B<;B9gFr(M z9=s>I3<{REuJkcsE_t~A{&D_ysVn`D{O@9yian<^3EvR8KNaT-UzGoNl-iX)#xCh% zuNatF3LyQWd<0WhJF$r+@}63kW}n+}rayGOw!tgg+af|2i)~D!Ge!3Mrk7ocvFO)P z5~=2HXkKc++c$YWDg9Mm3|O(bcvi(f&5IjrwYv|iMN&LXp>~?UtO;<_UtcMt@x_?W7p zqj3gIfIB23y1>qUwHWU_8mPYDKGvUBo4l(=T7&sUsge;SVCf|wWLE=sp{ck+vapMx zPW(h9GPowpMU}mF9Z>K4Wd7O>1Vfo_scaR0t`g}jgc3$Qr^+mOk1885hbn~DKw{Zh zQ}=o*tFcNAsKe*9bHbQpQs%$g3dcreR8Bo{&rAXL48`<1T`PFc; zSzI`lxVlXo=)^~R>-sgx4N%U_PL(cXVm}tc8 z00RhQtZ&;L^$T*_kEJZelmZncBoQ}nOkgF_e?81fsX}B5ftb>8(bF1VMn$OQl(<}p z-Vi;}I#~h_>*K1UB-x;SN!lrbpSM^pa@tDN-fKb)RpZhO520(V?b3U z4X~Uu_#{=n!*^lqH{Ga_{F%BO)w(>7^D13?y6+{+h+VsyKaG-;j8+zYs`4{@Kg`bT zum~eij8Qbvi~LaS2wF0?999*3$$#mpBg(e7sc z%n3bFb}Bx^BI%(c6e*FW#i@>|mgfDvDM;pRb=* z;qS3XW*HV{_|s^3rgg{?{O(~tondHmH>RIfKx@X@oaedg?ON{5<=)hYTArKFzPb7N zVto366(L~@GQ^A~`*9Bo5Rlt8i2Y~B9|`Y|q%-C-{*;DY!+&6qlTceB+oSfK77QW_ z65NNFAbpR@clmA^?6g&6J*XKZxxA0loZ`%{*0s;`4$)0Tlfz4dO;?sC_cZH3O$y4^Pv%2>AekKH| zlQ@vK5$c~kN)si(>ADV+WI%=#ScD=atB$&QyO#U%ceF1{$C#IlmM||(k6An~DG&3K z^5e}*t_}0j>RLQ6DG&3K@)Aa+qs>dMJC<2VBRtGY>RFzbImT{T#u_2Vsg<#J$#G}v ztb=12B|^LY>_BI4LP|y&-P>6yZI_~ahBmXXS$Ht&`A+)Ov|`A_t`ej1*pwCK`+ZiR*(}Kt{iTO_^TT~bNCC7v++FV35b7jlhIq7Cm{#0+OMHa90p|4|;ehQ0 zj}cN9zuE5S`KiadLf#AWogrQ!2iY2;()EorR5#7y*^_iMr2cX@4kZ~H05;~csIJeh z?W09-__oMxEh@E7X&ew)Q2nrd3Ix_bf zdzu0F?q1#0jlks~OHhaCn1y5@TZ1`;_@Sjp&cxOqo1%yqz5&k2X~5%y}cU?;*R)SbOVe`2T$7f=^he&#T~8uY;l zuFW}{-B&m2JqOsva2QGqUm?T=X=Qn9jdH_M=>5S`OydpZI;Dc*FpWsIWCSgLPDOUP^PBG!)OmGN*x(eN^CL@g|x(+*7!o?2E|dM6jH z&_(i@vbI_*dZ+vR7;7xdb7#a?meRWwhs>@t>_g9pucBrZU7ZyL`cn%-xrU-D1=^#+ z>Mh1H_Ns7b>lR1{-d##>DKajgsLOJDv8>{4RV+FMid?T*0(q&X9qK?>MhDH*$M7&x z+{R_L(ZQ<6-&v&J@yEfBt;ch`n~7TG{}}<1Pu$m6q>mPZ_jQi0AI2@mLmT&~A+zZ7 z*uZ9%!DD9@RX78F*WJ+}c(#g7o>x7|{H{5N-Bwceyt_k}HSbv618pfCTIaA^*xQe` ziaSzt9liZg~6thKdKadqQ^tM8Ks}zLZelX5^ z`-pC#x4&hyup}@sr5F@=2>q)qQ}$QSJ>-a5of*q9imO+=HBL^C!@FT ziWS4y=x5iH7WMY~h&C0cI=N%B%xn-A-cPh?{EYVYCmVbF3dNH(%bd=a zR&)ESE#~&4Cr>ZGe+hc|Jtv}Bp@(%~S{QK)!u}_j-9$unZ zFTd-W+gs@6fA#e0zCf+zX&~kN9ghQoW#9%c!}m7zv7Fn zdi?9pnI8Y{5_G31S>+x?at;e6W7S#_t-m1r+ zW{c`c)ZBi#gdTtRM0)%?$LsNLFRjO)wd?qeSKQG;SAXuTH*6?pFD1^21c*MxY;MWc2F-X7-*5mpjNzcAKjM#6SPc~&G`$@nS>6KzpyYnJDXGY}=J9kCjI@dOu&84DDmhQgsZ~n&M!BR0I1r8`KO1e} z2^GF>W`Uav=hg@xIpwSF%N8n}dAa1=<+h4o76rMq{agV6HPgY%}?2m zPcxFQT7*}YPbqSrTaPdL0DVg~ri*Zi$wv|>y1A^I%Rt7@M7;~raQI%ijc4i4VgnqW z7}Edf#CO<~j(V1!E!MnS^zDGVXO+U)Efs^{B;eh-NlZe99@%Js15lTz`$3TPpe_e+ zXATBHJE<1czll(pXLu~4DtCA{1_P30lMW+*Nhsfm=Q2Z@j#6&PdN$=?63TZ0CK1xK zxL2=ZBs_EYG7XdIKHWtp7v;0OSib#>6LFx=03Vq-JK18bxg|@ogGbXYu=EUP#IF?7 zsOWy`S)1GsE8T>Bs;exAy?H^F*pIhQF0CKGdvg2nhfC?luRRC)@pC7&A4h-VemuOy zeth`k_T!^V>Bk421O0f{$?V6s4!7>d+lukbfpUw8BESU}zLQ54aRzz9OIc82_iv&) zoMoYefFVa=!dPHsZ*50vbWuWBwl2s3c-{Od(hXq?ShjjSZ1}+TsHKmR9GVBloyBRJ zcYd1yc*=dY0OPL3Yn_%$K_wj73&4xaAy`-IfMC`Ar}_18h*2&YL>FifjSUgNh|0J7 zp@1?hAa~pSrrnVwokbAsj%I98ZLbGxS9D9@LZeEpsqmgj;u79#QAH|0oz>Aoq6U&N z$}JeQqC?eJRelCw_Y6~LWM_i!RfHhPIPiD+$sAKS&HcuKU(o@;p6=h}X95`Fi1Nj^ zXGw9EC{RB;wKReHR~t_1!ua@7CgQK30~7I!Cvzfx@+cGW(^(ij)Q`Yr@p(4o$0jkh zMY^GyePJsh^gz@2rNct}7!I*}SD(^wiu;B`H%e+-NG#UoI~9a49jDEAN&lmKAkRXG zzS{|hh0w$#~ZF0F~BoQze z4ieuzpY+&uJ%|@e(YrE)2AX2CA7QGTKDO&efD#;iUUT9_VggrdoO2*hTE@pD&IhNBEAur)tK%y4>=H1b#sWF8Rs;Au|yfcP;M8>|8csoh6 z5glAI8s2;?e21t>FbODL50d~OM?qCN6I6AAN+&7ESXs&8Bu@KZHQJ|RyXx5yg(grQa)HJ|i*uWaJ5+b;}r`Y3ve0{QtwzZy| zPx{sKtS$YFkzFi<Z9WKcT!Q>{LF3Co`K(}-O(!U`DqarbvaA}eZ)wd9TH?OJrD zpHcHX4{b9;xo+XlEsC|A(E-G<6zpw&tKX&-*x$kYck3g~F!7_R_Zj?5tR;$n!eZD1>U!V_?yIaT6!#3Q`+ z{Oc_4<#}bhbOnD~K(iU++V(+k7pEmf7a)eDm|CbbWQ+U=S00@vor}V%{+&CRUNDFH z+5N$!_e`v$R1PH+vbC732-Az|k*VU|i`m4*r^nA{cg`buo{=(_46Hmzwjed7CfMD7i1BZaSU)g07lEL zN40Ov`!>}=iE8nkU7slyCbfJig>wVRhi%C%3dQ!~Ln!_%X47ngbG{FRVJE*@j7J&9 zsGmb$AxY1ET$0{4;bP{t-T4mvIFLa1AyG_QGnH1lpLSrjF34={-F!XTgYR0!ZNNdj z1d}~^7Y9Iwdl%;VALmCrO$l zmGnxT8pz)><@|_6(NHZhB+joBgVrcdX7-&!U1R*odUrm5j{DKT1+q>wYo+jZ61fxn z2|qc*gb(s8fgDB>76uthwRn-~zydd>xzP6RGg`bpRg9;D3&K+0+A?KqE!L6PtaW(- zuL1{bE4z4-btH))sgnc)1U^wjR!KTeP1MQHo$h0+8A~f>qRh;)JNkVeshzvSyiptv z(H*~}XSMJs*+jcvxjR~|Gi9CW@xAl(FRU*7$S2K2tCK!T%tJ9Bx{`Py6+FL5Yl-(N zVRS^5){h}G<^bMd^2?w*Xd$l z?MD8r?FnN^>sjI^XTus^b8_IDSd@z}l_FDTc%iOwPL0#0O3#g&80jM9UxjMBT9QtTG;DV15IqeT{JHgjf? zR^`)d4A`)#@*2%mwSneJw9!&ABKPlLxv3qfx`I?5MK|5pC*Ba5v`~W^Fb} zgwOc0p9vzK86Hp(296M^9OYYB_P3~9T4t#pR$M~;aJpbCTBfZLN`BQF+(1qTlADD! zVpUipMA^_A*pAF0gifjQZ77!8!UNXvfZPPlY--GF=hy4n)A0IOW*HaQTxEb>FP($H zVU=%Z3T+P`ny|7SG!|4<(MKgH$QL^D5EX4CT8q}Bgfzc!ta(6fb)JzV&*#X^trAoOfuTrBh` z4?>UfmO_sUg3z<3TP*Y_pT%CBZG09BJ<5a7vj-eo=y7cjdiE@%ux=81ln0?lxs>#U zLXYww^eA5>^e7BM&njOm^eC@6z02&w(8%TVt_eNLbEmhd5GT}4NX+H6>6ENZC)7>! zap)!+Bg?bt8JbNWD#q0VolE4dw5^kISF*{$1g}lXBzoOs5P^o0lu_51V=&*Ue9Euz zQ!1DHq#TU$W}DB9^3&LuOoT4*r-&rP7=&jqug`=BCX1f2MBV=k+1muu&M&sEo3= z!6z~h~7fDZ&=kZDpjL=Ljvmt;zWX-8&6dAm516N@u8rsAo= zr6$IiDmCCzlf4l0Vi_ZbNk!^}qjI^=MCYS6f9~|zr;3GO1GBfC|#OCTT+;$jb4zDt{ z2=-wF^1J(oWYv`|f?QR$ZNg%!OeXzy!5S_Qz}jJqFhsi8m)44t+enyRsvie1O>h`u zCUwXh|1u7kZ(q*j-oT$5jQ0)`uXr7b?uS|Em{nV*&mzB(5zGNYu7) z=23d>&-l$!)}%u)IA8N5r(o>Z=@2{s)#O94*xgwyj0H%}kvb$G!*S4Kd%PI;SWyYp z31W|Dw`cs?CAu#|J6blN^TQi;(!B>B4?aBCV&PhGpnDdswSoWXBK;wn}$srFRvLe9}U~hLEw9C zGZR(fK5M`c;S9Jy#(0cV;q@>M+v}B$znjsI^c6pv4L5u2w7q*ZF(}YCp;8Q3+`*jWkfZJCQOC$@&>vtrPx`umkyYm{#=pNy5r}sEBcFX{KsdmSHTb>U;}`eZTQ zc)$fD|FxP-$g;Y(nJIR$w`>`&Ea8~j zS-jFt2N)&zS$7t%hL}n>Rl~({Uvtr}P`H;7T-)g(Wz#BiG_wtNAxbqTf1=!*jcG=( z?H1h)o?p!`oo5>{yutZC){C0UerNH;zI~$j;$$qnTgc=bbimYHG zS9caK(A5`!TjT1++#{$n6S{g*S35*kJNud9%XIb2019)pIkB@)Eu1dXx_U-e3%iD! zcxUkyy80E#R$Xn5Y!MV%Bo`8otCjp?9D6c{N#!k#WGZLe%Ah@v(nIx>C7M|uEyfce zz^w^1RY$ssZ%|+X8mSI=qdEqW;qTP!CMe2W2xdTHgy4&T;$HnMV2Hp2Z!_?KyL%HK z4J=IEHs!vtfqgpoJVyp}t`)F=gBCtxkwQ2qngfv|Wv(YJ04XroIK2f*WM30{z$V#h zO**a~VG%3|FMgKJ2CSPbR{?+pt%annpJyEeF()QYfCPHK^_r7*!G=YfI`DLVy@v8G zzg_?cQGZ^(9-8GsVm``w#S!#S%+;sVZ%>{;zXi~TyL@wFzrAHJ>o+nT z^M|Mnv8v>#DGRo2bb$l5Yz9z>Zh zvT~S?N77W!s-e|@vi`Xg`K-U(T>6%K??91_Q0EZWzVxCVFnFHzrbJ%TP^&7Btn!rF zRQZ*54+1~DPD=(4av-Sw-(Ru`I#(dy@ zRb_ctYoF}jk+Mpb?qcB?GrZ8PPT3MX?+telzVn(G*;nE3%I@gqB2w0(Y`_=$ zkz`cgI!0LyFCYlcn>TV*UF}B-6<9d#fb74B3~FmYz1>hOY?GqDC=USRhk?C=dTieY z*p&Ms_ZrM2S{u+xq@Y`@w$xXn*d|0-Mgqg0dTINetW6+H_o3>uBSXBeydhb1qiDDeObKy8jH8rtd94htuvdgdhlzqK`1<%rC}EbG~_+u%!jj))T6%_ zGjj-iFy!7o$Qq($#Ix`h>*%%3?z$xL*+V?fu(d4Fp+uttNpuenCd1+8P&g6_N3rCL zQB`Ppwqv92yEKHYJvxvHmT^4E6&V7bM6T{TD^(=)JqN%V>BHYVoNvFjf-)xN$-Qee zvDo}t57L&(@$t-l1vPOb)2}b@XOeWXu60UkISyE?`Z+KMc5y%y?BT#X+{=Mkc@~{u z>Ew1tJLw0@#;ZRyu~77sWZf}uI>Wr_@dd_wuX`^DRlOXCCG=zT9sV%j*y$85TsQmQG zCujx>z-M!{4jAGWH$bw`9k$MzO`TYpRMQ)*{t{Xmbw!D%0Naud?5XLmuvw?fCy6c@ zp=+bu?o>f$YGg#oFgLIpt5Sw#jF#1K9?>D}w%BInhAQ5ACfbQ=DY0-ohki1QLHE8L^hF8b7lnuli)nd< zI>3TnEL@lAGu_+uv0`C+Fn2KCSU6ew5qq_;73t{oPIr3M!?z3K-9{`~2eMB)s}A>* z(~x)tx&s^WJbkdj{d8?2@NTycp-0@^vpZtxo{8FWGcm8ZGBY|vboYNvM0b%M{2ukw zFR~fCpKodkW1*J*-BC%GK}bTUt(m7+*6LyF_+^0kF))u*#9**HVyMhS?a78PFa3sW zR$i<6F;6jxVtNITHKhE!|0dOXr3!)9BrHC9ctWiv0Oy$(SSe}`mw9(&J|PX99^N>4YqlHoUL; zcOVc67E|y^hvt{}|AQ%p(Lyf5#Qi6BTs=;Z-W+7;-cZ#u%FHwl-Apm_E^8&jSZnb( zM0ZLwNpmoh1?vQtV&d0fgh>bdCTJSCo-I_xWT&Bhr3zkOEKCKZ{a~Sm(0e%=lGGH! zyV%f50en^JrLkw)gKu+RwP7-X9?4Yp*!>1rxGcjkwt3Wtvil19vwEys2f$G@DXMF> zrSd)41wUt3^wW!6!IDKQtm2B`*u>}Q+_z23?WR+?qRgUIG#fkzj7-zTz3IY)UhbFU zCKnNbJ9H0L_*4rP>{@3BUIGN!P`08-4aA=*HLxgK`77y(a1)D|1Qh)xag|VvcJT@h zblZhGqwC(mRw1bP9HjXbrTP5<2m0n>H1Uf2l$OOVz*HmrTGK)Z0Cew4_;s9LYk?~h z?ibrrdZVuHtD~OYNp<6?o>Z6Pcv07%+)4Gez7~_}8&CVB`paTrBItnZuNLcoL&d!{ z<^1RNGAQIsVXWucjRo~@UlT;YWSHV8)k-Do6da_4qYj#VR@`&!P22~zvL_~xId@Mn zqnvvy>Y2NIQhSNITCOq04L_6FqF1t#ImKpbAG98dOb-THrpSQSdgg_6|<--bhNGRW8Hl2EWb67!QD2+H`jUK0FIvSJ~AcU`wT8TV=me0cWNNM zK}jTwEkYDVqS{=E++%EHC1Beb0p@AiAM|VbnSRhxGe~FHW{EBkCnMuvUyG<#n@8-3 zMBkUYdl~+QP}{)Ih8`T)kT*y^6et z&4W525!)c=%`z&y1y-Q}R4)TsXtYQ4N}(>n&O?G7NX%+?QO-NmfNqM}wjx?01Xhfg zGO|qHcOKnxK=wPo`XUfb+MXhnY>B?dPss(CLY#zS%1;l%v5u=YOuX36(;E|I<5E$Q-ukHPZXVBiIjg2w#H(ChNcnG^7QwYq|dNl>1t#G-L41RA$$!;(U`t!BBo z4o|j>T^U;j{oJ3aS<>5b&J0H37YtrerZ>4>QqCN7nh6;1f_59MvpIS~nzcs8RJ(eVr~QJ=w@NH-PnG7U#qi1t@H=s`mSc5|ScWN|h7 zD(eXoDs&Oe6s1oV=2sS@f{+3o>5sl5f6xFTJhD`R=?@!zU_N)G4`)AgB)UOH3JAAs zyrU>|q`T(iVEPB1p|d-q`ri-mH$|c3%+gN2yCc2tt9srAx|D)FRH!NfY_9`1kVb@l zEA!W0`)h!|cJT|tZjGOqWT>HtlS)mU%>s@FNU3wpH z_D$MIe;@Vz^EbZnm~ZTPyBFJgF74glsHoFIScGO<%q|TI8c0IP{O|r-)6)^fxJO z>_b(Ca2Zl(xz7SFu);y^BG09|32_BTeIKxfh)yYFX4B2SBD1O2YBU%YAwNQU8~dFf z-v>NFiZ08{ysXxKQf-Y%Zgo=&8{0uzrkRU%49)83t`(h60(J#@DFJ=Ye@DgSTo(IXPvbH%d1wZt+RrH6l zd`K?`Lv`;qmZY*AORvB>@f|GRoIzi5VYtMHvXSs()%R)U>9&7L}yR<>Ug#sH)ZGFGM(E`g2h_-2$zRZaRlf&h)g*)r}lSRU_B2 zg~;Q3coTe&ni(r}5Wf$`HYC=!)hXs9KOeQBhd+Bn-?LI`oAlCJP@CL(fPw_!g15&~ zuB&_&(IuZys6#1qjaM>H4GWW`d%T?9`L4qedmo;I8{+3U-1XT&X4MG7^kUCGivxPW zUhN(XI$PU~x-X6~gNEFL>sj;fQ%(5B5pEkv4E$;>^xhpxkZ^5U(|0gg%mJ>=sy0Nh zOlBJ*B6@l1HX1t%4H;9rD|kMS=+#?I_;G1=##v?>o!QcmWYg|7!)pB*s?6Ca%x>eQ zP5&nI2Oa4%G^TFpx*qd=Sca5lY| zEt+iEG-pj<7~c6#e4l=W*%MT{&rKMhz4D-BTOV_YrAEWPBxj9#rCF`_>3k6CfXAcz@!60K17T#3+f`p6@6!BBe74>@d1zpuGPXE56ys_@J@|CxKx zG~{mDo*D%xHT#aVBF(yRCOw@q*>zBx^)$|gf^I!P|8VC}GD0_D?kR=dGMlxj8gtrs z{f>3hmzUa22M^t$Zn{#3jY6g#t(%TKW8L)AxX^KcA!>V2A4@AK_&6=VHdkh^bMQZl z^J)1KCXUQ#w)fG@Dem>qunBSiZ`w>$sPH#4Mt?_@g74gC)pVZMgNcp%x)WH#eEDqf z=SA*Df~^3T&Y^T(559NpaSK){&)3tTibI*CF77Reqz&2%-*vX27N|Eu+AXS87K|Qt z@ZaB#&O*if`91yFt}g;HqFpqv4-zn;Mtv^dz#bgLnP$33h@(oJ4qTiL{Le~H8VO6d zB5Bhc6QGIL>`9-DXp4(=Y2gofK`?eWT(ks(&@1Q`@Ofzgx>6pfw-pm|`rv(cMCnv| z=o>kVj!Wjd4i)3c69b4`8S_!>Y%UCkV*o@XY_kyg+ER2P0FfCq1PlLM01yEcVuH+2 zbAlphA>M*KGi04ZimeW67-ngcU|NVb_yOCiBZdYkADlx8SgS)8Pq-E3%aC^iOa}Ho z8RsU8zHN3gWC+@UOwR`uK~mqsOVqdzuFCw_3=P}MoZSpWaPI*X657n5AdQ|i&vJ5^ z5Q`a92fd)#Uc*Mk7)woC2obNQpb3-%7{sj1`pQn07mHS69guRyL19W*Z=`kGR`RUW zGhJ9>%t)l5s z(0Qh;LSVwrH}yC7iz0bi**|MNuoU&T0i81z6vrrliOQz`ntKdzlhEwVV{NDPD2P45L~tF4wl+bmK+#er9X7huo>21~5fWTQ8hlx143RD*@$-g4Y{t z1_uCVojIs9(hG0(U17Wl1cx&~y%FhvwyYO60zNf%#4=wL3E$3C=Cis-fRUWL0{ohM z8q6}b4OFGw$g!q@;-CR|Xc`Q$22>gKI5V?R@3XMyjk#`{u#8*Sv(Lhw^@<}N)ETohprZN{lb;r>e7 zNW|^!jNoV{Dj^U#fCkVx?@>Wriz=OIiC7(7CiQI~eeeBX=v3E&#%%z98Tw~N=)NSdyIXf|Gek6H$A|6nL2uDF&IfMwr@=WA+ zN4sC-yuE8Tw-v>0)geOdSc<3~C$C$&l+r7O_C)9dvO zEHbFtp)QcLaogc&j*g4EUajS%EkqYFx6JZo(M8&|pX0H!NY}IgqjEUw zMiw*%0tGp@1>HD{>^C)8t0rsjVr=0q<_o-)Io?_TwuN~@wqg}C$*%cwj65MCpA#{& zkx#Bis%@aE+J=1>3q=F>q-1lE`iprCaBX@1&3jgnv?^fgB2HZLMtwWUR~IT;FTmGzG-*Q^tgWxzbO zaWSM#*s7e3#s8ibz>SRsOYLlZsx$PM7KYq2v0CJHnCA*`QiYA}} zL3P*YZ8Fa?9kPyH2=1DFO&s-psHY$;%=~Cs(k^@cCXARh9z3(iS3|uC1r?8Tb1pH^ zjC#bgn16p`ZYJ}i^Yn*VCUJL{l-+BbH_R=QluYoVR zkhP#SX0b(5uyLAB3!^P6In4dD=DpoPUtsQ=Wo9rp+$UrUa9ZDGOk`G{RR!urB3z)_G~(k-#ZxYz4K9&;7~y}rZNpN*UKj2pxF5ss*3)KE6U zx@#lJ{}|$R|8%XsZaS6vq#Gd9u+@Cm0PUp&l#PZ>uo{cu8f0uz(24uE#rzrH+a zjeqq?ogs@i^O_lqOjEKnuxZ{F^Mp8Yy?3^qmpP0^Cst%%X3EE>*}x&M-NOmbjtpJ# zlxD}HPs{9B?t+Y{b14Gq7f(wU9Ln&^vGlLS3kA?Bv)HHKy7~?lawfSg4;BT$Qrza= ziW-8dp%-j1%C#ovDO6l^(umhJA}o|G+YkCV!||y74bF&uD>BGVpg;$S`8s%!yhJ3Np=u zYf%hz73GPjX6@7D=!Lenn{p0fucds#cl!yI3ll~nQYlXb9Tb>B`6T^8EHVOz9+{;_ z8ZspG`F{7F5+w>)<62WjRF@EyQJ`SL=Mji(DWAseIIVI|R|N_td?H}O2nNvoGe9hj z8+3q;2<$N0kFUuC)+pb?#>2QlMIadbkCfwvOuVJK+)8I=^wA2ev9*1T4lDwyf7TD9 zqVarN1#m&u?1Im=R{xvdidKIzhIGs}2*vbZtGLX^V}@nTwqa~6$BoN;g6&C*xXdrG zGm#9ttB~GxoVd&>9Ogz<=23E5#AQyS@?=zHE#oq080HyMS^^Hh=b8G3=jf!shzlidO&67?Wz|=w{WmjaD6=h-BEojKMIm3)kr*tAo^$zbSS% z&uHuA?j2@@#jc{wEd~&@9E1}t?*_fb6Q%0@ZStU+t59{cr6ONqZqK&trdzO1XA;Bk)ml-_o`*+H+Dpxzt&~x1bwi%a*Ps@g z40*Y9;pLBQ$g3u!+#J?O)Qs^3menesU@(Gl9f0TPMW+0O@|#2!IXunn(`J;AtU=f> zx&8m?skHy?W}i|A2zm&PcX0>EjQTs*0Vgs69(^hu@L!fEK&uIGBJKZ+r_%oaZMprQ zYWsibskHx#mfQcSw*O;KrTt&B-2ScF|3ntxd!9=B-^Gq?Sp$-3=Qr1Y9)2nv@L^1H zGm$i)_-GoC;%3l*c1OQUD(H!g!PUEff{XHC>Y-fGuDuH=xF`>s zG0KI9>|H>?MfofiO|w{vsH09F*972xDkG6B)D8JV?Y3?r#NL=Md+ngE3`^Pn# zatj9}JK>W1^>$i-_=kE<KxYu>RHKB3^?q`hTpzaOjt@25Bx(0-=Hh32CC$3Xr zusGYxSyD+Mya;VEe7DM{L9Aw`I?Es_gbNH#HK5lFzQN2?w~0ozo$@*zXm{Peg$USe zP6*S@hlpg0E_Yn%@^YHwcULpj%SY&D@;q8^}*b{7#iB$5g{3Y-~|&t z`NT0J+?B|at5o98XY_)P3AX!gd2p3w)3&zAZ)?|Ljpm)o>--1u&gwO{G0Zby`mwVZ zD_Wa?lMEjZg9G6uHfni=W=xQ9kY+y!uK+VleRPhv@5PKu=tG#aR5He&HCtrW{j`Tp zFUntH^a|Z{G3;cryx_duL7x`QhM==u^k7jrd2HW`mCh@m#5%k*327(oo0nvvn?%-S=>8yOO1TEqYG z80cJl^oY1=2D`#+Lk@OdIJar|8>FODUhdH5?mq?6Papk@+r?K3B`~q!J?VWq4e=!1 z2$|jxz$@F1A>jv@8FkWvBv{t!NX4969Xpy@Me$b_L<$5Y3zx4$6lu>PcV!22tI3mC zqESsuG~}HXN5Rp-ah_?B`<;@^rdC7y$eVZ!n;I=PO*xZ6k$;w8QK-e{@VDNsAI0&S z1MAiDMYBa}CL7LtQsh!Ft6Z84oheuqL-tP*HPJ+I zmL(C#_+>OQAP-^KilS0ZK<)U;Sq>36up;vbAX42&Ky2$dKt5DzvRIGfN0vxEMS<62 zm(%F*r3g7!WXi2}7lhlaZm1GHp>UT=9_cm%^jt0pr02qk=w~iZw$R{pq$P^Wmfo&k z#t`cnzi6w7LmtMQE73CMy><r_qh+t3PKWxR{{AC;5-~+Ym6u-{#xTPJ{}~`P+i5 zv6(^mNBX}Q`5BKMVQuF@5n(JwzHeUb5dz-t`BNqcUr984Lj32!D>wxqO=l_=ZC#iz zd+EDgBW+_;5e=&D2x9+ix}%rA*!00<%bCwd!fx?fFGVGZ{OqA*8_%;isd>7?hv!{; zDG#83@Jl7haC)VlhwGIwU!hw@Lp(g;f^^%NPYR~C&7XE@0)N2u$ry9Xx@L|^P^DSN z$PsX(Dj-e`c-2TUm0qh;oauDMq=&M=>bs&AW_T3NsA-05-EEF>|6b;>%=bi68)Siw zF}#Ag%xTjO_m74RP#_yubkhSCgCh_GIAO$ua8J0;Ur?vfi}%)u^sF=k7f2EjX}F66 z)_%pVaJDy`oh6)I76UIFq@AszRck9jzv!se@QblY%uDC7b_NFZ)>*}M7sOx$0zu(6 zK2$yuDzDOCnJOpPJNdMw4Kejh8`2VCoGW4VN^krnjUBiRhKMG; zTBi%S4dh4H1M6DPiTB1gi^uDYkd5J)=#BocUSz$|U&mgVGJ5ph`15*i2*CKP>5bpb zrQoB#;ZpGbo{Xgc-)@bP|It=Zs+TfAa5layUk-9G51||Go)*zGAgZ!JTVkMX64dtr zmVSB)r8G;dwvs;$z=P8(0C3`<0&o37_i+Yk3`I8m|Mf;usDpm_hrnfW464F1$ElJGcc!)bDM>5 zl!UFaa2bPJnbVP#0z&=EiiKfCUkZC3Jh%JhvZb&?s8kY9DGh?>fP;6M1IY7P4glnL zq*2&)?T!W!wYJ6OPo7zDKNHxwBgBZ1J4yr$5j27icd{gOYXj6nDWs~;msSIQDlF0B zrhy3j^<@2#(kgwlLzcGHI@2Oe(qb*r>~;AOP?qBD8zFAQ!rr|(hdf)hgE%A8k{(5- zt?;TKW|7{APxqnr{B;K@hSa2+TJ^q$qCz#sqmAiAzZhAadv6=E-V$r|r~OEIl55$P z*OaT+y?3K7?nmD9ZqQEi)^Il%+bVA|3jEGAezOb+6gN&oS9-f1jSFoDe3W)wjOq!_ znKh`$zml4z$Up8ariDv3vQ^e7f|pWhkb+ibe5(4rLTr?*PE@NbWQs7CSrY8RHyg|LC0tFQfR4Vel zKHk@ZfraA7AK_~mG;p@!=VC&?xU0LI-^q^yoCHXOP!}_i}@dAcTy$7U+j2gU)Qy ztl2!foBA8eP5n%b>TmxxHT4^_g|jGP5Hm_PL825##)`Qoz3=etT3FjzRj~@l25-M$ zA`U`B#(DGk86L_QH^O>J^qFG4R%m;{PF9CSoJ9wa7Q{MSRM)q&SO?!P=`3|glxDmL z5G@75z}qiFp-4Z-rglCDjASoHNm=V|Qv9j0eY_+rzD5B;P#pp}%bGX9pCL<715)bF z+xbAYx-5np5O`fcFgLq5bs~S)xf{16o;op}y)+yy(DN@y63%$HS8(9nE(~Wc3uiCa zB`;$I~2O?_Hv1F*A)m$pY|vs8O+K@PKIh*ceL3 zUCv$F6}VOc#V&caEO#iEUMXBoDrI|JrL0J1n^i2xbTzbbvS4tqkU9-GyX7&g+Wx?hc}u49m?+SVOi z40WS1y+IYba)Xa-$Q?4uDTQHU%obxVtj4f!y%j5v&S8Aga%?uCV6awNq?{hr$e%{g zm})wbG$xst>&BwsSPvY-F*?fPNJSaFSsg5-9a0YV)vOjlNqQmL(E+q0zzY{)OH=A8 z6utR8KH5IATf2I_tFn#eu3HQ?J?FM^u&}*dojxY71b+5lsZXEKX&@O^Yr(4pb|1T$ zdjc~6+K!diwH;$VjnrxQ@dY?F`4QK<@Er9RMKx?{HJX2g8n>j^s7AsR z@%WGu2QFyU_{F$zM&LPf4XrODTNGNJ=GSMS8EZ(jr_xZ(ktiZfV{&8{VJ&|iZd~%# z^KT_O>B@PAv~<$m!Fp5g$9!N|kk!IFF!D zT9TU0qcP9O+sF=M^I*Lp_tTIAhFG9xd{o}=PewgXDuVv$dP}B-D~f8&|KxpQ-oW#c zX?_ZMf~G^Bpc(pQ>tIsL5VRk^R@Hbgsdx^!elrn&=E|m6!+J2?XZ7 z%k6oR+w;$qY#($tr ziqp?=R7%D;?S?W%9##ZSx@Rs$!eDMZGv0|YIZh87mvYrE6ko91eFc86&bgb#9VS;D zwMS(8)D+iK+oChy@U8Fu`HydT)BU#`_^$|^+B5Gu3D1NKLr?0q*CjnD9Lb+WSLP{D zEAuV+nJ?Ohc|9He7x^}0V{q0-^B&GVqDJ=|pIHnaeCSvooD^lj3>+}UE}&-a? zzQDwQ*f=Nbm(OS8S~E{7(9;;MYNTN@GZ^TsZkv=y6VsdEHi-F<8m69Y6ItTiTeL_t zMptoR28o(MjAZVO8v7w$adGw=vMdj|D(+>^X-0(1l}e3`F;>W%jqXl@OSNEc(nw;w zZOQ;a;z=fOvu0a&pP!Ijn`?I@W*XRq1Sg}WoWhWaif!Yt#8GY&K%nEXB?Rrq-6|NT zpdr`GTa*vd^88IwP~X6QI}UTe*%Sz`q)Ct-G#h)I((IZA2c2@yLPwH5f1a{G+#SJH z$65O&>0zC910UAl<=!wkJm4W2?6Fw$UPbqg6;_}g=M-Z$h9UjJ3DiOW!@|ux=^&YL zHOT9af&(@@Du4D$`=R@i1uwJelC)z!eKfpJiT9!X8tbXucEm1OSgWG&%!r@8I-gL+ z0&lZ%zc0Kfd9l1WVNQofzg^<7it5v_Vj? z*t;ikKK*w6*}=d8by9QY0dZjj&oF|sVQ7n@!t?PlS$ICL5tc@caG;rLT}Z3wJXRrVz*-VF2S4tKJGmRUg;GJ(|s2*rSZEG95v zQ#S@|s@I_wLpWwcNlNyD1@;RenUnHM3c&6C82z`OfYL?GU*_#yN9Ws9-pOtigB;U4W42iy{afKR0 zqm0DP5`EWrQ*4pQ2qlOzKt5Z_2KV_+gf(dzsLhB{HX^Dw1!+GRT%2M_84TKo5ey}; zq)=O6Nnryhrscta+TNrC+aQ$(mJ~i|&|TJt2p@G{8AlNrbN9_8QlC{_ZKi=E* zZ!Oi0xTV5zE((XK19G^Z=rSH?dRwa^*B)0Dky_fIf3#9{7N{1#sfuC>Q_z%-s&4%C ziK!c1KUC<9;i=nX5;0Y|j&Wf>a+Wu6%Q+m-+zn1h;0y@@Ye5?;5|9*O%y#97A$&o> zqi+o5X&pR|sSEF#7iJQROy>qp%C zXa{YHfIG-AA*3}45iq(4RAgqR32vLnKt;V>P*7K7=qNGb&9rCCmF9;-ea6uxL=pUu zaze;!Mx!g4hPmT_^-yoYeY=RpXQ4}QDatC+$V*+H3w#?|ZwxA(jZE1Zpz1 zGG6NTRT??tKkmqN=S9?48hc71iZK<#6qY7MhmrCyPe74z9Cznn5QiK;I>)gf-wlxi zvOL))aVxgHj7@YvX1>PoBfY^Ofdjy?WNR~woFQ$KO$@0z`#s~>#PTc_zl=Y$!k=`8Tn4vJ*hzkeAp_{>JNj|g@XFqrt8N7qbFNP4SB^Sp_jZXr1`dBvYOz2NWqR4 zj8Rf&ERfxd?DJ`I6Vr1@XADiqzPDJssfCsuHyK1%VRh z@r;y*ct-A*rMoX6_~SgDk@67FNVzudeIcGP&f^&=5AlqYYx!&sfl3udc|>^5u=|&G z>a9y;8{dCp@uYRwggga5hzpxEq+3Z48W>}kRz;fDeQ9e@Rm`5MR;S6ydGaE-lbVTy zMU%?)?@totfj80eT0=j|zPBe-sHw>rQ&ZKS19DYLT+fBUNFw6GHt8+kft0?)@lnow z6}ydlUlNRf!G^nv4_~#PWfIaQd5YTnYN-}>HWJRN)NMJyFRXWyfsCeA_q0hM?iEoJ zZzAg;XE{cRd$FVXfeTT7`T}km0c8?Zu}?x7TM#Nr&rft>E9ZXttAMZUjaxNn>sCWG z_irGwU)y(dk^Nbqr&64jMYcrtKa!wkp~(IX8vMFrtdU$i#77`xL}#CVp+KtICT*y{lS@NKE)Hvo)qQbxJbmFY!Ny}_9V14O^rp_ zlLo>YWZ9F1NHc|yNlm>q|AA#s+M_D=AR@BtNn(*Fu++Q<1SKn0-_=iNS*83K1ag{kC0{cbK~bRJ4SQo&&jPN5YxB{+vxC_dv~QXQMo|)VP^H zDC~diahEL|5>W1tLX1;>hGFFydK@VKW zGdu3P15fQN;yMdcY2=wDonC;M3$w5yWV+__4PzKq)>S#oyq|L8$0PpDc*X<3d`(zc z2Wa{gK|iDitl3pQg}c{QRw*tk!bX&Yt(Nja<3&V!qSOJQHapmylE+)qG?SXmuASQ6cO{Xf+<7vPaQEYHC7eEwQEEFgYkWWtMDfWUK;N`oexT<)-s% z+Od^sOkWt*dFcq~ALs}&IFQd!28WegO}Lf2byYye_R_!gK!3WWH%m$=9}RbOo8p1S zA*F`AY`d5+(j#hwk81^vWq&Df>_7m=257C68=1TX!@?CneH)5N!YxZdA7Cs?aQsM&H6Ju)<3n}>ZhR9?^tg2Q_$+4UT*bM z(CT+CxB4k)_1l(P{S>tNCzf0N6tw!`V`M;MK%|m0JL?bS(CPPGJei9CwR+pnB>wu6zMydb^gJc)5vd zpsMHWDE^v!m94F>%#Q_TLX40#u8wL8Ga==*WM968nUL~Yvaf*_WF4(g33?&=AcUQrJlq3NZVJwF- zJqoKvVAvcMz#J4Ifv^REV00e%a7GbQfe2TI?c3u*`G5@m0JeL@@`7VQCiN)g&;4m} zz9Irdic7}ig4clryv4ovo`I`GVAp*+fOf=mkpqz%Z2;H-+u-o?rTvwT^i}f}42T4m zP(=YU#Y!i2swyn*=k!3Jk`^zn0GpUkV*cjp6(GXIi{sn(>sQj@X*JLzA!YILC0Z7u z3d_R9e<*=ju*-cL2Y70VJRLAS;$O8#zB4J4x)m+=b8|mq?bQ%VpU=#rrV?La_ z`Qq$L3;I(0;7wl|b$wqXs>Vjp%EW3YD1(Ze<=!!Yk+x0t@pEM3?8o`2^(@DW== zyn;FWCeTs~{IR}3s9ZG>`GXl#ai6F6>1{xV5QhiRWcr{^4XTi8&Jk7S$2@Qx_sbG@ z)`K-z&xjv#iUItl{4g0`DmO3ifzj3$(HL9@ob3sK6e$s`tE~L;EYsi;3(_8Z=e`9Y zj=tN*xq6_-M_?HKX#L9zYRt z@Z=qIM9G}!^m?P_5MWwk=m(i^A`jT3$AV`@omop>ByZT-fN3b?m8oFJ zS@}Xq8>@yH4a@|^=py9Efs2@@PyYH>e>69b#If)i6|}3MJuCRb^dL37avrgQ3MB%m z@(WEG@nHVY^YIZrygd@~loRn@aoEpjKw2Th8os8(UIJI1eM`qa>ckmh-vXyq+$|x8 zW-1CRJ{yV2y&a10L5-77k?@nK>wb+^BXVy->G=})Nb?#BZ?|Ciq9oH*`GTCtf`R0nyg_3YqDirh+cDs7jjq=2 zM-2>K(hmNn4bfW?n~pi!OGzdDfEv~!p}~bEV8{MQZP%<0d?k*3?u(_>7c?v`6cE#L z^Hy{yC&LSy88Cs&e_hfm#WwWG?V5 z$Lbj4)_mvkeMdpOnhPB6UcJ;fs~nug@(%Y?Zfcjgz!l#`d6jW%6m9Z-XAW9(f#Wz- z`2-GHqiB=wJ9E&Q3tZIUl!wilsdf4GjQ0!F;VKW?GRkQ=8`X34K_V@S@mf9lvPH8l zVn+BRXbAJd>Ojs~CeH%)-LD%oLX<^Z0c84vzkF0+0O!}h(MElZ7VvfVJwI#4B(2n#Pbjv zm*%zBXw6*E^TTYx8)$ zCytX`4Acn|7fyCVmlIInhb6O)0?8O*u`rjhqdJ7+SPu>pD)0T3p6a zTC{1EYRDwgxJr$&&(9Rema9~QeXHdvRRw&Tfn3%w*@*QHWatLvZveS0$|Rzft3ml2 za#OEU*iK%H8W1Z}SC6z> z{4>~}SXp10o;FP1VkwP2pX2y5Vvly|q`<_9zr;5f|shtt)HU`ywY)mu$_8Nns zc3rmM*^ooeV4;9PvSBL<-S2fsDJ48$3wb@;(gMqL0}ubcjLHNq9jHv=y?(P*I#Cp4 zhx_)joM8IcS$r`E^oR?>nIs=)RoM-YaCJfGj_@wha^U@$C@Peal}Gs%O42g;HhyK$ z>Y&}K@I&NFfHg)c2<=zlLbJpSO9eO*$D4wcpk0NAtk=$?%wB-I#6|=XTw6(YBQkgs z#IB7aYLs@aY(AtVNDGKEek7sBW#}e$=PVA~`%;WEP%eLv@Giyiuze+thi@YDL1r8P zf%T~YUzVobr-RT|Fvo~0u`CefOTyVX;p}`}at_;84(FRrHNt1FCY}AeN*j0tyUI*F zxPudD3tgBD)&b{+$7dfLK3U3&`D7^G>xXP#?cUiPA|EngYOn2h8lT+Hfluc3^vOdU z_+-yxHuGnV9AXm@5%(MIV}+md_VryEj_}z$d>?vdhwr7#pOZFxf0D&A9EEUmkGBZF zy&UMmvrzv&Gakmcrm|E6;`@Zw>}0E5bRQ;1nNWd5kO(7aVIzUAbA`qrds={ns~F4e zLK0qJpzl0qnY-8S8e&v)GwFgDA$?qkg9Z|1OIi29RGoRNAe3K8qp4h{ecXH^C{ zYR$s2CWK)5ZuhsFlC?5^a={LUGqHcnsq~s7he_PRG_rs{%lV|_S?(7`<0)$l*Na5l zg8ZgA5X+`SJp2XW>NKL!Vi)+)suui^JEn8MvCIV^kxgcJ?x~}W?~e=B5I{1!FanL) z?lG+~Z8X=3vh?k9#Aa*Tl|wdZUD2|~?)DOw7+h0kL%^Am0cQR)aHiNZ#NidYFKwn# z+hobYAgJAk5XdR5&5xTfnmcSX-wE^ zH*3iRkE=(m-W$hlCXCbB{gom#CF6m9-A89$`Nin}V=ao3vWz~PcFxIm-Il&; zjwW&aecD0kh5N&G z3$7?pDZLw=`Q+{QZ~bprEy@YE$!-UWJ#SIxO<`J9XEd+ji9YsfBvl z(iLKsX{rOuRnxm_#AX*j`p!ez(%CsI{2?Ix;al&B(!7Sblr?d`yGaBtMXr)Pivah0 zlUtBsfhh98M^F1=cw>cA4uMkIVJ0&($<8MowOQDqM)z&=3}DD#LO59`e+Di!P~9CH<8d4WtQC)!U2u-MW&CH8bd8d@c~vZh>R|3N+93|0%_cp z-{T<$Cr*=OFug|4#0bDVhBggCmWL{|O5|?XmTb}}Q6y5)Zw~ayoc$Ek^{o@+twxN3g8%ShZC#HNE5W(dn4#-Id0voC2(sKzda+%4ZeZi#}LwKNGaB7v5a-=ASePiq9-jP<%Wz@z2J8=LN+lo~|bT=yDUYH(pJ8kB>cFO?=C86K73)%hT1w zw?5mN_>?VoAAh=<_!G-boQ>j79=D0_{)gKe_2T=NxZGVfYI^b4o;7+g*~?Fj()Ow2 zHt{w0H8t^UFLQb+OImPc_WC=MUDiEsRQQxh+B z1O4gH#LF9Kcl*=T#J4@$n)sB-;yaGp#2@(UJARYp?yJu>L2=4tF`0FR8$6zJbIvF0sB#@u;uGfiSR3Vfx-t*r5vgTSQYGYRtNCb;}o$oiMYzk&iLRE5dqkHmw{3<$Z#8bO{y|gQUaQkqZTrNcwtYmGF1PJ5+V=AwqK}R{4O1R;$ z7ZV?zNiiPFXO9yNmr*@ZZAA!>P!e(;Wyou3~2L7 zmBy)pa07<6EM}X;?BTy{8m@QgwAFBZa?xhBf}*X6ctYTE}s)YP^|blR$I54J5- z4?ghW<+eSx>UHzYO>KLtPFuC@s~5HHp^q%L?XlbT;oF+p_CcMtYTMT=YTH{6FSqTn z+xEe`o7(nUI&Iaqmo94C8^5sJw#RPUYaVQB+jr}@>)xd@)xdwTs&JVO_f1w#R7OZ@syxZ6DETtF}F~sBLd~%W~Tudo4S7LsQ!x(rK%v&docfWvRhffzdF;62bJn>B6dX)9~QJiw6MbHEL>#{IJ9Db#JSSr4z5!CJtX2a zRJ1NMqMJODRZ!DUV&BlCLtsx^NI(L|iu-e8$mzy1OF4-HAs#p8a0_9@CTqd{ZCR8K z@czx%V1Wa>%Sx%I1xbWtDFTyGZX`yfW|H-zq;P$;E~>|(0F{n>yPtBGx2xqyo8qVE z;0T(LQSA$HVO+NG7O-A|DTH{%>MX=7XM)Ibm!L*{SzV_`#9F& zvimDbt3VS6oGs}RJP}u9S{J)ed7;gw$GyF3!9fN0I!B?nZ)%Br`rOUKobyz|+H@ER z4`0QFd1@;7a4gD#hR0U2j(-FQdT5>213_Q!-bFI{^Z+eQRK-QKv^a%^{Kkw^2y+Vd zB+JS$2b#K^Bs7-A33-wUd~_|1T@qlopQqIEy0kgjrlthqB}OI71Fh!#>tdlqbEYBP zv-ohLN;DHG&J|-maW0vStC$uyDT%2QR|J=O3_>;5@S`701~wyzv_`UKXztM zktz|;K6#QlsKUL#j*$a2())ekGHq5&&-oO2`qvM6)$9=HS zl#n~#Yc@z4%*|T}lNZ5Hbb8Dy6KD9HQWAB;AjCIC3Gb8?i+dGgIF~*d&84&H{rZkx zXv~O!f;2?|O?1lvnnAyxhqPjpU6SxoSnnt~sBTGLP0DL(PYdZ0g1J&9;iN{&XqKV{ zK1HP2JnBPtK3&g@c_y#HOcRY!)8DaP4~ZLfeO7^3mT^0li>V$GAc0Y3BAIblq;2iN zj;kQW1%xfe?J!9IVP;~jWpyoNge_|Bl~9ZjbR~0bqiCS6M(Zs>DO@{+c+SkMwUl0Y zP>SlZ#DJkLgZ*2aWirS#Hi&Sz{a<7jaw2CfY*_b`g^O=MwQvnaUM%*%a2pi;dBOS^UDH z7SxB0BU42SRoqK$#IgjFco8}K>te_bM=Cl+R}4}{i0WA!a7ymgk9(263R6Y;o-IZ< z{nu~Gto=&ENO&7U*!zSgcK5wD>t3kjUq=Bo4bTZ|15lwcH3l z8>!2v1n~p4b?tED;AH4B7ejnK<8+qyX(L$BXvJ8|I*1Gm@5P&y6>{R+=e3UIE0?Wh z7EeV3lc!bvZ^43OqNAOSwT+%q7u#T!8`*+Qj2%bbqKO}d znz9tx#J83eQxp8TO#D8+AVgvd!lY}fym>8Wjti_zG;7F6MEL|Qo3W885GaqjVhlHv zVXCeWdB$@^kjq$=PPRU0V4}Rn$1)pQ)@Vg&Rm+cqaujIE%E>T)nwrKqolA%nROK@? zu=3~hN`Nl6qY3Nfc3d8hzg6>kSur{ZiqW!yd2$rYFJ)$vIQ0!$dQgM}6Emfu-`%u5 zXzXH!FNOHsnu_V(IGQU#1LRCULcUUN)1IEN-zES?kNcOQTn{Q!*r>4+ymWXfEx^kp zw%}D#e8R?kUlTooX@vvYf3kru`1O~BC0bU9$bEiWqSVIe;rnmT;`r0`xr-Vea zAVbUqGo`6RgYF-;q49{Wx~}oC{w4(Xeqs&3kMet9sYb^ccYis>m&?czsQ*v|CiTXi z6~E-C=GYNTOSN2Hxbw^a%M16jVc~vMJTs!JMprkY8Jj`>KYQ;QWmj3{d+)XOu1l(R zRXugDO5N73RFVoL65D!BI-Sv-m4jRcoMXRdoDY8J4?V^^#(Vlydi2|+9F8A65*0KE zDBfB`R8$miD0ZW!+gpOD*f+671w{p<6t8vcdoD3`c!5qwXNZins)exGsJgzSy@Yh*sVcgTZdxih`l-!OmA`A4j@Kq^7g1UrLx z9816%`uf<%?Ep{k&eprZ~YHr@mvdvX_Q*={w zui4^*qjGdhl>~BF=O|kJX8w+EK8ZBll+fBhQIO2v(fw?ZL#cxoM@pYXH2nGIbsECg z$Hj*yl7>xsrY^ab^S-GPKuy}F``$b7yBf|_k*TcZ+89RSw3fHh4=ps)@8wU6XxJ#A zJgDIZ0kf6|IA60qsRNl{X+WoXVKM53g-QU%w3ZE|>eq7KU0Uf6>s^uuHriR}SWyaW zWW7stx~$PGYuU0Q7V(rt#9Cgb;c?Osko44Lt&2g@9vR)@W0FZrh?UAd_r3UF4cJgG zr;@ZM6-CQ5)q|N6(k^Y#5KObMpO~_s7_lF(E<0sh z&#SPT_1lptZbQ`VQ{q37gi|+1AlB;bsKi|uu+CI<4Oll7#W?{fk)@v&amh&mo@VPx_kl z_cf<6^!6>wO-$3MC4hT0>gVM)z-Ek7d4D&8{TbUTUzMRy?^2Fj# z9CLkH;rxqSOY%gdF0NObEnG_+WR!qP=C&-df08Xdq#_9bH_M=zZ%!nCJLj*nCJTQ3 zs6m@8^jrf`8_{4*as!-0jZ16SJ4ReK#fP&u2GVQ#b`KC!xA6v9AYIQqOdy?xr4l0} zoXaTazPW)EyZX3Q$3-L)y4P7~8N%|`w@jm@aL_Huqy5_;m%{QKNRntbe)*G=NV1Ci zam7GhYuhPoEWP;2(n-{9`y79m|?Tv$Ds0M&~?2MiH#YYF(%#@xCOHr);MV^Gs%w zkmEJx+pc{M4Y|pEt^)f}59z)--pO+;iXgpX6ZEP^kYpSET^vtmdL7V;TUJq-1jQwM(H?18VwT)a_D9fs=k7^@a_g|2u z5T`0k;j~Im=jUQys2isZp-V*DKroK9@exa?=YC`_3#H>Z$n=f}G7&^jzwb8pgJIBL z5j+UsYoS8$0uJbe0Vt+zXT*uhc$Lgm^pf_e7m=EXLJhA=`WCQ$dXsX}KZgCI*=B?2 zm;vM>BOfmEGLfI#9IXW;;wUE2nC21%*wF!4@1;5GVXR4+7~UxK88@_%?wZ?`4)bd! z`@+;oJ1hu8s!4G{N(RlF%t$6D7+0l$1rzVxwOkTh;Sf_1WT>UO+ta%)*J@5$;6oc_ zhTafGtO`%k*{&G~x>wW^#EY)&1(8xriKgjH%I7iiG=hFzN%umf$Ee!_bqnq_y%i^| z3^lnxFF~JFX>c1}Ho~|4EGSmES2~b2z4aGtY$G&}2Iw&6^g>eN zmuYP$<1bm%oS*kPWmo>vWF^s+@3?{!RuYs8s|{VE^V_I6#Vjasen46D1i;Vb9jNRh z^{H>^?9+^*2Uknc+eCo1py)p}r|2U(|EehZISqqq@qP~|jz;--aVn++NT~{UV@TLj z+%LXt^%)G-iWmnj9zi@Ai&`Ie5S~goLL(V^VjB=Kt5^J=7x=09=#3kX^q`1H_k2FjLjL`qmArmO7B<_)eP(1 z0wbFkUNp$8K*QI2OCA^soWno|TH|-f_cn`siNTQjP%22vbJ@h|ldneZUd;sjQ0(5V zSU}|7FpNCffE2NLkiKg$4y5MC0f+UZ>Xu8Hld3GGOrTVgE4J_xMqDK6UGHY$_%^K> zJT{3j*##VQ54nak8 z2tOfO{`LmO}3_op*bN6!|`Pb+b^o!23 z8LkV;dx$@6b|zS%c_ibA_HP048kF}a`^~8t3{H)w)<#b)hotPYI%W8@Ix%M!vpgv8 zDfSx-YfzgCNMg>v4XJ3#n^y}OD<6r`)A<#}Ey7?@b{eVbaM=mehw)}$us6q^2HXIwSvY=BuFHfRHd{2R|I!ljxF*e$-414O6-kSf#?ZK_L|OzpJCV&C5&2(^OY zFyZ7)J9}H3mF+%Y;&8y*+T=qZX~@pvI%yQC*$jJG#*%oUKS{UNF!m3FU6|DHjWSGU zCbmr(#Iv4-2N@%p@n9cwalUIdIi0Khi{e!c`B$Z@j6*jfyqc?Fn-@WHfyW`*pO_J& zp8&a3=thVu+Lc_u2B+`h^t#_b38)8W7NpP_Nc;n9kfNEy>i(Tg9fZdx+^^6DVx2^r z0N2KXeC38tA@FN0$ezyc=Jq33Sfp9VIkBjvG9c5ALeck-%bqRU5^`%PL~*f%U0{)o zU>cRmB(H*Lq%rZ5n>SpG?jxmBk%d!E-~4($nkC5_5v`%L>`C`jsjT#pS2pI>lz{oB z_1<`TwGKB4z}bfU*-UYBwo%L>cvjI1oed+=&Sp?H%t4UKoUPUyPao3R$me+Wvra8) zC$3ONrcAJjZqgIrp$h)JUh!Hw{ zPob>|d2jkSH&-R^4Y%^K8F>%37YH`w=}s19^88+M1L18(|twv$3v-gT1`HmQ-lq-1U|?ct4*N88urefh}vDZLN6s zu-WzF3Ja-3rVEi$%}q$0x?f|I%i)E7=5BKZ8fM5(K;7dtXtYgVzC`+}Vj!PBti{b3 zoQq|2KY7g&NX^|=W5o=2`UXK>Enwt^mU9pmIB$|78f=3E5k|Wo9)F$vsH8WbRb!m( z%TW*@+l@u7Q=*z7Sz5#UM2g}`)mJ5m45nj}mHt}mWLB|BN<{X(^@#TyAiCoRyEdxR<)cmjC*a622RKid@Xb2WZFsjaPg4RK|DxsX&@it zG9qjy^SWo(7v&NiD| z&OOI_=brs??!$0rn@t{uJA3Dz{c`TZaA%uM9)>%6=bruT@MjqA+?F}_oZmb5>_;nA z>pknW(vl4M2G5WWpAHQ9)QMrp|KQ=P>->;DuGKnkj4dr~LwT2KIUDMm$F!jyT~izC z$aOMTVXHbD>Rqd_p+0g_ZK$TE={i{%NV@i>={i}Dm#pjDsz}V5J5o&gLD4SqPuIEi zc)7KyfBNBLy8S;rrpkJiS?z1(_TP9%GnMt7Rj90wpH!74bb14~e&m>BeejrM{r5Gs z1fIIP8Ckz{OtLCt>Z2*2I;muB%B{B?ldLD3TMw#tT7!YL8gBjDlSapt#_PMvNp8@es{=P4XK`7vNq+`TaU@DCtC>IcSAF7J+=_2a_g5) zDz`S3t-m{Dt#a#{lJ%JcsUBPpQjt3OLL9YRmeQmq-j_t_!I)|9=~RW5HOz>Ay6qyM zR#8e&FKxf{zfZ>pE~PJ35;On(K>COC6*U!7A1KYG01hzDp7@gV&@Y){Ph7j;K0a3| zWhte2pSnjqr5;l$A;L?hTh%N}wR(aA#qOuS$3#NGG2Bs#wf$Y~{3KC?i0vGv8z z*P#g~CI7?KXf-vWK1w>1HEvSL;l!nsJ01?8iEkVj15eELqfm%4k|rnI#ud z{C&DaM=+~C)KxF+GV-X-k~d&kNxO*w?uB1-Wx*6lEJGQt%7({*$Zp=fvP*~w)orpt zX7GkeR9A{RP)=9`uFW&(a+G_z8$syv3sKwONrl!|>`*f?Lt*K9(|kdrD(iHWv|Pl= zBVXDXQ)+4ZMN(am6vYqdBgHjZtO%4ZbZ_(vBew7V=4HO?dDA71P*|61kU197V3jnX z=CY^LT}Lw7+KlO3M+F))&`GO8sclfa?SRtoB&OS~2@V@x4LJ`z=ecY++XZYm_r;=@ zpX9=qJN=h)0y6F-zszQ?qWpQ89a$+Rd3&&;NvHd?5Tu+~eU~_KnTT8ue`fva_()qH z!`5Qk_f_tjCds_8t)n&3#B)cHkyy&=z6MDo`dky00^TH+DP=+Eaxe0FPN!BsW zdo5JV{X+M$f$yxm2&4m-?{tR%G`-qTw-6s3oR3~foe zvt~XekJV9?QCtUfa^#TuJOU-wCIF$ffTs=B4>=Gjt^q=A1tcO^n7@ykBG!swboLaU zh=}Uf;>dI_)gU~%hjAcwub<#o2}gTa4&;pJ19()@4w`0t7sZh$lYswt<`D2uQv!bB z6cg~vXAS{h+mwJunh@|dNx?P`ojp>Y9VS6mS2<*rPt)Ym4En0Vj77Dpk{MYYIyHf1 zPEZFHD+6458!!pDVy;3hhBSjuYY5>QJb?n8Ua17@-j&2%pS0gxe!cpuBL)r_f+~Ny1 zF^bMaI*NVQhK{QIptIyk==jS}4Y^LoCj7VxIzIWkN5@mLu0OTDu9udNtKi4qF3*pj zisMRFQjo|=PT~XjQ$<{qBIdT$@)}%OVDXWvx-KLw2JV*VrN@m;Jwppx4W)oEg_@%N zO*kc?W?x>Yxhn;2x|42M(=)(1t^8oT(gU8-gr7UI0X0$-INlrFy}q(QWe2_9;5NG( zgIl*iahq^h9`e%bU6#H~QM2DGYW55A((CJ4`Z7h$ey^x8$a~$LTL5$)dL0_M3YEpn zNKnwl8U?*hxN*Ih8p0hB;jUXJobOMw`#&27U2%Pe%+26m7TT^l{TV+7DZ-0 zM!c{3FWF#8KKZG>6h0|jNH|$dRjAcokY{RjLq0#-u42j}Ike8C=TgO%Z>h}eryeqy zNjAT{vSojQ8?+_adWd-L?9Exc?!StU z4K)Nsg+|*|T6EW|**~6)L#7I?Ssv5R8yZQIc&5@A%1m?D)AJ;PHsQt7paxfU)+f;# z+XjsIoLbg4!2JDf`17F$j^!*>I$Tg20a^&i*(UvHCGU`%(I@#_bHW4Ne9V$&zI)_Z z`1WCLPDA%dooj#yJWp9jA3k`y`oby+S(Gckm+BbW?Rr;!gz&CBcc!#h2Q<+_QtfOC ztHLCm<=ZRFRw^899c-p6oBYLm0}wS-d2dVBN2Qog$xqy|42|qIL#)CY z322g#64vDMNfG~sKlEhGzfq>sIxr~LNZVh<=J}E;cv!-hz^lDa`On^ zSMWFt)qIasBERwgP`r6ADJX+qNa@R{|IZ7t0GMFR(($D(Xne9juDl$0d0blCxTtCgh< zh(&20np`XQ1Hbul>wL{x&yS=S8m9mcxn5)KI$$J$Kj_I-M%W?#y7;!6Z~V&DH;6c~ zu&r2VMGxy@JL0ZY$*>XMI;Bq+O#0L>#oA=|TUTqCuvP1MI~$Tcvn=94{v6E44Guf{ zrO*vT{Zhn&t&93n)R-ybx9mbmp!H zjv-SBIEHL+gPsYq~SC`Yi6UG4#= zU26TnrVK?}g-4lTL!%h%2laXC_ogXtwm&qU=y11AR@Bi!KbZ0Mi#kBv@BjwJ5C^Lf z*RL>iM4Vx5WL>w)x*lgkW0(;;Sa#4j)~s1MX6*4(f&18uV{ThlaSU8lH5&9$N1Men zA>(CDsS1r3QB_R&ETrlu@_aY0fp_1sK5)VdS6a;22QI_2J9Ifb zZIOiZY&^L;^pTkE)^NsD`Q zr<@aai*J0Xj+cz276d(StKQ*0G0rmX6t&AlRV?CifaOd7Fiv1#J=^MS<;#vuH( zdw7-;ZsLUAo8ZlEc3;}Yvuxoz-(HNjG3&m!4XM42@3zfX&PvYGyZBff&3Ib5#k9il z6fGcGna8DUz-y6(N}HEL^um!l=?R8ZkQ_lm2=7P77|`G}3I+C_bo@CKq*og*9ImhJ zs_O=Pp6>>n_ZQUQZ5?l=vzpVP#+Ej6Sbc1Wwor4)m0OzAS2q&WHd@}jxP?O%D^OeN!sPJghaFB(etXVLMC0v1ZM=zZk{c%DGR`dkB zaWnib|;iz18buR)Vz1GV7uv=2)2RM zXaawQlS{A@s0kiF>qK*yzrx8S*a_4GuQ~e}5NuVNz+a((U|)@+VHszw>chLJA`d-~ z;BjJ|&9K2`on?c|x}8l;4PLx2DPX02<=&&3EUADzV(ZdWhUi*bwj)XOLQ);}f(^7ZGU zA#e=T$+*S+a1z6=UGer8`2%zuzf@%(KN<1+#??9Ap-Z@)+y^!TC=fO(ZecTy4(XP2 zOK}=Av3i}9NV}RK{|VhqZ=J;kgl3fc`KcM>SpOS)IzJvq5d=-06^eQ_S_sxG9u=7` zOQdkkR5h@qZIphgD$7E8Frq@2M94vRA$BF(gQXX$D3d?`Xo0;i-c#tdPvuL~`}IkM zt%bDp(tLLpZbU)FvwY8P)L20on%Xl^T)$ou?j23gnK$G*YMeqxRrVgE^zl4=TzOMk*0ZX|zTzKug0t z7vq9hIAvZwm6;-B!&=b$aw4h@6%iG_oy82P8Re&BY>k~^qx?4Geul384ary^M(Xon zq*>UcI^lwc8FF__(e7}VZ?gf3+?@3qu1m-+*Y93e@C8qVJ9by_6sq|fl`nDys8RK~ zRD64aN%e&jPAaajwxoJPQ&REm2`1GSPdKT#!rGGRO-)I~wB}NY&cF^?w9Lx)6iY%+CVr!+uxZWsfB3kDl?bZcb%5cZE;W9FBK7ks zod67M5YI~*2Jr;#!8jfyxkDU968ZGkMq85k>#?zg9z=|Io4m-adKyDGr z@HOk2kN{n(lRG4`ekUpR(Gy9rPsh=Oc&sVHVNYR-I5ljwn@x^zD53(}#7>R%tKuHj zuqMpgo(g^Ab8LgmfTFtx4_`)*r3V<)#+fmflo!C-vJp(`kU+A)=IPiWuVB2mc*Vm0 zik^`M@Gu9W{Im2IQDVRbo>&H8PQRWb7&{9m29QH5G072kcdT8qqu6L59x;D^Z7?;u zwxt~sJazWZ;8W$JL*Ym(6c#-!(w6+rvKyUrPTT@LE}PD}|sLn8KG!esU@um7nd`f=tmy)c6 z7lRH4HOo&EDPc*prisriB_)ZrR+OB2)>HCRaa8dIN9E3TKc4c5gI}6K<6ktb9CE*gWGA?GOa8wwF%g+`U^d z=cHl%;5GPM-5|mc-$8e?RV@S|8zBh~&`j)Z0pwsMBp3fRTh#ASL zCuxFu%{U89I_ci4nNiqrL4RVoRoweG`B-;L9_wBW3w|ifLsjS|cK><~)T&v`vnQPe zi4!$h%pdtCZ?4H=K13Edr|}6{%=g4m3=5|85sL_ZSe8XW7x=D_%c8iu$j=l@A!cIe zT>kpU58n<~l3Ly$?IMsCr8ged7sTgi-IacT4>ll5Q;$kOeDM|b6bPFTjfobfVlg`FY` z?WNa!u)|~jy~UhCs^jL#KxW8_E_;zti^6Y_VX58g1qE(5 z{mf_>oBN?~oIK6E!2!WuYjB{Ow89Y>J}C)DZ4oZvs1LoFRVgTVgir)WZ7Fqz&PtSp zfwSA$i)$hwS~u!$P&jI;Nj#3aHZ13hZ)OmXA)~mFKdowlp>>*eJYGk(S*VsxuB#+a z%;Tsld|9Q~KgLnlWq#d!;K}{d1%tdljrV)_$^9uBJH7GA+Y3}lu*&$a2!sGYyW|Q_ ztcQV$x~O4m(kGv|ov#U*@>LpL>OL`NAP)Dv=gDUSJ96dRG?-0y?eplCH$UA*_rwZD z%G~q@`;u@wf{eY8+xb7ru=Qtkw7Nxc3aqAi^}(A5fOBA;;Ifv!7Ui{1?oZkjj&5`J zt2bfFQl#IT9zuVxo2meRgRC2O+nhhA`(pOv+4wq6(Q@GVwvBwGA0E?H7vbJPt|acfDUK(WXov;XxsN8ZwmCI|PZ889RPL0TaqRT&uedL& zX||E@^F(93urYTrwI)Y2XeI;ZpeDw9I^P#iG)t9wDO^A& zNsek+@SGLzOIkgACe+;6%t79Slm-D4GbNa}=tBAYQPQG0 zezp#)>d^m{wARd!O!#qu>4r(c|J5SVW|oaX;V=Sk`|G0xI4>I`x!jyXB5?J<*7Pxr z7-X0cCJEv{wSy66i2njKqachd6qIvetf9XLn`c;yY)hZiX{;(vO2DiEZnIVkq@U4k zR+36(8iG#yiIRj^M6CKgiAO@ewHA4HrZf*I;Q}wViGjx1pb`=`SS~Yc2u01ZAuqTc z#*;|2gdi{xsG}C0L^*vz&`zKtL{5OH5+ikLQ-<#t3ngT1oAQEl`ce(;*vw%ww|U$M zlc79L7SpbWFLCBzU8MjWpYZU`B_T)(u$ND$iVOTt!oC6jC5b)h_CB3jEi2g!pp)5* zpnkjL*g^8X-mXG@IJGSq*;9BSFKHAdGP;1Bz0n=sR2dVIM3M}xnvC^yeliS#Y+fu! z0hLq$I5ziQb^U8`_Y7|2Z5b~ntzDLl<0mSZYjgJwZiM%AfM7Qq0NPUfjxoUgVq&XK1;$dR>f=isRKmFW5-!x2D$gU3H^V`L{7Gm}_&@6^BzO&Fh;nFH zp4(y25qHZDD8d+6>2y0A$BU#JO{uWTeTAHK0ws&Q_E0M~4rfg8l}8|YLAPSMz0cF_ zpP*ZL3A+7r9o;x!t?0(78tKND&FCi2jc!cM==PyCq}xa0c(bpJYhuQU!$^z%)UZ-i z1M^;SW8tO{G(HbAB4Qb0B`kR4R#G-IM5{AEwot=h$RD>UpS8nB!B!srGy=px`kbXd zJ))0(Oe+fr1xjlwj}k8-uxqWe^v2KdQ(x(;nSdHzi>78EV2;W4YJMx=+b}qMia#yh z8);JkZVKPdBF}6T_AH_;gK1R^pX?5rGT6-5o98QAk}WcNS3<2vj-OgjoO#rGMH6b7 ziDrY=i|LKce5)IRCnJl(w1qW8!@%$zo6RRM|E0zpGj3DSWh~&XW&!dZ{VYH;$GYK0 z!v)6LV0~!6p9RSN5%{em>9rQb+GrLa`~56H_6yn3;e#l#HtJx?em@J4{R*UX_~d=8 zjb;I|-_HVMzXef}je82$siU$*Qp{UGUeUPJePd9BsOnbn)QTn7wa+z)|L`&r|HpNb ziv!k5a&f9g$;Fq=B-b($|M4}HTq~yAL!NHGfo>qhWv4Z0%BSk+#sO?d2!QDxwc#F1EIMox<^R-R0sEuO1}hO`NoX#eIcpotpVhpdlz`4Ujb@nE z6YWF})D}Lkn8P0R9QNB~IPB><4e;xJCt$YFfBN)Eey4LR&@G#S>~&BskbL%f;o z7!}_dHEH(!e8OoJDqb_mxOR^505r21!h8KDz{UZQ!-=Q`_ivkJDi+-9cls~_h57FD zC|uPPDcm3xnE7_!EefTi2qJnC1;F z)Cd|uoQ2A0ye}D*-59&u&bBm{8i8{ywbQ7t@7u{z&vFsoAdAL5=mB4~HxOU0g~3MV6Le3A;rvWltzrOYeY;U zIQ0faN4)jz`lKE};5_s`i9XIkpq8cWe{cQUIl8!sE_bUOQ1?Uvb?jTBv+~0Qi^Ks} zr5T^J4)~Pdk6F{&KSx;*{TBC?ED5SB&pW3aG`!^cnjrKdO#ThW8g@}WSe=-VJ>AgcGlDR{tyys?ugIwSat+Ibu#XY}2Mvmx)D=k`W4(X;iWm>E1R2@3ebo+e(*d!haa{@miBj8447& z;>Ot+Aek>=9-f8T131T`Wy$b);AKL=8KH)FU$Rk4i{GkRHZ-TP&5XXB@f2`}r&yZY zQKl(L^W8rTg(*j4pWY&mn?R*%2Ou2pL@v?kv;wc*+-wE@`)caDgrhwwyXH3{1DChXZrF_SxD%nKa-G426q+zl1XKprgn#R6?d}YEF`{weN4)4PvH;wMpX<7jPOl4gpL1bku}2dRICl< zhzi~xA-O<+>?%sB@)Uv=jPMDaxUJ|AVr*3UPRYQoqKw^9O}&6JQm?+@!ReiU7(er(1*t;>41yqb*vB&228TN0qQl#9fl( zGS`!~7ZNbM%!}WbEV8pK*dr7(W*@V7(isfVE@dXYrTN0FJwnpAAobu|(vkRZU&K_B z@rxJj`N^^w3HFoaHxk&2{)%R4hF%fHya!u)>j!TS88wu^q_S#67)G$Dt`y>d{A3QC zN^krSKlQC5Xb%&hIJzQj72O|n!d093c{Kq2PPx|Byfbd%S|geE!pyez%QB@plI3a zph%lAaUwyUSRP$|PuWkLh-yZ>RWRW#kFJGU_7sh@!R^ucr|}TO7%N+}^C9YwSLnWN zNcVa#8V;Hg2gSHyjs6XufaEog?j9S=$b=sCWMZSdSxtW9KQCe@1H{|UFx+*Jh|zrj zhUyYSA)OeDbs-6E(izHLEK~-9KpDt*5GOeqJRtKS89IPer4q~nRyrFY18qk6$>;%7 z^SH<43jb|`q>o*9jMpodC8DY17(4v86L1)Ci45g#zt(w?)zD#zi&T;BR8t$mwu$J5 zG|opD0taCuDXkYg!0j*#sao$5!#Cm4+Ickd|5eog~N(RIb5zIh$^+dP|1LT^#?H9N)q>KO{sT? z$k!$#E^otnn)vu2-Zg9>uL_2eS0!`GlmS*1KViv@aXNDiDbBP;B&#AA`MjK9dHBtW_(BBZEF#!V$0C>_t1#VPEFu_(i(njn@(Ffx91nUKRg{dX!YQ=&WHMn# z$@=D#40k>e1-^xM6y3r*p;OAsD;xJGUL_xb+sAJv^BBsE&o_&E;~$#MMZ60`Oxb?0 zN;?X3W_yFW+s#=q!NF;$0hVkaJ^^PHeA=Q5R&6ZUkzGk|jx zd5*NG4}hPHXOx99*)?y8{?9P=RiQ8_rSK5}2H4|E<1EEkOHu83D6_Ug)^r>a#J)!w zeQn&`I6%5G$ucoK3`Iori{q?8l4FXv2)z`0+bRY<_YM2K#&q&~8IcOse{LLBVl1b! z0W&mru1`Y9}N zeoALJulT#+79vutj!yUPEqu$;rS%*Og;w61c+FM<7Gmfeh$B{wYlb{(e+H;rb|x<8 z!aoc`n3zfi_}$;+Z{?9(&?w)>NfZ z=}hm|N0OmPa*$eBl@Cl4w;*3gzd)iVEf*0pR}7J9sS8Xwg9xGeDP2+b{(BlkvZxJ~jKi>5 zNRx=9xxoT)w*stvH8DaN=%5oY&;=_sjLe^7Ls?VJkU6!WCcX~#dNyslHn!P~{q4_G zrXdXG`bM&Gl(8tNyHj5XJ8JpRIW}eT8n45_m7iQ#ip_y%B@iZEnAN;$yS<&6az07Hb3lwyZKGi)#iXW4+s z*`5Y}4fhGrVsw%xMGQmsW+Vzh9;DGlb@O84eMz^6XIKwnf3&63@yyhU0Dw01tLZ9G zz%~RzgrD;N_#}9U{)g5AW`ZitrGC$$wZO3XDqp4wl3TNKD61&oy6!!52uAC8FwQ=! zD_E#Za#xe=RWz=O9uj5VDDbT1)2TwkcjH#_v9AiR$u~3iHyaGo>i%Ph@2s*S)Bs?# zZgAhF4ILLWisVRI)d#^U%q^h|PmU!JD}F6-Bj+$wcIa`Q&IN^KiZp?b?Rt0ngsqFrZu{5fCsBojx63GjdO*}PObJT$q`>_(ZI~WXsI9{QWlubBW6H<+ z5w|+tR)--vQBeG1P^k=>IdTA}Vii3?Gf4LjTNECW1AaH%SH-zp{ca`Rsy&(blYr2D z)}8epu?TDEzJM5T|75F&*_<*}AG>0WkAlF0*bkYQJO{~ocG)eef zmL@QAS#+skrVwO>gCs4g97NpmbsdUGgIw1pa1zyCM+_+-B3jsb14k43(7T~Pkg&Bv zAJmz=KqGSezoaviuG>BvmNR4AX1&#HSk7J!=hM=ob8f6udSOiW`g5SZNAUAe=a=~a z_Xfm*H4qlgh48shRKmFoxkDDyG^@dVeTQdFB0~U#xTOJBCz7Z-tO&HhXiw)~#qp@G z`dSoQVz)(<_Co2%{WZX1NEC~s1>zZ3o^&Vc&evcgG5j1R?Vlh^JE8rvP>5dMR3NgS z4HlF3Phv7nYQI9@!4rtVhR5;sE{3w`F z_bMeoYWtm~m;WO_C4LQ=$H|Zg$&VturWdjjwN_}5jk_z+oaDfffZ{M*88}%>QaMyT3K%QvXb(3_Wbx*bq6mM1-6sI)!-%TWiGIonbshAq@)#70RVM@J}DMn z6fp5(nd9ydHUP;j;&4gdODg@G+vZa(R0iXH$sq5DN2#WwSOjet(#j;*n5tR+9EGo| ztB5MWYd^`l@)RG{HH_}pZYU@mxoY}+`&mSv>h{|=&uIR@Yz&q0^jAxde#^EsG5L@?x@ z82)>fXoi6(3=v?XHSJK+N{&OR$kx?JM(WUhETR4bSV0!-2=IZB|4%S?EYfkQcjqty z4H2N0Jb+(FP`-}TzLu$_{^ecNrvBw2)TjQBf3@AdCcNa&vKn6c_-c9S6P}m8woGj3 z!%cYU_$l;-HKC9{%L%2>ZO@ECH-tKZSWerbcnA)@!gVY++*U2H7F#?m*!9;vdQ{LY z`c)I$p=k+q1nute-=iyn1<#U>1s@^VQyBLCSY|B}Bq_L07@wE5&}1AMfYOXZ1@!0O zb8N=|7zV90q7b6TW--Sgy;hg@jUaqKY`$Ev#JwhD&^4sIFH;K` zBtis6CTjrNPa+B-73wnmPpm(-ggDb7l$K>9uiuUXA}Ik~#@(--VM$zuDr>-6caI@= ziu({ybrPme*@(Lip;18j5$@iE*nZ-*d^EAGus5Kr2b6MEAu2^Ac^S1w&l4~6g{@X! zDM@3+a72Z4ix!F#Oww*K7vY)-kyPrtz+D^18!u~Dg-*=As(MqXQJ1o6OaWR z1`m-oP(%ACkjWF;uV@-Fd2t`ENvIHNa1qu%d{*0sYYKH|C4eOaa;S<>+RUm1NLnNY zK2{Sh3R#sL$f^W%@d}Yi10Smim-9`ydPDu7_D@qk7{JFP>^CCzYC~dM`}3}PsvodA zRU)z1hbUUJHr()wLc}Dni6LUq=pX4Nt5T)9 zRa&k)z5i$EZ=WK{>re|&opxOAJ0U%0wWunIvRYK-@T}WxJ!XqHT33Wh^CEY2uv$H- zA$G*pxrvZ8n@ELs2kpLq;)fe`-YnIjiip38qfH*2UCS%zI6}7~jhR9ks~7OcBk+AI zAL~Hb7cNZ^W`u>QT&QW^m=d-yu)o*N|G5sE&GiPVbGrtKvzqttl0~)2tmjeO8Au2y zo4c`Ek-y;CNs_8!1`})CcfY^sCLWp&sXYBxc>46n`}kZ*DsU3>!04Q1OEQ6RvWbX1 zJJ5#}(j_F$6ipUgl>MmztFMSIjHo|BbSZkeT-uB-2ft8HmmBU_8C~8MJk?^_Ac5f* zhT_P~Nm{|eARDOEQ<0LF$*SoS#-0s00EyUkXl5mP=X)2Gx7v|c`N)W*E9Vd^&%})9 zB7b0L#5>OM)`8c~sHS3Ar^*5tg4W$et7z`0-UehO9N6K(hPb_w$=Wki*C&iS8p-zb z)Fr2R{Mxd2^$B}_-Y%e-pfO9hE+HQrcpf6uwo|$;YZlOc(x%CLWCt~wPndls^I2iL zaw+`CfWt4SbbH;#U3Q1eq3yFoy)UCDhq0FxuUc*$2dEdZUW*Au-YQq`+`qOUw$fYw z88)!25sPckJrueg8M0Sc)-X&GxY=N4YpX!Z|GYEUnNFt%*Xgt(etKw~ zPAj6*1M75J5uJXxPNx;o=?5o`PAfE#R3?LGmYGOqQ&)}Y6`4o_C(J}rI~)A0rl#XZ zt~pv~I^Ov@K3CSvbhPf#Rk|#yb6gQ!)Zoi{y|1}R9ecX`&t|6M9e-6%m;2wkrgS-D zP3pU@ucyl+Z(pa2Y|4i(zrAi9UH)o5uV5X$LxBu~a<<5GwO~cHcQHqpT$sRFA^WlKvBskrt7DaYu zx(f@&tK^!x4^vyH{>FSW$2WugNxkcCoY5g{YO6zUQ*Gg19lV#24=so7US++H`ZI3i zOJI#^X-u7~wJmlmJPsIO;pLs9)SgTfu*i&RiYJ9HdqbR6n8n&z4fJHr`y4Q%I#{QL ze=1xoly_V7eI9B>DpkbW5G6YCKGcc~GFI~!$Qku$UflCxngB+K#^mJ)Su{uIQgb%z z`A|R58#lR{vfwdC+&#dr_3|vT+@1*?MIU%}5{q)`LQ+Z<)r2$LCr0$t^@Y?|sTAM3 zn=*f)9#BRIzaB~Ee(}7dNGfM1x(Lje$glw#wBd7I#V_S`c_<>6^H4-uae2lu{vqe! zp@>}>6fuu>b*g+*0WY9}Q$(o(6tR!vE#L+IM~K4#?N1<4qVp@@h0CQ@cAZ(ki~SV> zUKQ=HXJ>`a)7OPdJudSrLjUH0z&5C15X~A0 zX4Y69N0DG)po@&tL~;IiH;6T=onA$aH^*^**0-o};Nz~Ml2tS+n%%E} zt@ZvX@Mq}#)6SoE6&nBWr}b*5IS}uQ7Doz0aioG7t^7$}HebvM@J}(-7BQA6vXRH2 zN02De!Jh_dC8C^zTE}?rW7@CsP6jE9lpAV5t>Y{<1I-F(&iG`p*oGQV>jZ&RaVj@x zT?fngXTt8r8E|XGrx4W`9E9-4>Yo1XJy;J{D2dCz$;e z!WLR!MvRq9kEfQD9@qR%NDpG>%fyAV5}cY8dAu)a3Bfz%URVfX5d)_v=45%!AY{|q z{tn9sK|+$H1u*4j^bvWAq#%)iChj0Ce#3_P=pA)7A&@Lc7fdZtVTcp8`ZKtRwE-nk z{4Sl(nly6yjpSDvwR%0@m z^#yH+f?|nejj7ULwD_8t5D=Y0qUi^@#_4e1S4E)0oG6xsN|z7nC0%6I^Y|tm4`esk zJTf2^5Y(DW1+X_dM9Ad78anyviz|0ve|x??!z=2Ue`tFqBl0`q7~XJfB(B@ zuRPeqUb#MwOD1E|od>3AK$1i$^WKWAKLPPPlut%oteJ7`^V2OUDjP$D(P~BY9?|zQ zo#T|jYi>SaUc)?&5Q@%!#XPAJKgqsgfR}cTuybHOy^RTV_A_@|OrZk5llZX<;AYUc zk-$F{IXX3$M&Gds`y=LG`CBQc+yk3h8aPX+WH+ND!;KrJeIL1?6)?fmYI_XoO$O_n?!Udy{Vh{@^n0`F~K? z1e^ml=f`t1>QRjV73 z0-@{#d&P_MP&p!T&Uvkel=iERB*Cg=4$HjM8$3ca)|&!)s|9;(k;e=Pn~(WPA~aIW zlQTf-qNb@__Tr(Tqv;=CUz(1z>-8ybsK6K=X=!rLZR*ccUmGK}X7w>DszOFur#8KM zo}lD@ix)2s5LsysvVU|r$au!q&^mXOaif`B&d-+gl{Je75JT=Nqnt*RmI1dAav)#DF0~scbVp8b^DVUy$i;9<(bY zXmTCXG{6+hFk7B=eOkH77glsHKQF?Yrg6jJ1`R~FMcNrtX| zOofA!T468CUTOpYK^Ns-t#*$TFK<4S6Ayb5S_U&Db+eSN-m{I3;&B9zFh@ZB4=gH? zgGR`Pi^!LJz}GG7KAj|!VQDlqH=5qYE5_V?TXU--_0uo*N1qqD)R!* z5)9)~{!{8Z{S~zKtkiZq8PdHo%uV+$dtU6oM$F+CpT%hS(k>_e6}hb0c6IIFt!38f zOrL|_J;n67Mm~1i%f%!!l_GD)1km{zusHZkx4q)1w57nsXTv-m7W)8jG4F*N)xDRE zf?5R1!iycpX9`|+9;V7cS?r%+Q3WqM4^!pC5!pXUm@0VLd6+66j>!HgT#Vpl=SwW> z>+Zemq0Gz9U5cnCOjW`0@?Q2Eb1;_m46T(e7IZN5l^|IR`4iNsXjX}PZ6}nGoPjb6 zCWzm84uaUa7vM=I9S0}0GIA{|8h!;HLzg+tMa+Gl=blfch@suZu=IEH`8Xh3q`uYe0>y+DH&t_omQs~r zcuO11q3%cz{s)g^(FgmfDuc`J`W>bPtejkeI)emCb#@CnGf-KC-_vD;-+RJW#@RIg1vs6U&1Clj(~@7Uvp! z?L=F*h8`heuh)e}AWK*_3R*%MA(dEMbABT;gii_yE*^w_0!xZfq6VZ8p}df}s*(D`vAOLPIl93s>p{1ClK| z0RvTesfza#qoFjYX0V8Eqz34^{G8(u?d6mbY7vs!_qFKk>3oG|i&$sk6{JHhpToAQ z?Sg^>VMX)y>^%4eR>{A_{K)#BWDnjW=^x_FN(N}clZB=UNag(&rVyzi8IXtWdTRPD zB*3FX5@d+u%{Az$>9EL^TwAFMpdo%wndJjcxPc;?5-@7&HjW?w%Nf)WUbZqqBxZI zU}jgwGsFj?#!9n&df@%#>Yir3xtcZgmdjhyA4tlz37 zs#%>unQAr?H#RFvPfXt0euKTG@Qxqg1D!&rsu8;%;q5t4jblx}NU@+_%mFlaAX$AhY)wHL;i$T8t4ol7+U%<`i-Vo_B&@NE2i( z(OtD`X-EY}4$BkPo}LE#*6$H>kJT+Ro*Cft=}C|9%uVTGMVJ~TUw282jJKSx)&Z{<}i>)UK>t5mq^YsNyDkE)Q zCT%$YNc?skps0#{!qNBbZDhGVy;&y1JzvEfHb017T(6vJR*r$Jt4**WmtK9g4wbb^ z#Gslus};}K4^?^W8RgnQnC8PINL#r(doc3D!dcK{P|XGPl+yU@!?RGuI{b`4oPSV3 zjy3ur$?QJb3XL|n2c8RY=wfG@IqA5txj$%Kv=VwKg~06$fBH6dglo-M!Uk5i|7J{HHZPaGze zIF!ARCTY8pZbkGsvJ35l*xUaK8qhgej74&OmS9T@I|?^FvA;qLIgR${Phu1W`cx)` zuE%PvMN^W}{^(`9^c8;<{wv|=`$!$8XQzigc6-5>*72)wrgS`H z2IKS}`ISN=N>}22(3tY0`hqMJ`M>l@KKQnC#r>9)Btc{VtLmu|@_$ zxl2ytbC=;Fe8?_x=#$w++UD&_?yEzE&R<8-w6B0{u;$R#JR)XXi#w<>4>&|31}0J) zR@}?cMMNX9;!uPgve67XNwZM>Efh=F0(zHDD(B(opkq;Nz5LgQ!(zjYhzlhBV_ENJ zT%9GxMWO|5V5D7lj59E3CK+GA&!N4gH!n5PNF|;L&cFM}Hj_z}gine4`VdB4rGjhz zo3k+9ra7oO&*3d`)ax^2;1n7&V|n~2!Z-fVIgo(*JqxwDeZDd11h<(k{HSa_he6F`=tC(9+PAd$BfS?D_JGog4|)}bKB zipgH(&0B?VO)F-bRV0^MiBy)0Pnfc4OqePHn{{bkEvwv9$0|QQEm`I9wPBUjte}6X zBMXQOvCe6>f*xHPvH)GN71YpM*q!6Wuh7F9)tF5#c3-#d!kR6FCo)3Z$u~L8ro-SA zJ%BRzJ|UX{BDLn+Y-dBoi>bNBxqUNDAzq_oo|+0Q_o$eO+Y@y;+sW*f2`Y?`Y3ngK50>6p;%1$DOQEW zrZ^7a{t!GebC+~b$N9c>dDgbv-J(|g9A}k7iZv?|g~cZI>?2Y7wA+8$i-_q)Kl>)u zUjyw;o=mAVHvAa)o>cnI^x*fAM?hV&z~-F)rk}&Bachq0cTXBZMSv*o!KX+NGzxTQ zNGFR{1t4xu=WnAZ!kS5)2UuD-PObwUMA>T}EVw8=7+r`J$JSlg6={30^ujIxmi+lg z3+#QdLa+K%zBIjGpYUh+)Ou;YyNeV^R4%HAIbM|ly9VN^JwsP^%n>^S(Wpowwe}}! zYEgIE{Hob)_>=Tqnzk*_>0fsOeL0IBs*H!{e#({k+sS!~WaJJlW&1+|C1YWc8iSrs z0+q1=Y$lC^J0Ok2*gN-*9U&zWItBsFz-q@ma^J>Mm&U+M*J~-K2R{lg%6tc|K`XQO z+kSxy*&mv?skF|_cje_U-{l&hT;v+?NeOH|;Wo&RFq?iaEMllPrMlsp5tL}vq=!>% z7NEHf!dy}!;(k0$k_WHHYJ6pgFmY*&`maAhwL?TKT zfo^Txl+rhUoVTi8@}M4k?T4)Y7WW1lgP=63*$p9JtGNRR78NqoC7H|azO6)T)zUAZ z06D$PeKy`CQG4`W_qC!o9td$gmbDnWOA~T?z0u1xjG|Qw#qs+vWdx}#w(R&FRA5NkqCEV z7@<~%AS*s@;13%Yt(Vt^$tVXAe()WE%$*kw2AxCjUqJz|>M%;da?AW_9f9b>o^-(| z-O7!RBTL4WdsmT+6<|6!jJ^(&{S&ZF$h~I(H(s>K1CC>^f~wu zpbT7R=b{w*YefUARtBZMSk+3UcotSlkWbt7Nfa=6sKt(Fk)tgNDd8Uj#6E8k5F2pMRYV{}4Ory(_8%F;#2IHx=j= zFge+~7sk)mnzDbI2edNgY7MT53@}N#$k2HZ8d;ORWidHDoo|n$eyP?as-aXqjuus2 z5OJ?@HUPzh%`c&L<9$S13+Y$xJ!&aHqKg9JU~Uy3 ziqf&8=Cn@}i`mSvbKK8W1zw{C}hz2$+zVYTrIDbRgQKzxTOb80;$kv0qq$ST92AJTaMZ(w}g^5ViJf z;4+Cx)))2fT0;n?ZABS$Tu3%P8-bd@!D03h?CsrbQU?l1%KF(>XNc6fC-BZ6MCUa~ zok!|<=MSQ#MDjV&GZ4vV1n+!p8Q%HDvz>Roy$tU>b`p5!WoGRhQ||o!DUv(i2)y(A zP2|qw^}O@@OUj+Imz6uuIb-Ecy+W_oSwF1jooAo5vz(p$vwGqv^tXm~vKPw#du49K z?o;GO+#MFy?#xmS3SDl*&+~>nioB3EjIib9BOB}ac*6*9ZAFLhvD(}(Y{xYuu5VfQ>Mo9v;M>V}T;#c60 z6Zqd%{LB5f{Pr6U-F?MxK5&n!pP4AMtN7B|@2r#2%drK4F3YCm9E#2m*}VcIkg)%* z;su0c3<&-F_`mHB<-J#8Bon6CRmASwR(uh5AJP6@#Xqe*wdMAA75}XEJL?($a<~Hw zyZRj1ErT1?Re@M0gI8c)lEqi=Bel1;=*r&xBR*nrrH8BTD(=%&_Yt(9WF7!iPv>j$ zR&&h*Sc*5{sm~JoFuQtBVXF^n``8s>?(?&9-eg0l=v4n^0#-Qd22lwiaCzt&#cUBQ zJB_|cbT+C32s>DG8&jr}!2VC9#rI?tx%vYPyg>9!R^P&1Td`N}oBV%}Y>X}MlCG{~a# ztp#+(DMEr4sjO+wXJaYCJc@+6X9X*JI@h0l>5(KRgVx`>sg~MtEbBZ^?d|${Uzc?l znCo&rDNEz5>o~M^&1kN5{l0G7Opx-GCv=MJy5X#aZZn(KHw$iV(`r3ii!<3iON?6^ z10`=ZaSiGr@9bmppv!;{JbP~C2ET9wD;GGOFc5h+29B5{`5oE}Go)DP*`EJRl#Ph3MRx$7v&J$4)sQC4YKN*Z6Sz%@Lqbedn9JgRg9dXU zK4Sjco`PBkT0~?|0XW}|LLW@dMX(0cGw=WPkU>KLs_UX502NsgRskhZhX5RKKLPs3 z`D~(GD0%NvaK^n&z*WxP-#kd7o=(;2uRWco%j5s|Q}g(gw_7*Gr7*>z42YK)0&rGs zqY8$a!uDHyVf%xlc=A@*4mMW_-K7iLM|?oB3LxeR_hC9n^E%V(zJDYu zVW8T_moPYYpA8TYB!dG4$?(mi*-*e>Z4(VRHNbs`;pHw=0vVuqfOwiAi3KRG7BEo$ zo&$>4gfJiRgn3{s3G=?K%Ms?f6Hb`ZWx@Q}>K4qMOUaA(tWI8BnL`6h1Y9i^UTvv~ zq*Uuk5E+W{=5RQ5m$44I6F|R0l-E#T!on3p%uDfsF3^rF1KAJsDf68(6*`uLbncBE zh{aanlEQGoKG<6T+5Yn@10Lj_4CDdpL4K-v9ST^}j7(7aR`I%estvgh53vMV6;f7< z2K6^Q%pHBufAiB6O%d{600rQa)-ubK%8UJH-B4bGt z<3p`xm25BL!ep5$E-_ZaUbixPI7K=SF0OLtI}@> zDl;q)e555=`JuRAjf(Q^Yz}iz zXSvYXd1aWO(B#Q^WIZ_~au73iIhhJX->a^wXoDSv zjiJo}80&>fKR3`1blvvk%?^^mg~||nhO`HAREJszsTfLdFytD`2~;c~T0n%w*;w_o zc&WULW*J$()1s+7gdW~1l58U&qqXx^aS@NYmxm8N2&rD>Xywnag90P5lT|B?n>V6X zN}t2&k>)a2M0#U!3vOj#`?z7#y$jO4$$(LX!)!)}NNMi2*BUl9i>I%xPEw(TZ-m+; zOU>$_+(xS-BaipCL?QNtf&(c-6y>b$R=t#3#VxE9;N|C4>g({6uDsxY3IojRuUo;v z%@rQn{5YOf@JzXT_*)_mpF;hW3Jz@W@+CN7w7XDeg%%mwRF$b1*a|PiP?Q@03;pp{ zf6ClFQ^!BEw%cJ2ow{meXZ<=NmKPOqNqhi9qNsKtdd_we2F5e<*byyoNUM8jhSk#M z-a5+qxXiDQmo$`DfVtP?rDAC6DLzzLkm^aSG`dVxl68x+ni3wXPv`CD+W{fot%}4Q zdJZqqs*c*(v8d{ZpOY4pU7<>&Tc3-BC?g??p;Nsigic9!V6hTgU41$kPb$nQ|Ly20 z5fV?Wt&sTEvsp-d@8k#xY|1lCdOmt`2=mLRIx(@KL<_+w_rY9`c}a~*+x`NJ&`(SB zo=APuPw!v2J&PR+Y0_?FN!67=6!wCNqN36LFah~sJqfMZ49$Ne{pmkaH=$`7xflj3 zj_{`mKl;hpkOnV5MrCLeIF~BCe7{@YhS&Y77m-=t^z=2s>nf@WysA&7EF{FyrIN>d zLNDl(_0TpVB+-S4PV39FlMRN(oCLULy%8^)LzY_Io|NW>J%vB=pFlI|lZpC7NR1tZ z8Hhz87it0>h#6*suK1>FPhpa8y7{Ji!L%s_Nlcc~_z>%tq-xKFN}pWSq|dtPa1v?$ zpie@dOWi;1DCp$K-3bfEM((SHYUGVdpZ0YAB8mqI*83K(reV}ocsF{48fnJsNS(|> zA>d)^ZCJF9s*qD5M@HVMX?Jzh5U+<5EhUxWXuoqRV5{!2am1#k0S_p|=}uM;9Hgr`)YX;WSn zSF5tLOa^KhTHEwit-Y8=oFPo4*ozfwHb}#EkFn~^;#IcJRi$h5L5a{xbmfzF)r||( zXKqdD;2e&nFfABQm1q*HGTTZA4J!4JHt%GpZy(6)(A$~m(+em(`UYBkHX0Ab*LNZA zg@#SzUMy4wZ53*cPr>~>&fE-J3Qub-l#}5F*q>8m{Ld)dPd^7=qiD8*c{6Ag434VL zf!j3RL+ByyVnhvLmty)@y@eo{I5vTXuwWqwI&GgWKm^1uV+9jv{%`0-TtJodVJPe= zyeMheR{Ucg1TFp|vmSbZcC!!b;s0a9r(jE9Hf$^Ix;Iv;{%|BQ$;FEqr4x1m6&DVfkBd zj!)MAl27V_XsxUFChgK}9q2RqR?9XX5`=|Eoc`*Tzwg7DZ7ht*S?95D@%G{TM$|1D9j>le+efzoxw-!D}hAn4)oW>1gnh zd!D(k$?F2cH z7ZqW2>p6zd(3ZNiaeudJf8C6)ZiI_LBuWN@FjR!%l0&>y&8>R;_bQtFIHE@P3k+s) z@NB7W7Afmwqi+io!$5hqx7jczpZCSTmYh`MC|H6lri7=a>Zk({8$PwCT0(f+!3!us zl*rG+D@lNA?c@+y2SrHPW{rYs5ON+b$l|K?L3jjfgkz0iBu%|b5{B~V$vqm5!*p+c zH7KO3-%UXWL(N5qQyY<3Usr;Ysl-rCUOXHj)#8+J=BCrUHYezgHv3O!kA>SGcbK$$Yt7#$10(NJ3Z zE7&a7?rGLb$ZSTJm6%Nvg$^c(rX9Pwrg0ITb9RnVg%%x->uL0Yg*!qX3& zmsZ8#pgV{!xx4t04;ULr$O20SEmX8gz#~9U!WbDAil59%0jO=VN{9(IxuZi$eiJFK z)q#c-O=Ko1P#@`j4-jf*n!9^Px94*i1~FiVGJGEU5HpDf)xb;58McYYv_5TMKebTf zFqyT*4?WQsDyp`h`5?j`{gy_mUdIa*%Rl$`8!-4r&~9-UBQ5QwUk>s33aGIIfRam( z{F0Z);4z*r7QAZ!YK^ACb&V2D;51||!`v|al6V??K9)?NpLxVd4$9bEgP~UZ-rqF4 z+V}qYHF@vfJKp#H*UjJiiXZ%otA6mcVfY^&?}IPF@GE}sudVvQ-?Aoe{Ndw$@Gmxh zpvs8h+IlG zHVix?NXUp6pI;zGm<;mCT;?{q1&7X;3bU%^WlKJYHyP>ad_0QBmq@83^;S&if!UVz zz|5_fNI_(tTqLqtGV;@sI^9MJ`IGoDh-DZ#WKVdqYXYj>+IN#YagS^^EhlI@zeBbM zXKn;1r_PcY_Rb4)V|=tBAK%?H-&{Y_?Ib?*;U*7#^(lJjQ?u6ZwzdAj74~~w#ajRP z%*xmL&m$iUjb-H3TIyb;?Ph~1w-W zbXv?rq?`IJPZ1)*zQb^JH@EAF>YMleN94tMlwKP(0oYw0DUvmZ%^Gm}7m;VJ{g;%w zTcScCCe@-dRNH~e^&wOx*{WnuKum0KH*AHBS##&4(|u{10#>`BN+HB<+@qRk#RYSm zL=Ru->{URX&JN4u4SxIGFScPE=bdo|-P=_AU|MWX;s4UXRd}8b{zYKzVtQlLB&4aB zp9jh)U`WPGK~amE&evd@_OugEMPSOTW3i&=?m_ZkaxFqou`7L2!CSOb-s8tz zGnw8QFr!wigpb0HEMb-PrdB_!GC{YGMVRqbOep-!k=0qx@YX0S{eXTo!9^zKLnNON z8d3a*?b!s+sX~ug(dL_##QL^qtF6+l;A?Z`tc|$eZuJ%kAyWHoJDHvO?oP?Zp3XIT+dn!HZ~G%F zdfWVJm2aEsGfUvbyv|zTjT%^Fnj_J88}`c2ucj!%+qm)lN9B`KVZ?blc$sR+O%S{m zHO(nOv=#Nb?Bo)X7KIOsJw2$CV0XgFSZV1YeYB|sUT8W&`O_!jmEXCdSI)0i`O1GHoSy+2>R-BEILcO9 z)}#NhubZL!*l+c1GKrg^``ACq`ybW*1TDT8-N*io$m@;T-wfTy{xP(;)%7<+_pyH* zEgl9MEvODvaVXS9A5LVrtNhzO&(S<3*XB!Dm<)WsWx29vMQ9& ziCCjFAqWqfYvtM|1RGIL;bARZrUE*oou$Zh{1{vu9yV9daCqK0<+L7Zrn>?(?byB$q*rVy2<#_*Q+28EVvfsa1_BVU8?Dub${mtGi z`~90`{}Q-O|7L~Td@}N51e)n)RHs3Uw%|Q6rJ$Q~+&^W~0hP_^yp=zL3 zbpK{r+ElZQ7%Fp=SyS9hvdZ4Nar>8|kk9mkmvyv88oGOk= zW*d|=b{9L%kS5C9;#s|?=&fvJM`f6SInhK7)xvIYzwT_Pbg|gEPT55@Or8Y+n0ZkX zpb4)C5P_y#rw8AKdg@R5aVsjo1Ri@QA8qtGUKgz`e} zMY&WfH#9$8NM8}XP*+K#^!{(%UPv|Xi*vFs<@f{c;}M5MS|Re?XrQkFCSZREr0YlE zAb72u`e4NSdH8t+EoCcwZeHD|!a8#i8%Fgj=dMH-h0ViV5Yba65Vj^<#3|F*8hfbDB`hSC39i z26;!yfmqdejy(EFVD2WSw#l%76!BGRFiK`|BVL8aFjysR;M_0I@;(>-m49M`bjVak zpd>sB9#-%dq4{SCIO*q}p&F z_W1~5g@0*yBm()j-;E!{=%F7SvZAF*iVS9y#FuP+Y`p`_d=2v_R$ zS!f6dlprpeaAQVCfVhm{As!+eCY~0w!we3KiYnUa+~pHF2SbF6b%`yoI?!NhVqhS1 zzbyEYwIam?J88+7)g@l%`Kl4q@Z_ieT7D0n^O~>ar$THfhV>V{b1dsTk!vx2?@Aex z$9U7CB}t27{D?Ef_@$nR@drdx=*+Nm1DG7!q)e>pll{gxMPMh=`0mxM;)bVwbR+{i zIrmu_ZJX%w<;Wb=zo%ePD7|A4PJA*?s*`0Ou`F=9fWGmBdY%mOmJIiFp7u}wKFe>M z{!f3{zx!9^4J+2<-5;IMyT9kFN2~Atm6G#PTgUzG&j|f}wRIj?WBq+bJo!~8;>pSL z^h(3E$UiZ&q&iOt6(<~$Ib1eKX_imef!h&7xI|1pct1%^c+VUVN*T<0?=b7#qW-8z z*p-7glZG&HraAvfL)!SXS16F(vc}2`TTwn{ ztE$>A;NguhdkP$@Z+0iG+lsp@!Xs95WITModoMp!aT-sdQFj&@Q_Wnf3fN}t;r|mv ziy#_>LJO5{9==P2!kro$~+XSTY#EAnC0Zg{AzjiHsjTh^cv5;U0TgO zFoo@IDoeBZz~G}b!~|h51A5HA?>4>NIi4&}aLaYm8Ge8!lX|kbq;k(~G@wSHV$n0{ zPgL!JR)$nMztU@Jv)A*MDOR#BDA((E@U-^hd;(ybRGD-q5yibcG@GUM+pA*wYe6=G zyu^7@r~x@6yI6t9ktV(qyg686PkiU>aHM_r;8mB*rw?}4 ze)X;o@YTCUYQOs4gM8Ip`_0Q2(sw@AalXF?uKA}6>HYu2=ScU&=TALE^y#ehs()p3 zBuf9`hipGtbWazpq$}bVUw*^?oKM@bJO0dN^XX%+y5zzNi!ZV>T=#trnN1(o=EgWZ z^dQ@h#hjt@!6gw(7!>$(+X)!d!8le0TmocJ<^<-f+rnlsmkC%r(1t^8ZhBVw4JbG1 zS1ck!F2Fdd`?f$uvxzpGpz50up`hoW`*2rf%mOl5I}BoQq3JvN^GjXBpZ_Vv&PVoINVm`kJOP2ur(=efPddpb~6WOsEL|k>W4`k3@d>o z%*qCjS?Op}j>f?~?6-({M@__hL}^SNuco{ke9*0)gdAI^JAc}n}}<3=BMw$seb$yFaP*2UjFf4y!_+8 zc=^YF@k$^6r+K`+S?pEO^N5}j5;|*%F#nOEPTw}IhtQdqMVPBtU9!w7OevcYuqzaq z(#8qx^0V#!EPYs8)(KH5Q=bYpQJ+;<$vh?c(y!=C^SqH#Lj*}`O0DS{r5kMX0zYXB zHlt;MERiH5*1A=x#kU$)!O0ebv7dy3;aT<}apk0NLYc9aNE+cClU;IO1Cb@MO~J5` zs{wQ_m=;oB7n4Cko}tUnrY7O6@FpU7=GCa6-YlB*zdG`^t+zDkN(w@ z^5{>51>S_=4Yp*4O$I}SuL?K~U%B_FLX%i;tRG7uxaW^apZTxKBV~!IFgUfiq*y3WJa|CEg?qE)2f}ysP?wuu)*}!@l(BP zNUPGM#TL0s`e}EX47kIa$gju)&tQuf=z~3-r$($jZDQ?LD+ALXQ>Sqf55R{eTy1G$kE(`MEWmD3R}9ufjH@An$#0a1Vh<$~t6^%h8CG5d-ln3XvtY}ZA zDau3mW9ngZl*jVgS}+N;b%F_Sf4_gzUcTJ6L*AGB`ljsN25l?#420Z02C7E-)<7R> z@L=ARwB`TL-n$0bRh4_c>(HRrl?uhr>JR%gdct*o`?nmwL5#(2ha`9J>$i=K0o1s5NY%!+Kor5 zdt#UgCS<;3J-(RH22-VS+I`z>3ZZW`{6-^yhhC7?=OlY#Dx;DYya#9S-K&>-@G zO_d+&pi7uKmJ%rXWr>Tb4SfL8g6N`B|L!iufDh*KxP*DQJX=X0I->FgUlZcHdP&k} zXO{GxmLb?Jn%J;mas}o6|u9b9G-Rk}FDoUA53&pFKYZ|WJUx|D$vwDxIU%fvrG+w=DmB1R- ztlnLU?^;|i&j}TCrSp5+voSroacWqf0w14CptN8j4KwWZZ?812$3z!>{0}@1_kz|ZILkzP49UUoH&dFGj{w2Ue4HM>(;k`}$QjGUnzphfEh8Ma2#)UtnN!PJyhngcQJi;d){jFfW zoB|Md=S6%o#y3^Sp*vNnF$H$B)pu+15NbehLCUV^IDaSMaC0kK0oC7hJ3E<9g4~PC0%sPx1s;Nl1VEm>hWikRi>Z zG6l%bV*9BT*upmf*l#1poXwSgw}%oQ9knLl(fdfgC-YEQhT8UQSeb*MKKHu}#Tp80 z%t5U!ZTFP-Ax+qzwB1wQ^L>-jc29Y4X~Kr3?Vj@9zBlM@TpkU?!F@}hcn}2$7;Ql0I^A}3x&}fh&@9mPF7Bp zsR2y(^#C?Jj)fO!8FT_0M%mPF1O(B&Yj_z0swfK!6|+08TF7TkVU?Lt5%T?LX75na zeqLsFyPw(15)|HC&+M%YX4c?&)tUWZZ@#B92%QOPf@h7;DAaWMQau%r zVD+Unl6-}PMh6B4>^_SVx$S)o8nnpsn80jJ3j2mUOabV)753?Fi!p7*3eEn){Ozqg zay=W*0%3}GSd5LCl)Y>fw?3){cbxpDEX&4%67%UAo_~}lUq*A z*Fc39zzYdHfeJ0=D^Q_jHppHGROmgKq#~^BuChRHiq_WxgNjTtmE#uOJuH*Ozz$gy zr|!g^$87_jh@V#gW`Yz}J$5OkXYz4tY*t2nY%EUSpd-zoH)aVel8dovv}_PlZdM-$ zq)8=K2|}K3t9>uOh3|c5I>O#-{X_XEFQjIU;f1u#v5YBAFk;Rbam|=oz+r_2T!c-RQGWW&+G!jTsjhA5-!6N}lj6vfYRVEYkR6QdH5CBF+0)?Uk zLO8(#O>$O7sKH1L9`AEj-3pf~7RN6+tt6*aH!AF#t#0JIDINtctJ%>;Dk5|w&)}mz zXBCQ+j{$H<2FqZNRZds)ixt;^*95ixeX$Y1M1)LXEOYfvJlSFF6xz zOwRn1>7Oc`@uT&`f{pTRs&E!>h&5=FD_lXaNw8pCg(TQSjl;`_BI1y{b`7#wf<}O{ zDhCkrx5!<0xQ|K@hH#fERv(v|dj-B&A1>iTXfG9LF1bHokvZIp^+z>cb5_1 zCngn>wsKq&dNEc#b^juVyeX#fiv|sdn0NOb#hILEUcrzE5(I|C|HN+ioxu#+n{O%N z(+z#;UQb{EqYj==@19n|?{}Jn-_bGD-W=XPt%R3Tl*A3Q z#drtiFz{#|Sf#04Y3rJ%l5nh_e z@@eGlT{Y^p<5TE>hW767gJDqO47GSshCNQiGnV`|J5W|3b|5W(Isc2^Upq0QWPI2+ zDu*-S)DOzav%*J&c*<1(EusvHaToXWAJS(Fmm znREa}L2B=s(yB`tI*CQhM6?x+TvJA7$GtLYBTB464yWHA1T|jZq!DR3-G9c0%kw&W zr_D5bG*5~=rZCMi(1v02sOTsyPp=SmHjay$ zu>`&16d^K|1P<_~jOWR3@4zGzad3bcvx9>JBb02Fp@73{Hk!Jq^l@IlIkg`=`$ z?8MXQ#fcZfA&OD(PSk1~iqwDV-LV`2MTLQkc5S_a8hFLLv+BycyX0Wz#JR5sNpGd4 zil*@MDKim_W>w5>eDY6xVwI#HD}0=PGWXtfwgdDNy74Fc0jjee%%88b!WvOv7K1@K zasH?i45~^CrFncVDLu$WWLYbOY?O)N&#UvQor&vmAm-eKtMKYJYx)<=CI zfv->xeXZ=L_>V92Gkjx%mP=U?dv3M82mi#bu~dd&o23}v$1fB+3*`qiDxDg{vq*)>t>Xx9Ke1GQz_)B&7(l5bg<)r zrO4&Zo2((1lK~eEsG60f2DU6(w?j?*A zFJp03L#C->@=Ryi>sRS#?DOxDjOVu{ zHY#`9o~YbQluuY7XUq5ZM9|ar(b+Pa8GU_E1l_WLX7no`*aNfZrF}G`dr>8wc8Hm~ zzyH7jGk2fblX-ojuy9n;u00X-#p1#d^bdO?=(+o7r#_v}FKb>jtsnya-s;LD=j{|s zQozg>7hrxS{5tdvXd-(SpwKSSXS}*|U7B z5y8LduJwZIvh3BI(BcYR zNmSOTXY)u|aUOJ9@W26HDy0p=4p0m?Ub*?Tow*8*ab-fh(q#8X`az$9O3kgysbwNB z^j?(bN@I^o?}o|_{h-9ZcfGhX=T0qEey$IAV%)WIFaPGVy`o|#NB!2*4 zDjgp4lX<}#^bK;Y%&*CDw@tc0qq)tqNM}crR~*~EzCmB-YX-}gRC|a_+Wtl*cVe0O zwd_KHr;YD;mS$d|3 zGy_DeN&WjY7K8!~4D`;jcThEYZV8$OkJDl(^{EsA42X!ako36iY6~{V&mAy%tp$_l zWe45Ehq0o)Ou)q~r0E$A2ss3=m9feTMKqs1u_oGrguy=*_sX`;WW*Q{6jo_1WXqmp zBM!sBi@l4QuFt8$Dm1)IsZO`seVDqs7{$9D1V9V1WE*N?f~))ZXA=4=+ts0-L&cX| z9U){r2 zI?B+h)jSFu5u9Esb=0zauOr{nnn^h9TM$r}3ls%q+@1>f<5>yV_5^-@YB>tARrz%F z4Dwyu;spL~X8FETKY?w_cP}H>vC`W7>FOEeyS+vEZkNS4;x7L{^98zX4&=M1E%|iy z9Lcw1@5px_BUYHNwfWQ4b0pvPy(8cKZONyr=SaStvy$&|p`oo)S#4?vEmF-ub0Xeo z=aEHdbsqMz3p0tJGU~p^T{eN?kO`)TmW4wxiaI&+;{HAU+;*NQSgIfF6{?^6B++xu zZVE8Ij;*1i#1POqLqG$4*4alRX&G@@1oWeU-=~{9*~u*qu3n5C>=B){SYOCr_q3Z+YZEVZGtW3Od96;hk-15-l1mn9YUZ*X3TI49Kk0-q(>- ztwy}3iW^wCYMV(eZ$$OS~mj z*D`#HQr~0YX-OGY$J&$lWR@Yg1Np_UU(C^Pk{r`0;HMbV+BJ6z=#H2w#B)00&JfEi zlsjBtUqdieVK8FJh;8a<)W{6xMABD(zRx86d~1?E89?|dsIQ`xHBSSTEh_rA^p>B= zlO_|72)dP6jl{1}A70cJf$>#J((k>WlPG-8vz@?FZIaJpI)zURh>S-v&`qx-f|4++ zR3S(wWg$pQ{ErH3;9`WD?DZW^gqB8ITGq43DlQ7B(<_uKmN+dPg}tAv6?^+rEzRTG z^RQyS(%L*e9$E(#n8zA#m${6YRXCvot%}YO@7$iy09K|s6|{_-C6qCr0d#C9g(4SB z7(t7ZGZa73n4hTYpW$KQ>kzM424rlj-h!-RifEPt`r)aSb}r=I->e6R`j2YMFLxKo z$uILaX?7f~*g%QVgbs;?DB4>!qFvZnw7FWJTTkE7ibj2D9@giTT`g(U{aep;vVpd( ze-8|_P8RGZdt!NZvS4pw{mj~=?qtDk-jf;IzctAIEnO!s%J=ry-FEAN-PX)6=;ZZy z+n!9@Tp5(RzOu6wgK|Dx^xrHvhv)38d0174=bfu~+tA^8zs4)r+Sn_2IAo>^l}4G% zarcvhd_42Nv9M4iM&0Fe)R!4ov2CM9hnnkxj!2EZzNqs`f0r< z93HxF+DtAMgPs^B^gh*o&Nx%^5dd(u#Mn zFVom|Pb>`!-#C{Omw%Z6kpJAF ziaEQtC;Uecl<1=_V%qN?nx+lp^KTtIsqz&?8++Uxhx;E8$<`0lyY+7hQ?U{tOV&r~ zC90<3vYc2ikzQGeqXPqmzOJefO%Ha_wRXX{cQNkut zo5e8u3Y)Yn?eD#`Z>6N=BT4&St+eN*rM*z`I7E}Q{6NyanUa=|B<(p(q`fCCE!TQ! z&zpB?pY+nco067~B<*JbR)%nLx8}v2pO*H#6;)~ZfuwyaB`qIG+OwNT`#@S+uJzJ> zecq-0lb80rl(c*#X-}<{_M2&GA55)eejsW8nv#}}B<)w5Nc*d_v|Q_@{o1@s`$sSB z-&4}^k)+*HEA2PZ(q8qU>fG`JN&7}hT0WAr=Qfe{-n6t_>!tnHY^9CEosG4Wsy__q zV)Z|kKLXB!ip~afDH7sBpY`iA4hghjIT~EyJK!1K$p9?e#+|b|j>iKJ(dlPA=kCmd z(I|`DDMymUbH7?PIa;~wUQ~~#euN9h-83!?i%N&mg~6z`Whxy)Awip(K+#mR-?B=2 zbd@RK3l8%0A_dGxn#jv)C-Ua>L|$=dbt3tJCi3&j3YyCuC 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

94_3Y&k;~-lCf# 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

ir!Yvr<2L`ig_7cN-4v2UUoZE}l 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

7yG4%)Io5Vxv%u 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 + + + + Tauri + Yew App + + diff --git a/examples/test/src-tauri/.gitignore b/examples/test/src-tauri/.gitignore new file mode 100644 index 0000000..f4dfb82 --- /dev/null +++ b/examples/test/src-tauri/.gitignore @@ -0,0 +1,4 @@ +# Generated by Cargo +# will have compiled files and executables +/target/ + diff --git a/examples/test/src-tauri/Cargo.toml b/examples/test/src-tauri/Cargo.toml new file mode 100644 index 0000000..74230c6 --- /dev/null +++ b/examples/test/src-tauri/Cargo.toml @@ -0,0 +1,27 @@ +[package] +name = "tauri-sys-test" +version = "0.0.0" +description = "A Tauri App" +authors = ["you"] +license = "" +repository = "" +edition = "2021" +rust-version = "1.57" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[build-dependencies] +tauri-build = { version = "1.1", features = [] } + +[dependencies] +serde_json = "1.0" +serde = { version = "1.0", features = ["derive"] } +tauri = { version = "1.1", features = ["api-all"] } + +[features] +# by default Tauri runs in production mode +# when `tauri dev` runs it is executed with `cargo run --no-default-features` if `devPath` is an URL +default = [ "custom-protocol" ] +# this feature is used used for production builds where `devPath` points to the filesystem +# DO NOT remove this +custom-protocol = [ "tauri/custom-protocol" ] diff --git a/examples/test/src-tauri/build.rs b/examples/test/src-tauri/build.rs new file mode 100644 index 0000000..d860e1e --- /dev/null +++ b/examples/test/src-tauri/build.rs @@ -0,0 +1,3 @@ +fn main() { + tauri_build::build() +} diff --git a/examples/test/src-tauri/ci.tauri.conf.json b/examples/test/src-tauri/ci.tauri.conf.json new file mode 100644 index 0000000..b23a6dd --- /dev/null +++ b/examples/test/src-tauri/ci.tauri.conf.json @@ -0,0 +1,6 @@ +{ + "build": { + "beforeDevCommand": "trunk serve --features ci", + "beforeBuildCommand": "trunk build --release --features ci" + } +} diff --git a/examples/test/src-tauri/icons/128x128.png b/examples/test/src-tauri/icons/128x128.png new file mode 100644 index 0000000000000000000000000000000000000000..6be5e50e9b9ae84d9e2ee433f32ef446495eaf3b GIT binary patch literal 3512 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 literal 0 HcmV?d00001 diff --git a/examples/test/src-tauri/icons/128x128@2x.png b/examples/test/src-tauri/icons/128x128@2x.png new file mode 100644 index 0000000000000000000000000000000000000000..e81becee571e96f76aa5667f9324c05e5e7a4479 GIT binary patch literal 7012 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 Sh@|Ye~|0>}wMPLT8jm@Y!H33Sz}5aFI6 zM9Lzqz|;A*0sGs=2A1uU!1nk2dGF7knQwr99SAFen)x(eCO;F8y2C~0FD1YxRTPcy zPWVxkUYmeuz}Tv?7&Fe-!UE{)ZW)Mb;H)^#eHDv$`dkZGguJz@^MA!ZNGAUqt{|0H zpZ7Ch9S`q5!>R%}>}62!+(T^evyO+ImSo2wpu)su4^3nw5(%)KD%gbSev^*HZZ&3( z#&c@Z0gH|}Ck)w6fh0&NBJ62ib%R}(3@$VFl*_#l2W$wQ-~4RmZZAt5O*^2Q5}Xr8Hy@c`#pM?kc?hFWxRXr*mUfUCXf4ka5DD~ zat6d85COB05l#(P9*cQZ3EC8fVdS~?&vN#rce(aF9@xp80O2{{FBvU+{X>Hoh;xI` z{$e^Nw1y*VbO8wv`8|-m?NwNaKGTGaF{P^JLB^DbOYWIbn%eT`*!^C1H36=O8Z-M> zkD~88ry`eSo`tEBN4>w7OWZwUzlh{WM1m8R6zepqGcGMaV7vWY9b?K4b6~|HVG)ec wi>I@ws#sZo7or4_*4M>7;p5{nr2pZ?Uu4>Krr0kU)&Kwi07*qoM6N<$f)&@lf&c&j literal 0 HcmV?d00001 diff --git a/examples/test/src-tauri/icons/Square107x107Logo.png b/examples/test/src-tauri/icons/Square107x107Logo.png new file mode 100644 index 0000000000000000000000000000000000000000..0ca4f27198838968bd60ed7d371bfa23496b7fe5 GIT binary patch literal 2863 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 Y2S8W#vM)6=T>t<807*qoM6N<$f*y@n<^TWy literal 0 HcmV?d00001 diff --git a/examples/test/src-tauri/icons/Square284x284Logo.png b/examples/test/src-tauri/icons/Square284x284Logo.png new file mode 100644 index 0000000000000000000000000000000000000000..c021d2ba76619c08969ab688db3b27f29257aa6f GIT binary patch literal 7737 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 literal 0 HcmV?d00001 diff --git a/examples/test/src-tauri/icons/Square30x30Logo.png b/examples/test/src-tauri/icons/Square30x30Logo.png new file mode 100644 index 0000000000000000000000000000000000000000..621970023096ed9f494ba18ace15421a45cd65fa GIT binary patch literal 903 zcmV;219<$2P)2 z+CUKPMqaqGiH;zb!R4$B-WXS^YzQr=@UH>k4?*L)&R=zYjBrZenKdc9|JlS$SO*RJ zKt8FSTDAdk1g_WPAO!p^V!AuL;Lm;uQyV;zKq)J3i(;q*;k+pD%f3eltU`PYdy9(k0&%` zuWAPcV6|-y?|?7O1W!KSK}pbk8#~!|FA@(VJkt^V@0lio{afoAeo*f&$W2s6${5!1eKvAGD2$GZwSB98L2ZVS- zKn8ENRkZ*sb!@QugOrQNK3(sy1v%J#m|rpB+h|Nkqa3FRT>74xSs{#&saU2Lf!_Iq zKmuKAESh`gs!fneGWn+nf}l?7jE$HW!Af&vE5=G!QU)U2v&HLIBGXKk4nQx{hsHjL zLPMAo5=*uInFbq7(aa`Y2VX5wCmaeqvECOFv)a>0t>ZaEb*cJccER=BB?KFZhV$c^ znL*l8x*UYZv4WK|j?~Jt6~~F%{pk~z5A*>^M`?r5m9@RJ_x|uEtX(6Vk@Y()MVto* z93wr)%3m%|#OZ~srm>zF(JvDuTq*@;d&^>_BJm5hOU`3FjG70L#Vzv9I?`<7$T@

jU?lMi@tgxr7CqX_r3uw^y4tVU3Pm0sw;|1WSUO%?=bG`*Kmz6u4{#ti;T7AWIBAEh!(Y zz>O01&#X?Ds@L)Sb{CkG#Yz4$3o d@96)?#cz^xWoA}>B$xmI002ovPDHLkV1l3&k#zt7 literal 0 HcmV?d00001 diff --git a/examples/test/src-tauri/icons/Square310x310Logo.png b/examples/test/src-tauri/icons/Square310x310Logo.png new file mode 100644 index 0000000000000000000000000000000000000000..f9bc04839491e66c07b16ab03743c0c53b4109cc GIT binary patch literal 8591 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 JPDHLkV1lm|RXG3v literal 0 HcmV?d00001 diff --git a/examples/test/src-tauri/icons/Square71x71Logo.png b/examples/test/src-tauri/icons/Square71x71Logo.png new file mode 100644 index 0000000000000000000000000000000000000000..63440d7984936a9caa89275928d8dce97e4d033b GIT binary patch literal 2011 zcmV<12PF83P) zNQT)H*aaHEvPo@cmXa#lOYSVWlpR1nAeK#0OX|;=*_qi5z??aA=FFLM-4Sq2kUOhO z__7Kf+yUXO;t~3LY3h_?kg^Ly_=vx^#d`M`3g*hiK~ZY3AT~jwFz3ZcM?f3JYN1%a z6(!V_i6eLKHt^>r*a)I0z_0NJhQk($6o5l!E{?JkPrSxoeQ-;Fqc_D`_YF8=rsANr zG)LA_971eEG~9CGYBLi@?p9m)@)Tx607JQ+*Ue@kj-@a(D+T!4#k)I>|5h&OqgB`h z?c4$tE)KfVHvW8WK2f$Y7BwM~AJbeyzOSy~m#(8wbuiN%36#mj3KfSHV@MPU&upJC z26nV0*ffeHL`yvW^BH8IFmcq)d*U$Vl;hFt@(S`@2NOr}7Sd+Fp?rbjZ-XVpiL+ZJ zVf=)*k4NU-1sB(fAHUA1R4M)eyT=i=ZEY{1xRDA;0LLFcXEjsGBO-LlIJ_9C(9GAXuL zTaWXYBX?I{f^r>rHH*sm()GzY;)y_KC4pG$l!1wRaq#9`i86Kr+wt%Lp<83lq@x7B zc+~kD7&vz;-52pYhf9^cUJaN~#g4OG2QA=;{?W`wITJf(pw%Y67s?G_QcOUGi6G6& zes8BV2#>7foT{<4uXDpmrPUS?Y#N*Dc@w_-L=?H*HrkF$d z3#j0$2Sp3K2%hvFtymS9Sa)qEdq;w&zs&Xs0O0ycQ zotoD}7%D-MawgdX3vAu0raMUP)Mv~{MWbR(S_xv|QUu#_sO6A2bqlWvmiXwRRCa(P zrkd;tCrIm!27Jr$U`;uIDWY{FbGBTGA*OV zaq5*ndh8t-G|j7}W|J`FP8pl}HkPBUggH&DxJAlnPY$8scRI#6B;VhC88^|5Yw+Yw zFCZhin_c2;@Q?8%idU?`0AtcEb2~yxj9bROOps?20l^aI_TFE9(tF{z-yMMgA%zc2 z&=P-y{B&LH&tZx4DR**bcD>1&f?pVFQJX093q$1Y1bU|txk2hWkd(uZoI-_?$%A_< zj9#-AT7##pEbqV(?3jbINuVFV+y(4ETyBH8=ZjV&T43g4Od410WtYMbY;mOUw5}mR zm}em*yjgmZBrt*Rwfgs$&57DLxX0`84J8Wpfr?mqW>@9Q`v=b@3@>-;s2ay^AGb|G z<6sHfKvDhCp|(Ve;bzEcvl3O;*J%g4%2fpH=m(LF-ZdyZU1QbHsqFQSE-uy)Xaxb* zSL{BCOVmU2;8(hf{{5BA37-zT*~-HPxP<1#!&DztK74BQf4R+BWyl2;uM4NAH38ll z)?^!My^IQCPqXx!6D!LZt!(O(KGg{Rd}Pcg?FQ!DagHC3ltZvYG*|f@ACA5 z(y$gMwjP<7kBkLc{{3_A^=#U;p=LeX-Jli8g)Q4S zGsR5xg_uRQNQ?m0(5Dd4a{mz+l&#zm6l9G~=l9G~=k}HOSD-3Se z=jhwnuK|Cl<(>yq#FY^_60{B#=L!9<4oE+T!cL+`@6H3nF8HuR!uOycre0(cw+R)s zrXgw)9=+XH;QO7tEq!W5CUINfkhlOY*hZ-ijQkgQi9K~92bSxob%4Nfvqh88H~~nx4}GW7*L4jK^Py8nIo~x?+DryN$BTbk-|idT*N-e1Rex&uYxV8 zs;+vp|9Rr`zilkh+9til7D(?B%R(0-awITYu&enHvQ*rlq~fJXBoGMhV~fOV=|9Sz zk1j^!w~cK|E}ELFSzIe&R%qSO0o{x1yR+jkFgySCIvN*o&;lgREZ5PMw8rCoZ%QaX64C6^AXjaDf@M)O$fvw-Xm4 zt^`?V3UU)UuwtamC!Smc9uo<@k+`s;bllrS^0Va7iZ6r1vL1bPqV(2-93i1s$!T_D z7tto2#+s{;0~f3~jCJXYVqMD{n-L>?PJ6{s>>3BCj-7BZCXma<7nLp7)5N-2qp=YV z=uVqAdF{DaGK9W%ej3I74qbe*Ru1bXZOmb3#=x4dbdQe->(6ixLJ_>E)#QNzWXYcvW6ai{SG;$nFpf0nwv+(Nj!yGQQA zUjKFVWcY)R=mSTSED7eq+Po4|hgBUmOg zkxAe-S?M+cy74QOzJD{YBEl8BjD+U{A(=!MwcUdbDtM-|mVC1Zx*)wlldbxix&h}~ zRB>33<*kdnuy;t-t6PvK<3wNI%9No1-|!#7YMWLcVAWl)1%p7~kc$3Nj$`HYL?M?0 zHxgEOAjF!;?1ND$Ef*2drN7=hd~o}v;4!>O3aweAlzARE_O}LilNFK4f?FK>YAxny zg2e4Vs4e$@uZb#ffkjd|RPYdw(%@GhA!(do1fM}jYLPj~0OjZkyfM7?RV?ngr&#W7 zX>~NBj1Qz>{1lVP2ySYTM{2Z|9H#MIhAaKWJF8x!k$U$IIvSxxdzUT<8vqS)N*xyF z<7b`?NEKahvOxm3lGd@nhY#*Zd~YHoV28eSq9K;?>@rv3-WZouE6y`|u9yYXY%m~Q z2&dzR6|@f*?FxME>BG)S>h6kG4^pWuFu>SduoXjcxYq42)?UC>ppv++c&4o~W06%- zxJK2rAr7q$?q!9R6{DG}V2niO%37i?c3{JM_^St3fp9J_9t7h%(n#c) zI1GAp+(Mf4lE_tjdT?hR1hBxA)FjuQ$)d=r+mM2As#CFx(5bUnnd%h#WNL!Or=6fg zSrK0}ErG))U%UPO@26l$bbO7cO7#j^KK@~2RzxhaN)kiZv!lDBr6utA>3wGtgs`~5 z;JIkJAKSK$3X4VN4Jr2bC=;11U)JbUFc&34T41-n8HlSr*&jTr9Zr1O!FrERIr{b1 zDBgBKiUUj9Yo+yH4%aLS%;Y-+{sXhe$40FlMCA&W3q&RhZuYEasfCVd9na1V$R~po zrGm42x@cZVTpyFZk|kE=HRcDjk$NCS2_`F5;_C^+w2TC1x+ucV%B0sb2s$ib9Bd_un1t9}B+W_q;KcXHeqea5`f}#vwDo;9E(yh-Bp~2o zJ1Nz{OB2MFJe;k@UUh{iN*35uR)R_oo=Nz~RRkam&4m)cMMec9L)|06# z%}rAOmFG@q1~y+tYxV$h!wE+OQ_4x7-z({de9*XF4mQVf1=dWz@46 zg>a{{Gg}lEOcsz*-|DxY^8T0`EjT4#cz?KFJsuq;l?ZHMe4HWCWw13vwc$OS_n<(= z7R%@GcvBwlB_<_VQ;ah{M0~}k_$Mx4Ylb1a6!{cSN^b4;TaLmf6tUFtWatK_6f^cE&b_un2M|G?W_mkF9Cw)GzMsK>bTBr9#h4x_TJ_mxiyvpcx z(mHY#ojg0~sYK?TnQqBW;=&w+W((Hou&^&4;V9REo74rO)9W*EFf?P;`-M{5ebqtk(uz+ljul8XxR$4c;uCf zPh2p%Y@JJ++Klp_Aoy&xO%M?I;pL*n#;l6Wme+33E;?q zyB_qeHy|InYJ`nx5}3)GqQV0000N?3#xh7$lMzK8K=2xV( zktZjJ6YWNPc&1V{V~9QO?wPSoe)&new!5c$`gL_xy=nl)7-I|@5S|!RE;#(*f`XTT z%IP$>fC3K!xWbiM1xA1;A;OEF0;RS9X&Hz~*wF&SQ}Ba5Cgs6^7&#F-f3wB^@9@_t z$O^=xK?#kFNN9x|9p)QaAUVyy&=;T|sk zwhJjSG?B<3unKw-yl^_;g;(&W>UnIOJn!-fHn`t4%wEFf+A*ZS@I>Cf;p0RlP0s;G zB{}b{#5u}^5^sk1l@se~@i8l=@tL8BbQW-^>Dl6){24N!b39M@YXN#!DArs_8n0j& zM7tPYQf3l@aMuHp1$({Ify*S_r11k239S(w1##jdA;7!m4npDq;V}$oy{{vu+pySJ z7!XWki(gQUJMkz$=Y@S<+E!0v+E`2_>}$m~UZ zH-FM*u>cn2AtPR2G@Z6;pKvrONJx2ntwR0z zRj_HCj7Ti`&d}?{ep{75CX38{XcpSwS0fTBLDmIK(TCzoZBGDy#h(QWQWFtNkn+nc z&HE=LXekQxj*eiAG$2mDRQ&_=D~l7fDuh%-goKX<5(vBP$9+U0P%XB-$mzC<2akVu51 zlgo=P^}d5VpZt~UrEfh*fsW{#ruW6=u)(J*o0#lK5~p_(u+}HZ7D4Ej2dH+vxAPuk zL~0d~!_BUM7$E@bSgVhSZvgbx+-!}b>xJ1=HNqeWHC(*PWG$B@<*gR+F<6baDgVwY z3MJd;Z`$GcZY<7KAOo00fqkhzNfPWOjkQ{Ykla{Ht-kb~(Ya?X8wdH@_Mdzl%kqzZ zH=W3;i3t573JATCF@-e*3E{UlQc00xdQv0{%aqOD$H~cY*mkN_V=|LcnYGw~mV|^{ zf^A3vJCRrjL^8*6MBLD}Gnr?%FSLCfE3nEXos98pqB4$55+y*To%Hp^?@m0=^o#># zlQcSOJ&^DqC59_?JGhygkor0+MRoPyBssdv=ttOB9g>F{=5yuOz}46V&w& zb7%Z<1{okpGn%*@BeMw&Uq4`weLC;GC04vZCMN~FHmn!ET^;!t{M z=&o?zkssvFyM5mj+0|(Jpy#B&oYVj^Dir- z2+^5u8u=)#@r}uT;vy4YOh@+p>sMuNwv2% zV`mX&0RVvA!ra6W0KlhHFaTpb9S)*@kxmy`T9_C*N9S!&S!d3=xyV1=_B!lXe$8uc z4wlWdGBTItapnO_-~O!KZO(TF#Q%JBHz8%{(mp%(X-@^}N}rvXgUL=pRL&DHONu#q z=N>0>n3?2~bOw~i);4&Vbbp*ioNJh{Q z^{t-yi7pEDX@5PJcJJx`oBm&qgRyWqHl9?otN8zKrYldLFZ{vuVZqFLDRE$SXzz8+ z@Z4e4E$W;7_(v|EXWtPgpLRY(eIGQCA8W`Y+ZxyO+`n*B=^SS!S3 ze^OWD4-VhhKv(Vu4+$}MnFC)x7$JteaQkTLyX@uv?dYPeY{I$qjAF*c%sFvCSwQ7- z%icb+?_HtyMC3tBvEs#*#zmbCd?WU{M?7|MH|E8rZaO|N=_VhFk-o7~yyd80-)7hnVq7j=Ji?5o%544B;xp(Il zD4w~0H%NP@9N^1~Hmqi>Mkif3$ zN8x|bQoAK`TG~0&clT#-we#K~5@e#%+rGB9eV)-BFXKB(Tz2Io)n3>GnB$F3v5tW` z8sSMz>th~{D=9)1}@ z3g$b{MPBt85o0-CAhXGWnu%96nSq_!!>dM6Z61vr*vR%JO&-ZifMrDoj4;$^+Bk>_ zgtz2FLYQ~tq%)_nGT@`%;&>@pbXLkilx*L(EVPoLIZgxt7ft{8#}2srLc`t><74cj zLYW0qw_fncrc;SJmq*R2t2!8A335z1LZO7=yX%j+p33^l0*fmE)u7mbg~GS9>(^S< zLxwp{4_e4NxopE5 z@qSLnC_{#M=03^OtsiUfLYir2{~(^DZMi@aDJu!+c#I~eAU=I~@eL%%-H$<~>4lQ( zme&uomBhF~MKsd-wLS#(Auidp;L zZ&i91s%QbjT^}~C9u8Xx@D!H!CCET>pi8dQnRuNH1zEHWuOtt!omv8RNJ5bG?sHsr zY{y?=G1&VP>rIEy7h8y7P~R8*ICI7;;Lz@bc(q@{5061B_sr>0K1Y<0W_n<&L~O0o z)*(c9fb^*uh;gVU7X>CT1b`24+s-US6sb}4;u+=);K7Q4rVH-w_du4g%7>y-8A&MQ zK3z11aI|^hGqv>-!zS@=11M7f$D2|2?ECU^KOo0&(9H1+L9}qv%mjeAw3|1_SiVsr zeznoRzDe)c8bHlb=Y2@|=`$myj4cOXnKMGnIA##Z3o6+(l}uKrQkPMEF~r&ehk}UT zP4AzRK6xMl17v+2O0O$23so@@fGBR+LUoX~xGdso5mAmwrx;hpDqB>jSy}-xV+kul zT8e(2u-I;{_=JES^HFqm#KALpKnAbidEYtK<8QHiGcjFpx6aC2_rs)M7ysSc2@uP~ z6q!i6nQEkE0(W$IMi?kOD?OH-?$_XhU>*g>X=|PlBJx%Y-XjIahvVcB!&bsy%uvNm|R z>WU=ew>1fBz9g6IYamY=P&NEiTS>iiUh4eLUHIXv2}dw`dpY9&gQXEd@jy!$Q8UB zWf84B$mI~9iKbWMn~qwWD-gN9p`tRN$&0eSu$|5=E%oD&`wg|fkMe$l2d;#GHJ~{H zW&DJKHxHq|9^}hGo|rQ&9l^abfmLLBvPK=J#fr>Pb{n*`4khuSaETk;WKo7{CN9kd zT}VYZ%lCt#gO`#Ljt@O+;t|gQezuQgiCMOWq&uU#0e&*%?bmILDS$j+dC8Li`L!R&qAAKU}BIAVS$Nx9FlJFikZx>c`}s2 zVK*hspd>D|sVPfK74)Mo)`4I)9EG8v$Ked|HJV)gK(07!n7q9y4VL;hI@4HMVZqr( zUyP!1ICF=ZptFF==07PHPjeiz5e|dmI9_kaj#WM(XQN$s8UGanPoz&jF!Cp;KCWXh z1@_~$_)2|oF1kI)hodgM49#QM4}#n9pB*??r+?)+-TQ+tmoDtFtWu>;w<$UH0FgH;7! zcsVH^X-pprYF-u;6XR+C@t~Kl44D;%tcoi`mS9($r7Ln?iWi~;U8&q2*Ne|!xQ>y5 zx6wag2iz=aD;IdsWdQ2)FbK|wdbb8&m*PZyt2rdmHk05_p?uBMOBm=KMHmOKF^`z7Z5-3p{$M4_ur;(#Ocd}y++ZQ&{JRn zaq#l3a$LwPsbh9brsIMdnHxhumm5CkqT?V6Q?$j&bI!%K5dy>>l=lVgi0h|e1UkVPBMS#ma zEO5mpN%d`TF3_2ZOX|WJb`KFgHh>BE1qNzPj?jV>n_#}Qo|$6dWQbaA&;caCYsfrE zWh$5Vwar2So_P@8;_MenKXKT0DvY9iF-~w+#EHod906>8TaZ zp-XeI4mL>wqsWX7tO+A20KDSAX3RmlFZe@;+46U{aTjVbX?j!}28uKRw`?T(b2Ee` z0qu>s;f0bcy|M|9A%U`Jo&*`*$b;WhGt{;SmijF>;C;166~mQJ!pyk0nLw~E6YcBE zy=`wIozk85vy*lr3X1@dK9)in6GU&)w*)@%{DYxC-H^!Qc=@pKPNR0H0AX8YFB@jG z73q1?a9}%%J3;MyS37Y*!Ru{%owFDk3Xyj zboWC*D&VF%VkV+d{L35=;2>qCck=Bed(x3dYft`xFdj*mhO2fdxLZ1m!55j`Z}Lj5 zQXjow9$N!ap$84O#jBVnZxfg#hdkJps~EKj!!B$GtEw5-28X4^d&!|Dh>t>zMe$Zc zBzIUi0c*p4P$|4pBAC&SIdDHbU`2Ery7EezKq`EIIgTlGA9bmmp7w5WU2M zXtJoL;bTvR^|#hLXb!cR^2buLl4ii8EFhKb>}9b~a+l-m!FcR18=vN%`W^d6wawFz zCVWBL5e}o<^!MarxwfXaX28bTXP2)A?w-3-4{7W%s6)0sBNyZC>mQajDQ-n$UW@8 zGN~^sJM7A0t^~3W)W|wD_$>5T2Tu3wM{OP?!#hQ+$+c~&%oT6ZLzx&;W=Qf|@RoLf zXg})Tg$agG`jUT$YZJZ!Baiu#?7$lF^|yTd*}LlH*rM0*FL;mwTjw_3c*{YiY8LP| z)5Jlz+wEiW=Fvm(+U|lkdwwk;+K(bB+Lt?M&EPglIdNyVz}l{?!SO@ik1aQ=@+7D7 ziTO)8-cLfB@w0cEsz;_$P_0~P^%1szhrb11kfucUYk>-zqXsy{BOVlOwTIZ~A4im_ z8TfnUhpnkaGG@RkS+Bc&6VE2r*8hF^R5BxrdBzha0%ayag_#M^g!_{LI2HOIy+mGE z+Ulv}cZ7F-E^F^#Y13qKExjZ+ABkxEJHB_&8v0Z8#lW=D)nA%t{Ebfp^B-6SB#|O3R^59ZCTO!P&AY>oa?!7 zD$FkQEb%l*t;zz4@S08fBL(^|kzb?^@^|01mzQ@31sJ=Ro0kdK59ibIO8~tp9pxc* zc`StCY-Fg&`L6J6je;4$a~4D}{frxJ7M0EvFRDr~?=D6cTme2Whm8X6W&Y`z&X0e8 zuQs6Nx5lrB21m4AGDy~z9trvSNoA^N`GCTn3Rr`VJ+dW2Hp1t1V!=|{bSd&>P`lk< zK#OCon%R5~zAy4H2lyoTwS~(XEWfrA>2sNqV9jK2YlG0exC@4dcFyTG}CRhl(axm;Lc=h`A4kf(C}TIO5mO0yhI?6kmh zf_ggNIX>)F+-P2W;c$T8{*=FVopYv0tu@pVrZ#iwcrpsvad0W+4V&pz;9ncg04%i8 z%m?tpI7S(sCY@ec+A$JaL=fFyZ$Gv+l(*@XoB0G>Oyh|>LKqAT+sAXWgeqnjI{3sR- zf=!3t4b^R#kaNJUGQIK+`IFZ!7G!D=X@c>#l!+|M-8gC(dom9Vn@&Dx+!o}8Dv6;7 z@4H8Ju*IOSM?!NABD}n4{bFmBaN@vCNdEk$Nvq-ma-?u~4?wz}NCUjMlGvqkU= zjf$N5{O4T0g!1VJtN_!2*D%OHfh&(;C;1(%j0)Om?gz{mKPv*i8BG$IwW3UsllWI? zGq)9NK~M7xDq>5J+D*}6y95O-nPdRKWB?b zNiqCmyZ+q;Mwl401lrb?VM(RTg-Mb#q|TGFT5%B-=oPRA{Maf1&OssO)5SO_6C;)> z5V~mw+SG+fv~~Gn(-i7^t3g?s=qrrPZRMzq z&ZAS{*PcNor9gbgpaZ#`awtL?Ebufah~uM$Y~hoL8I8f!PCC-9Ix2qU$wKc$d0tvV z2On+N6c8}vx%CW8cpi^cL|nw<8E$t&Rhfa)z+)8JRt1(N*!7~=CO^iY^hTFkrtkIH zmp=gCFH3jJS@I;9Bq4{Zk6VAJ9rF$*>RmT45JY<_e^>dnW10BxLa8j!_@@F_uRdK} z5c=)g2@7~W%GZK%kG-&Iha~HW_Wtg|6sr2Ds6Et&=ad!71lVeJ%L(u#=n^7sE&|QR zeB88NX|+(-cwU>l1}BmZJYFP7aflH>-A z_)6R2=HUn~2+P3Xis$wIF0SxGDQ{k6O=`0--P%NQkEswzvIz8@i1izJ)Q5q2#yN)Y zpz-Nmf3oXP&Qtx|S3cR?mgTc$z)Is}0T}Kj2iMN32_sEu((Y($w)K`BI5wy$O0zXo;XiJD|Csl;V34Nw^ElH5_8Nxnd+RjgHFf-P{9(&Phu3T~{r;tU zXBaiuTU-XzeRH<7{&aPCvAg+7yq`AZYm0Z?DaVQxLuf17^-aZzWM-9DJn`}XAPwJkW}`h1>=Y!b3V1NjJFdQM9}kdX?c}CzPA>i% zHY3I|8Tn3y3rJvh%tHBaNsC3JI)Q|#QTdIMQKpYKakLjL0fzl1oe!m!@6=D7Tk`B) z&c4DVBmsG_@S7$xJ^VZFr~Ic7>)1JwaUO7!>$uo5JILO6OXN!qgVEhMSzJ*1xgYwE zVz#>_hL5H&xlKe)@tR*u@Nkp%#S*h$9r>2|;r}@HUOm*|M0!)+G`!E4f2}$q`YZ0z z)EPvPBH}aqvin(B(h9EK_A2>>KXMsa1&{7=t9{+EeW2tu9WygGb%I19^{op9AONea ziKyPZ6L5S^>jbnz|GiD_fWsrbun&owBFq^{n4UKa{h3MANBH*!ButdqLWf$$pw3p8 ztipSA3l1Cf_D0AA%TKG5*~7S+IF;}BGgS)R8QoXnqFbulp8Y95Ti)sIl6)_78r1?oucV`U3Q^C9t|(vKK>J`Ye?JaQpJD<+kmN;!}DP3l-{?v3zS2cZDTS zwwn1~@g1oz@EFFm|5#+=La9j&*F-kGN|)riiO;=5CNXWhsz-lST6^j=@y8N9gJ(sV zt+}9s@9AErw3A-Iy2G&@^E<=gw+u_naLl#4!!L}Gug-Lpof(j{ME=Jj?4swEwyD{ADCg3-iaB5P>Y~;}Vy5zan1F67h_$Qu1 z#R&g`SeTS=58cz->-G?DnZ9ZsWm7!S9id`i+p4Q6!CEZQq@SO?8M(p(MbSznz= zb^;Ch{~irL=x|i7zIO2yS^L*8vS4L@kxQ@j>Lm``<}!N|$n+`QcB!4v5$wcppkLCb zDVCY^)<#?XwRsZ#E+zge1kOP=QzqWH_>W^gp4c?n*E21t>T3bS+WvZ_nWn$rz!~-C zR^Pv-(fL@Byb#~`UH3vk5#XVHJisdM$(k<@W_e%CXN(z&&0|S1xSGWj&~y#Q>CSK+ z#d$k}1&x}~`qwCE`cH4ZhaUX~ql0OG`7(vHR|xfk8mt~?A&2Zx`YR7 zASkZm!UTjis3`|Au;GdkJ0>P-b;|dd@fN2417bhFMj5Xqt)yeTs>c!NAz-NC%*sz=37pn zjpwpSnyVKNJc{|-Z>xasRQYDqrwa!&_O^>BQf9b;FHNtW`LAo50@d^t&xhmjQZL6V z?n}5a7e1DKu5lntaAd$J{U;3>jqxdM*!~RV8X~HFLFG=W>3lUhz^MEb`M9_IH7ai3 zV$BR25jOL@PKLdU`e;TOJIlnK->)L+ClU8axg+ApsU~LQVA73?Ib#NF_o)iatHyx) zOI13iZ+$PItG0?C9Z#5};hfAb`_8Tm$(SDQ<?&)>k?a$RAO}R^keyZq&NYIn>EDLMoa2w2{4A33MoE-4$ z>(7BYyDVjdGQEPQF#WH_1AX)*23nWWTkBN`x%w>suY~>Q5T`V@d!?-00L$0?EZ~~z zX`QiQ5zDSI$M~mHp_z-tMdB9|qNSnd0W^XDU?*9__J8+Sr^5mIyk z>igxoZIxYl5h?JPjR`;2Y**%+&OZ`oX_!25nc5_ zWqf`D`1+3C%@}n7Oa3)rYicKi)%=>`6AL_lJ=ah_-FZ=wfnboHJ}ubdBL{Hon=NNr zgghzMkJp}h)~!1h!=t83rE*1m_PC_|ms zMbMpHTlplB4)Qg-=3RB#ZV+3I^;tkHx8>_of`YQ@)9KOvPb)+)ocdacxQH;Y-U%q1{pT`mF}!^Sm!F{T zMNM{8l&1_o2X3>^duDS9n7+MIvtbuo_Da9QQp9?k=?GUC6Qgl7ERyN1zt?C0B~?otAHaok5)tpAtf1}Y%Wo1ilAv3 zHf6kyQ%m=rXq;3RuBCN#43c>ek+Dq;Tf*MUpkff1Ki5;5hq3n3O5Vt^-r1`e0Wz$C zN|NQ7m0nd>`mVB+CE7weftn|L6z0^imuyY{J-D*_H&$pzD`&>E@1wrFO)O*)?xP~h zR%=Xv2Wb+rFNucBCF1w$X4gt*;~yC>cRC0oCyJ^66niBKAUC+EG=`J756l^kcQqv| zTk>d8dmV>;*f`RwkirK*Y;5rh#sV%Sw87ta0m|Judi-($*^m9gn#ezVTLdnj+*wQ` zsLy2ykxGMa%vvr7WI3JO9XraKXJ)_Gvh8`%NX?dM#El_;KWO-3;%aDqj~piAn$ko6 z*0Xmm$jdt_U4zj}s(`XIA16s5vgQ47vmDi1iXRBXs7+XW^KdA8&8fh4Hc10M`>09A z@lhlwOF(kk=w%BeD+N&u@g0LZC>NRuqkl4+%f*ITZAMKumobbNO`#2-Ql-$2dGC!7 zqwnO>3~TuZjfp=NS25`F+&yFDFbzWx@J(@6h6TFWEyk} zKB%>ULs3`Zhl$HR$Dc!DQ+HLOF9bZqM|B>9hfKj+Q>c2M_2xIMLh-yx+{a?GTNiizz9@eB*%{cWuExBF^$A2$vVZ-)B8pzq3EWb+YNY-VmLMHyUW*Sn7h>N_#uvjenHEF*)iK{`% z$D60Kq4puaM!UghbC(?Odgv#xOyN;0Wc99U&{U47&GX2YHcCSyR>}7IGYbKTW6B&? zig(}LHKm&K=!%3K@JhCDfD^c(WhF0vK@WT#_5MbE`K`aTMzWHYOc|#QHK>hq-Fqmm z5-{iAaR13!CvS*4AU1iu-;leMPp8JpRRW^=b2TNCLq4`^TNAbcgKPM?rd#j`{Ot$b z&ej<>jT&tpFgnWrm~T`~+Jx&F&}dDSJ~SV7wtN4AjMlr`1j8_F|dJz&N{b^-`TVF!9d3T<<(yxAoj>LXOj>bP<{b;q} zUNkk{VPtxI)Lb0kMjgd3a9rLVRe4X_wUjVH*0FCnNub41YL~Gq%6O{Nd;XC6F%{`_ z6pCFQZG)f4`VeaCKK2w2t5N7_msvl!CWeY3R!P?-9j zpT2PDzd$~iNxr2UDi%FAzLRCFtY2<6krVm`B2a?^>6?aYHP@gcsqz7k!xYArVH_VgC>Zx}~MP zCQ|MJtlznXm1abo7r{ct?Qm9FBV~9cptEpnLLPY*!}cmpP8xijUKI=v|NE}s@n>bp zsI_w`*rXj+aoly046r5F&P7sz=%~55u*-I=AJ%&uWGT0tfYh%!59^gO31m6f&XvOS zQ-1_mW3>EJ^oqtnp`}H{HOb5p-Q^Fuh3(tlL5o3G%9mA<*0G!G7p=uX{+i!J-hSg@ zDQX?QCBQ<{n4@4~f9?Bp_{=^iTw|0u@G1_s3Y6F4Bl5uD{2w{eOfWPd+gxBX$J`3wv26J#dmTwghWu+(UZxYz|qWh8SSot&ghzr zz#%NHC&XeJH2uN#Z6|X)8x{hIGTA6Kg!x3{|9N$9i|Bzgn2k*&FAuTlsPun(_8#4{ ze4)Sb^+oPtVZhjl8#XzLq(o&`oVi-*WaZPp40-8S_~V2L8fxtcW1qh5-U8qLOnZ|2 zi@rZlyDJNn8!9RF_9mH(><|-SU<&ODt4-nvd3)AF?`RQ)91T}x1ei05f&b}FM)^r0 zHC9en8O@F9Iy|^%-+r9_NF$wVF11f^5_VibTBr&}Z!@*v3CBvYZY^oA0YcYnu)@%IWk~|X;AkadOz8qKS4$w)O@iey1SS6 z{2;N1_SUv%897yOBcq%jwBw!|b2l)jCzAK0-aRK=;q|3{32!ipXRTZc88;mbj_$g# zg$`XRmbt^)qeGqV^F1ngtht{$yWO!4Ac2q^fy}Wh{0J-mW^;!2tuytq zr%WCjlAr@bS<6amJPd#^`ijIL)?(SdzA*w{o&kG+c}!DM7}2Seq?yitV&JIvmH89x zyKhjHr-{&w;j}mS&1@q5W*45ek{&I ze@rD0Dy>*0A+Ba(=y75(qbl6JUUJ|mwLm^=7bT~6AIKv_D{0}+*yg0p$#XS|ALr*x zp#S!^WTz0S2^Oiobqp_(Fj+hH(W2edojf`R7bs<@q2*-R;D6ymf6IYv7EVR4I!kaN z;60LIC=N65PO~8H>iGFUL^Wk;#&p5ZoH=PCj3ex+5J%%83=na+P#RQrrLn_0mCgIG zep#0X2vdpouBgbCHyC~FwOf4<;PUPa5=6STrSG65iAEJoIqF%ejp1X34C`bG{_&{J zmXm*p8x2f15EQZEm1O5&6;HYlMQ0i3WT%Ebobu7#enTz=H~Lu+8fAb3vjtbW00s5e z&S&q5$hxksEB!q4ig4Z)bXsRD^-cbJb;dX~ik*Up(}cCHe!li~RHZcTxnhw^?vcuE ze^+N08d$lQ*fjk=l2Nh@;`@eSt>NS5UyjyzMfCs3HjW~B! zgn~cQSMC40s9s;0;Abfob5jq=--`#g{mvKPNJ=Ya`W%K{11nZtyK7oB`Bztf-rSe{ zdN#R3m1$|7c$U@mI%h)L#R+ePQ^m&*$zD4K%>3bFyTiK19-*6=ZiZIgV>_sQ>fbn& zc3)9CD3uT4jP|ZhWdbfMbX#^@RJG>?73TE$|74KYZ`8Uiz=zKDcxAR0hY4jnlf11{ z6~AT2*(i&aB5DQI&t$!nT~hZ-UTH}l04AA|5+q^0mB3T6X?{wR7>JNV2WXp1W#9cN zKkA2d{(?9uQAl+A6R5M83d&Y7fZqPkrPjf%lW6=+xpP(7^`mkuk#tpo8x6gqd%Iy5 zX>%*QiG7@-$0UUa2_rO4WXs-|j|0}2Um>RLQD*_!>>Km30OB^l%cWHMWDLA>wS_aE zqH~_R3ixCZ3qd>L*P&rbjQ67pm(3G+DdX|iye^q^{fe=GoBnqyyz6|sa~0gwdSPrn z1}q1jF=*abzDjiy%_uYnoc8+5Zc2w?T&a`gQkJZL`(@-3R<<2?WjW}rnubM-cfV~{ zJ7uA(!S-dKSmb$924jT7XKck`^TjSvMJF3f+|$1!4pMp( z5TqK`p6kE(vXQ4T0U^Q=5Z|KBQa4)-Zj6MYt52G&x2Lf?cj*kZv~wv|4fL@NQRbB@ zj^kFh_9@J%8Urv(bnQPD*m8Srkq2A{d#hNNE``)p!327*^Zz#m1D?3yUh7X1xtVUv zOUOZ^wMVf`56VgEFCS^ln0&)%H&2!kAImd+6mz9S7%dsm?~ADN@+JRbNH1{GGU$vm zL1b?pcko4ixrdCvQ+pMK39cgzqMBTh5EIjv&i)ngL)ke8fA_jZ*F5=mV|~Xaw9NmS zM^F)#pmIe`aNHCG5tYNvxUZ0Pd#CcDqBLSCb1I;jnInV$*2CfElY7%yK^TxHF#e7! z1SG@F7}nXzBg*A4C7mIoEHB%{NKH<~hHVHeH~bT__Id7%cu<~MSy7bc zIf%!Kusf$@1II1(+oJ4*-js?Nl@AVOMFy3u!f_Lh-=W>x*KYS@gSWJnLjJSCg!O4i z^KYtBdXjK~5SH=ckN<8ToF4^Igo<=kNKWsz)RCOAekd6)lbHC9!3#>OA_138hbK%# z-TC4kC%gK*Y}9dJ(PZGBKhrUjUdd&ilqkx*Qyo($^k@eT7?^PO27O&|9#2P$OfUX( zgmP!vU;bnJC83aM@~kv26J5H&nb>Bbug6pEcZ1iOnQI(8`N6;3wiu{`KLg(>H^((f z0SC$RmO8$N>4y1PK=4COvP*#OCO_Io3t1m7zF4grt1BN({?H7HN^?Px#TPC z?*9EhbTTMn>NwWt%q%3xitA>2swz9#s{2x!#t2XQRPR;D21kGXup+;i@k!n;r@&CE z<%11aKZWCyGQj(6P#UBje<*g_uQ=^dXHN=bwITf*aAXO?+f)n`iGviv_wgf~EKX5e8f~ zAA5?N106ul*}n(4+`uN4K=3z?QoDvFpqu^-B3|J8e5S7P>SmsaTa=+($ z!}aD~U-}c^;IZ`5+7^`>I;-e>>oJf=f+mqQhlfwV8DvSWrv?}NZ~iJd$7PFj*eOw= zC&3POKj69%jP`;yjPE=~w%g`$Lo-nvgP4BN3=@X)mFz5}`E^@*q9Vf0gK(b*63hw) zy5T9n$V}&(v*qx$DTefDFw+onfVR^S-O6|F6pi1Is460D+~<+g(8K-bck)#*27~0L zeNQnXs?bOY?@VtXP~x;JVJmiE0ZAgBItP%<5AVQp1sQIDB!}odo2BPR{nVC3GC^;D zUKQB*wr+eZVWZqqV@#7^1=~0rDDWehRNeM*J|D&2t|6d#?sc+-XDi6Q4@C+dZALQg z#G(ym)d%Qqk&@ui$L&@1j4lnSseTdSa zvU~wCPnSwaCw4k`yN2IT zBSnV79VjVFIEbySMCv|k8U9w*vaPhq{~_do*4Ff(o$4itfVAb&RM)7P*^F+Hkm_-o zu0sBDq!Cw=W@4;uB%KlHwh$5<15Yivk@8}=q@YD*8V5{>4v|f}>kE89lx=2sT0Qv1 z)XCVzF75MNN03?&h$q2fME;Nsx7dVQaE_!k$NJfE@lOjvDt>N%MG|*Tx|n$)Z;k&T zBFV|y$25t!(MY$^7hRsM1Q&^*X%OY!DmI6VI{F^J-nZ?EN4mZWYz{21W5MX=u5)f% zm;f(Q?ES*tciL~7Asgk~6G z?CP&|0Q|u)yV?lt%jC^qIHfDb?th4g-x}Y z%?_`t(BtbeX~%QO$%;2`q4Qfkma}2L3tRZmH;z8-C63sZc}04=`JrK}vLNkd>DzQ0 zWI~A?mz*;6K#H2-ovkM8sfs3fTp}@%I$r*g?kVDk`X;>1+gM^iAE#BXFUEpU$+O9bR%+Bqpn?y>SThir1IrSu>+Za#iq}r z<#yAvQ*blz95tQJH$XKK7U9Kky{I*!hqCM--Nx!#%C85wZ;Ehoc-}&_#7* zCSVO8ZO87J04Z;v|LHP>b$|*?pw+&!83|uYEXtSbm;P?&Y%4#o9@gccgq0;)FiRod zGsUq{ykrs5QZxIZ_yE-nM9=rG+?1`}(fx0pf|1629^qJF!X(on%CguA? zI{@b`TtX=6g%Iui4!UO*PzBStp28NJA&-!8YmldoB#nM=aCFI5wv-rojZ%|FI{}}C z(Qn+zTtcE-=`a9!_TitvQUpuUt4+)DsD{sKtVAgtj4Sota|JP!`Xo@o%#JYQ|fhF}`C~i4E?}#Jtozy71v#2_Wj6F(2sSsG|IV`;k20GkH4$r%FPDc2^s*RO*dQ z3)Vd?j?I#PhM$$V1eMSe7q^`h6`h?VZ}s3*Fz_|OLO%RhZq43L`*?CZLrDoH1yRv# z_8QYMiY}VMTtX2FR!>?=Mj;1se9h|;X(cz$JpGE?YNx$i9aMRZots!FH%B*e zuH0vazPhW;ZhuQ!C{-ggjXRa=|?dd5MV@w^TN8(G?gS<7m--hntMV>I0oB-R#Ntnje5q>wZ zW12sW7(_P>LPDQ_HVvlbSn9@v(FR}P=_D+DfBOE$%m)$oXskIP56;n8(gfX)TdSXV z)Q0-e_vYKwVeAKAuN-cr0Hcg&2z7Lf!xeAPCmG3H*U(CEA|A52%z$RC&Y}Xo*+j5+D$SZuXTle}At6Iq0)Hj?P zj@zVPChfb%W^XewKbn1SJ6~q54xU}R9}tgy0XVMva@@(t7|}nXO0bAEUEYGC7@@}5 z5@o#xpm&Z1?(1Q}nCS6z84l#YQEBG%@M|db+cnM&wn|{8IRgeM(F9iS6*|Yotweo+ zb_Ig1Wf=1eD7kN)d}X+&gB{SPq04?6|BoqY9OaUS>S|7p%C2Jn``UfO?dVunXso3Q z!Xfcl{};KZ%+T~3*U?u5XQ;^3>Ukp^7cF_>i*# ztEDvpum(vb%Ohnzqk`v-lU?AK1zd5&PgVoG@nv}bN$0M5iKZTEeI}+e9{(XjKBdKj zbkyFkTYb%b+t1#NU|S8I5@%ABw$ENUeL@p_EgNi}r*~$LRVlF|wm^n+&d^E8`M1Kv z$WJoJq&eJO@SR2mX>VAVJ;Phj5ybgNFzQ?{H2Hz7Mm4RQF8}Za`JrZQP!;5zQ0Qf1 zTSX;fKrcFvEA)AvWjR24ME8OM@{T_{U!YWF4i=9(|4HD-+^JcK-}Ti}$Fw=7-M&4> zW`S!&?Pa>8av2NfA1EI$-ae&Yv{lj1ziYAs1kO2Nl6}PBE6(maNRA*V1354dzmNfX z4PLQixbypzmBnj&{e`d22d%}b&3Wrk-wRzd-FcCIry|`u>MWzhP2Rj5i1KrT7s_C5 zbV^06sMcmf~Ji@3@nbaKD& zF~)V3ll?ItCy7lb1Hd<=yNh`_`2RK(cj&)Zc#tZ#KhQ(||RqzUg(<(23MmKkS1J2|4A zz-Ny+JuS3UsKRCWugL<(sHN%Ozv??9`#w+Md#^h|)#D$%mz^xCX$~%?Eeu>y!9A}} zu#!|b_UobCJXANREwbRo|57RUujCe*;J$9&v)}9uN~Nkd|JKgnbYRL?#AbEsuh&%q zR= zdPR)!Ifl3SKl?~{`VZ8Dzz>bT^+G`W=cd7#AYegyCY|{H%$27So!f~M73y&W$ja5< zNBbt|;psoRuB%7H(y~{Q?~aFqFStZx-ChfPFY=MlD8ehu+{}kGD=Anr_9C9_}mZbDxdyh}o2(oEq$ z`0IR=aW>v(yrdI+#|dSS7;!!Nr|s6Dzrw8KdURNQOq`bgR~(pbr*|)zG$=7uCLT-E zJZd&bpzjL3xS5Z-RatN{nZFiap0oDoT2SP&)XxIP{y&^GQfxb0anI-U2HI63sC}0) z2xu5Q2Il|fpM+<%Wz+ELt+aFElUlF#KPiAOx4AwfzxFnZj)i{OjJMY+q_&;8Cunk3 z(^&HJuyLPYu*+Jj+FXhC@uxvmwUGPxGaala$lC|)Gx*do2Kj>Wa`L-Xk~i5FP9ArQ z-}#sLQxP5LYdmp;|N8Yxb4Q1FtmtcZ&yP*j5jC}*q93dxnQcT14(s82k`3W*JhbE# zK!Blf_?usrChT@!L&!;NM7LJ8Yoc03#g;g>QSry7>zcAF(drpm7^q4Jmu$PV!BovZ z<6$q@_P+KfRMK%?nxQVN{O`qpi!4fjm683BL=c-N2`~lSfdZ^xDSbdCc3BJiX< z@4oJqS4$63s20@stG!JAq~*hmen7nN0BwIUXkmIJkgIx+RaR71y8Er^y*?eai2kQ{ zVn;1s9u4+2g-VP;fFF9HH%WUX_j|V5b36-@>1s5+F?_>TI-T?|_IP_x6PDQd%t<_y zQZbnsB)c?(F%xeH1Zt%s0)a-u5#_fa*EAr)gHGyWh@h2-k)%80ukAheP#T*ElO>eU zk8d^LFOj;sYP&yqZEDm7fqqDj7T7`T-8zNZzW)xJXoZG7GTJdH1mW6go9_qdesxh~ zgev?l@!A`6CVSR;-nKd0;FqGINnbtcjB;C7<=mCeXlHkT9yRg2;QN7OLK~EVH{dX0 zt1ae@EaNAYcqU3`!~l%)-5P4Ez~A?^7s)W9ERF~Fw{j#Y+MwM??jmR{z}H^3U^wIF zmEwy)C(zq5Y`_>*nUf~NH0qi0GhIP0T8R)<1_>Lcl0>#rJJr`x%$*>qW%93U!8otjT*PpcP|Z@)s!8=)!2Ni_dcW`fMp_Ewgv|0@ zNNS`s+Da|rk-0vF>+P|eS?*2HiS#Fgn-mxb&k-6Cen*jYcAlx*?O>le)}biTSzWH~ ztcI~}B``m+(k*H0t-U5C2&OXuzBTi}x8_#g{(LiM|M5?MOrJK3r^N&Q9*~k!yC`v> z@3C1C`Jc4herExy{<>6P2)~1LXE^=eip55=N!U~LvMnS_4@~?fDhv(M)_3B!d$fXw)()N$V^R3@X zl>Gba-_vjwL51$;wm-|IdJ${9f)97Lk^IzzS7su0e44w#AGPOVzCa-hs{pw{Uz0@Uddaj+U4aM-U^XN5iZ9KIqSai`x*bxu8v#*XpxHrK}b9*A*? zn{(@?7}luAtSXoDhn?p_rUSC@@%<@wNn9K95fR1=gZn8P882%A7RtL) z`-gd(*&D{ap|4h;27ZDZbsje82Z7skFCuF)nU)y-1YCsuP_cM6{&<-+a_4J#a@|bI z$E#njrYlJGFn01Ptp9O+y}nQ)olkM6UiPP#cvAOZ$?Jolnj}_`93_7kTDwnPZwD(5qYhz%M__z=3c7p-oDCs9fj_$hpRa(>GPwGiddP#z>uvLuFV0lq`cx~}>kt5oo3Yg_sPhx~{MYyh zcR1N{QUi4LHqlbnA2H{^1Fzqds!1c78vhHx24PO%3)$qb zWz2LjI6dZBB1Z{Ckec4zzK`0GZ`M5)=u;hyKEbmO43CvIh$6G${`J6gO{I#9<9qHA z{ihzXJbp{@d_W^&v2he+_i!Ii|40A6oe(3*Elvq=IV1{8rIl+n7R>IN#skD%V22~1 zj46>Cw`r_(*GZB?Y6Id3_Hk-iT!r`s5);oNX74q3`%-8X1ZB6L&S29uc6EC0GWJre z0tK&+vdLhc18%?+JMv-_x>*W0O3828!lRs#P62^T)yOtQx z(o!T@h-e=X$bR7s+Q=4cdw7!b{^aPannj*RIV@rm^{ViqUtixZF{=_5<u%oFUn&Hh~ zqsk+#0zvj!1svpX^1)a?D&;S8oNhTg%!vn_s#&T=q5QAHoyUIm8P%7-nG$95&mDs% z$(qR0PaaqoS|H{9@09S0a}~My{wx}sNWdOg|KeGY2|R%CVt_Em4EZ`_RWl=2a(u2k zWIx3{E*$Vw7u;ay4r=*m`nCS^}fR<@5yet_-q?Zr{+U9(x&*(3R7*@p^Uf9O<<4&Q3ekMI) z9usDi0q=0ftG?c|_PkiVN23(S@6yeTD_62a7i_-y$U&PKKQ4)uq|Jom zTC7$DbeNea8HscnWPuaP;@5!{fIBYbAz$n4#A+^Io5hv; z(xT7`lUwNKoy(o95Q}30)g{v`GVGqjGyPNQ#f9^~4%sqmb&=_O#IRD!s35Vk>W_H# zX*46AL2V{HEAf2oliNKU9}7~C{Ovu`0AIsj2E6Q_q9d;z7{97t&?CR?!19HRd*ZIr zJ~>tWItaXzLRzr+68rZN$WwT#B-(DlX!mel*@-(|H`{ylDi~37L-$77Jz)cixESn> zs1-m#9Ni0zj$k&o8)zNi?xE<&{5HNTMhm!}U!mTw8bG0bBD)MC{pJSI2&A+1Nk-TQ z#6@;|pTQ1%z9YxP1p+3Wr_{bSBVtd}GTf&U%zHO)UPXHgm`iRMM493Wrxp*2im)zH z81DfE)c((QF`r*+Wh8Ch(2c|i$!6RT(Czq zu8=H{3x8oJ8lV5&{lSZa#t}FddcZfWr&bSxeK~8*<>Kq++eZ}xLSSa0@ z3l}=-gjPoiw}n+qDugEpgI|I*70IT2K=|vn&6RwxMt#9%(BDAZlWbk98IU+y zMUnWNX2IcX)& zc&1%-TS3dXj%80r7`df7Ha22mdfrxc^R_ZTAa;S#VPS0Yzl}h8hJ?DI;6)*$R;6(aMfz3JXc!g?S19$&8ze9y>lZ|2mof=g%}`&tnDg$b<)>M3z0ym_>d%);=fo1((=9()zr8428+H9m zc<$E)X^x&5c)IVul9ZwVML1S?js7^II2b)*35xID`$#>yRb3vCRtHyQ!U^5uleo}X zvTQnZ>dDVIy-m-z%2@o12~g`t{sV%*%6N+ouyN%$A`R+UWol9eA{OC?R@D`e6SNtj z5eyqHjRLJdgAhN`;?E)sJ?YqoAT~b0by~rA+PB%`zB*in#QAn3A?l0R2Kd!CX7QIR zPd)am`|=Z<9EsYU(Ge`(f?TrE8#=f=8J0pB7rIy_yJXOX@*S22*4xNQK!2%xxtg z9E!{SykzLH-}d^R%w+IriY>?yyFzb$gv$F~_zY?T29CzX8w#(+J^NNh7ORQt&eOpa zBSaxW4273ti#@{fHcN1p2^|A=ks)XIkND|=1)}k$W9SopPj*11y0Ylh>MwQBaG4kP zEwX%*QZ12mO!oV673_8(5Zqj>M>t!ortIm|A!0c@8qBSfXm3o+{B_Zi`#EQK!XB;p z>a3;>ShU7DE|_g01PeulY069?E)*Y{;1Bagq2`m|jDEfot`OlGAIt5ab)^p{$v7EQ zn5owf7k11m+W-F5f`iXiOYDQX*B?T0O8~fmS9nYR7|RDDJ%}ng!S=~hQ7i`yf>&`r zq=!zhUdLA)4_%Z9DO)}!fdIS^l&9^RmJa!B7TkranE0|Otpqdcpy)|0U_*W|?JuI5 zeQJ04yY*tVQ!2s;`}FZEr*G~P5~y!FgaLK_=tEKDPn{r}xRl)uWNeAsIf&G*7C#OP zHUt+Gqn^p5BCrfcBO*W>Q;7uWR}n~5HVRqyuL&00AB9NZA7CTgf5w87AX+wGBXd$kaqonyujdwJ68^5Y6nxMI|VibBFA(>?5(ta@PHR$>R&Y zN)I6NS7l$kim$ndZu*gDg#H&3k#=DkmBRQ$O%)a4ZT2%-)Db1fZ+hx>V?=*FYI_Ex zh#3ZMfs=MAE>eQoiuiuoJBB)}HTUnbftI`&A9PC_fE+9!=qte6nG4FGl?#m=s6XDL zl$YCaa10HRrd>d%amfso3ftJddoub_LPBluw%*BLtBn%y?16BWbvbSPczr6Rq`w3k zdC1n&5=#f-7utFa!pj2vGpXPu5MuslW=VaN9vC z-s-8VTR#@f{;Hu%3URwz{SJ%@0WyC$^|qy5&pX2>1(yQc8*-^}e5~z+fc*TgUK+{! zs?3(OMYu;5dh8gna3K03utKV8DcQyKl|a;LEXfD_!DH@|SR#2~LqO-=18E?tu?2;v zPokCa*ea<%dpxG`qlgQ$YA@h$Fn*#c0{-zD`S7wou$Y=5Lh4V8oRW6;XYV@vZG{T$ z;{m@J!8xsTgRt51X#O?#Dc^#cs7^E?Od*`7fGj?XnbMQj#bB(;_baDR9K0 z4){TdX2yjCM;VW`zHAY(hDPMZ?@gcOnU;l4xH#&y@ve2dY@nF=n{l z^%)KDP%G%RcyO_%!yd3!YpB3M!^E$YFMmv-{zR=^%_c^-%^NhqKRJ<(<6LqL1)|i% zK;xj)Rk#T)C{-Z%S(5W{3aLLOmw9BRiW(5mJ`etm|2jITtp&SU%poM;5v>fvsUzVZ{TGUJg4XWXNEKTVfw?lMi``4?MbNSbvo{aGNUJMl{=3= z?LjeU?l0llH!uDOM(h{z(bk~l_nAtoPtC)ae(z{w!CqKap3mttzK0UF|MEc2B$}s~ zCm(EVteE!3zv3(_BY%(jj-96UVeO8(dCmsT{m;Ro{Q$!O_ulNUs)KeWH3M3rz4e!K zu-VBgF_0j~IY=EX>H)>lZy5avB$oEiXj$jCG&;C98<(fJV$H+%lVAS3zI{CMhcLJi z*cW~!C_m%Me(GsRLa3WW&gTiHy$Vu{>B@|Z-R zpeLDv7MMu8_c3?S;V8gx=+j9=|WJ zRbr%c^vSOlVnfm#^ZTy&PAgfd*Q0&vC+Rr7?Tr~l$N*GAQ^QH*w=JPTnlL^&lU5b^ zCHv-u-O9Ucr}miy5cyFIc7Hz$5?)^L9B@~=wI*eF%&yJ&J83D#@OOm^?+srA*X{Rr zvWG3@Mv9nS9kcUnOP}_;Y6=a}Jco|YEF}r3W$uA{(m>|il75&;nt-SWG``-BXH8=8 zM0vI@bZ;a54OY@j?W>~3be)a=GL+gEiwDbg`z!yAvHneE6`l4UkEk!n4yl<8~>7${x8VM{Es)Fv2Nd($msw2>I+OrUnZw z7*t}@lW`SdOszQSjL|nEpUuChj9L_T`^pAngNB^FzgXIWp7Nz}0xXeeu$tiPhD@v| z;q+h^wPybB<);V11C+S?DkEV!AK&Pxzv^Y;uMGRTT6F(?{%B+flUW=8@6AumUi-hw znak@V3V$E;1pFEaM)`+NW`LZ-{SVoVrnlwez()aS%b19Y071C~TLwR*!U!_k*T;kE+cO|4DOxj?|g{P&w}SH+_rcxv!(puZ@wYh06FCJJY`b@P{Zdpr#MhjS!-4(%73a> zqPPGA$ex!4_q5R9B_53sExPw_ra6&T*Y_-7o?x*?aUv9uv?&W)&e*b+z zS<|SRP~F zZ59uJ&H^q1|L<(AWv=XTqzqq^Wf^~SQa<=ll+biw>qnkR2cT!koCLN4VF?7&Zh%b0 zn!vzk9eHq9zp3_W?hB`SOtpPxsqDb+TA}-xWcr5V@oV;mcwAe9)Y9R#V|fh?fUiUd zWGKUZ$u4;9MS`W~7Iu32p@i1Q@^i07gZ(|Fs?!bd z(mMQE`?gXI1Nc-&le`V{Q%$$+_aZB=1S&_}T^<`~ui-U|-|X^FN=swMyjO%#}N}zg2IA$^RDucRT|&b zbzUmwp!XK#!FBv2qoy9YL}s4hY4 z*a^PJ=e2)CD-Lp{aTBsrL5^^-j;LmAKZR z?oTYt*I6;V2<^o~=CbC^-|=Wo1CW(E#((*A6#JKjFi~oj^IhQ@P6uYxQ~uUpl6UxAZ(QpOtDT(`+_;ROwFUWFfsheObHnMXy~PMv|a{G9F4pZdg?p zu0)y1$rj0ArJ)t3%IJnK+Us@S#yaV5z45%09m_ouRQ}6;p&^f6iIE6q109NM6Lzi) zEgyZ^oUD6@?f_H1laJ$1vU$spAb+9jPDPJ}k*(|3FFzAiyd^m1E)|TDVGykss$bVd zc~|piKtuY{fpVUZdHqMF`5}M3gT6JEQ+S=zPs&j>j^}Fve+Do5bmmfO+i0X0*L{)C zY!H}^xnzlN-vT(mfw^N0U9%Bw@n}*nE#&PXZsyvHQd!?6cc3V(_@QUu?z%Gb(iG`Z zWarEr>PqOd)%|5ZIs;4~*oC;H5kCy+>$776xugWCQFN6^3(jp024>jGPLu`))!fnD zc?}{nR}QQICrW#5sRHTau;y;LTV500-v0`3Z)KxDcshdY&MjTRZ@-~);yI1rD;j$= zM1F_}d%*+%pL$S9d9<|XbAJ!J_b+ZF<-ENees+}~U~9$VC*Q1u*z=!f_+Ilex9^VA zq9<#7|1#8erE{upJ6&sLaB)_|U9C9cBxS<^bsR_I`eLq(`O2-D+X}%y3U1mh)jm%B zdj-+{h+Bi+jFeN${q=TW;jrM(eXgdTV^{1!6{89(2HevbFOQCPPXg*wIZ*ddKR(fm zi{c??t&DgFj|wgR*kT435yE2=;_K=^toY__<*EjT0pvc4aT7A0>&5zxLIc5GyQ7<5 z3@cEm98?6%-e0?SP?8*K_KD_s0XRI2Ml_BP?~^;nTfO&A7dc6ayQC@bs4ev0{qu*( z6xHcKgK)}~3#8!18}{A6rjMT}P6R@$IA>(7T}-bwzgL?W5g?L{G$LHAsIf)YPZn&( zoNs@Rq+o^*PkZ*+_D9^CZCjRtj2&Jh#&-`U1!hfwW$y8yYhOlN#KZYv?h|e9D>69z zg%)u@dH6ST1~?B)B63kbjEE`iDMUK)YlQA-!MikC=q-ug!}85yTfHoR+Q2|`drBR= z!4}g`rTVh?asbkD>kt;fWIAZNRc#+mOvC}Swb((nUkGSejLt-tQY2FRf&gW3hxWP% zdfsJQZ3ySK*x_Tyn@GQwr;PjyYO9vRX+RcU({~X>o;@_gs^mBI&e?Bj7q{+?F}-Vh zayWRDDHHS61|Yx0=>X+&JADZ+0))BHgx@cgp6@Z?_orkhPG|##M?a>eK+j(S3>ZtcC8%07 z6ks8J-KRVXIBUKsjE3SjTJwD?m@q>(t?36rF5n&(klb~Wc|`B0Gs_Bul{6^W1QstA z5O^b7Yj4|di5D&wiEd)Idn(0NI0#5W%nP9EGV{wSxyG*cgZV#qQRk|gHk8fWWR2Tx z(4&nfl}A}RNl<7Sp_dQk-^$+l7o2b50(0+Bw-!o#ddb9|#%bPhECJ>{!oh3^OV4-a zdhl{C%Lg@|JeOOg{waMC&jBN^Fuy9?sPoZ=Ke)xn$1jmi7vBrN_9bFU3&96@yUL9o zCM*h`bS;6m&XGI_Y>EUp4~51{GZnDvTgtWW)V=Lv&1sX&SppW>dmh9+Ck`KDZzL^o z;@m|*IT_l9=H|j6wo!p67em$#4EFoe@O$5cwFI)rk8$;BU=k&8$@LpGUk8a`6`)d3TCMTeG8gmmD$uCb9$Gy5DFlA?~l^Kq#A~2UcY*?3MB^I zKHFQ2dGC-uHZT$?Bn1+7=?n!OxzR>gGlRa`5{qFE9>3D=D_5zA-)C7|D`c}75{(D9 zAr6+bC*-1oE?s2k4V%w&!WiAwzJfIFV0>9i+*0I^4}lJ&#)AXZZJ;5?3kVMK~CF{{!p{+R!+M zw*}l}&?3;;<2>i5wJSGY&UdxZd|R&0!gFI>i9~_NR(rTzmRpSm|LYt}zxr&>Q z=8F07pSbbqW?q9A-hKprw)5X3)px+nzt7vf#jYYU5@Fa8!-1G>#t)QVWy+lNq`_h+ z__CzZ%o7^Of8K}XM_J*bV0MRjJ5AzwrMy5qKTHf`iAY3}H}#Di?o~iR+#Ll94U>|@ zuV?_wib>{Y#4&ZC@^(w~h`w@f&Liarf*VvxPCyIntAom(WbXe>2cq=jTPUXQEpWL# zY?lRJy$dMU$deD>A*}PnVH;)EQ)y7o z&0TtKW!}k(1?O%F#aU11kz;?@pqx%0UDYs*aQ0s@U6wRJ)Gz@M9UXDgM3LP%_v2&{ z3*H(tDG-%_-ZA_rOrFd+^7d4kgLWw1RL$GYDcj*IWo-Z`FlWoVKaQgiIKgeHO>+IdXzf1r{QvUb1XzqpoNl8~!h*73Qei|>A1!G2B z&58g-%b4yGE%6^-jWWZt()|ysCxzK9wwLL%4jNKUJ)dn{(z9q~%n%y|rG6U+>99fW z$Ur#F=}Hk+8Bc>p^(ddJsA_-v08RA}18eus8jde$t8)t6IKeMHAS65i>TeYINJyyP=Qz=oMo$RvQmioDWmw>`Iox+iz^D5TI#bJ}2#|@zmEx$0i4L(4{p;PI14_SaJo28kuAP13v2}dVda>khHlqiA?wK7faj#saDOpoXGU)I1yS}7T~66-=pyoy$bZ! zU9xXoFYMtxQj5hjORK7E#;t@5uTJuyRywXIp+IXkCsId{>wt@>iewnxlm8aFy=Zao ztI@d8fCh~?BC`Ua($T=+ng~>MIGrdGuXRZBmFlw-EUET4aL&yCf*i=$^tXEw&pnV8 zAqm?ne=^CASfSi20$g&`Ml2mq)Ku^KWO$-y#CU?+?t_g!s#Gx`QdWOnyE@23m5#^l zi2dPXC%w^R+40X?%EqIvanwlF^5_Q>y-&4;<^8D+U+g5~WMFC@{Ji{;=Lrg_W>*Wn zY|mbzjiPl9(~D%e_}}!~DiR~q1jLSpWtb`%Xlsh_4bp%fIZXiP(S_sxMNG9I{ERNx zWwwXcUVsd>^b@jlTJ5Lnp_{{yt;zluuLnNGeDIlEAbTMDS;0@9@(R2d4Ni060S}Zs zD@fsih=IZp5WpC*$aQXd(QQ3$4>xm%;&%ZTdP3fa%$uGlMi)3^u6+_rVW+r8wwEed zF*39T{HOdel6e+u#2;g>{B~{LraZay0w-qm9o*2n zDZuGw|7zo@ErUjDeuLhxXy0F#<6~V}s8O5c<@69*_7CG}3sqt_Qg0E=e>x+${OP(@ zz;0Wr#;29i^&tlKAQR-c)P+$E4(q>xk-Cpa?7n|4D}VkX_Xu_=@N-fnRN)oyQCK0nc8-+@9mh)HINvEKQ@Dee%n#5X{y7WzU>aOc`+#C=C~#vlPdZ zfGh}I)P1_HM~J;n+PBZ2I9a_9TEcF>X7tdrTkCDR|3#p3ddnrrJfPGPupgS+(Y+vq zxYZt|lX~S*k^7hn*PUO9Gfo2-|b%Jg#n$GZbN6gib5Y@xS<);SBbFTeAc`8(V`BjUGOp1X!-ry zeBmr`?6QzToGMZADai3UgoIb~1XKdCT*N9nppRnPk9|UABp#VZ6!p`>mUWn@gdi`v zy}acVF_7m2bL+=0YL;E?TzqY}vrPhA&9Y1ig*^odnYF^t-ti_k&D{Sj1Fg^<7#3)b zESbEA&?fb-719hQ9z1Jxhtfq8WU@|2_C``4S7a9-QIcUA_WvI!xiP z0TlJ0KlX0_Yi(XC3}s;H73%lL!&ZG00H6}*W1U20u(@!=q;=^AbMCLr$}bUVBfKzCigzOcuz$7 zMbMB9@-cb%{N56U656{%Pq}o2B|H3#-F^3%p5}pzKuEG+yaujSCii6~qaFv|>L*AF zWNc(@CYYxh#2N6hEBd0y%a6rPxT$T^WX*tS({mQ@&vjC4E(?KZB$QQ2vrDOzfs@?gS z|6s3n>t_+Tz#A)i)_)CZ+b$pu%DmJN#k_!0*<*%_>o6jxfS|MKK^Sc)mVUwWpTIeB zT#?%l{-K~<=x11>umN0n#xGYQ&xoerE4nob({OuQ=9s}eP7et6#ZpBudt)iUd6%Ni zC4U&?89?SdQ%AmKldfDY&Um=kFS-Qt{nPf&D=h?vR4`KqqzHX@>t@eUFNl{YGFlqn zbO2!|Z-jhwoZH?zVY3eFrj+FI% z_&4B%)A?UTU786=b^&$7$-_%{E3{jKL;H>oNuyDis2UmMYj@CH1c!TpzPbScOv}K* zyOu&xjEO$Miaho!+^GNkDH{q%<|fKIQHIW6t`aMluH@!j@bR>EJi1q{$I5BA$ ze_i|Cy3HUm#n73O;!aPw@wZ?u5fmG;hl*9SFC7m` z1F*thhd-aRJVgYiMf)dlK@y8@2qL~Ph1qBlo02~omqy}N*@!3RZ={DR;y}NjLjsdS z#AIXq)C(zVTc2C%UgEgg{2H5SbvC8KhLYU2``zAl(WbUCl|UwjP_ODSa7^`8J38)X zxGieK9=Jv0xfZ{B>xwyT2wGKo=7;Q**&q%i3UJnZH-kES;p9 zf&|z4X@Ng8zubOW8id**OumB~5qPQ>@AqH;ay0qjf!?`_O=`v8^+!jh*3yCv5bDG* zd3k%4qzt}Z6HTlpZwJ_M0Yrg^HysWK!?K|!rOlWu&Wy>c%uOlQmdzoLTht$DH`^+=O4at{QJF0 z3QxC1F=hIATO@fzcC|*&$(b{!f~4&$VTKKT5+5tL$b+oH3g{xzOo!3>Ul!aquvs4tLHde{_Y|G14JLMc z`j~fxAj(k40tmte1bbfXa{ky(Z1w7eNfdkHFUpz3)PmLYfE4>YIs{br3zPTnEL8Sp zT({%}q-$+FlH>+jGh{f4E3;^io(4A%Qal_f-!&fC=9l)l+g$ulF!ps&K!R29(=@^g4;$viy=1rREA4L&pQ)_Sz=pRueKf5vKIpzI#G3(+KQoYv+}R zoO^7RQ?C#Qtipt&ShKV%1R;a`OrF>~da0aNhN6-TeRw*15QcClLq@V7S|H{}V`68k zZ)ujOSf8ZG5uFhD8g;t_nkuqLq*D}|oAO_WxM-lkSm4wOUYa)6hCvvtp4^i_dt<*T zE1cjTWZ|fF_Dn!r(wX0?9uN>$wC}Qpv^8~4g7z-+EahSD8-44KAVo4t*(kD{fpcui zO;iW=RR;?nK;Yj$pVTM%d9DoCa&kBbl}_teSMav}W`t?cGDwB&X50-$EsKut2QLk| zeSnCHMIHxO-R^H*QhWET!~I)07<}Z{(N>V!%z3PYSEj%IYZ{cD=d84VhSu2sEtSZl zd2=m={f4US5|vrzqi+x)F2~cwg5TuAvN@IZ-DEmS&5dki)A{TUzXMKHrb1MRbo4e)qDZ-Ujws`^>>h%Li72g?}St zWN}>guD#q1EJ4TDn--#lX@?RgwC}E*CGyM|X9={+)<{mAzR3TKQPfT61fu^R(obhT2T>lb>IVRQx_v35jmP)@*)IjGvLHl5QrPa-=`L;#2)U;c}dX8Msu zJ8{ZMYFq(*{+j~us?rGy3aCTMgeN4fpJ(*I7sZhM+v4{i&)Q$H!9M(I&jVlL+Tp@| zjeV5;c%RbYDBzbAzSYJ0E-5I@F~2inATdiS=q*|@f#%c`+$HB9>7(Ur*8S(M8SqA! z5T#lZUgq>C62qTYUP@}k>am9!fFH19D1YisTe9CPQgd!{AtbqjaRXvv=lS&#szC@c z37cKY@q~yLMHwKyM399I)Ut|QvW*Az4HSnWa@avmDY++P% zQfw;B3y5yl0Y7%FA@o)1`G3`IUWH8-_EiQE`f-6yCj28D+j00Z92lIjT5xSGiyjM7A-zSFiP zs0|!F|MGDHJPBJS5lL0ASE8dxXa ze_Z_Y@a^fWdhjh711DyDQ7e@^}Q6`8SNsFsTy4EAxJQLmg zk^y|4A*dA^;xaNY)}S#Ertbyaq&p>7hf}PBe#dA|m4&_ddYh}NJiFzg>z~JmvGrR& zm8VVj!Gl4TWi;uJ!A0PgWQs=kW>4aHt-*Ls>2&}SE(m*J-)3hM-zI+qfw}_i%!l07 z?%S!RC`4Td9_SQ8O_=? zbK0}hFnT_DwqZY}jHbjmO9#z83}Tx;bX&kv7o>s0=EIXs(cgjGL*KTWvd?E@x*L}1 zApWdQ0jB}?@KY+u3W3kZ|E*D6L?v7EkzkKKA;lZtZw;}>CzaU+tpy9F0bd!ut$^Gp z?w0<^PrfUz-F-Y!q&bq`c2k70dQ!wfpDYgF!BAxKBp!?l7$cU#qe5f3V+~3lvEV^` z8Ndo$(h#inLH}xG!D^aI?pn|!TQ_x|gYOS8dHiqv7&*KE6tOSxiuW}Gi6acLoRN-Z z8lT&(c>We-=(0dlfL`SSWGH=G<>k<=Y8tg*nbTi<@vM4a0H<8Q${7bwO zVR1_(W(wS?^Ua4f1NU?1tX}4{-@pb>%E09 z?4GLBno1x)G#3`m76yEHTke3!1PFm7LN%dGs}d47sZu zXfMHfI;aBOZPk#zfV4CT=cd1B7gj6^xMb|v&j zqt_cMqT?$JhaKG~hd8p`?yXzi^cv@|co4Ow%OHLcOis&^a<#{G)&Jp|C`5eT$zN&J**XgdULX`71&!z_+1lhBDu-jb|$$f8wj*SFGYHy zO5~0*dDY!3O$SD^tK{vasb#nIoF#0Oa=0C(i1sqS5zf19p2hs|V)Tqeli1|ecD|kX zhMh?d#PxT80q!Z>q%*Qr@@&KWC*S-4U^*%S&V)wF#z;xwH5 zm6C*;YFugmee3hrp#ER=Y9FlP7O=`QTm;V@imQi{+?W7y1{BN!RHCaBenhS$!iY*R zL3dt{x)g^KxgXM%$VTxU@4Qpz{-8P$`AL4$d-MGRe z$$YCni`_}Y2DfojabVd&l20aK+$vSR;pSH7V>tpX8OfphK-e zAkYwa&U2Ri8XzIij&Vgdn;*^8Z=Oaghlz_6Io83R&|MoshWIXXOmc`m@@mTv| z{tF&!L4cyq{pe?>pbmR^cYTjg*S`p}5T43eT^1B!>LMlUUcR@T&`Gv~I$^+n_0xwE z{hIpK|9ejUtwnCuQMPt`;{Vs-IH4_y68`3I=WLVr?ud}YH`e?+L((rc?kMQi)eS#u zK!m=%Sp^w{)LXu)BLBxpWK|1z?8gTqx#edLH1^9H0KRj4uJI&9TbR?aehM`#F<^=F zzB6O72yzvsH7&xWo^tJjksN{oKOQkX89hyIJox-w@qxi#P)T;x8y3g!DI$=A&)z+r zd@oaQ7alSX0&f^nli&ljpjLZnQ20qsG0)u#>W_I5(LrgjVMhU_rzoz`FL{tEQ@qG18{N)f7D_kb4w(z#r$S>px^*54H(; zEfV#uH;?6KCCA6=*KgY_HP2^L)eXIcT4zqIw-{+A+p=f^C#P#{cC{dq2h*M6 zk=36LA3Xtl!$Fcf*?~a#Da?R?dW-N?0$(2z3W84&TPW+&(~}f460!?(OSlWLkjU17 zSXxlWQ#U(*JqRPDkU52*3A^rg+3uqCH#9LHPJDRJ?6$)cE`Uy&3T01!>QJnvT0vBOOsA8i3hOPD^FN6TZ_|pT5}BeM zO7?QzYAllc;o(E~Yz5z)#Y=G&E}B-!qqDPWYLkqh{w$D<0zTSb`K7Dx1cKne?}atK6|5;>OhOR`5yS8A+}>} zEBLaXnagQ~vxg@oX4U;}p22^M0cO`1<5{^U#tQmwEPZeW`Dn5blAr^UIM?IF6Y>>s zd(WE`Kwpw&uirEVnukbzU1Ru3!cc2)f0?zrs&_mK`?Y%J>G_09I0phW4S$EL1rrhr zKu3C1r1#b?UW@Rny&-EW%Ho}YM;6D9>+$l7QgJ_CxLt%{xAqo3B=WxvT8VI9O3S#NmIm@zo%jAjvK7UnoJsW#=CqA<+4Q_HM@g zcg>=I8|k`e2{f-fzAR=(qtslxf9WH`(Ug^Xs!VQX>-`#-T&Tk=VLNSAVq?mMQtRWJrLiGh%3pv2tN1x+B^eZo>K}y0nEDrpoD?emVgZ@nZbWudE zYvxSq6_}@N^$}a*-_CSvC^1gg)os9-?m8t-Wpp-P?@gB{jk&OCN!|0HuUGMO#Wd=) zl)D^9+I=al!1!JFAFg@Nxi-CSy3Dt%|60DKs0NT~dp(XAGfDpl>Rd`UwL2JO;6ek1Hk z8z5p^z%4}yO9eh@`Q|>$I(7)71|GT1z$Z*9V9ZafIe!OboXlkzIu68JhzeoNp$ZpkFr%Yu6p~o!y?W@tWEoJ)NV}}3I5|Z@>`MmAiMpI(&N9t;iCTjCpd}v6? zfh>iyv@~05enLrjQRLhN^iccIvn=7`_)i|hKb@yXho=AG1|&<37%S<>Q&|>L&Eb_l z+?mzW1n0?}DqmTho)!A;KOH_r!knIa1kr9^j#Byjo+N*XRmtYJ$Q$<%^HUmyXrOw< zkQA$Euo2{X^;yrU(FQgY=jk-Cu*ZLs4wH;$c5~#w8GwJqSb5w{5LBe3q1zFa*1GIH zS5<71>Xz)DLjr7QF)@*Lb$l^z?#8PO^Z?=}j6zm^(*h>6WvsZ9*{(3$OHf)XX)2m7 zzblq_lNPo4ro zAK*s+Zm@0*f9tHYqKoM8;!3VldojDN^antT#svI6ELeFmq=xXh|K)MCb-+0UjUo(9 zsW>vC4`(%)A{MLpZR8)X8qt#*Bi4scv)rX@Kt;Lk=`~bhrW)82^%NG7eNn+LTKI92 zhk06#xJad7x!^MJ^8$?&N0g&vb1r1OD8POs`rrYbs1bAFiO$d_e&c2Q5VzZ49Q(jx zGc+nZh^w{&`Sk;p&u{_f1=J`Y`>wFLG-OImWL4ew+PB4*P0y#u(Oh9&dp=4XZd2(2foF(XxX3xqs9f@knQs&zKkj z1NK3MsofZXpeIT}(qOS$ARFGJ_quvIQ~i1Qw^z8Ac!rQy?}#dW`{ct}VCA~#OkMYz z22_11H}E=@-0@q|I(rh7WKx)D3;XdMlCl(!9tkq{7sYrq!yWDwG4nDCEfSKzm%bD4 z0pIjdE1&LO=iNq%mF6nxeq>HAF1!dbHP%%CONVU!A4z8!*W~-Z{cAyYBNC%Kr9l`7 zN|yqPASkGGm((^&LK>vMAR!$pO0yA4N|)qBx|Oc&zu$d7-;=#|y*@jy&w0Gx2hy|J zg+YnhtWm!|L28Cy>iFuw0sJ-4a9zrk5Ab=XEnQA<=-z|!-GN!Fy-(-7@CEV;8ysls zaHZ3=p%$WtK~AZOOLYQ2RfEbaBDSc;L42j*YUH#aQ@Se}J8_MFxSkjt*NZ2Ghdd3` zwL9gHq+%MCJ07Cg+w_Agw7$iG%uJR!2<)|ytV|Dgtc5p~b}h(FOlm*;i2 zfqJ*h|9)}obDBBfq1(!rERkQcjow?EK84c;uidMSbBQz9#GC& zGQg~exk#>+xygW9@MbZHU}HL0h=dZ}16gT#q_g7$Nw2NCtNWUg9ba3@y`uj?hs=YK z!-WSP4B*OeAkM9SQybZ93SdUaN% z%r1Ero1h0*CvyC`4-pO91I=YnvWb&}wRw;>pcHe@$0rP*0pff6O)^WM-+{UA^#=_p z%zCEHOm{X4Y^D6ahYp_zeTC2g3qg%WcZdk9VrERqpG)$BuVOuC*be;y5zy1h7O_8F zU*g3~?jy+!tFFbFc8HSY3An2FNqk*J@{XW6$eK^P(zz2+JQ}Ye(asAMReWy+jd?o- z9CL$IK2~+t`eH6A<$7c(4UBv83hU}t3dk!;++W#recUDDG0@SzU-H(?;W^nX1A_2pB!YyQfn5O0HXU?Ai-S>I_tU>p?!?axT7Q+1T2d8-B0>dk= zrRzID{`i504IOO}4J73(0#1v~`c}eSd(hjAKUH*m26GH~!*0(!X`ZxvcAY$Yw`~u1 zW;UGtw;}D_Q`7(a;!b-j9}(gPUQ=xUqbGLUl`A_ubJy|A6HfsT!Sh>b#(d;MbgcVF z0X5UbE)}QIAa&+kO@34!1aJ9REt+c^(XH>w40t>e{ zh3II+i&XwjWr(OB8LJ*(-x*%1pN2kY#iBS3%$Ef6tJ>Ua$l}NmTvCW6*)@T)#WyY z9828`APGn6=Nt!_rxYeHGgJvmcmLfNbLCS@-=kIWA4ZftMMIT03z#zH1CU&n6b)#U zQx1_+ej{6{Fz7OG{RpS)!?7&W#KJwPD*e41+;Q@v9^=)S-2&rhbtvfCZ`GS_=W1bWz2=s20_!`IyN|gPI4@;0-YBtX}hG0IBo*&o0U+geHE` z2gW!h-zwy|oq$|twGjqfy33>T%(zSmo1%IxJM_M#7i+$2<>oO<*($v9=lVGL`0~0y z?gvBEZj{q^R4AL%s3Wkq#RXrc2OTi7YT`?jfgqAez~Y@KtT6%1+nV&1LV{dFi)5iV z(HA(+YGzW~rs$;86r(o?3qV-!I)l`13xEw};YXpM!+?Rc+fKK*V>u&Z^tG5h849da zSxPhh>b8=fH0bM*TpqRj`ZZ(gy>B!F>y>{U^qr}9(!5~V#I{}k?+-k=<_%$iDAr_X0evi?6a-Jf zEnDJNGaR+}I4MpiupgSDnCwot>j`~o{vc9&lZ;Tj`-;OJYL`ppG+vlS#F9F)rXmLx zHN0N*IYrC5jS9ZNpp=OUB(SdqwRET^-HuA`(-c~z6zUTJiWd?N4pWjDqnT`$Ng#dDD|AmF<#-JJctQd&sn);}W&I zzv=r=oQuJuMp<$el_|AfYrD76RjLZye-iY3p_{OBU3?*sA-@8XN(ajPj^H?(Bf z|I#jrSMSg8H0xLMw_#C0*zd0ug^#KD{n05xV% zh4?^mHLUeF*5_(5VC}=#T^D5B$;aSy(#=VmIupOV7PFAvfiL?tlXW=ElDLz#eSb8O z*3$x9-m>~^36XLP{I|V+)8r)G_i|r3wZ?j86oZ$^QwlYKOkAsPiRCJHt)@?n#S0LOQGw5I* z@#7#WfF09efr*EKY+#c4g*LT_z3U|dw%VT_WA7=Dj+X7q5VO3bFJb*pm1O2C(PVgcmfPDdVWJjDV$yc3k9cQV2 zC*fuL3;*gH45`{~5W5f2e?RhW*DW{FMYuDL2=cVG5XgEZ57Ip9deIOVNSH2BJHqTC zY(J=X3)~M5c`^=QNe;7bCk?2O{jA6l{l#}W<%@8?twju`8}-`=5y>e2IO4?ICtSV( ze>Ugt=lJr;ao495Uhimg3=<9?p(tvrNfPsfF~zPL79XU1rMi>U&e-!w=D4%lFBk4O*i5^B50bTGh1s{jlGe#mJtloXQ9tzlh z9Oo&^DcKZ~2@%Ys$H;dghbimrHFD4lLNtbSkv=B0)ZQ&9_QMA$a5G^TnQvw(8x~Z? z^bnl<3za&&a3PpiXLzjpb?)|*1r63r^E8lJEdB>z#0%2h=yvEhDCgXCBvFk6HdqzG zQmcM8rhrP*hWPoJG{ry^cCT_t=$9OoL`WVn&Be~C)< zKz0Gf-Z2&SIyOpnD}P_vI6bC z{fT-Y$Y$joZ&-9|fqq!wkkYe4b&){& zOwn3TMAwkARyJY@tP85P9@mxuBJ8gcrH!F>F(d#b+4WbN8JcXq5(e30WG7XW?6xGf zAD9MtZh=0njvC3B=ijGP2CTOSlRQdekmsCPP$`E(VY+Io-xeB{{}!!)-z2(Ku;`UJlj%!rejaKBvVx;GH#b;=OR6iM$YK~#T>A0hS1&02vT zh`zg~10N#fid;RcO2rLDJ9!QFOn%LLiT~k!&!^;d5k&(tkKHa;bMYIRwEUM+N3&Nu1SGg|B zgAIY|b3!=UGm|iMt5zip0cSNRbLT=BH+j)q$c{|(jSnA|043k7=O%flY5s4HiMIWd z#OCDG*z=HV8x|xqUC@#|GTWS6T1Euy4W)e3^o@O+@cH;3?Qg5c6IYRx*Z~x6g4WEN zpXqhuGOzW(n;xmQ>HUT%A>l0Z^VcWNa46haz0xM-2CWt}Se-1RAP)J>zedVI&(rl2~k(yz(i$+`BGc8!yh>{)Y* z{@1H){16*Ih7S4Z)@UAtx^NX5(`oIEA8ZEejjS0w^JIW2#8&xFB|JSFANJDNv+c=W z$2c?l0<>QBSI^avwM%=U7Pw<2%JsYhb>d5QjY0=*uq0i(=(i8FF;`v7L)Xj|rRBDJ z2hEK+A-!ipN1}C)T-5O|EbGvlri;fOwJgBh*IftuPxD^T_|oFFdyv5%wUNnA#OWac z+tlUbv21m?krvClMEIH!l@Xb0sYC8E-nU$nuoxb1ln7@WElW8s2Yk#&e$@<`eyE?& zTv(CJCve@9Ib_B@?=v!&Ey??FBdg-VN4ia(|Ff%tPJsaC07NI%f~YO#S5RLW(U<_s ziogpz*0;h8QBoEOd&muTPoTMtybNQ_NLD!De#y?X8`S~)Hx+$d7d!aGQyG*-8c35z zj1fg-DIWG43;w6})8GY|>Ft3JH8POjxE~0UU}4f(ZqudXV=(NSdH;MWnQEqJxeJUA z`}bvXj<6aQDZu^FThlvVzeUixrQ@|Xhy`T7K}Xf@(}9DZ%_2_2(swNVR+y3(4n7m@ zPv|3Ezxd(4O}d-+9^90rnPFa6LL6Ix5H)_os6PK8@e=MQWcpXS*pnqhzSwuKuT=Rw zg#r~nUHOr|wd2H=IiQf#E}tN(We990h;1Zo>)YeCk!3BofXbl?UTW#DZ)zv;dg-X^d znFMq4OLmsr{u}!O^E}Qf#L`{&>;>pk5 z?%P|+Fmc|_zr6A30eSQ$6>sdGtW4qTe#O16ZK(_n;H_RflYcV$dmKo;UpV+)L5sen zrS?NC@l#@j_JjE{w?xF=+XD2Ps?b;I1^BFjV*|6=p2dKYks4gCy?DiyQ+8oFSzm%g zJLdSy<4iQcC3^NPtH%`)jt&{o;!xH@X8c_;&J()jfjpl}7LTm(fw^csWE2}q-~kne zpUtZW`?Rl_X5TShds^^1_nlXfI>JF3%cA|D0dT75N;eR%&2Hw+CJCl?CT`$BJ-gl? zy#DQZ?vPT-q|^=&tw_D*fv@iddsV;|*1J%T9w0k8(!!Ieg-C_V9}XHs&R$TUs&XwV zVyUaQeXs?PvLK{sBP39U>}~(tWQr%Pz+wNdjf%?+#Nyg{lHj?@xYtBxAI(5^Ov#2Z z5KuslVFQt$9(&0vBkz^P8RYna^TXbk*|gY~-opnz9?Nliqy>tNuijJeuf#@D z#P(Zi{-j5Je8`o)zFBSKS+Xw}iJ}kBdt=h-b1S1Psvl%L-Vtx}b;H42{YKFIfT1X9V7uF0cz)bX_u(6k7o+LgZ+JyfPv-)qVq?G+(@Gqe$fRj-$Isgdt0($ki* z#+(AnR?>E*anFjf9BzB_7L$#B3|l_$H{HLGjJguu^r3_9=m-t}WW0R)yhSWJ^Y&B0A1UNNA9%^x;`zrNcNtP}`okeYvDTe%AtN9iM8!oFgN1 zOk=^FIUDo~J_{i{Ze<&nuW@^`X6z#mjh->6w+boVComV#56&3j%cv!$g$ox4Ua88^ z?Mh^-YuJ|0B%fnz8Th>#Sc)%1W~>{Xs0EgS>o=x2(!>&LPf7`K6Pw=kWqLr_AVyie z?}I1}!_7RpNRwRfMcHoDgW-7_XUN3)972O3U!nO)nv8}fo0u>Xao8lZZku9_>zfk0 z+F_F?A64NSs<@1kU6zz1E*h!HP^F6*-e`HX!MeTYb!0O*3jjvVo=swD0~=U!UQn9FT+wco`(e*rUU_=XL1wgBz;jX z!cULPArfE{<`fc8`*{)Ca^~8;Hq0vTj-TMD4@UAETXYU$eI=m}^K$vm&g`PmO&RePNoZSytkDB=$G$q|qG^`lKX z_<}Hh8muWqQ4qryXWnP3(zcvZZ1@^e!%3rT<8D0}vTU`l6^CNW)U1+kEXX3e*xR-5 zoPWVXD?x_+EzN=}C|f(w0py<#ITsW1HJ9ahX;MK3CEm%1t3W?4&MOg6&b@9mkdj$S z6)DC}bApV~A z1kFNC3fYsXr)TQBAvzO~O|J^)|AeGQs9uZz+>s33JRP{1_`7-Z%K9$LCsrvz>U4?Q z+fc;{Gf!ij*l=ku{A*(X*RLR0%UOrqX$xgevF5%wYJ=0A6zP*yWZaX-R8n@SX_M2v|}J-z9jtC4i^5b_)NcnZEhXu zqqr34ig21yMuy?u8nPAfc4jh)?d@BqHR|tGX5Kx%6nv8uQ?zP;KyJQiqA`W+3Y(;v z!L7-n8VrSRVQp}V8ZcUDtk6)L?V$4eF!@bq(n)Rbw2n^2Aif|K5F_p44kMpC|1>|+ zL)m=%b!P=<(2K4-olpJ&yUdm7l3JvB7xD2b^CjKJ#Z8Z;o`A5F%h;Ns4ew#CHnuDr zE-XG8@Hh%_vHH5)J6=2N*C+h+t0~)DUvI59_!wH?@DE56zIeJ_R)vdZoa|%(f`}60NB3&}%)o;%NSy36ife_#X3$idmPEtKOX9i;E$e$^#@5BI%IaSguZNe8$l zmNd-D(UuW4B_j%OfW>CxsgLB6cNAjdjn}zJI+*l6JWflw>Arc(pM@_sU{5Vz3xt&x zAZrMMu{bHcu}l+O-v2X{CfY1!;Jj0_;tp?Oq}_pFb+>tRB&7*iLMN0nCv7~z-@e;y z_9vZZqQdy{+D)sP8KkOq;Ie)`xhI0I)h_&pYVwV6aK@5 zw@@z4mY)!sx0;a5Z+p~!z;=F)P&_v7M;#FfnQ;KSy`{{LAv{GCo>)MXwI*<)AkWSD zhjF{f;%UeDw>-J}`Tcu1=l^imy-u6mXMrj&@+VJv!?tRu0fxvX*SK@=rlJ*XDcEEH z{*SniuJ`Q{;wl2oK@*Hk)Jpj;Z)4Z>aZe=Reiz#+q`{%UoVxVhg|&x{h%!gRK=CGE zf<6$0A)zjGHdDcR+6GZS&7KHRKUM0i!GzKvi-a^8;`#ArAE6}PGX9r}Sp3cgl})pw7uuJ}N; z(S1W7pFA+_DwG`Gl5Jxx(L78Lv=|0iGr9$$kz}Uv+z85l-}cc}O34%#lK0-&jy&fD zqF!}f2Ko_D+!&ZvZ}?v#Qf%#Z{Yvj8Kz-i*X(&>N%X9AZ5q`pJU04}B-E1-Gx5EH9 zAi;{_CBH3BtEEjA)p|=A-V^ir&aFw^3X>=irv9W>P?1a?`7=U2kux$b0&Fh8sLkU$ zY{gX7z$8T+woTu+S8xt>kSdoR<1> z=w_>UDxiI(z^;!8;qx{t1*_E$eJO|T$Nub9EP`MX3gUZ`^mK$r%RxLWjZ#5$_Ynmh= z>SFIIoe1A7))(Xq9QZq91IiU`y6G}3ZxicnE<5E(*n>&JI; zL-3_Zwo1rfZ>|i>?`0<%BBeA)8M2HLA{fz#7i>K-BN(nit9;5OFAl+jb*8hu$fbi& zu>X|bU~sG?T#Ga&-&5w7v$xYrEuTR<60tD4-;X~pM-4UCca_bjF8AHeA9H@^X#3$0 z>`bXaS`4X=p~gu1(Yw+Ze>$nT-6#se*x%s=R`SG}0PicOg7_|B(9oj~&$!Ac*keRH zeoCpObUSzGoP8;zj@AfVrWKKxqxjWcn`9--%Sb62YMe#Rw?{QE!ymqX^z^WiD#QY| zJVH$+9+xokGN%d0RkL5L2Z%8CtRb~10PKhpAf)8U=kcQ)A>Zd1i#}^-}Ia1ejZWCbn5)a6gk}q8b0{j0Adjsox zyD+1wG2FKbL5^}ve)viV^jxV7KFk&nv0>G*Bm#%1c{gj! z-U3fa4zGqia-kU7f*e*Z`=(QZx#6X#-)FLJY=y?kg{mkqqXXsY&k3JDW0Jj2D*pOC zYIxrnxF-1?zs5!;&3*WC(xqu6#wuZAQ_m=bTikwo(uP*NdhS^N=STXI(}6Aa z+~`XuM%WBP;UI-wO3jY3BN*8Vl6ZmH=EDE^kstKnOe-bZ!0x4lp>nk)f<^|Y3KpSU zRVJDb6_!R4>MfadG;`$+IFKNYw>KJ;S^88>BS%?+)#>Bt5#W%70}i-q8>A!~BT4@m zkOS%k)mXm;KGFbY*Rc0Z-|IQ_(=3-(pS$_;OBEGi_z=~xY63Z8_TDDFj4(qwhh2qK zv3Yu&thF!?@ssOpL9KUrS88ofxmvV2pcGL-#I#ROVsw%(m`9ptNlBMIaL-yU%T_Q8 ze`=*IKts~e{*Ya^g#mRz%3UAR7t&lCQzQ9UnS$AOHc(17;ue0LX%A(J{7< zwTz%z(!+TkjY7Sj5tGFQo0GWtm#({NzwqwS=Jb$c!F^Jx-zddu`oq~Pj)0elnM$Ni!;$*ilgiz&K?;5gF+|^$WPwqz^a?Fq( zb~@rF8TrYSGI~`>6PXZJe_22dC6XC^tbXJcDeOc_2TTQNta{%xE z<2SXs^OM`|WuV2U=?{n3{FRcB&_kvz&X`Emv0!~80i_Jz&B9kju`~wZy90=Ml)3_4 zlTYCu743;e?+V=hMGEXorE$>%0bY^gA~>Og(ek=h2Dtg5u=qqwJNMU5&H}XggBiC> z<$Rl|(XaGxC%2n;VCi4{Y>nLW8iIGqUIo`qnvax6?>8p!+p}IfIdM(!k(xmo zTwnr_!&!ORfg0SF+)qF7stCl}{v9A@XR_YV7eRi35F_3FM;6nwD7Q^z!bm5KNu%00 zp1InGigK+BJ~w%~jJE0I5@GEc zKvq8scdK@?yh)_>3IhSVgv@=bBsU~QgVtSO)lw$I>4enM7TsP9SlY7O9vRJ(B{|>q z;7L#OI|bjL=Sy(2E)6Tj1G4>XtTs=}#p@k- zA|Dccm?d7r|HVXN92d7}kXJ;m1VYCg$d#6&!^}rh=FIn|C6;WG4BB0D`c6Gd*M1*) zd<*!O%vP8J&MKu(9nl6H|6_ zC?*}pf0ept-7lCZ`$3;2=(dne)=}10-RA10ozh%i!WK-XKkS<0Aa$V1rj9hSGcO-B(aSdo;KV|MT zl-z|^Y1n*VdTT%<1FaPYMr(!@dTSi3Rpy7c{;vQM+LE76XA$Fzv8OmU%|LQ_v;_q} z0G9rKD$d7tEoMd{^E2S9Eu@)r5!ZyvYVyzG@x+BczO|jIIcpCqi3{|8anHY2{OhAN zZNL!^GB;qws_iip21(3`_5DFyw@Ju~+UF3Ra1_&xf`7c4wCLLAS~l|Kte0->`4Faz zA{0qf=6-*r(afz)?fnt~%8OGRqG@~~3-?rthreY2clm2E4~6c}C|-JN|jMknCo=7QW7@4{p*|roO!ULXk;>XxLSdqH$XH(!R zpJH*J5X+h{=avvG4&snDGby&dvsbBGY$rEx!QwUBvVX`h_a)d(cusyf@afLbM$v8g zGxuZ~%_lKO_O-i8#1>3%prgK4TEw0t8agCd%G?l}6TFfo#u|Zq(v2S!gIYgbqgaxE zF&gxZA_}awFt_(0Lk~GuI}X}xPPDWE!woeZYc4+(jt$Iqb&6Tiu`^i`54L`1jr7JFPi~HF(6e&`l`p)0FvfU3$ z`mm#yU346d5hfe`8jKL({GI_uTqkyKr}{K<=>`+R5s#(He&cIj$EngWs@sEjjkX~2L(zWWozIC z5oZp405Rh6NkA-UetD74AERquC`_D@eJJAYs6dZILEaiM*Hrf)X_B1Ix!~yR2^arV zY>Ng1x{P|lUdM{eiUHabo z(N3|4S4rL1kN6a&TB5!Ja45l9m`fZ;0216p4-pe`y_4brA0-er{7CkCePohtuQpXG z`j0NK&%^pHA`P}R?Z%~keq5ve9~K;Qgb!S++YB$SO{lm4y(RAxkCL~zz;6@r}NL-h=zrP4$q|v zwk18!lf9JyG|*C~fVeo3`rFrc2F2As25_CeM6_Hy`zi>UO>C@yI_n>lyh)re^b*cF z{l3Ayc)8phFpW;44^nX6Q{+3!o>-G1&LPmWx1^MUX*;wz%I}^dG}o$ z&^&cd_S0sfFX#d3p-+?SXc-HkiuO$s;(F6zO%%Mljjvm3<*t=z?YeBH_Ri~gn{ckd zm;B^L<*>vnEKp*KywXNx<~@&yeUghJ^~b~koTs@~(Wi1VUd~GuY;!6blwTgrdQLa` zU_SU8@Z&=m8xbZ2U}M_+vZC-K=6UWXj>C8MbnSphTEIEP8-qeKYk6Ax!YrTez6*<+ zUgnBWckLe0kOYL8U`l{@Br-U0KVlH9Ee?`p0FNy{{I9vC2tDs%p0*sCBJ%8VdFpbn zu>?+=5$>ObR5UeX`{&VvY-`QhVX>Q0))9n(RY^|&4l$@dAc~rlc--rb`d=;em;+j` zn|$iOqbrgxSI7LI!zTTooHq2DuT|e|Hn}F=P?E=zmbI$w?_~0dUPV2vbZzyt=FDOr z`7BIVVhY64M!Ho_0d{7z*`&JhO7|&7iLOJV$25HZSc5dG=yOkwwDsD=4ls z2m#|B-QhuGdES+tCdD2WLr!ySPaZVB%ua?bc+oOI^q{*gtw{DdoYNidAY1l{HuTp^ zoA1wSLmqzFMxXxKJ?KMyy>86~{w-{yx2WujXnEQ`y7|pLhYUT&#{~hMLVY*W|3RCU zXQQ6vZgd1bsCah1U260&?hio%=+}j=bxDKd=RIX73K7;r`urZdV$#%qUb`bO_e#O$ z*l*A@`?;w0;l>|~+P{048DpCVDS**o-o)$C&u9ySsv=Si=sCNz-MX(Mc_f*}Fbh1l zNgcBZ4P<{yg#YPG67r~~BHuYxbtXfi&<20_y)XsQ^wCh9&`eDS{Mp&zCZ|2QEi}04 zF^)FP5&?UW&6d`pj+^UgcqBw~&(5mCPA)AkRnb(I-%8qREBE_jz-?G+X3T$&NTB+5 zQ!S9``x}dZ4--hK7oOiCnMI_HzB=}K<`ZE`i1bYHfS9k{HqkWaJ~w}yqTrT)*i8F} zwScbBxi<_E>h$BxLZAI{*@LFwz|~E@5E2En6KYb3=@-$T&`s$w3VtU$Dh-N9eobrt zy{?-dvX+n|?Xu{cly4FxhdrOw0ba4QUbFm$##mkux;ttvTV(-%CJ+3W06d)!+aE51 zYwZIbK}WCZ*@(=5LMj$kBKMZAMksjZhQM10fay>$BP2m%r(oG0Z*#&DWAgjTm&dp} z!>do78#Kz1yt`3EB;p^{tyT2KZKR*Sk&8tRpqIL7h0*s^Ak{|Y=2H4QC+!nbO*dEEU7MHW{ao^S*R)5Gol6aXEaV}4X3*iT4%i)(-V zS$Y67><0tN@^*T9(j@Tg^rPMq_-CsBzEgQJf`%1aWP#}@r_JEGdiBPEku`kt=-p&O zUA-K|iUpBw)lv&l&;tqI*0}(zdV6UPuw?(@GV}%}l2_~fJp}!es@rF>h}r+m08O>U z68=!byd7tpep$6lR)wp*FQo*JDfnY~v*)mO4{unvIV!<=MiVm*77|mxgDqZ`Ss?fC z(%{>Cn?TvNyO&lf2ny{)k9cH3__x^m*(juE5dTySA%(qzsrX(dp!r*$qKHYBmBAOR zBXBmalhhm+ALA=s8?Gb{oPaS^!8#Q1IHWq)u_IB4>H`*^&-dX!C`EsIiXu>Fz66H^ z=3tyCGPI4ikh{IM^Y|?rMU*O{31^UcHG}Ocn~Mw2b4;!RBd-{>7UYNJ2BUG76-x-V ze|5M`MAgdROqBhwp_Gyx;rzCKZU5onbx3ed7VW>J$S6Nofgbue_QNwbDZaMhUnIe( z!uFfR#`&~APgBSJ*2Xe|YyYsH1y3BqheZJbgk|td2T3fqXZ6bqugEEQE4;pW?!w6cLB_H*X(9bp9gZpRbKRBWnwxD*75uS z@aF#tk!DPdLXp>qRStK0PZC3T zI(gqYvF8m)kq1K$4qC7fIzAY<`gno+np>-%_@6TBK|Ix8eF(Ny-?(^@{=-o!bfx zA5+iwn9r|@Ewe#Ms0AoZ+ZS9k+W+lB8!h5z_dlFpik#=6C!M5s%g9f2O3@=FaVnJZ z;d7^I9i>$vgnh!@5hrN07U;epM(M{Zc2$ahFOzhkb;n*!To$MXw_su1k(oJDu6Y%vUg&x6zL#=%xy!rh{ZffstJF$4=-^o7_ zt}l&yyhmu0wAsqDUQ(J75_&+{%;Z#?LOTr_)j=(WZM_*Z#e4KmpEPDqmvN0+KfVxj zDBSRRos=Z?+PgQf2Gb72oqkzgmu3VNW&k#&C`D~4hj%=L?j-#ioVH=2(;8jX@7WRV(G;K~803`U!5VI!CDpnl(; zQNDbVfi7A4n5JL5_(c}guWmF}_c{<3CQwPPBdC{eyO)}nm`?}RCBYVShr^o?6Zuh> zTy=L>ES7s!*z8b!76R9^TN_EFUs@dH$T@`u1 zQfJh%yvXNv@_prT3@tIfJV=wN-3-i#O;ZkQNczg~V`vZ?poOVyT z@B|$I9YlFtv}tSbE@K3>wt7qZbFI9hD_r0V)9nAEBFJHhaiDR&C^+ z#1Co!VZha`dGN02i-NuRk)U_k|A8M-vI>xP&I&5`-(IuRGO?Bn%)ierR8EqLojdzh z*XV$uE6X{f6ym&z%#ga4t_!LVsSA4Bt*`n-KU%_!)0-~g`P|vKtNLG7thBI{YYq|| zFfNgi1Ky$@$M|x(vV-Ssyht?kpt#fS2a{*&l_r_$-o2Xo)2`+C0b{O*9(lNg)*z$I z(9Qw~V@_`La#&4YfuzkAi93Q0quTUL`EKIic={Hhog;9jtHr7N_GGBt%QlO{cAD)R z!SO@R)i)Kf4~sI>dBmaDJ{u&&-fVLlL0}UzWTRve@1712DGj}TTa6>cL4R>s;HP{= zN`9JeI&(e%moTZz-+*{f6Hu!%CEPi*x;UfbMIIpDr*I{E)#3|^BgUq}&HFwe^ufpE z1hL|I6-_&D%j9jQ&!#S=%-t=4GPlSt&BUeLI5j&9z-^Pf$Y3g@oG-%=wXl}1F0coS z5ir#iw6BB2kmmW-IqhG5*xCL}F=GwM<%YeoytK5ntsv}b8VW};{JiETcdZhnNG2Cg zaLs2UYmHaul-M6igY>vYbietG(cHDVj8L3Ax3)?7}s2<8efC(}XKwA+YY zY5yrwKbRM*WAcL@U+3jm5L14oAlT#u61eG*A3oq~Z^RE(OcX>)fL;3si^*9xrLjIe$ne%Qt@F^FAe=lCu!_9PY#mWJC}A7)n+vHP{326XQ1HY~6&m`avZEj5ToawpCN&jh5VXTq8g3HVRJ~b4CTZSyg*%NArf;@Q3FW zwd)h~%(vfNE$dedN-lk3oOvh(h$I&#f>oIy^pcQweR-f4%xz=AgrO5G^hRQIncxJq<+9iGV#xvw|!;mSdXq1Ngs-g4MxY;)jlxu6i`3jzb~%Ux_~3U zFPfY?6r3-ZlSFCYoFEXE_L#)yg~qT@3@U~Ac!qkd=%q7I?Im$!A|p`9@(Q+v7a2^#YJ9>(|5L4)y3 zsK?k1vaOq+8h-wA_p}4M{95Nt=%saS1lC`K$U6HOpt||>CGyLAyx+(J?WbfI)l5L; zD9M5v(_!`m7JzP+DlxIRW+RiWw?t0JPg3b(!Zn_rmbslHVmp_wCtQkjzkV|XRx5?p zynJ}j)>LN(1$VT-IemaDg(*szdM7>uQtk|(13uU7k3EVpvcAK+h4j|V8})2v zVWFcHY^R0@=_XH~uwB-{IPSV|*dAo6J8z7~;9avfSUQ|}q<)AVK`Z_`Kbvxe!P=G- zRJS233u-PeFE{v&i?r#%?&_D=eF87kGB@u>P$%?V^z-ZdQ@B zjHF4XYnUu4J61|~wB$oV=q?YWqW~Zni>}}~#gF$ts~^QyrN7y!%C$%3ge%6|*whcZ zx-NTltAPFeS#xtKVWX1g)b^)man+G`=)$q|<&V?@K3m^-*X|UmFLMaP5oK1B$IsW3 z7JmQtH}x`CAAbz;H(+Z~9@8EJ+r$V9wEna(6B`ViDH9k9`Qs64v{I$8u76u1O$bfmaAc5@HRNM02*m3qK+Z#!jUj-+ph^d3946*9#npeMS zaGiE#Bw0EP-kEo$9tcI#gPe)-00n2h9#q(8!$B=>tKTE#&eXy{?&&|L|J{`JM0_bB zIli8t-D4QhhPJ#zc=LgF^jdPJJsXej%#Nd9ZeEl8xm)l{Cpm3>gL{p>Co_iDB*PZm zLE3D}Z+97Rc|Gl?fSEWe0gUe98%`wUNmg=52@7QgEIZ^3jLieKl4XG-N62pED-8yV z{?lo9pS{4F5`D|-@yY^qQ$Of{CjcW)ptm5 z2h=ll&P~vQmle{26nl(}XUkf1^z6R**gh}_O~srrW6t;`fhIh`Y}YQ^`#l=(cELro zQ~rj#E+%K;Y<8A0c_Ynh^T(WD#9iwi>-DV;92EQgem*PfW^yZB|xYr-!!>*_p zXbpvBBAz%XBiHfVa&TS%Snv-Py08x-#kwVEqM0C{-BIBZ00TINUQ4jHkt+K6JPAqX zZ^rXIpJcr4`V{)jO@UB5UQ}a~SP9XTghJocwtOKHW^zA?1%`-KSwmd>*Cgq{(ZjOiJCSO8UISl?a(#~eG$wd#$0}@eKfA1-eg@l zg+6(aC7Mz@$D|-Yey&@~S5JX)N=Hg_IDC)Rqrxi_gj^|6PgKG8>9FsLt61O?_|HOy zNFsbP?->JI2{Bg9{Axls>4*#yS*Rt#BCidfyxBXO;o(N6BSpEjs;=b>t0O{XF~ayv zy6d`-v`V*Tu9$^uG;pp)4x}KH!J{pAEcHb}pY!L}d4Rtj(`4r&!$%}jt@{L-zAsOx z6=dQcyoDnLNPHYQfczt!aV$p`?u+D3^i&gEZrm>3x$e{gn_)wTbMZHj!LP88!3Xj$ z7`WoPR=qy!el-Vk8=4Fj4ln94MG^H&H4y@UTM=qwAghfek5)FEt3pJfTQLY@M{~wv z%DgG&qx(3`hbS^bg_(q!?rdx57KIxUq$<|8Ap$=1IkXDo@W1-9N=zCa)>E8$0L@yz zad~<$0?-f(3j)WcD67AFL0f#1O6aladUh#F(Dm^_nHxgsHHLjOehgy2a-<0kh$W?5 z0FtHV7+L`m{}ag*BFx#|-r2Ly9kK%m73=fmO#G+5 zCnX=kT7II!G>(~xjCtT#kaBNYWadIAo2No0@4-OnyhSij z>sBC_06#1n+UyeH#0MSuNwgYD7NJiuC2aR$zQZlDR4?U8D{@z#QS13hENCzd#SCJeiMIk8>JeK_rD zSsH5$xOqV!3kvGf9}8#Sw1)-gAqFtF>|w)Fqz5h*QIQ!tBVoO?WwD{YqzIqUU&t1X;&=2art+rx)&vCE2=JJ!zmpYJKF>L>Y#U z1_Ri8egG40%mt~YFo7kFNTyCE1rfczd@Mq<_Xph9UdN$+l&|vM`NX4FMQ!X$Q{0!$ zqj{w?m{lB^5mNWk&P=dSqGm;j1H~wfRokZ3#F!Hg$@~yOD*Z5_0&MpFIAUJ05_zTF zN}$HbCyLb{C{^$PG;0Vy4mzkcbDtbd5giCd@mK-7gujk|??I?wxl#GTmG-xN136HO zyL))A6p)}>1u32cjrjTG#!s?xHh^Z8=IyAl6W==bLZuT%O*hob9ZX2^_pz_tjWXX#qw`a2m>f zsCu3(K`x(1qp8t0-g}DHPP!G#M${~Vd|>;{7u`y6^AOWn6=pzMC<6@OKVr}y=f>ed zxx66Xe+T4rG##^_OJk+W6_~r6&_IZ&IZ@MIGmVfrF@cr;KaS4B5z7C8=X&Yk;w-sAQD zddF8#Ac9svaRQyO93g^qe=y?kYTvn*7~b_StmWKt>1OzC!l}n;T&H>X^V1D`eiizV z>I*biIQTK~V@~JLI+QkD1GiD6PnoqCJgtFYAdXb~8~2Ja@MByDxc?W#i(?9Zp>4M2 zS0Wnd%YCuhM;Cv`yV3TXQQIrVS+*F!(7|-eqTs^0g2>~MT=J8ex$%4CHunR-fwy(Y zONsVAw&qTg<2fdmn}tQcux+U^uk0Z+{avTuO6_&5=!lJa#Y+yulgdh(vAkn{|Beej zgxzDstYg;Bn5Mpa*MqW4;vBxSdIpinVTto~pXTCPB{Lm`KohZF?DoBrxhSXqx|N21 z7ied4!fk>hfs&90_G+(;o|l_c8R_g>MLNie1oV*={`A(Y1Hp@rnC^uLi67TNfXaON z6*749(&TSA;E(4|RJ2gqDMT8xq<|ZtXX$_h8$wnnU;Zh$)d|nEpHgkh)Jkh6x;ABq zx+!R(wbOlfWI!$YM`PMUA8yzH?gcFnDSwCOS`<7~@Qu5a4<(pNOqaFq)TGV8>CSDU z1;csYlTWH&Wq!0wx>q24c+?axm1en$ZA--7dAoSu>qtym)M6OP1_ z1@8Gim}lV_aAn+3R^ZdHOMQ&}y_K^2ppKaRhc3!)^B`=knxT9F8@8X2x6;?FMj744 z!erc9pOnLu0A-?TRk~5>jo^=EZiTQR?w6{&nHSM@uv>FIWuV3@;Y}glxUP#Nh-%AY zm{MQ11AI4?l{hh^$~a-AVfG{ci5QTvY$ihycnBr-$={1ZEW7g*9y|nRhahL*{i*Pc z5Qn|)Tg6!IxzKOQ)b6=2-((2F!f$iii(zvnq#%-IkN=Z1<(EEb#7|S`+fF(s_7hyG#DFNNi75i8b~TXJK=Gk7oTGQJ6|#`01-^TQ|1SJdu~_}yI4jePm# z2wHsqttIC)vXUh$Tn*~7n-4!R5yolK)Io^YYi*3Ievn_s!?Xn#TWOve(;Ztx&iEFd z<5dZJjyRFtUNMZbI>io`JYGp|uEF{p$b!s!5d2m2MY&JU&&{dux-mB&0^zSh1i>=xoc-syAu@(>n0=F-s!ug3u%8$`ws&4~ZJkVgM|sH!{x9E~uh| zt=PJ$z)eagC3M7gpz6<>hradaBAyb(R9-tS<>UHkEvy`nnAb{@rZRYmbv$zCopTfk zRKo%Z?l;$SDZ!%!xQGb-gA0R@nH(7Bg3`GrSAapXn#RtlI*08MxN3TN;jm~qt*hnaQigf{pDoQZ=(($%)p&jzf zNE$Y_eQIWMO6h3bpq<7L$1_N$hcxwAp+fyQdHJBq)2;s&%23S(5m@cjweHIdy&@`1 z8zm7na#a!7r!E*lh&E2!gz>(m)>wgbp!QD+6*2fVWV=C43DC_uvl=Ff@OHYr^Flu1 ztTSGaCIoBp6cHjTwkDnOGH$%2sNn)i#r^ca^ScgOm*k#qAGjeEi-d1$%sg#8f1zvk ztKLQ6J3tHtTKZQC^Ip*UkLz{+LOXj&E=~|~q46Qap>-LC?JLW`))ya$g&X^%_lHdL ziyL+=mo6XHT6{R0w`3vs6HsaraGs_+P7 z^Fa&DK%I0ecRZI zMNS5ew1?P;W-%PBi~t4oxKe%y~e33da&Qq9wcu z5ytax$wLFUD_YGDfosMSaV3A!82&BE0CkQ)xNt(0(huDOXUW%xth_Rj4ZwfbW`_YA{B^_&{eq& zWA;ks$kJ+t)SE#*K>0(P4xNk)f3r8pM_bl}`EBO#0$?bEVbgCct+4s6Csx}%=)-cSe)BXAH(Tg%G$14aH24p7wb|>roZIj?sI{Q_l@nm!`2)>`0ZONBx=~>g87+-IsTS+RnXV zwxWA*gG6Ih`+Ecp#-tZVj*EB6f@%KY7NW!T~?rNKDOi)lnoy$po78TN#~ve1}vSNmXw{eklr z3f1!Bqs;&&RR~t>IES=G4kYakbyht=10MC1ojRc>z=n%ap7gqkYcb%&&6xp%FZbKF zZypVuJ=}87sJo_cvW1KP3jdVRgt55(f~#!VY$7Z}oJUWPTZ#AZRTMtvZTY&5KCCZk3j>O6HrfQ6$%T$lXR0lLGLNPxIf zl@!P`8Eyn3-?9+5BxQwlD%YI06G35Dx@mtvqZ7zQ0KeDfW9r@rHwvKssOG%Xjj(q* zrEOrLKeeUVC}7%1XNx5(}A8VZXb6OwtDVd-n+)4omHbJ2%Ik05WK zvgljoo}p+EOh_X+Jq~f$e-SIRlnrsnj6)}&5ttbpJtBpRa)*Q}%qtcmul@9ZTJ^wt zYWK5Kryc>LbF>&amEQpUNocT}>*MWiCQq>!9J(b^uuW~Va@3pJV~HJHW@eE<(B%9k z!`ZkS^fl9F;7idf01hevsMmW?!*+culdd5Z!sNl~;{()Wj-&ft#$0g>51;hm2Ae0o z&*RgURNwQc!ciaAOPG#+>k^|8wIMpHAkVq`yDQx}3r^udd9}f@O8@0#IEdkdI@{T_ zLfuP8D?xQd5@5BZxxGU&6A89$O=qykf+ivGr&mbKFW+svO{hCwNrf=Jgit-O5XM?C zKM7_^oTohmcRO+@0-E?~3p?`F7oRPQ?Zq9rQ+gg+-6=3ZUp+3F${l{aOsQeH^1CZ| z=Q+DPdR+c68*ulH?cK<9KPSTB^)ir8i1oFWD(9jSZScomXHk{k3wLUlu(%3CG>Wuh zr*qnQe(u<%=^x>n%IfHTuRw!3XY*{mERz`c)({adjHYgv0!U9}HuKH;1LhdC)nT8% zSSi8X0CjLh`*HgiOQvII%UMzgax<>e7#YwlOA{VtwNwVrBhlL8gqQpkPU;gw^`nqS zu7-$y%M1i?$N~=uzyFo>y1;*KpAnz54Q?d`$4SoX2jT>XuBog*WycQc5j`MEbc5P+ z#pz^F=f<$N%Q8RfZ8J3NcYn#EprVK9Cern5eE)Q2T!yqohwvzWq66FfpB$84MI)g- zaOR(OR|>K1YaXOjkHB|bF9p=qFk&nwl(mDgfpy)-01A$+Tfsp;h^q6OJ!J^9hnu=U z8m%h}MYjA}Izj;mmU@1ut6;7Od` zk8T?5sTM{T)E)ZB0A}#Em|@s*Pgja*T#Nu4Say|I@eopx7vB~^PNC}HDEC5g2@63| zuvJ&VqJTGRAD-1*7Glx@u$nM!%hztc;?3IRaRVwaEKh-{*!*=7f-`I>2iMUpK1Xpl zWtkt2(Usf3T)CyyeD%ZLsb>9g+mLM`W4t6rE68dn0G!rCteVjbYB|0;e!v)fLPLVHN8K`rYSCJ)$Bi^wZnLTPMQn1=}&)OEsy}Lmb zs@^c0L#j0=-oD8J6#lin-em*iU>0%K`(PIOiWw9W&pOCtKtLHW2e4dWha!t8EJY7jf%h^%Rb3I?5)1rEfxo;7r!VDv z;2t%$N5v-OT2ua(RW+szJj7D|{0?%zydFSWN1UA9Ho;d~Bp2Z}Zwuv+bb=)cFubJ< zFrl~4Zmg_z2grK9p8vq|eeF8sZ)q71X@R<(iN)?21A!eQ$>XsaV~iT-pW>Qb2%8W# z*Z^bYwdV7g&$zHvT+fyiPv>DT(Mh{dIyyx6D|%h%vtl}4m3ziaA8(*T7#Yb|W`Q5V zXI`F^Da1WTwE|=}U%V_6>%hiY;w68undu$^T`Ad+-IR&IWg}xyKy(JL#`Obd7MJ_; zjqUrR!`{qAf*`h%#wOjB7tVY;OjEVd#PF7%4E8q88YjyY+V=PNM-$ZW&snO>+xvl> z<6ZS&>$rHJ07ZK1>4pfo9)HMfLQ`q~hLaCj$_(x7aQHO#Q;TV&+`z4>WI4uK0Q9(f z)P9^+^y7^!Q8o!z@4q* zwDG>At^n9T&{Z}XK@mE;>O@5w#*c2Er@}2%TIRpExmMo6^nZ&FvJu`pO81KIDU+4K zh(WxcmzXh-WtHUU8oZ6Es`IK>f#^+970G?tPoZwtTEcP}==-!LT(omw)niHL49Ag7 z#zwK}Q)g&7YZ}!0lgRN3qp#{6WVH$j9D-x%gv>GNb_y)i8(Q9^oQzMUe9}{?w?= zL+I}&?rn?JA$tifgz6Y|#I-5a3|1n{Z3OM_jLN%u-M8+vlsXR%<4q!m$QtfvB5JIXY*eo`izE!c^ z-oX`zKfsWtGKS|Np}whxXPXgE4CoOI1%Sg=8N$!w;m@0liGf@M=Px3rH8F=pzfLtp zaXcYt`WYF{0=71#(^@jnc7WdM-D3=l@0MV5V&*&kjjGGA!m_xEe)0kDs^Al}19snj zUk(!_WTxhJs~P=Z1?MR^KarVxN1Z`gK7a0A(RDu01_(&3y7C3~@Z}ySZE0V;61?eq z$At3dTT|o@lrRIPTBji-0!x3g-ReN(7i-dnppk40rW(Qtt+1U?ZFr2C08!UO=}&jTk#&>+ zbvA5`r9qAv_p6+r|I&*>gG>J3B93w0wnz3if1Um~zzD5Nq5LFz<{$VNemcVm-t+=8 z2jr<0&JVatzPOtZc3WgqI5l+Ct%&QclU2FIlX`%I-!&I#IEOqjuRmy&ZxL*MJNWC^ zgEDXB?!4U+K`A1Qe%vXUb}aja2G69VM&)b45Xdr617` zR_mE@LW4h}2fDY^dut;|@hCgsrkBHxo3kc$vyvZEbWqF`uOW}lkXt4QCTK8igxG^I z7oZrGUO{M(2N1NEUKm0$SpBDaFncUK`ki9^kMhXXHDj5$3()pA$+SPXsqs#UL1a6V z8VjAI&n|*9`!R<7neNW>KWCu>d3_2U+9I0j`L|~V4442$uov_9gOU^1fT~XQmjXCf z{!J_iJ6}?G+WK>Ic|whvq7_>!*FIVJdy_#F)j9^u7)X}pRK!>?6Ju_Yi@JnNVOC)4 zmC%AM#h9}mDZkL6_!Ogf&!5!wl~9%6w1F!?;V5+>4UlH}V@8LD6aMb7Xe`j-1k*+U zVA8ycvUuS`?T}_RzCahB>68Tx$tT>rj6Ay)U_j9@!ocG<)hY_Res-4}?Jz}bucpwC ziLhnG#}wZPWX`U=7sc$PQ-3U7A^vN%E()HNHwEkcHyq@>PrC∓t$dRJGIadE?vc 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 Kx8Vjl{{H|h@<;Lj literal 0 HcmV?d00001 diff --git a/examples/test/src-tauri/icons/icon.ico b/examples/test/src-tauri/icons/icon.ico new file mode 100644 index 0000000000000000000000000000000000000000..b3636e4b22ba65db9061cd60a77b02c92022dfd6 GIT binary patch literal 86642 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 AKmY&$ literal 0 HcmV?d00001 diff --git a/examples/test/src-tauri/icons/icon.png b/examples/test/src-tauri/icons/icon.png new file mode 100644 index 0000000000000000000000000000000000000000..e1cd2619e0b5ec089cbba5ec7b03ddf2b1dfceb6 GIT binary patch literal 14183 zcmc&*hgTC%wBCeJLXln+C6oXPQk9~VfFMXm0g;ZP*k}rfNJ&5hL6qJ^iXdG;rPl-j zsR|1I=p-T?fe4|6B>UEP-v97&PEK|+vvX&6XYSnlec!}dTN-n*A7cjqfXn2P;S~UY zLx*sHjRpFlJRYS&KS;kz4*meZ!T;|I175!of&PT~UopM_RDCs#mpz{dm* z+I40CP^Xy~>f1hst(sm!stqil+5R3%vrLgnC*MQ4d&;9 z;#YCkVE=nijZ2oA&dg$~*dLv_6klcUz7sXWtz@@nzE~+QLAmPNQ10W&z^aJ+*{z+z zt-jG-nm6Hv%>O@s2=9)k5=H0YTwx6IkHBFr70X+2Kfcr`H(y{fR z8Q<7Y37J#y=Kn5k;}svC@8y;k%s8IeiS9W5+_UWF*7kR-CtmhCKsAN~BK3Ojr_5q*Urhq{djxt3B<3W0RE@xz&;xiz;*JqY4s_gI4FUqmME@*3Wu>7lh_8& zB$3)u5php6pcfT~!%No9%OBoWCk_1S(^XeLrK~Vz*_#5FV}6cA0z453@b=X>+lDBN zch$4uT8yz18o_n~DmW=h5lu#OsWf|8?Q?Y~UvZMSV=8<2jnQZ_07yu{0QluMTf*z7 zz()`I6F$DfxX!E+iYt$JP2Ch1BzT|!T#s(*?$`C_hx;S?s=!bZ0EqPu9KNAcJiQ5s zNx}f_>rWX4>nl^Z>Y!)&ZZ2QEOl3oE@JAE_f<|z__L}RQ)qFjdoIK}NuxuUbqZN8U zy^K9S?h=4wUu9w3d^r*>Udo;y`R{yXclT?Ul5HeAEEud&gVtyZgeUN7YR$1K7RwH7b3(fRy}50|?$WJ%>i1m1@UG!Wgl zM~Jw{8I29T{4WTe8ifE(@^XYKU*%*kFofQO$?~?x!$GD+CS^IO1;dL?ph{S{`8Bz$ z+3Rh}(HG%Byj}zT(L#7oWx_*D@zZ)B+7J$KM%ZBFWEScH7N`Q}bLiy7J%B|I4p3rk zFxnkn05zEnmrFUUo?$1Rh{R}HH{k8_CQN@e1H$=mz&XEh4DUL<#v1y&9Hwy>Njhx{ z;QYr)_{=;il0nX>VEHpn9JmjEqsI(rGCd7vv)oJ5*ARa!j)NWs>g{|2;X5CJmk-EK zv^tPoETjJ_0De6*A?RcyypRQ7I013v5LzCx1NCcw-^B-sV+RWCDTgR_9#IeV!Iya( z$O1z+t~Ag}|KJ0Pry|`OIekM>To(;IzY;V)JsV@S0(o{=T(K3+-$#E`J&Jp;VQ&Gw9_7mzJ39HdS7WBj2hu>RK@AZc>+DtZ97&R$;ONX zA}>#G6M5ksnvL$nK`XM+YjvREi{N}rnk=i@wq34B>DhNqYVN;At|cO(a0o!(z0YdJ znLzBf+CAf0aj&D@?O^l8>(De=#D*wRKQ`d!>4sdkR%k$M^3u$H==}1XP-Q$SJtS=t z<>&Zd2mi@1alLgs`+8#v<^)$t0tolJE5fV(xCwLi=WMxv;Ug^c%|EOM5r#&1H^+K? zuewVttC9LA1ghD#aEURO0Fv4vjPZVXufT04CA?N2)b2@+5PYku%$CcyD}V%Ai>BOs z$1$^lluni>GavLpUVXfVlf$Q2+_a(`)ACnom>F$$ivy}SI%8hE$1Ln$LhpK?EvhvY z8L@DN$!KFla`|aeF+J>&4T*~ncpRgE)p;zcKIv zf`ROvVnV~01}M37dV@r%Hgw(7weTfLvK1_rz}##QVWD3H-Ki**{=??71MhK3vON$> z$Z9-Ff7Q%D&JJjx^sGAlT(e~p(W;jDA!~PXzOD7CSU@ms zkM41VQ8k^na;s+gi5__`g&sH+(CK$DXw*7==4%3TngKJAW}C{`leYBf^_^j17)QDb z)SOo2`A^#D4{PahKET#;UWry0mwQ)^&5}|Bo4E=ov0gh%W2DHv)R6 zt1Iu;Zj8GvX(ih~kxa=f>2|zj3kU+Xrtj<-(}|-eWQu>QKQR}7hrp=msOBIi87jSB$axtJt0QnD1iN^| zWfb=-EX$qL_lbP@H=En;JbmYoVf|6Uub>og-)g3}H%FC8%LO4so|5EYGfT-T5@;Z^ zltw{qklaj%P``y9^I13K@jhsKp?nc4dGA*ehGb-B-gvgbkK`SL%SIyretz;wo-`&? zv!=C1&geB?u7haS2K$#+2q1-jbtP{pR7K%LU}td|qUZf(W)Tc@mxhfcSeM@_{N`q} z4?q2sMJgfl*_B~X^YP+V;DLX!_R5PgIWZn~@*>g>_dp6p7-tTq1_jZB2aXFS5p#wp zxlzyL2$@NMJMFU;y`+F|GDbmrEbOusQ;1!H96=K*cps@vKl3-CyuZt?=n9h64yPgs zBRpmfq7KC{uE6A$$F1G<4o`Bvi1-4nSRVY-D?}Y~=P*jHN`#&BuI{a?csJTr>+^g- z{7Brs`OjTyT^43-?P_(oGKE!Xej6~VM~m3PzC?@xD(cN`wMsv+lqGR)$_6hg1#4F1 z>9}PH_Bp!kpGM`H4Ze!nA`2-or$Z0K<2okvs{H<^G5zoYje|s6Gf(r8(3ZgJlmITEnnmW5+=gk+X0ts!tNRpE5Jzk4)k@xh<)3BpV${G~HD)O7 zO&@C%0Ga+2g&g7Rr1MV+g>RX0SH`!%0t!`cWp;%4=~l1oo2`gb5A6VAHFN!T#g{(_ z5tssyS~!)W<)lH@*x~~puJLxDG8GTi8Xdg)C?ejt%aB7vm$Zv;ZwXUgJvmIJMwqTV z#&CSNW-F$GhQ`Go!vj#6>{eewXMM99aj!pPW#5%q#FH#ydFci$D))O)QlCi_0EM{r$W{SkJg`Ic3Y(t3i8=o`n#ziabr z5u$TNp+`u$?&8i&2D1My<)2rMJeLL(L;)PN#DEg3yTH-|2y8Hca#L=m8CZ zsdOnOC=^!y|ia&g?BlXg)XP{0d|T8Nwhfat~l z^w##=Fn@B7fBk}p#M?Cd#M$i)jc#V-PJmp_O!6-(KRm~aAdd400*00CHJEHgmtrr? z{MKr>GYPT+$^1cNJaoCrj_2Aj7| zuCpx4(fR~fB0w-hG1D8?qs17kMu&{e4=WwTB{_B?d_e7m%nMp&m9yR6?C{`^HFH@S`Ey0K9Dk^+berIidxcQvOgnin#^-O>I zNF(l_XJgQF-KE^~GGT<#MuM*uZOyoi-gj%mA`)apRZ%Yr&`tzt5oQ7i2k{w|pPsb0 zz;&P%WbPF!qjefP{yR^gkP|#%Z{|FNS5z?_^oZ1l`HLt83$&>Y@PPG0*|sG?iNE!#k<9vt`aps~m8rA=`QXa(YV{8vDwjk5 z8qW}xn20VZ$tMjiu$YDSC-dO znG6L`L2EiX}$a8Onl~{PzxAn%rIn zJNM~=!OI}ZlJWb3r-k1Yx%M)oAWjVOrio4XjjFn$-;cg%bYYx98=-fU>*<0Wviq6Z z@*1!wztr?7-8s~$;&t_6wJ&=Yh?y5%VJFjPMw#2Bw<^guDXdvy&;M?$H#UbL&_N0?VNk)as8Y*!5)|8hr8rI3bUn*@3e z9t$Q4=~u-Fu0q?R~EXBlK$R--by1SCTyQU13HNSDYY|%p60rI zCThl)A+>lEP%q?)TTAXKnnUs7#6;j-N!(AvVd-&dTcSYS&53#d!K7R)p*c?+OHhFt zu!iY}7CWs4izL;NOiZ)^DMJ62`{Xfx3Na zx3MI$BXIsU41N*L!xo8Ayg7aw^UhYhHBLkZGRi|!^1ML|Eq%?-@^enGRSNQvwA{^D zggCHKj_N=O_uq6<7O^XrL5(tZ{1U<~O(&x^4)(rGvHlR?{6hAB6rZ2~lxsjQh@9!P zd4HTdCR`}9D(30hFO$y|UEaqEAzcg!*m4AdU~}MumD*#bt4v?7mtHT&*xI4_qi`EB0 zxH_3fe{#;nF^IY@_9}o0q+WJZG0alF{F*yx6x6NzZO7Eg4o`4gewgfp(D#cj+ zoFo5kbKX#IG3nArL@%DGbb?+&x_}09GlQps&B+-15th20HvHho?~RTbmf`houEWB> z4u>mH{wJyVZR~_p8R^0x@K`)=U)Y8B%{(0Iu{lYD+$^9fLC7&1W0nn`0B^tW@I?cH zLI3^0M+;pI&uspdUEjBuK8 z^itfn`6__A%iE;|guR7ZUq8_~>}KhG&MIJir|#JR0(>~X@ZB86)@<9LNzdyX5Cv=j zsy^KMa`!8+x$E0*u1-&Dqp*4Ku*o=10elGplcNF4NQ-jb# z(*r!T#L5*oQ4==X@hy`X#1+|nE4v5sr1UOT?X;B>kzhAv;)Ve&m7RJ4Zp~XoQA$!N z$j-6C7LK{`c54$XkPIeU`*r+UI_XAisJyP~1?GInw+ZritPp3`h;8+LF~%X~(lj)I z1-o&$*EeD>)dU;Xkjj*^r}}2^wi|vo}_z5DE(j`*u=_yu`62TW68d=daMJF z>8{4-<(XxLf71f!Z{fd`do)_chDWNcwK`^xqG$Mm7=bvt^cfO)I}-I$j)^8sZ~qh(lq zZAr(i7Tdb)jpA?eL*3x<`qUuVUKQ;L_=$7EEcM&hh?zZnnunW>RO;&SurY!F(+#Vl zCuUDYDDn~E;EqSOVP#y*;MNfpZ)kKCOHf=upFFH2S0pxbYXY~BBi&$bT>ij?ES_i6 zOHu8>Bg*CHr0fqm^fF13#NtBlUGG zc4T_|`qP_zUaEVe;U^9qV9Gy8dtL6A0GT_Cp0=J{3SLe^a{sqTHs_$JMf&#LhiTn& zc1;~t=`;6TzJ|7~#ZSzoHT?bi0ebXbqX`N@qOHp^kOEUw6rq-T!@|du1l9 z(A?=_?B5{GiLa6F?$hv0oV?PmvsI-8?BO0QYnPRFRh#Z4>~;&C)+r9l#2GHUjq3H@ zZ>cAI5+nqv`PBIR4oX`T;9JV}!=Be5Qsgs{?!FZx>tXCh#m%pgC%`X1ld`je) zAWlVDB8Ty!9S^V>vz1`?P6`-7Q}5>6w*A{qM=Mep5q|rO<)I{V%x%E$tSw;rpGuCq z4CuXrO(Ah3zU+m7uU2I`umNa5x_t9b%h=ard^lP={?Ryv6@h*p0v;K_ns%rW_*|ZB zhj*tBuJOTB-j|FCU4iku>e3bjix!R6wEpGlsizXVF_1O#_y|}|_qiO}vjP4{1X8

5l#v3A#xI3*z~1~fvo9Q(N^(==!|_FZ z*duZ=+M1~)8E|otX8KNZlr?qels#x_1Xq@9IIw~@9uAREJVH)Xw^}UclF6327}E42 zT)E&?U%TK?(+K7%R!`H5oX0i)4Qn5??Iw3p5J~6_u+aWehY{DSn}3V2p$bgjnAu?o)v@iC254fXeMv50$9YrpU`N?u@QIWs)T?SP|fa}(|9 zqAX+!7`cx=4)cCBg5h~pu(?@9`)aCr#oyz$ld=#RFxYCNZCZls@4v2~*e-t6PEVvV z&bbK3b3wt(Coc!ufAbXXC<**#HQ%J9k`New6iG<5RjtO4XVO?dCvwxD{kJ#tfQr(X zg^NTwF-FwAeS_{V4bfel8l`~NbfrTR2s!G>WduFWxH(t~aK4q=6rEE^$+Uox>gJO2 z{L<;6Q6nHa5#ZEM>H58not!)z(6*_=^~8}jWf*IG$AUKVWOZ4?)GfF z+BM#*wKKmLFD7E~W3U!$IVm$k_k1f&Kz6WV8@55P?r~bcg-Za-!rvW?ns&)KOGT2~ zlkAyqhQj=P$Eg3w#K~}zH@J5bo-BfHjInKSz$@?+Z)NPD4pHj^_Qxmi`UqoTy=`sV zLVxrXGuBr=QRm|}wg75yetQQK4fY3#P_~J}zEfPnb2C4Wo!E(d*(cA;b?7$g2in<( zPn)ghX}nzJPmb6(3Dpeg_GW~Hc}Lt=lgsSZz z!5QXyz7KaR;D`3Ee}d`af{H>WWZ|Io1QI3~4Ll_`g1(cRnhLK73Ro)7zPCd={1W2x zRp%Xlvv4>!<2@}$hz|!V{T}_eHx2xkLl^hQoZTCnsjCl|W_@5Fx2(+j0ogy&Y+;L- z<)G$*CiN7hOm^s!{U>1F7U=iNk{+u~dAC!eDz%=|glFW0jEZU1&o(G_c#wTxUjnG} z#cg3>jEpUi#Mlq@t?Msg_#geK^Lx@DyHWf7=AS5vVyM7YOjvUVCfcpVR<(+5!H?9- zySI6s>o3m&*zr||=wcPGyBkQV`EWJl@bH8qobjOp+sXL*)=&yX)8aAbf~tGv?a2SN zu^Ddo-z?DWk9h9Yz#5p^NU#x~wYSd?H@w@!2Gb4G)6-utEMV~~M85Br5ff(v5O1|T z zIR`9v=XXbK8N1BZV|h34+~1u1oJ_h>7aS*^LOi zS?hm+ec#1L<6bZ!Oc9OG-gV_V$j{5(O1RZD9`g%{h;v>0d zWiz)=`n67_-$k!Qp(dKW6m@Xi_CesKg~LL=e5V3#YN>;l#X) zHz6W=*ucpXy35@nx1)e|M-IcA>?RmWa)fP$3;*?-yraubd*HgRmAxty2ChoMmOJ(z zJKCPRl#%}U=5It0RrpPM-!VH}hd=~)Dgrd$Xa{xl7m@&qyV;7{bKiJt1}0(zWG;nM z*1KXcyD)ss@$q)hg31UNhb@0?Nl9`#klSY~0mVw;&b=%QK~s8IFXc!F5p^a~%zWmV zZJtPB8R=a#DYTy5Z)F|d(vv8Le0cDUfp(A=+8=zftD?-zNk522{i7(|otj9m+yuVX+hY6rRUn6cGGIp1ZdbJid*Uj}>|6O+%M$p(Q32+w2=sfwN14nBnms&GWQT;bYy>aG9 zPr6Cd#uA1P#}T@__%bE|_zq$$Uq0D;)oI(51NepuZw_VsS}Wm3fO?65Ghs-L5Y7GJ zLIb!-G_V};j1QOoJGZuU!{_^uLL^q?67ac`_1g7Ci)<1m$~^foc2@Oz_+n^`6C*Q) z4T02iPh}_YT5x8sN4uk?9(*=IfB@7nLJx4m+z4*1%olhnL{b0QQ?J_k&g=uRR#T@ck<>fO@F?_=pHVa@D;b*RSyCu;(cPAe?GFc~o>pnJbs_ zl1l-I8t{|mTecYcs@j1uvW09EKFp82PJS04Fs+8ys-MS8Kj%a0`K9hOFsr?0KT05_ z-qPfC|ADFn6bo)#`5S)^%6XKt9>$%BPRiU2ACnI78LtlM!3Y|@WCuRmwTvdeR}e|O zoQ_8f>>i3%vce(s;hDMjqMi|dq)o^x#NC#}_V3i1xARk!cH>NLtnx*VG91+hRXb2i z(8Rh(carI}sY2CavhN=3-`7;QH(11wQh zP;d43IbKw1Bs8TPtY$TgJe$}bJ6dRQH}XAxtwrzArUe%5#s*>t*c4ri%riv3((Aa}(}jAR@Z4(p z-St<0$zye=znm-re+QT%YgT0lPQW`C`>bnml$OKpIUb_K)Ln?HtlN7&D? zce9gBWPlhOdWJU%Z$Rp)g}T_;Q-S+@A>VbkYDi-}Xb&x8WhB@;QZD`|oq&vvW6`i`65b&(uy+Zt<<-oGX}plTUIr!V9THGPYbgYYYZ zj~5jMhZ@h}sNarolPDj80vQqXKK3UV90%jX`t-X^Z2HIP%yZi7SW7I*uG-UA1 zVuRN1Z-#@F^j8(GI^$^4?DPv4;ZtL1WdyjrQq$d>ItF4s&Rdc;l6asHjkJ2YfANQ0tp93~R_WJ6W;!Fw6 z`_&T%lm@4jAACAX+oQ?1G)|xS;NylhQw_dgg=$xgY#$BUy?y&%#DFTBJ}oo*y`*WW zh0BBTF|O=ILcEXiIx*WvX?<#QHH=ot+7rnLLWDsQ6n9`7(>}SUD$c_hy|u87|2ehz z!$4Gq)@1SaVZOOIr){?PUr#i=QZXpTP4SE^_HdZ615YT-Mxq zaU=o9m|f2%zQ!`{{bY$e6hmX3)`!B|4Epd^b@RK%3s?=p?RQz&wO;j-(5P1kck$wd zSJ&DfjKN$?vegNGkE)ftChzIhc-&J&UP~)iQS{5IgFrWb(-TpP389q}c`g5_UKr}* zTV`e40XXe8`o2v{SM^gaF{tN~vs1oYEH0ZIG<2|4fWlpe;{Q7v2eV4MT?@pAC#FQ} z1#v^nMVh9F(f8xk1twtl9n%~9=PhY~kse$*zeza6>Y~mucCA-aK#_m8kW$;ho}k)d zef)!x)+xig;L+^Zn@-hLjJ|=MGQgJO48Zh|BVx3qjQpD~&keYzu08*c`6L77$Odq^)ySMSKo~EG>7qO4) zGQ)1PUpjB%VxfNDiDf4Ro1o$&^7Z)mNLab|_7)vaPv5!^CHt3vXwv#|+`R07+H52% zKo%nK#80s-o)YZj?*ITk+}k^g+myi0bp#KfHwslIGiuDjs~yxHx&gptDVWHG=70&V zJ8Io-FR9z~W&kLF(n_>c?3f)cYo6``BMI)wm3jZFbPN8=?HR1B%7>HqNtp?ns~LRX z9I^(_-#Wqs4rYIAzyB*x_rTr;$D0IjmOVaIb*f!eRcm`A$QFiU*E+iYVy(ww*D#+G z4HPQp`u-fa`BDzB*4ZfjHvM8IMi!3!Rv9Ifk3a)bnSGPt_|HayKxwKr8EiZp4ENUM z53~}@bJhH>Z+4qaz_de#z`Nk~-Xj#@`R5upr+J$E_E78H>WPHkEn!|F-Wx92_)~gF z2)F3pQ^!@nTj?i4U^t|f_WD0c>fxtBtXMyIl3x(VyD-sm2;X&fx~*6;rc?rV_gch` zyN$kU`>}KvO#R2AS=Jr7_3Ipox2Z@^{e^GbkT-DuOD$?@^P~b?+CL`B%(rGrZX(XK zB;huyA)r%y72y_VVMa0v_3;!uONHw zoRni;$j1Ra@!^urL#n@$>-xC*WIGo_R5kih{`Gxs4?X65^Z|d%#zxiVbe&$7!wqpB z&Gqq9c!_(*Qp%}ybz$e$eNfD%25@W1%^-Lv!No&Q7eO-*_+I+nyzFbkExed7(pohd zFcaui&L7DXAzjue3 zAncEwaY=bSyTKAntX{Y``Td(kG^niT%yilzTza@SJ?iu5#t=xpcNrHq;5&!j8s6Oy zetM@f_AI0nlI6oafRq+dpX=eD9JgvAw&63Y9DJu}eMQtm%uMgk3K#)+7{ZlVy3fxP zBR(sz&2{V9I!pzKO(qAsz>_xVOOyl^XwC?y4S(8G3sSSj#eFOS0}q)SBw@cO2`27r ze(`We&e5WW?y7A~hhHz4;n*9u=1}rRDJ6V7K~!v*_peughtWU0tpa}h8`F4r1z?lD zN3U_T4#UQb{975_<1b`0`)vi|=5-7rGUbFJ>TCOS;$2XR!cZ|m1HXl4PvaWzU#)Av zV^0!NYg2Yd5~CSM9#DJGNkF{Ab335tD*S3or#<1O%fW*o?Xu^@CP<*c{YpDF|k?t^m$uBbp4Lwi@Baxp9=Mc*(~xK6`g z=hKP^8aedgD#a7mFY}l#Mq+QAZERu0OuxWZS1ULRxwAufv^C?3d%-W=%KJC3-uH}o z1oZPfArJj~@24Pyk@?>uWUms4%sf^D0npR@uxOruAu#d#f3rWINyCbv1WuszHEAz& z=?qL;EJ^}GJt`ml*Cb64NCM3D_Z;&ll82@1V*Vfr;x~{CbpuZ_w~aAeS^5l>0R?!d zOUu`UqI4T!6aN@F4>pDmc_^2GLMq=H1kArrC$v-S;Ly(W+)6v}=fJXt#Kw?r z<4BNZ)kbJ5nvgPW^BF=39{nSI5a0dBXlGZnU!2@8@uC@|B?9ISkRZ)P@>eoY*k`i{ zpIdaL3~cVlGz+YqmT|aE=C-@QkuSOE`e&o-2a`_m#D7^@wTL-hCp^eggtg@r#Kl1# zw4tC;ko=KFA>wgkGS=z*cj@L-#$`K*B|(33f}w1JKLmw^yYL(j>aO0cuko3}1W8{o zrx%w0qh*SnV6qR)#I-k`UGfwvg=!lp*Y)<$?(s5G;XptR`oXMthRorcd&W&C2| z!^L@skGCA-~}Ka^T8SSo0nynP|RU!FKm;e3uRh%sH=JP2(kzg*8>fg z*#_C9z>d<_M#%~*0rduNj`qqMZAAIrbkJN$h+hkbG|IT8OK{Ug*BfV7`67$&?LOS3 zhT3Rfp==4iG-;np#jrT<8R%UC;K~puSgdfHC=_ot5?)jrFH>g5KAHEmwtQHkiiyN6B2g)XX%#m5#`fPyR!RI z5M2-E&!BSvrD+Em(}f*VFd%7AUmA0^Xux{c6R@kes6AJzJ& z$cFLCdjgU*hhG=2ehpu4QV4{1_1}3xN*GT943{@|4Thv)b7D;}$=^aWh^Br?N?865 ze}23(;yHT?oU)V+g#unK^kTnu+&VG#yu?!i1ZS zX#zTt$Y09M-=Rc6Iuhe|Ob~eU*%@fPZN~VrOx>t^1`Q%}NUp)J0DC-ery?iN=fNtg zq7es_@hL>?<+(aOv@b@GpD7&pcXKau3j!2~_)QD3BkTSIY|}(3XJQ?06)6p4G;-;}Y@)~&+B4D(Q#kj~nC@K=65{rb~5fQ?27_$O{UA`h=+ zk-SJ^m5V?CHa5hGtTxIb(OyI-KI(h=_sPXWD{u)Jfy&f{MB0%pYWZKL>oHzz7diuV z|7}09KDCW$bxeIded}%F(v~XTCr-r)5uOjh(AFjgg#6KCwXCfpXOq1yFS3^Z6P|1A z<+TjRjM)9!)l+*g$=V9-@u+q_sGjk)=&553xTvh7zFfhz|Ai$yQkNtPN!M4%ED^8g zosuJv=Y%Lz8R20ju_!X6`D) -> bool { + emitted.0.load(Ordering::Relaxed) +} + +#[tauri::command] +fn exit_with_error(e: &str) -> bool { + eprintln!("{}", e); + std::process::exit(1); +} + +fn main() { + tauri::Builder::default() + .invoke_handler(tauri::generate_handler![verify_receive, exit_with_error]) + .setup(|app| { + app.manage(Received(AtomicBool::new(false))); + + let app_handle = app.handle(); + app.listen_global("foo", move |_| { + app_handle.state::().0.store(true, Ordering::Relaxed); + }); + + Ok(()) + }) + .run(tauri::generate_context!()) + .expect("error while running tauri application"); +} diff --git a/examples/test/src-tauri/tauri.conf.json b/examples/test/src-tauri/tauri.conf.json new file mode 100644 index 0000000..63dd763 --- /dev/null +++ b/examples/test/src-tauri/tauri.conf.json @@ -0,0 +1,66 @@ +{ + "build": { + "beforeDevCommand": "trunk serve", + "beforeBuildCommand": "trunk build --release", + "devPath": "http://localhost:1420", + "distDir": "../dist", + "withGlobalTauri": true + }, + "package": { + "productName": "tauri-sys-test", + "version": "0.0.0" + }, + "tauri": { + "allowlist": { + "all": true + }, + "bundle": { + "active": true, + "category": "DeveloperTool", + "copyright": "", + "deb": { + "depends": [] + }, + "externalBin": [], + "icon": [ + "icons/32x32.png", + "icons/128x128.png", + "icons/128x128@2x.png", + "icons/icon.icns", + "icons/icon.ico" + ], + "identifier": "com.tauri.dev", + "longDescription": "", + "macOS": { + "entitlements": null, + "exceptionDomain": "", + "frameworks": [], + "providerShortName": null, + "signingIdentity": null + }, + "resources": [], + "shortDescription": "", + "targets": "all", + "windows": { + "certificateThumbprint": null, + "digestAlgorithm": "sha256", + "timestampUrl": "" + } + }, + "security": { + "csp": null + }, + "updater": { + "active": false + }, + "windows": [ + { + "fullscreen": false, + "height": 600, + "resizable": true, + "title": "tauri-app", + "width": 800 + } + ] + } +} diff --git a/examples/test/src/app.rs b/examples/test/src/app.rs new file mode 100644 index 0000000..7ce0760 --- /dev/null +++ b/examples/test/src/app.rs @@ -0,0 +1,34 @@ +use anyhow::ensure; +use tauri_sys::app; + +pub async fn get_name() -> anyhow::Result<()> { + let name = app::get_name().await; + + ensure!(name == "tauri-sys-test"); + + Ok(()) +} + +pub async fn get_version() -> anyhow::Result<()> { + let version = app::get_version().await; + + ensure!(version.major == 0); + ensure!(version.minor == 0); + ensure!(version.patch == 0); + ensure!(version.build.is_empty()); + ensure!(version.pre.is_empty()); + + Ok(()) +} + +pub async fn get_tauri_version() -> anyhow::Result<()> { + let version = app::get_tauri_version().await; + + ensure!(version.major == 1); + ensure!(version.minor == 1); + ensure!(version.patch == 1); + ensure!(version.build.is_empty()); + ensure!(version.pre.is_empty()); + + Ok(()) +} \ No newline at end of file diff --git a/examples/test/src/clipboard.rs b/examples/test/src/clipboard.rs new file mode 100644 index 0000000..e84c521 --- /dev/null +++ b/examples/test/src/clipboard.rs @@ -0,0 +1,12 @@ +use anyhow::ensure; +use tauri_sys::clipboard; + +pub async fn test() -> anyhow::Result<()> { + clipboard::write_text("foobar").await; + + let text = clipboard::read_text().await; + + ensure!(text == Some("foobar".to_string())); + + Ok(()) +} \ No newline at end of file diff --git a/examples/test/src/event.rs b/examples/test/src/event.rs new file mode 100644 index 0000000..7c207a4 --- /dev/null +++ b/examples/test/src/event.rs @@ -0,0 +1,10 @@ +use anyhow::ensure; +use tauri_sys::{event, tauri}; + +pub async fn emit() -> anyhow::Result<()> { + event::emit("foo", &"bar").await; + + ensure!(tauri::invoke::<_, bool>("verify_receive", &()).await.unwrap()); + + Ok(()) +} \ No newline at end of file diff --git a/examples/test/src/main.rs b/examples/test/src/main.rs new file mode 100644 index 0000000..83aed19 --- /dev/null +++ b/examples/test/src/main.rs @@ -0,0 +1,86 @@ +mod app; +mod clipboard; +mod event; +mod window; + +extern crate console_error_panic_hook; +use std::future::Future; +use std::panic; +use sycamore::prelude::*; +use sycamore::suspense::Suspense; + +#[cfg(feature = "ci")] +async fn exit_with_error(e: String) { + use serde::Serialize; + + #[derive(Serialize)] + struct Args { + e: String, + } + + tauri_sys::tauri::invoke::<_, ()>("exit_with_error", &Args { e }).await.unwrap(); +} + +#[derive(Props)] +pub struct TestProps<'a, F> +where + F: Future> + 'a, +{ + name: &'a str, + test: F, +} + +#[component] +pub async fn Test<'a, G: Html, F>(cx: Scope<'a>, props: TestProps<'a, F>) -> View +where + F: Future> + 'a, +{ + let res = props.test.await; + + view! { cx, + tr { + td { code { (props.name.to_string()) } } + td { (if let Err(e) = &res { + #[cfg(feature = "ci")] + { + wasm_bindgen_futures::spawn_local(exit_with_error(e.to_string())); + unreachable!() + } + #[cfg(not(feature = "ci"))] + format!("❌ {:?}", e) + } else { + format!("✅") + }) + } + } + } +} + +fn main() { + panic::set_hook(Box::new(|info| { + console_error_panic_hook::hook(info); + + #[cfg(feature = "ci")] + wasm_bindgen_futures::spawn_local(exit_with_error(format!("{}", info))); + })); + + sycamore::render(|cx| { + view! { cx, + table { + tbody { + Suspense(fallback=view!{ cx, "Running Tests..." }) { + Test(name="app::get_name",test=app::get_name()) + Test(name="app::get_version",test=app::get_version()) + Test(name="app::get_tauri_version",test=app::get_tauri_version()) + Test(name="clipboard::read_text | clipboard::write_text",test=clipboard::test()) + Test(name="event::emit",test=event::emit()) + // Test(name="window::WebviewWindow::new",test=window::create_window()) + } + } + } + } + }); + + #[cfg(feature = "ci")] + tauri_sys::process::exit(0); +} diff --git a/examples/test/src/window.rs b/examples/test/src/window.rs new file mode 100644 index 0000000..0954ea5 --- /dev/null +++ b/examples/test/src/window.rs @@ -0,0 +1,13 @@ +use anyhow::ensure; +use tauri_sys::window; + +pub async fn create_window() -> anyhow::Result<()> { + let win = window::WebviewWindow::new("foo", ()); + + ensure!(win.is_visible().await); + // ensure!(win.label() == "foo".to_string()); + + win.close().await; + + Ok(()) +} \ No newline at end of file From ebf3c07e79ffc019e15ff7b02717e3b6da384e0a Mon Sep 17 00:00:00 2001 From: Jonas Kruckenberg Date: Thu, 3 Nov 2022 18:52:24 +0100 Subject: [PATCH 4/6] Create test.yml --- .github/workflows/test.yml | 42 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 42 insertions(+) create mode 100644 .github/workflows/test.yml diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml new file mode 100644 index 0000000..31e73b2 --- /dev/null +++ b/.github/workflows/test.yml @@ -0,0 +1,42 @@ +name: Test + +push: + branches: + - main + paths: + - '.github/workflows/test.yml' + - 'src/**' + - 'examples/test/**' + pull_request: + branches: + - main + paths: + - '.github/workflows/test.yml' + - 'src/**' + - 'examples/test/**' + +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true + +jobs: + build-and-test: + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v3 + - name: Install stable toolchain + uses: actions-rs/toolchain@v1 + with: + toolchain: stable + override: true + - uses: Swatinem/rust-cache@v1 + - name: Install native deps + run: | + sudo apt-get update + sudo apt-get install -y webkit2gtk-4.0 + wget -qO- https://github.com/tauri-apps/tauri/releases/download/cli.rs-v1.1.1/cargo-tauri-x86_64-unknown-linux-gnu.tgz | tar -xzf- + - name: Run test app + run: | + cd examples/test + cargo tauri dev --exit-on-panic --config ./src-tauri/ci.tauri.conf.json \ No newline at end of file From bc8818e6951b6309fc7014e7391d4e0ebbf0c803 Mon Sep 17 00:00:00 2001 From: Jonas Kruckenberg Date: Thu, 3 Nov 2022 18:52:40 +0100 Subject: [PATCH 5/6] add process module --- Cargo.lock | 3572 ++++++++++++++++++++++++++++++++++++++++++++++- Cargo.toml | 9 +- build.rs | 3 +- dist/process.js | 65 + src/lib.rs | 2 + src/process.rs | 18 + 6 files changed, 3664 insertions(+), 5 deletions(-) create mode 100644 dist/process.js create mode 100644 src/process.rs diff --git a/Cargo.lock b/Cargo.lock index 305ed81..cec30af 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2,18 +2,314 @@ # It is not intended for manual editing. version = 3 +[[package]] +name = "adler" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe" + +[[package]] +name = "adler32" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aae1277d39aeec15cb388266ecc24b11c80469deae6067e17a1a7aa9e5c1f234" + +[[package]] +name = "ahash" +version = "0.7.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fcb51a0695d8f838b1ee009b3fbf66bda078cd64590202a864a8f3e8c4315c47" +dependencies = [ + "getrandom 0.2.8", + "once_cell", + "version_check", +] + +[[package]] +name = "aho-corasick" +version = "0.7.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b4f55bd91a0978cbfd91c457a164bab8b4001c833b7f323132c0a4e1922dd44e" +dependencies = [ + "memchr", +] + +[[package]] +name = "alloc-no-stdlib" +version = "2.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cc7bb162ec39d46ab1ca8c77bf72e890535becd1751bb45f64c597edb4c8c6b3" + +[[package]] +name = "alloc-stdlib" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "94fb8275041c72129eb51b7d0322c29b8387a0386127718b096429201a5d6ece" +dependencies = [ + "alloc-no-stdlib", +] + +[[package]] +name = "anyhow" +version = "1.0.66" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "216261ddc8289130e551ddcd5ce8a064710c0d064a4d2895c67151c92b5443f6" + +[[package]] +name = "atk" +version = "0.15.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2c3d816ce6f0e2909a96830d6911c2aff044370b1ef92d7f267b43bae5addedd" +dependencies = [ + "atk-sys", + "bitflags", + "glib", + "libc", +] + +[[package]] +name = "atk-sys" +version = "0.15.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "58aeb089fb698e06db8089971c7ee317ab9644bade33383f63631437b03aafb6" +dependencies = [ + "glib-sys", + "gobject-sys", + "libc", + "system-deps 6.0.3", +] + +[[package]] +name = "attohttpc" +version = "0.22.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fcf00bc6d5abb29b5f97e3c61a90b6d3caa12f3faf897d4a3e3607c050a35a7" +dependencies = [ + "flate2", + "http", + "log", + "native-tls", + "serde", + "serde_json", + "serde_urlencoded", + "url", +] + +[[package]] +name = "autocfg" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa" + +[[package]] +name = "base64" +version = "0.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8" + +[[package]] +name = "bitflags" +version = "1.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" + +[[package]] +name = "block" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0d8c1fef690941d3e7788d328517591fecc684c084084702d6ff1641e993699a" + +[[package]] +name = "block-buffer" +version = "0.10.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "69cce20737498f97b993470a6e536b8523f0af7892a4f928cceb1ac5e52ebe7e" +dependencies = [ + "generic-array", +] + +[[package]] +name = "brotli" +version = "3.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a1a0b1dbcc8ae29329621f8d4f0d835787c1c38bb1401979b49d13b0b305ff68" +dependencies = [ + "alloc-no-stdlib", + "alloc-stdlib", + "brotli-decompressor", +] + +[[package]] +name = "brotli-decompressor" +version = "2.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "59ad2d4653bf5ca36ae797b1f4bb4dbddb60ce49ca4aed8a2ce4829f60425b80" +dependencies = [ + "alloc-no-stdlib", + "alloc-stdlib", +] + +[[package]] +name = "bstr" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ba3569f383e8f1598449f1a423e72e99569137b47740b1da11ef19af3d5c3223" +dependencies = [ + "memchr", +] + [[package]] name = "bumpalo" version = "3.11.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "572f695136211188308f16ad2ca5c851a712c464060ae6974944458eb83880ba" +[[package]] +name = "bytemuck" +version = "1.12.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5aec14f5d4e6e3f927cd0c81f72e5710d95ee9019fbeb4b3021193867491bfd8" + +[[package]] +name = "byteorder" +version = "1.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610" + +[[package]] +name = "bytes" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec8a7b6a70fde80372154c65702f00a0f56f3e1c36abbc6c440484be248856db" + +[[package]] +name = "cairo-rs" +version = "0.15.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c76ee391b03d35510d9fa917357c7f1855bd9a6659c95a1b392e33f49b3369bc" +dependencies = [ + "bitflags", + "cairo-sys-rs", + "glib", + "libc", + "thiserror", +] + +[[package]] +name = "cairo-sys-rs" +version = "0.15.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3c55d429bef56ac9172d25fecb85dc8068307d17acd74b377866b7a1ef25d3c8" +dependencies = [ + "glib-sys", + "libc", + "system-deps 6.0.3", +] + +[[package]] +name = "cargo_toml" +version = "0.11.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e72c3ff59e3b7d24630206bb63a73af65da4ed5df1f76ee84dfafb9fee2ba60e" +dependencies = [ + "serde", + "serde_derive", + "toml", +] + +[[package]] +name = "cc" +version = "1.0.74" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "581f5dba903aac52ea3feb5ec4810848460ee833876f1f9b0fdeab1f19091574" + +[[package]] +name = "cesu8" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6d43a04d8753f35258c91f8ec639f792891f748a1edbd759cf1dcea3382ad83c" + +[[package]] +name = "cfb" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "74f89d248799e3f15f91b70917f65381062a01bb8e222700ea0e5a7ff9785f9c" +dependencies = [ + "byteorder", + "uuid 0.8.2", +] + +[[package]] +name = "cfg-expr" +version = "0.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3431df59f28accaf4cb4eed4a9acc66bea3f3c3753aa6cdc2f024174ef232af7" +dependencies = [ + "smallvec", +] + +[[package]] +name = "cfg-expr" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b0357a6402b295ca3a86bc148e84df46c02e41f41fef186bda662557ef6328aa" +dependencies = [ + "smallvec", +] + [[package]] name = "cfg-if" version = "1.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" +[[package]] +name = "cocoa" +version = "0.24.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f425db7937052c684daec3bd6375c8abe2d146dca4b8b143d6db777c39138f3a" +dependencies = [ + "bitflags", + "block", + "cocoa-foundation", + "core-foundation", + "core-graphics", + "foreign-types", + "libc", + "objc", +] + +[[package]] +name = "cocoa-foundation" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7ade49b65d560ca58c403a479bb396592b155c0185eada742ee323d1d68d6318" +dependencies = [ + "bitflags", + "block", + "core-foundation", + "core-graphics-types", + "foreign-types", + "libc", + "objc", +] + +[[package]] +name = "color_quant" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3d7b894f5411737b7867f4827955924d7c254fc9f4d91a6aad6b097804b1018b" + +[[package]] +name = "combine" +version = "4.6.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "35ed6e9d84f0b51a7f52daf1c7d71dd136fd7a3f41a8462b8cdb8c78d920fad4" +dependencies = [ + "bytes", + "memchr", +] + [[package]] name = "console_error_panic_hook" version = "0.1.7" @@ -24,6 +320,341 @@ dependencies = [ "wasm-bindgen", ] +[[package]] +name = "convert_case" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6245d59a3e82a7fc217c5828a6692dbc6dfb63a0c8c90495621f7b9d79704a0e" + +[[package]] +name = "core-foundation" +version = "0.9.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "194a7a9e6de53fa55116934067c844d9d749312f75c6f6d0980e8c252f8c2146" +dependencies = [ + "core-foundation-sys", + "libc", +] + +[[package]] +name = "core-foundation-sys" +version = "0.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5827cebf4670468b8772dd191856768aedcb1b0278a04f989f7766351917b9dc" + +[[package]] +name = "core-graphics" +version = "0.22.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2581bbab3b8ffc6fcbd550bf46c355135d16e9ff2a6ea032ad6b9bf1d7efe4fb" +dependencies = [ + "bitflags", + "core-foundation", + "core-graphics-types", + "foreign-types", + "libc", +] + +[[package]] +name = "core-graphics-types" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3a68b68b3446082644c91ac778bf50cd4104bfb002b5a6a7c44cca5a2c70788b" +dependencies = [ + "bitflags", + "core-foundation", + "foreign-types", + "libc", +] + +[[package]] +name = "cpufeatures" +version = "0.2.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "28d997bd5e24a5928dd43e46dc529867e207907fe0b239c3477d924f7f2ca320" +dependencies = [ + "libc", +] + +[[package]] +name = "crc32fast" +version = "1.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b540bd8bc810d3885c6ea91e2018302f68baba2129ab3e88f32389ee9370880d" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "crossbeam-channel" +version = "0.5.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c2dd04ddaf88237dc3b8d8f9a3c1004b506b54b3313403944054d23c0870c521" +dependencies = [ + "cfg-if", + "crossbeam-utils", +] + +[[package]] +name = "crossbeam-utils" +version = "0.8.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "edbafec5fa1f196ca66527c1b12c2ec4745ca14b50f1ad8f9f6f720b55d11fac" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "crypto-common" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3" +dependencies = [ + "generic-array", + "typenum", +] + +[[package]] +name = "cssparser" +version = "0.27.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "754b69d351cdc2d8ee09ae203db831e005560fc6030da058f86ad60c92a9cb0a" +dependencies = [ + "cssparser-macros", + "dtoa-short", + "itoa 0.4.8", + "matches", + "phf 0.8.0", + "proc-macro2", + "quote", + "smallvec", + "syn", +] + +[[package]] +name = "cssparser-macros" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dfae75de57f2b2e85e8768c3ea840fd159c8f33e2b6522c7835b7abac81be16e" +dependencies = [ + "quote", + "syn", +] + +[[package]] +name = "ctor" +version = "0.1.26" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6d2301688392eb071b0bf1a37be05c469d3cc4dbbd95df672fe28ab021e6a096" +dependencies = [ + "quote", + "syn", +] + +[[package]] +name = "cty" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b365fabc795046672053e29c954733ec3b05e4be654ab130fe8f1f94d7051f35" + +[[package]] +name = "darling" +version = "0.13.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a01d95850c592940db9b8194bc39f4bc0e89dee5c4265e4b1807c34a9aba453c" +dependencies = [ + "darling_core", + "darling_macro", +] + +[[package]] +name = "darling_core" +version = "0.13.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "859d65a907b6852c9361e3185c862aae7fafd2887876799fa55f5f99dc40d610" +dependencies = [ + "fnv", + "ident_case", + "proc-macro2", + "quote", + "strsim", + "syn", +] + +[[package]] +name = "darling_macro" +version = "0.13.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9c972679f83bdf9c42bd905396b6c3588a843a17f0f16dfcfa3e2c5d57441835" +dependencies = [ + "darling_core", + "quote", + "syn", +] + +[[package]] +name = "dbus" +version = "0.9.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6f8bcdd56d2e5c4ed26a529c5a9029f5db8290d433497506f958eae3be148eb6" +dependencies = [ + "libc", + "libdbus-sys", + "winapi", +] + +[[package]] +name = "deflate" +version = "0.7.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "707b6a7b384888a70c8d2e8650b3e60170dfc6a67bb4aa67b6dfca57af4bedb4" +dependencies = [ + "adler32", + "byteorder", +] + +[[package]] +name = "derive_more" +version = "0.99.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4fb810d30a7c1953f91334de7244731fc3f3c10d7fe163338a35b9f640960321" +dependencies = [ + "convert_case", + "proc-macro2", + "quote", + "rustc_version 0.4.0", + "syn", +] + +[[package]] +name = "digest" +version = "0.10.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "adfbc57365a37acbd2ebf2b64d7e69bb766e2fea813521ed536f5d0520dcf86c" +dependencies = [ + "block-buffer", + "crypto-common", +] + +[[package]] +name = "dirs-next" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b98cf8ebf19c3d1b223e151f99a4f9f0690dca41414773390fc824184ac833e1" +dependencies = [ + "cfg-if", + "dirs-sys-next", +] + +[[package]] +name = "dirs-sys-next" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4ebda144c4fe02d1f7ea1a7d9641b6fc6b580adcfa024ae48797ecdeb6825b4d" +dependencies = [ + "libc", + "redox_users", + "winapi", +] + +[[package]] +name = "dispatch" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bd0c93bb4b0c6d9b77f4435b0ae98c24d17f1c45b2ff844c6151a07256ca923b" + +[[package]] +name = "dtoa" +version = "0.4.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "56899898ce76aaf4a0f24d914c97ea6ed976d42fec6ad33fcbb0a1103e07b2b0" + +[[package]] +name = "dtoa-short" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bde03329ae10e79ede66c9ce4dc930aa8599043b0743008548680f25b91502d6" +dependencies = [ + "dtoa", +] + +[[package]] +name = "embed_plist" +version = "1.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4ef6b89e5b37196644d8796de5268852ff179b44e96276cf4290264843743bb7" + +[[package]] +name = "encoding_rs" +version = "0.8.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9852635589dc9f9ea1b6fe9f05b50ef208c85c834a562f0c6abb1c475736ec2b" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "fastrand" +version = "1.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a7a407cfaa3385c4ae6b23e84623d48c2798d06e3e6a1878f7f59f17b3f86499" +dependencies = [ + "instant", +] + +[[package]] +name = "field-offset" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e1c54951450cbd39f3dbcf1005ac413b49487dabf18a720ad2383eccfeffb92" +dependencies = [ + "memoffset", + "rustc_version 0.3.3", +] + +[[package]] +name = "filetime" +version = "0.2.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4b9663d381d07ae25dc88dbdf27df458faa83a9b25336bcac83d5e452b5fc9d3" +dependencies = [ + "cfg-if", + "libc", + "redox_syscall", + "windows-sys 0.42.0", +] + +[[package]] +name = "flate2" +version = "1.0.24" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f82b0f4c27ad9f8bfd1f3208d882da2b09c301bc1c828fd3a00d0216d2fbbff6" +dependencies = [ + "crc32fast", + "miniz_oxide 0.5.4", +] + +[[package]] +name = "fnv" +version = "1.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1" + +[[package]] +name = "foreign-types" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1" +dependencies = [ + "foreign-types-shared", +] + +[[package]] +name = "foreign-types-shared" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b" + [[package]] name = "form_urlencoded" version = "1.1.0" @@ -33,6 +664,477 @@ dependencies = [ "percent-encoding", ] +[[package]] +name = "futf" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "df420e2e84819663797d1ec6544b13c5be84629e7bb00dc960d6917db2987843" +dependencies = [ + "mac", + "new_debug_unreachable", +] + +[[package]] +name = "futures" +version = "0.3.25" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "38390104763dc37a5145a53c29c63c1290b5d316d6086ec32c293f6736051bb0" +dependencies = [ + "futures-channel", + "futures-core", + "futures-executor", + "futures-io", + "futures-sink", + "futures-task", + "futures-util", +] + +[[package]] +name = "futures-channel" +version = "0.3.25" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "52ba265a92256105f45b719605a571ffe2d1f0fea3807304b522c1d778f79eed" +dependencies = [ + "futures-core", + "futures-sink", +] + +[[package]] +name = "futures-core" +version = "0.3.25" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "04909a7a7e4633ae6c4a9ab280aeb86da1236243a77b694a49eacd659a4bd3ac" + +[[package]] +name = "futures-executor" +version = "0.3.25" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7acc85df6714c176ab5edf386123fafe217be88c0840ec11f199441134a074e2" +dependencies = [ + "futures-core", + "futures-task", + "futures-util", +] + +[[package]] +name = "futures-io" +version = "0.3.25" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "00f5fb52a06bdcadeb54e8d3671f8888a39697dcb0b81b23b55174030427f4eb" + +[[package]] +name = "futures-macro" +version = "0.3.25" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bdfb8ce053d86b91919aad980c220b1fb8401a9394410e1c289ed7e66b61835d" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "futures-sink" +version = "0.3.25" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "39c15cf1a4aa79df40f1bb462fb39676d0ad9e366c2a33b590d7c66f4f81fcf9" + +[[package]] +name = "futures-task" +version = "0.3.25" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2ffb393ac5d9a6eaa9d3fdf37ae2776656b706e200c8e16b1bdb227f5198e6ea" + +[[package]] +name = "futures-util" +version = "0.3.25" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "197676987abd2f9cadff84926f410af1c183608d36641465df73ae8211dc65d6" +dependencies = [ + "futures-channel", + "futures-core", + "futures-io", + "futures-macro", + "futures-sink", + "futures-task", + "memchr", + "pin-project-lite", + "pin-utils", + "slab", +] + +[[package]] +name = "fxhash" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c31b6d751ae2c7f11320402d34e41349dd1016f8d5d45e48c4312bc8625af50c" +dependencies = [ + "byteorder", +] + +[[package]] +name = "gdk" +version = "0.15.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a6e05c1f572ab0e1f15be94217f0dc29088c248b14f792a5ff0af0d84bcda9e8" +dependencies = [ + "bitflags", + "cairo-rs", + "gdk-pixbuf", + "gdk-sys", + "gio", + "glib", + "libc", + "pango", +] + +[[package]] +name = "gdk-pixbuf" +version = "0.15.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ad38dd9cc8b099cceecdf41375bb6d481b1b5a7cd5cd603e10a69a9383f8619a" +dependencies = [ + "bitflags", + "gdk-pixbuf-sys", + "gio", + "glib", + "libc", +] + +[[package]] +name = "gdk-pixbuf-sys" +version = "0.15.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "140b2f5378256527150350a8346dbdb08fadc13453a7a2d73aecd5fab3c402a7" +dependencies = [ + "gio-sys", + "glib-sys", + "gobject-sys", + "libc", + "system-deps 6.0.3", +] + +[[package]] +name = "gdk-sys" +version = "0.15.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32e7a08c1e8f06f4177fb7e51a777b8c1689f743a7bc11ea91d44d2226073a88" +dependencies = [ + "cairo-sys-rs", + "gdk-pixbuf-sys", + "gio-sys", + "glib-sys", + "gobject-sys", + "libc", + "pango-sys", + "pkg-config", + "system-deps 6.0.3", +] + +[[package]] +name = "gdkx11-sys" +version = "0.15.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b4b7f8c7a84b407aa9b143877e267e848ff34106578b64d1e0a24bf550716178" +dependencies = [ + "gdk-sys", + "glib-sys", + "libc", + "system-deps 6.0.3", + "x11", +] + +[[package]] +name = "generator" +version = "0.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cc184cace1cea8335047a471cc1da80f18acf8a76f3bab2028d499e328948ec7" +dependencies = [ + "cc", + "libc", + "log", + "rustversion", + "windows 0.32.0", +] + +[[package]] +name = "generic-array" +version = "0.14.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bff49e947297f3312447abdca79f45f4738097cc82b06e72054d2223f601f1b9" +dependencies = [ + "typenum", + "version_check", +] + +[[package]] +name = "getrandom" +version = "0.1.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8fc3cb4d91f53b50155bdcfd23f6a4c39ae1969c2ae85982b135750cccaf5fce" +dependencies = [ + "cfg-if", + "libc", + "wasi 0.9.0+wasi-snapshot-preview1", +] + +[[package]] +name = "getrandom" +version = "0.2.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c05aeb6a22b8f62540c194aac980f2115af067bfe15a0734d7277a768d396b31" +dependencies = [ + "cfg-if", + "libc", + "wasi 0.11.0+wasi-snapshot-preview1", +] + +[[package]] +name = "gio" +version = "0.15.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "68fdbc90312d462781a395f7a16d96a2b379bb6ef8cd6310a2df272771c4283b" +dependencies = [ + "bitflags", + "futures-channel", + "futures-core", + "futures-io", + "gio-sys", + "glib", + "libc", + "once_cell", + "thiserror", +] + +[[package]] +name = "gio-sys" +version = "0.15.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32157a475271e2c4a023382e9cab31c4584ee30a97da41d3c4e9fdd605abcf8d" +dependencies = [ + "glib-sys", + "gobject-sys", + "libc", + "system-deps 6.0.3", + "winapi", +] + +[[package]] +name = "glib" +version = "0.15.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "edb0306fbad0ab5428b0ca674a23893db909a98582969c9b537be4ced78c505d" +dependencies = [ + "bitflags", + "futures-channel", + "futures-core", + "futures-executor", + "futures-task", + "glib-macros", + "glib-sys", + "gobject-sys", + "libc", + "once_cell", + "smallvec", + "thiserror", +] + +[[package]] +name = "glib-macros" +version = "0.15.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "25a68131a662b04931e71891fb14aaf65ee4b44d08e8abc10f49e77418c86c64" +dependencies = [ + "anyhow", + "heck 0.4.0", + "proc-macro-crate", + "proc-macro-error", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "glib-sys" +version = "0.15.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ef4b192f8e65e9cf76cbf4ea71fa8e3be4a0e18ffe3d68b8da6836974cc5bad4" +dependencies = [ + "libc", + "system-deps 6.0.3", +] + +[[package]] +name = "glob" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b919933a397b79c37e33b77bb2aa3dc8eb6e165ad809e58ff75bc7db2e34574" + +[[package]] +name = "globset" +version = "0.4.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0a1e17342619edbc21a964c2afbeb6c820c6a2560032872f397bb97ea127bd0a" +dependencies = [ + "aho-corasick", + "bstr", + "fnv", + "log", + "regex", +] + +[[package]] +name = "gobject-sys" +version = "0.15.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0d57ce44246becd17153bd035ab4d32cfee096a657fc01f2231c9278378d1e0a" +dependencies = [ + "glib-sys", + "libc", + "system-deps 6.0.3", +] + +[[package]] +name = "gtk" +version = "0.15.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "92e3004a2d5d6d8b5057d2b57b3712c9529b62e82c77f25c1fecde1fd5c23bd0" +dependencies = [ + "atk", + "bitflags", + "cairo-rs", + "field-offset", + "futures-channel", + "gdk", + "gdk-pixbuf", + "gio", + "glib", + "gtk-sys", + "gtk3-macros", + "libc", + "once_cell", + "pango", + "pkg-config", +] + +[[package]] +name = "gtk-sys" +version = "0.15.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d5bc2f0587cba247f60246a0ca11fe25fb733eabc3de12d1965fc07efab87c84" +dependencies = [ + "atk-sys", + "cairo-sys-rs", + "gdk-pixbuf-sys", + "gdk-sys", + "gio-sys", + "glib-sys", + "gobject-sys", + "libc", + "pango-sys", + "system-deps 6.0.3", +] + +[[package]] +name = "gtk3-macros" +version = "0.15.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "24f518afe90c23fba585b2d7697856f9e6a7bbc62f65588035e66f6afb01a2e9" +dependencies = [ + "anyhow", + "proc-macro-crate", + "proc-macro-error", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "hashbrown" +version = "0.12.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888" + +[[package]] +name = "heck" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6d621efb26863f0e9924c6ac577e8275e5e6b77455db64ffa6c65c904e9e132c" +dependencies = [ + "unicode-segmentation", +] + +[[package]] +name = "heck" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2540771e65fc8cb83cd6e8a237f70c319bd5c29f78ed1084ba5d50eeac86f7f9" + +[[package]] +name = "hermit-abi" +version = "0.1.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33" +dependencies = [ + "libc", +] + +[[package]] +name = "html-escape" +version = "0.2.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "15315cfa9503e9aa85a477138eff76a1b203a430703548052c330b69d8d8c205" +dependencies = [ + "utf8-width", +] + +[[package]] +name = "html5ever" +version = "0.25.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e5c13fb08e5d4dfc151ee5e88bae63f7773d61852f3bdc73c9f4b9e1bde03148" +dependencies = [ + "log", + "mac", + "markup5ever", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "http" +version = "0.2.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "75f43d41e26995c17e71ee126451dd3941010b0514a81a9d11f3b341debc2399" +dependencies = [ + "bytes", + "fnv", + "itoa 1.0.4", +] + +[[package]] +name = "http-range" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "21dec9db110f5f872ed9699c3ecf50cf16f423502706ba5c72462e28d3157573" + +[[package]] +name = "ico" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6a4b3331534254a9b64095ae60d3dc2a8225a7a70229cd5888be127cdc1f6804" +dependencies = [ + "byteorder", + "png 0.11.0", +] + +[[package]] +name = "ident_case" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39" + [[package]] name = "idna" version = "0.3.0" @@ -43,12 +1145,129 @@ dependencies = [ "unicode-normalization", ] +[[package]] +name = "ignore" +version = "0.4.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "713f1b139373f96a2e0ce3ac931cd01ee973c3c5dd7c40c0c2efe96ad2b6751d" +dependencies = [ + "crossbeam-utils", + "globset", + "lazy_static", + "log", + "memchr", + "regex", + "same-file", + "thread_local", + "walkdir", + "winapi-util", +] + +[[package]] +name = "image" +version = "0.24.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bd8e4fb07cf672b1642304e731ef8a6a4c7891d67bb4fd4f5ce58cd6ed86803c" +dependencies = [ + "bytemuck", + "byteorder", + "color_quant", + "num-rational", + "num-traits", +] + +[[package]] +name = "indexmap" +version = "1.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "10a35a97730320ffe8e2d410b5d3b69279b98d2c14bdb8b70ea89ecf7888d41e" +dependencies = [ + "autocfg", + "hashbrown", +] + +[[package]] +name = "infer" +version = "0.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "20b2b533137b9cad970793453d4f921c2e91312a6d88b1085c07bc15fc51bb3b" +dependencies = [ + "cfb", +] + +[[package]] +name = "inflate" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f5f9f47468e9a76a6452271efadc88fe865a82be91fe75e6c0c57b87ccea59d4" +dependencies = [ + "adler32", +] + +[[package]] +name = "instant" +version = "0.1.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7a5bbe824c507c5da5956355e86a746d82e0e1464f65d862cc5e71da70e94b2c" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "itoa" +version = "0.4.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b71991ff56294aa922b450139ee08b3bfc70982c6b2c7562771375cf73542dd4" + [[package]] name = "itoa" version = "1.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4217ad341ebadf8d8e724e264f13e593e0648f5b3e94b3896a5df283be015ecc" +[[package]] +name = "javascriptcore-rs" +version = "0.16.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bf053e7843f2812ff03ef5afe34bb9c06ffee120385caad4f6b9967fcd37d41c" +dependencies = [ + "bitflags", + "glib", + "javascriptcore-rs-sys", +] + +[[package]] +name = "javascriptcore-rs-sys" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "905fbb87419c5cde6e3269537e4ea7d46431f3008c5d057e915ef3f115e7793c" +dependencies = [ + "glib-sys", + "gobject-sys", + "libc", + "system-deps 5.0.0", +] + +[[package]] +name = "jni" +version = "0.19.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c6df18c2e3db7e453d3c6ac5b3e9d5182664d28788126d39b91f2d1e22b017ec" +dependencies = [ + "cesu8", + "combine", + "jni-sys", + "log", + "thiserror", + "walkdir", +] + +[[package]] +name = "jni-sys" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8eaf4bc02d17cbdd7ff4c7438cafcdf7fb9a4613313ad11b4f8fefe7d3fa0130" + [[package]] name = "js-sys" version = "0.3.60" @@ -58,6 +1277,69 @@ dependencies = [ "wasm-bindgen", ] +[[package]] +name = "json-patch" +version = "0.2.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f995a3c8f2bc3dd52a18a583e90f9ec109c047fa1603a853e46bcda14d2e279d" +dependencies = [ + "serde", + "serde_json", + "treediff", +] + +[[package]] +name = "kuchiki" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1ea8e9c6e031377cff82ee3001dc8026cdf431ed4e2e6b51f98ab8c73484a358" +dependencies = [ + "cssparser", + "html5ever", + "matches", + "selectors", +] + +[[package]] +name = "lazy_static" +version = "1.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646" + +[[package]] +name = "libc" +version = "0.2.137" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fc7fcc620a3bff7cdd7a365be3376c97191aeaccc2a603e600951e452615bf89" + +[[package]] +name = "libdbus-sys" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c185b5b7ad900923ef3a8ff594083d4d9b5aea80bb4f32b8342363138c0d456b" +dependencies = [ + "pkg-config", +] + +[[package]] +name = "line-wrap" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f30344350a2a51da54c1d53be93fade8a237e545dbcc4bdbe635413f2117cab9" +dependencies = [ + "safemem", +] + +[[package]] +name = "lock_api" +version = "0.4.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "435011366fe56583b16cf956f9df0095b405b82d76425bc8981c0e22e60ec4df" +dependencies = [ + "autocfg", + "scopeguard", +] + [[package]] name = "log" version = "0.4.17" @@ -67,18 +1349,681 @@ dependencies = [ "cfg-if", ] +[[package]] +name = "loom" +version = "0.5.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ff50ecb28bb86013e935fb6683ab1f6d3a20016f123c76fd4c27470076ac30f5" +dependencies = [ + "cfg-if", + "generator", + "scoped-tls", + "serde", + "serde_json", + "tracing", + "tracing-subscriber", +] + +[[package]] +name = "mac" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c41e0c4fef86961ac6d6f8a82609f55f31b05e4fce149ac5710e439df7619ba4" + +[[package]] +name = "mac-notification-sys" +version = "0.5.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3e72d50edb17756489e79d52eb146927bec8eba9dd48faadf9ef08bca3791ad5" +dependencies = [ + "cc", + "dirs-next", + "objc-foundation", + "objc_id", + "time", +] + +[[package]] +name = "malloc_buf" +version = "0.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "62bb907fe88d54d8d9ce32a3cceab4218ed2f6b7d35617cafe9adf84e43919cb" +dependencies = [ + "libc", +] + +[[package]] +name = "markup5ever" +version = "0.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a24f40fb03852d1cdd84330cddcaf98e9ec08a7b7768e952fad3b4cf048ec8fd" +dependencies = [ + "log", + "phf 0.8.0", + "phf_codegen", + "string_cache", + "string_cache_codegen", + "tendril", +] + +[[package]] +name = "matchers" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8263075bb86c5a1b1427b5ae862e8889656f126e9f77c484496e8b47cf5c5558" +dependencies = [ + "regex-automata", +] + +[[package]] +name = "matches" +version = "0.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a3e378b66a060d48947b590737b30a1be76706c8dd7b8ba0f2fe3989c68a853f" + +[[package]] +name = "memchr" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d" + +[[package]] +name = "memoffset" +version = "0.6.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5aa361d4faea93603064a027415f07bd8e1d5c88c9fbf68bf56a285428fd79ce" +dependencies = [ + "autocfg", +] + +[[package]] +name = "miniz_oxide" +version = "0.5.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "96590ba8f175222643a85693f33d26e9c8a015f599c216509b1a6894af675d34" +dependencies = [ + "adler", +] + +[[package]] +name = "miniz_oxide" +version = "0.6.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b275950c28b37e794e8c55d88aeb5e139d0ce23fdbbeda68f8d7174abdf9e8fa" +dependencies = [ + "adler", +] + +[[package]] +name = "native-tls" +version = "0.2.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "07226173c32f2926027b63cce4bcd8076c3552846cbe7925f3aaffeac0a3b92e" +dependencies = [ + "lazy_static", + "libc", + "log", + "openssl", + "openssl-probe", + "openssl-sys", + "schannel", + "security-framework", + "security-framework-sys", + "tempfile", +] + +[[package]] +name = "ndk" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2032c77e030ddee34a6787a64166008da93f6a352b629261d0fee232b8742dd4" +dependencies = [ + "bitflags", + "jni-sys", + "ndk-sys", + "num_enum", + "thiserror", +] + +[[package]] +name = "ndk-context" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "27b02d87554356db9e9a873add8782d4ea6e3e58ea071a9adb9a2e8ddb884a8b" + +[[package]] +name = "ndk-sys" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6e5a6ae77c8ee183dcbbba6150e2e6b9f3f4196a7666c02a715a95692ec1fa97" +dependencies = [ + "jni-sys", +] + +[[package]] +name = "new_debug_unreachable" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e4a24736216ec316047a1fc4252e27dabb04218aa4a3f37c6e7ddbf1f9782b54" + +[[package]] +name = "nodrop" +version = "0.1.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72ef4a56884ca558e5ddb05a1d1e7e1bfd9a68d9ed024c21704cc98872dae1bb" + +[[package]] +name = "notify-rust" +version = "4.5.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "368e89ea58df747ce88be669ae44e79783c1d30bfd540ad0fc520b3f41f0b3b0" +dependencies = [ + "dbus", + "mac-notification-sys", + "tauri-winrt-notification", +] + +[[package]] +name = "nu-ansi-term" +version = "0.46.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "77a8165726e8236064dbb45459242600304b42a5ea24ee2948e18e023bf7ba84" +dependencies = [ + "overload", + "winapi", +] + +[[package]] +name = "num-integer" +version = "0.1.45" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "225d3389fb3509a24c93f5c29eb6bde2586b98d9f016636dff58d7c6f7569cd9" +dependencies = [ + "autocfg", + "num-traits", +] + +[[package]] +name = "num-iter" +version = "0.1.43" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7d03e6c028c5dc5cac6e2dec0efda81fc887605bb3d884578bb6d6bf7514e252" +dependencies = [ + "autocfg", + "num-integer", + "num-traits", +] + +[[package]] +name = "num-rational" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0638a1c9d0a3c0914158145bc76cff373a75a627e6ecbfb71cbe6f453a5a19b0" +dependencies = [ + "autocfg", + "num-integer", + "num-traits", +] + +[[package]] +name = "num-traits" +version = "0.2.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd" +dependencies = [ + "autocfg", +] + +[[package]] +name = "num_cpus" +version = "1.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "19e64526ebdee182341572e50e9ad03965aa510cd94427a4549448f285e957a1" +dependencies = [ + "hermit-abi", + "libc", +] + +[[package]] +name = "num_enum" +version = "0.5.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf5395665662ef45796a4ff5486c5d41d29e0c09640af4c5f17fd94ee2c119c9" +dependencies = [ + "num_enum_derive", +] + +[[package]] +name = "num_enum_derive" +version = "0.5.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3b0498641e53dd6ac1a4f22547548caa6864cc4933784319cd1775271c5a46ce" +dependencies = [ + "proc-macro-crate", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "num_threads" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2819ce041d2ee131036f4fc9d6ae7ae125a3a40e97ba64d04fe799ad9dabbb44" +dependencies = [ + "libc", +] + +[[package]] +name = "objc" +version = "0.2.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "915b1b472bc21c53464d6c8461c9d3af805ba1ef837e1cac254428f4a77177b1" +dependencies = [ + "malloc_buf", + "objc_exception", +] + +[[package]] +name = "objc-foundation" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1add1b659e36c9607c7aab864a76c7a4c2760cd0cd2e120f3fb8b952c7e22bf9" +dependencies = [ + "block", + "objc", + "objc_id", +] + +[[package]] +name = "objc_exception" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ad970fb455818ad6cba4c122ad012fae53ae8b4795f86378bce65e4f6bab2ca4" +dependencies = [ + "cc", +] + +[[package]] +name = "objc_id" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c92d4ddb4bd7b50d730c215ff871754d0da6b2178849f8a2a2ab69712d0c073b" +dependencies = [ + "objc", +] + [[package]] name = "once_cell" version = "1.16.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "86f0b0d4bf799edbc74508c1e8bf170ff5f41238e5f8225603ca7caaae2b7860" +[[package]] +name = "open" +version = "3.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b4a3100141f1733ea40b53381b0ae3117330735ef22309a190ac57b9576ea716" +dependencies = [ + "pathdiff", + "windows-sys 0.36.1", +] + +[[package]] +name = "openssl" +version = "0.10.42" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "12fc0523e3bd51a692c8850d075d74dc062ccf251c0110668cbd921917118a13" +dependencies = [ + "bitflags", + "cfg-if", + "foreign-types", + "libc", + "once_cell", + "openssl-macros", + "openssl-sys", +] + +[[package]] +name = "openssl-macros" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b501e44f11665960c7e7fcf062c7d96a14ade4aa98116c004b2e37b5be7d736c" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "openssl-probe" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ff011a302c396a5197692431fc1948019154afc178baf7d8e37367442a4601cf" + +[[package]] +name = "openssl-sys" +version = "0.9.77" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b03b84c3b2d099b81f0953422b4d4ad58761589d0229b5506356afca05a3670a" +dependencies = [ + "autocfg", + "cc", + "libc", + "pkg-config", + "vcpkg", +] + +[[package]] +name = "os_info" +version = "3.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c4750134fb6a5d49afc80777394ad5d95b04bc12068c6abb92fae8f43817270f" +dependencies = [ + "log", + "serde", + "winapi", +] + +[[package]] +name = "os_pipe" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0dceb7e43f59c35ee1548045b2c72945a5a3bb6ce6d6f07cdc13dc8f6bc4930a" +dependencies = [ + "libc", + "winapi", +] + +[[package]] +name = "overload" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39" + +[[package]] +name = "pango" +version = "0.15.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "22e4045548659aee5313bde6c582b0d83a627b7904dd20dc2d9ef0895d414e4f" +dependencies = [ + "bitflags", + "glib", + "libc", + "once_cell", + "pango-sys", +] + +[[package]] +name = "pango-sys" +version = "0.15.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d2a00081cde4661982ed91d80ef437c20eacaf6aa1a5962c0279ae194662c3aa" +dependencies = [ + "glib-sys", + "gobject-sys", + "libc", + "system-deps 6.0.3", +] + +[[package]] +name = "parking_lot" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3742b2c103b9f06bc9fff0a37ff4912935851bee6d36f3c02bcc755bcfec228f" +dependencies = [ + "lock_api", + "parking_lot_core", +] + +[[package]] +name = "parking_lot_core" +version = "0.9.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4dc9e0dc2adc1c69d09143aff38d3d30c5c3f0df0dad82e6d25547af174ebec0" +dependencies = [ + "cfg-if", + "libc", + "redox_syscall", + "smallvec", + "windows-sys 0.42.0", +] + +[[package]] +name = "paste" +version = "1.0.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b1de2e551fb905ac83f73f7aedf2f0cb4a0da7e35efa24a202a936269f1f18e1" + +[[package]] +name = "pathdiff" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8835116a5c179084a830efb3adc117ab007512b535bc1a21c991d3b32a6b44dd" + [[package]] name = "percent-encoding" version = "2.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "478c572c3d73181ff3c2539045f6eb99e5491218eae919370993b890cdbdd98e" +[[package]] +name = "pest" +version = "2.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dbc7bc69c062e492337d74d59b120c274fd3d261b6bf6d3207d499b4b379c41a" +dependencies = [ + "thiserror", + "ucd-trie", +] + +[[package]] +name = "phf" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3dfb61232e34fcb633f43d12c58f83c1df82962dcdfa565a4e866ffc17dafe12" +dependencies = [ + "phf_macros 0.8.0", + "phf_shared 0.8.0", + "proc-macro-hack", +] + +[[package]] +name = "phf" +version = "0.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fabbf1ead8a5bcbc20f5f8b939ee3f5b0f6f281b6ad3468b84656b658b455259" +dependencies = [ + "phf_macros 0.10.0", + "phf_shared 0.10.0", + "proc-macro-hack", +] + +[[package]] +name = "phf_codegen" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cbffee61585b0411840d3ece935cce9cb6321f01c45477d30066498cd5e1a815" +dependencies = [ + "phf_generator 0.8.0", + "phf_shared 0.8.0", +] + +[[package]] +name = "phf_generator" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "17367f0cc86f2d25802b2c26ee58a7b23faeccf78a396094c13dced0d0182526" +dependencies = [ + "phf_shared 0.8.0", + "rand 0.7.3", +] + +[[package]] +name = "phf_generator" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5d5285893bb5eb82e6aaf5d59ee909a06a16737a8970984dd7746ba9283498d6" +dependencies = [ + "phf_shared 0.10.0", + "rand 0.8.5", +] + +[[package]] +name = "phf_macros" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7f6fde18ff429ffc8fe78e2bf7f8b7a5a5a6e2a8b58bc5a9ac69198bbda9189c" +dependencies = [ + "phf_generator 0.8.0", + "phf_shared 0.8.0", + "proc-macro-hack", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "phf_macros" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "58fdf3184dd560f160dd73922bea2d5cd6e8f064bf4b13110abd81b03697b4e0" +dependencies = [ + "phf_generator 0.10.0", + "phf_shared 0.10.0", + "proc-macro-hack", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "phf_shared" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c00cf8b9eafe68dde5e9eaa2cef8ee84a9336a47d566ec55ca16589633b65af7" +dependencies = [ + "siphasher", +] + +[[package]] +name = "phf_shared" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6796ad771acdc0123d2a88dc428b5e38ef24456743ddb1744ed628f9815c096" +dependencies = [ + "siphasher", +] + +[[package]] +name = "pin-project-lite" +version = "0.2.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e0a7ae3ac2f1173085d398531c705756c94a4c56843785df85a60c1a0afac116" + +[[package]] +name = "pin-utils" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184" + +[[package]] +name = "pkg-config" +version = "0.3.26" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ac9a59f73473f1b8d852421e59e64809f025994837ef743615c6d0c5b305160" + +[[package]] +name = "plist" +version = "1.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bd39bc6cdc9355ad1dc5eeedefee696bb35c34caf21768741e81826c0bbd7225" +dependencies = [ + "base64", + "indexmap", + "line-wrap", + "serde", + "time", + "xml-rs", +] + +[[package]] +name = "png" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0b0cabbbd20c2d7f06dbf015e06aad59b6ca3d9ed14848783e98af9aaf19925" +dependencies = [ + "bitflags", + "deflate", + "inflate", + "num-iter", +] + +[[package]] +name = "png" +version = "0.17.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5d708eaf860a19b19ce538740d2b4bdeeb8337fa53f7738455e706623ad5c638" +dependencies = [ + "bitflags", + "crc32fast", + "flate2", + "miniz_oxide 0.6.2", +] + +[[package]] +name = "ppv-lite86" +version = "0.2.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eb9f9e6e233e5c4a35559a617bf40a4ec447db2e84c20b55a6f83167b7e57872" + +[[package]] +name = "precomputed-hash" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c" + +[[package]] +name = "proc-macro-crate" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eda0fc3b0fb7c975631757e14d9049da17374063edb6ebbcbc54d880d4fe94e9" +dependencies = [ + "once_cell", + "thiserror", + "toml", +] + +[[package]] +name = "proc-macro-error" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c" +dependencies = [ + "proc-macro-error-attr", + "proc-macro2", + "quote", + "syn", + "version_check", +] + +[[package]] +name = "proc-macro-error-attr" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869" +dependencies = [ + "proc-macro2", + "quote", + "version_check", +] + +[[package]] +name = "proc-macro-hack" +version = "0.5.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dbf0c48bc1d91375ae5c3cd81e3722dff1abcf81a30960240640d223f59fe0e5" + [[package]] name = "proc-macro2" version = "1.0.47" @@ -88,6 +2033,15 @@ dependencies = [ "unicode-ident", ] +[[package]] +name = "quick-xml" +version = "0.23.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "11bafc859c6815fbaffbbbf4229ecb767ac913fecb27f9ad4343662e9ef099ea" +dependencies = [ + "memchr", +] + [[package]] name = "quote" version = "1.0.21" @@ -97,23 +2051,311 @@ dependencies = [ "proc-macro2", ] +[[package]] +name = "rand" +version = "0.7.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6a6b1679d49b24bbfe0c803429aa1874472f50d9b363131f0e89fc356b544d03" +dependencies = [ + "getrandom 0.1.16", + "libc", + "rand_chacha 0.2.2", + "rand_core 0.5.1", + "rand_hc", + "rand_pcg", +] + +[[package]] +name = "rand" +version = "0.8.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404" +dependencies = [ + "libc", + "rand_chacha 0.3.1", + "rand_core 0.6.4", +] + +[[package]] +name = "rand_chacha" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f4c8ed856279c9737206bf725bf36935d8666ead7aa69b52be55af369d193402" +dependencies = [ + "ppv-lite86", + "rand_core 0.5.1", +] + +[[package]] +name = "rand_chacha" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88" +dependencies = [ + "ppv-lite86", + "rand_core 0.6.4", +] + +[[package]] +name = "rand_core" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "90bde5296fc891b0cef12a6d03ddccc162ce7b2aff54160af9338f8d40df6d19" +dependencies = [ + "getrandom 0.1.16", +] + +[[package]] +name = "rand_core" +version = "0.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c" +dependencies = [ + "getrandom 0.2.8", +] + +[[package]] +name = "rand_hc" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ca3129af7b92a17112d59ad498c6f81eaf463253766b90396d39ea7a39d6613c" +dependencies = [ + "rand_core 0.5.1", +] + +[[package]] +name = "rand_pcg" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "16abd0c1b639e9eb4d7c50c0b8100b0d0f849be2349829c740fe8e6eb4816429" +dependencies = [ + "rand_core 0.5.1", +] + +[[package]] +name = "raw-window-handle" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed7e3d950b66e19e0c372f3fa3fbbcf85b1746b571f74e0c2af6042a5c93420a" +dependencies = [ + "cty", +] + +[[package]] +name = "redox_syscall" +version = "0.2.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fb5a58c1855b4b6819d59012155603f0b22ad30cad752600aadfcb695265519a" +dependencies = [ + "bitflags", +] + +[[package]] +name = "redox_users" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b033d837a7cf162d7993aded9304e30a83213c648b6e389db233191f891e5c2b" +dependencies = [ + "getrandom 0.2.8", + "redox_syscall", + "thiserror", +] + +[[package]] +name = "regex" +version = "1.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4c4eb3267174b8c6c2f654116623910a0fef09c4753f8dd83db29c48a0df988b" +dependencies = [ + "aho-corasick", + "memchr", + "regex-syntax", +] + +[[package]] +name = "regex-automata" +version = "0.1.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132" +dependencies = [ + "regex-syntax", +] + +[[package]] +name = "regex-syntax" +version = "0.6.27" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a3f87b73ce11b1619a3c6332f45341e0047173771e8b8b73f87bfeefb7b56244" + +[[package]] +name = "remove_dir_all" +version = "0.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3acd125665422973a33ac9d3dd2df85edad0f4ae9b00dafb1a05e43a9f5ef8e7" +dependencies = [ + "winapi", +] + +[[package]] +name = "rfd" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0149778bd99b6959285b0933288206090c50e2327f47a9c463bfdbf45c8823ea" +dependencies = [ + "block", + "dispatch", + "glib-sys", + "gobject-sys", + "gtk-sys", + "js-sys", + "lazy_static", + "log", + "objc", + "objc-foundation", + "objc_id", + "raw-window-handle", + "wasm-bindgen", + "wasm-bindgen-futures", + "web-sys", + "windows 0.37.0", +] + +[[package]] +name = "rustc_version" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0dfe2087c51c460008730de8b57e6a320782fbfb312e1f4d520e6c6fae155ee" +dependencies = [ + "semver 0.11.0", +] + +[[package]] +name = "rustc_version" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366" +dependencies = [ + "semver 1.0.14", +] + +[[package]] +name = "rustversion" +version = "1.0.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "97477e48b4cf8603ad5f7aaf897467cf42ab4218a38ef76fb14c2d6773a6d6a8" + [[package]] name = "ryu" version = "1.0.11" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4501abdff3ae82a1c1b477a17252eb69cee9e66eb915c1abaa4f44d873df9f09" +[[package]] +name = "safemem" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ef703b7cb59335eae2eb93ceb664c0eb7ea6bf567079d843e09420219668e072" + +[[package]] +name = "same-file" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502" +dependencies = [ + "winapi-util", +] + +[[package]] +name = "schannel" +version = "0.1.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "88d6731146462ea25d9244b2ed5fd1d716d25c52e4d54aa4fb0f3c4e9854dbe2" +dependencies = [ + "lazy_static", + "windows-sys 0.36.1", +] + [[package]] name = "scoped-tls" version = "1.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e1cf6437eb19a8f4a6cc0f7dca544973b0b78843adbfeb3683d1a94a0024a294" +[[package]] +name = "scopeguard" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd" + +[[package]] +name = "security-framework" +version = "2.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2bc1bb97804af6631813c55739f771071e0f2ed33ee20b68c86ec505d906356c" +dependencies = [ + "bitflags", + "core-foundation", + "core-foundation-sys", + "libc", + "security-framework-sys", +] + +[[package]] +name = "security-framework-sys" +version = "2.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0160a13a177a45bfb43ce71c01580998474f556ad854dcbca936dd2841a5c556" +dependencies = [ + "core-foundation-sys", + "libc", +] + +[[package]] +name = "selectors" +version = "0.22.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "df320f1889ac4ba6bc0cdc9c9af7af4bd64bb927bccdf32d81140dc1f9be12fe" +dependencies = [ + "bitflags", + "cssparser", + "derive_more", + "fxhash", + "log", + "matches", + "phf 0.8.0", + "phf_codegen", + "precomputed-hash", + "servo_arc", + "smallvec", + "thin-slice", +] + +[[package]] +name = "semver" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f301af10236f6df4160f7c3f04eec6dbc70ace82d23326abad5edee88801c6b6" +dependencies = [ + "semver-parser", +] + [[package]] name = "semver" version = "1.0.14" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e25dfac463d778e353db5be2449d1cce89bd6fd23c9f1ea21310ce6e5a1b29c4" +dependencies = [ + "serde", +] + +[[package]] +name = "semver-parser" +version = "0.10.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "00b0bef5b7f9e0df16536d3961cfb6e84331c065b4066afb39768d0e319411f7" +dependencies = [ + "pest", +] [[package]] name = "serde" @@ -152,11 +2394,322 @@ version = "1.0.87" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6ce777b7b150d76b9cf60d28b55f5847135a003f7d7350c6be7a773508ce7d45" dependencies = [ - "itoa", + "itoa 1.0.4", "ryu", "serde", ] +[[package]] +name = "serde_repr" +version = "0.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fe39d9fbb0ebf5eb2c7cb7e2a47e4f462fad1379f1166b8ae49ad9eae89a7ca" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "serde_urlencoded" +version = "0.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd" +dependencies = [ + "form_urlencoded", + "itoa 1.0.4", + "ryu", + "serde", +] + +[[package]] +name = "serde_with" +version = "1.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "678b5a069e50bf00ecd22d0cd8ddf7c236f68581b03db652061ed5eb13a312ff" +dependencies = [ + "serde", + "serde_with_macros", +] + +[[package]] +name = "serde_with_macros" +version = "1.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e182d6ec6f05393cc0e5ed1bf81ad6db3a8feedf8ee515ecdd369809bcce8082" +dependencies = [ + "darling", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "serialize-to-javascript" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c9823f2d3b6a81d98228151fdeaf848206a7855a7a042bbf9bf870449a66cafb" +dependencies = [ + "serde", + "serde_json", + "serialize-to-javascript-impl", +] + +[[package]] +name = "serialize-to-javascript-impl" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "74064874e9f6a15f04c1f3cb627902d0e6b410abbf36668afa873c61889f1763" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "servo_arc" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d98238b800e0d1576d8b6e3de32827c2d74bee68bb97748dcf5071fb53965432" +dependencies = [ + "nodrop", + "stable_deref_trait", +] + +[[package]] +name = "sha2" +version = "0.10.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "82e6b795fe2e3b1e845bafcb27aa35405c4d47cdfc92af5fc8d3002f76cebdc0" +dependencies = [ + "cfg-if", + "cpufeatures", + "digest", +] + +[[package]] +name = "sharded-slab" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "900fba806f70c630b0a382d0d825e17a0f19fcd059a2ade1ff237bcddf446b31" +dependencies = [ + "lazy_static", +] + +[[package]] +name = "shared_child" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b0d94659ad3c2137fef23ae75b03d5241d633f8acded53d672decfa0e6e0caef" +dependencies = [ + "libc", + "winapi", +] + +[[package]] +name = "siphasher" +version = "0.3.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7bd3e3206899af3f8b12af284fafc038cc1dc2b41d1b89dd17297221c5d225de" + +[[package]] +name = "slab" +version = "0.4.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4614a76b2a8be0058caa9dbbaf66d988527d86d003c11a94fbd335d7661edcef" +dependencies = [ + "autocfg", +] + +[[package]] +name = "slotmap" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e1e08e261d0e8f5c43123b7adf3e4ca1690d655377ac93a03b2c9d3e98de1342" +dependencies = [ + "version_check", +] + +[[package]] +name = "smallvec" +version = "1.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a507befe795404456341dfab10cef66ead4c041f62b8b11bbb92bffe5d0953e0" + +[[package]] +name = "soup2" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b2b4d76501d8ba387cf0fefbe055c3e0a59891d09f0f995ae4e4b16f6b60f3c0" +dependencies = [ + "bitflags", + "gio", + "glib", + "libc", + "once_cell", + "soup2-sys", +] + +[[package]] +name = "soup2-sys" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "009ef427103fcb17f802871647a7fa6c60cbb654b4c4e4c0ac60a31c5f6dc9cf" +dependencies = [ + "bitflags", + "gio-sys", + "glib-sys", + "gobject-sys", + "libc", + "system-deps 5.0.0", +] + +[[package]] +name = "stable_deref_trait" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3" + +[[package]] +name = "state" +version = "0.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dbe866e1e51e8260c9eed836a042a5e7f6726bb2b411dffeaa712e19c388f23b" +dependencies = [ + "loom", +] + +[[package]] +name = "string_cache" +version = "0.8.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "213494b7a2b503146286049378ce02b482200519accc31872ee8be91fa820a08" +dependencies = [ + "new_debug_unreachable", + "once_cell", + "parking_lot", + "phf_shared 0.10.0", + "precomputed-hash", + "serde", +] + +[[package]] +name = "string_cache_codegen" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6bb30289b722be4ff74a408c3cc27edeaad656e06cb1fe8fa9231fa59c728988" +dependencies = [ + "phf_generator 0.10.0", + "phf_shared 0.10.0", + "proc-macro2", + "quote", +] + +[[package]] +name = "strsim" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623" + +[[package]] +name = "strum" +version = "0.22.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f7ac893c7d471c8a21f31cfe213ec4f6d9afeed25537c772e08ef3f005f8729e" +dependencies = [ + "strum_macros", +] + +[[package]] +name = "strum_macros" +version = "0.22.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "339f799d8b549e3744c7ac7feb216383e4005d94bdb22561b3ab8f3b808ae9fb" +dependencies = [ + "heck 0.3.3", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "sycamore" +version = "0.8.2" +source = "git+https://github.com/sycamore-rs/sycamore?rev=abd556cbc02047042dad2ebd04405e455a9b11b2#abd556cbc02047042dad2ebd04405e455a9b11b2" +dependencies = [ + "ahash", + "futures", + "indexmap", + "js-sys", + "paste", + "sycamore-core", + "sycamore-futures", + "sycamore-macro", + "sycamore-reactive", + "sycamore-web", + "wasm-bindgen", + "wasm-bindgen-futures", + "web-sys", +] + +[[package]] +name = "sycamore-core" +version = "0.8.2" +source = "git+https://github.com/sycamore-rs/sycamore?rev=abd556cbc02047042dad2ebd04405e455a9b11b2#abd556cbc02047042dad2ebd04405e455a9b11b2" +dependencies = [ + "ahash", + "sycamore-reactive", +] + +[[package]] +name = "sycamore-futures" +version = "0.8.0" +source = "git+https://github.com/sycamore-rs/sycamore?rev=abd556cbc02047042dad2ebd04405e455a9b11b2#abd556cbc02047042dad2ebd04405e455a9b11b2" +dependencies = [ + "futures", + "sycamore-reactive", + "tokio", + "wasm-bindgen-futures", +] + +[[package]] +name = "sycamore-macro" +version = "0.8.2" +source = "git+https://github.com/sycamore-rs/sycamore?rev=abd556cbc02047042dad2ebd04405e455a9b11b2#abd556cbc02047042dad2ebd04405e455a9b11b2" +dependencies = [ + "once_cell", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "sycamore-reactive" +version = "0.8.1" +source = "git+https://github.com/sycamore-rs/sycamore?rev=abd556cbc02047042dad2ebd04405e455a9b11b2#abd556cbc02047042dad2ebd04405e455a9b11b2" +dependencies = [ + "ahash", + "bumpalo", + "indexmap", + "slotmap", + "smallvec", +] + +[[package]] +name = "sycamore-web" +version = "0.8.2" +source = "git+https://github.com/sycamore-rs/sycamore?rev=abd556cbc02047042dad2ebd04405e455a9b11b2#abd556cbc02047042dad2ebd04405e455a9b11b2" +dependencies = [ + "html-escape", + "indexmap", + "js-sys", + "once_cell", + "sycamore-core", + "sycamore-reactive", + "wasm-bindgen", + "web-sys", +] + [[package]] name = "syn" version = "1.0.103" @@ -168,14 +2721,248 @@ dependencies = [ "unicode-ident", ] +[[package]] +name = "system-deps" +version = "5.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "18db855554db7bd0e73e06cf7ba3df39f97812cb11d3f75e71c39bf45171797e" +dependencies = [ + "cfg-expr 0.9.1", + "heck 0.3.3", + "pkg-config", + "toml", + "version-compare 0.0.11", +] + +[[package]] +name = "system-deps" +version = "6.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2955b1fe31e1fa2fbd1976b71cc69a606d7d4da16f6de3333d0c92d51419aeff" +dependencies = [ + "cfg-expr 0.11.0", + "heck 0.4.0", + "pkg-config", + "toml", + "version-compare 0.1.0", +] + +[[package]] +name = "tao" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "43336f5d1793543ba96e2a1e75f3a5c7dcd592743be06a0ab3a190f4fcb4b934" +dependencies = [ + "bitflags", + "cairo-rs", + "cc", + "cocoa", + "core-foundation", + "core-graphics", + "crossbeam-channel", + "dispatch", + "gdk", + "gdk-pixbuf", + "gdk-sys", + "gdkx11-sys", + "gio", + "glib", + "glib-sys", + "gtk", + "image", + "instant", + "jni", + "lazy_static", + "libc", + "log", + "ndk", + "ndk-context", + "ndk-sys", + "objc", + "once_cell", + "parking_lot", + "paste", + "png 0.17.7", + "raw-window-handle", + "scopeguard", + "serde", + "unicode-segmentation", + "uuid 1.2.1", + "windows 0.39.0", + "windows-implement", + "x11-dl", +] + +[[package]] +name = "tar" +version = "0.4.38" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4b55807c0344e1e6c04d7c965f5289c39a8d94ae23ed5c0b57aabac549f871c6" +dependencies = [ + "filetime", + "libc", + "xattr", +] + +[[package]] +name = "tauri" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "efbf22abd61d95ca9b2becd77f9db4c093892f73e8a07d21d8b0b2bf71a7bcea" +dependencies = [ + "anyhow", + "attohttpc", + "cocoa", + "dirs-next", + "embed_plist", + "encoding_rs", + "flate2", + "futures-util", + "glib", + "glob", + "gtk", + "heck 0.4.0", + "http", + "ignore", + "notify-rust", + "objc", + "once_cell", + "open", + "os_info", + "os_pipe", + "percent-encoding", + "rand 0.8.5", + "raw-window-handle", + "regex", + "rfd", + "semver 1.0.14", + "serde", + "serde_json", + "serde_repr", + "serialize-to-javascript", + "shared_child", + "state", + "tar", + "tauri-macros", + "tauri-runtime", + "tauri-runtime-wry", + "tauri-utils", + "tempfile", + "thiserror", + "tokio", + "url", + "uuid 1.2.1", + "webkit2gtk", + "webview2-com", + "windows 0.39.0", +] + +[[package]] +name = "tauri-build" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0991fb306849897439dbd4a72e4cbed2413e2eb26cb4b3ba220b94edba8b4b88" +dependencies = [ + "anyhow", + "cargo_toml", + "heck 0.4.0", + "json-patch", + "semver 1.0.14", + "serde_json", + "tauri-utils", + "winres", +] + +[[package]] +name = "tauri-codegen" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "356fa253e40ae4d6ff02075011f2f2bb4066f5c9d8c1e16ca6912d7b75903ba6" +dependencies = [ + "base64", + "brotli", + "ico", + "json-patch", + "plist", + "png 0.17.7", + "proc-macro2", + "quote", + "regex", + "semver 1.0.14", + "serde", + "serde_json", + "sha2", + "tauri-utils", + "thiserror", + "time", + "uuid 1.2.1", + "walkdir", +] + +[[package]] +name = "tauri-macros" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6051fd6940ddb22af452340d03c66a3e2f5d72e0788d4081d91e31528ccdc4d" +dependencies = [ + "heck 0.4.0", + "proc-macro2", + "quote", + "syn", + "tauri-codegen", + "tauri-utils", +] + +[[package]] +name = "tauri-runtime" +version = "0.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d49439a5ea47f474572b854972f42eda2e02a470be5ca9609cc83bb66945abe2" +dependencies = [ + "gtk", + "http", + "http-range", + "infer", + "rand 0.8.5", + "raw-window-handle", + "serde", + "serde_json", + "tauri-utils", + "thiserror", + "uuid 1.2.1", + "webview2-com", + "windows 0.39.0", +] + +[[package]] +name = "tauri-runtime-wry" +version = "0.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "28dce920995fd49907aa9bea7249ed1771454f11f7611924c920a1f75fb614d4" +dependencies = [ + "cocoa", + "gtk", + "percent-encoding", + "rand 0.8.5", + "raw-window-handle", + "tauri-runtime", + "tauri-utils", + "uuid 1.2.1", + "webkit2gtk", + "webview2-com", + "windows 0.39.0", + "wry", +] + [[package]] name = "tauri-sys" version = "0.1.0" dependencies = [ "js-sys", - "semver", + "semver 1.0.14", "serde", "serde-wasm-bindgen", + "tauri", "tauri-sys", "thiserror", "url", @@ -184,6 +2971,98 @@ dependencies = [ "wasm-bindgen-test", ] +[[package]] +name = "tauri-sys-test" +version = "0.0.0" +dependencies = [ + "serde", + "serde_json", + "tauri", + "tauri-build", +] + +[[package]] +name = "tauri-sys-test-ui" +version = "0.0.0" +dependencies = [ + "anyhow", + "console_error_panic_hook", + "futures-util", + "serde", + "sycamore", + "tauri-sys", + "wasm-bindgen-futures", +] + +[[package]] +name = "tauri-utils" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e8fdae6f29cef959809a3c3afef510c5b715a446a597ab8b791497585363f39" +dependencies = [ + "brotli", + "ctor", + "glob", + "heck 0.4.0", + "html5ever", + "json-patch", + "kuchiki", + "memchr", + "phf 0.10.1", + "proc-macro2", + "quote", + "semver 1.0.14", + "serde", + "serde_json", + "serde_with", + "thiserror", + "url", + "walkdir", + "windows 0.39.0", +] + +[[package]] +name = "tauri-winrt-notification" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c58de036c4d2e20717024de2a3c4bf56c301f07b21bc8ef9b57189fce06f1f3b" +dependencies = [ + "quick-xml", + "strum", + "windows 0.39.0", +] + +[[package]] +name = "tempfile" +version = "3.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5cdb1ef4eaeeaddc8fbd371e5017057064af0911902ef36b39801f67cc6d79e4" +dependencies = [ + "cfg-if", + "fastrand", + "libc", + "redox_syscall", + "remove_dir_all", + "winapi", +] + +[[package]] +name = "tendril" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d24a120c5fc464a3458240ee02c299ebcb9d67b5249c8848b09d639dca8d7bb0" +dependencies = [ + "futf", + "mac", + "utf-8", +] + +[[package]] +name = "thin-slice" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8eaa81235c7058867fa8c0e7314f33dcce9c215f535d1913822a2b3f5e289f3c" + [[package]] name = "thiserror" version = "1.0.37" @@ -204,6 +3083,44 @@ dependencies = [ "syn", ] +[[package]] +name = "thread_local" +version = "1.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5516c27b78311c50bf42c071425c560ac799b11c30b31f87e3081965fe5e0180" +dependencies = [ + "once_cell", +] + +[[package]] +name = "time" +version = "0.3.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0fab5c8b9980850e06d92ddbe3ab839c062c801f3927c0fb8abd6fc8e918fbca" +dependencies = [ + "itoa 1.0.4", + "libc", + "num_threads", + "serde", + "time-core", + "time-macros", +] + +[[package]] +name = "time-core" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2e153e1f1acaef8acc537e68b44906d2db6436e2b35ac2c6b42640fff91f00fd" + +[[package]] +name = "time-macros" +version = "0.2.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "65bb801831d812c562ae7d2bfb531f26e66e4e1f6b17307ba4149c5064710e5b" +dependencies = [ + "time-core", +] + [[package]] name = "tinyvec" version = "1.6.0" @@ -219,6 +3136,111 @@ version = "0.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "cda74da7e1a664f795bb1f8a87ec406fb89a02522cf6e50620d016add6dbbf5c" +[[package]] +name = "tokio" +version = "1.21.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a9e03c497dc955702ba729190dc4aac6f2a0ce97f913e5b1b5912fc5039d9099" +dependencies = [ + "autocfg", + "bytes", + "memchr", + "num_cpus", + "pin-project-lite", +] + +[[package]] +name = "toml" +version = "0.5.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8d82e1a7758622a465f8cee077614c73484dac5b836c02ff6a40d5d1010324d7" +dependencies = [ + "serde", +] + +[[package]] +name = "tracing" +version = "0.1.37" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8ce8c33a8d48bd45d624a6e523445fd21ec13d3653cd51f681abf67418f54eb8" +dependencies = [ + "cfg-if", + "pin-project-lite", + "tracing-attributes", + "tracing-core", +] + +[[package]] +name = "tracing-attributes" +version = "0.1.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4017f8f45139870ca7e672686113917c71c7a6e02d4924eda67186083c03081a" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "tracing-core" +version = "0.1.30" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "24eb03ba0eab1fd845050058ce5e616558e8f8d8fca633e6b163fe25c797213a" +dependencies = [ + "once_cell", + "valuable", +] + +[[package]] +name = "tracing-log" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "78ddad33d2d10b1ed7eb9d1f518a5674713876e97e5bb9b7345a7984fbb4f922" +dependencies = [ + "lazy_static", + "log", + "tracing-core", +] + +[[package]] +name = "tracing-subscriber" +version = "0.3.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a6176eae26dd70d0c919749377897b54a9276bd7061339665dd68777926b5a70" +dependencies = [ + "matchers", + "nu-ansi-term", + "once_cell", + "regex", + "sharded-slab", + "smallvec", + "thread_local", + "tracing", + "tracing-core", + "tracing-log", +] + +[[package]] +name = "treediff" +version = "3.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "761e8d5ad7ce14bb82b7e61ccc0ca961005a275a060b9644a2431aa11553c2ff" +dependencies = [ + "serde_json", +] + +[[package]] +name = "typenum" +version = "1.15.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dcf81ac59edc17cc8697ff311e8f5ef2d99fcbd9817b34cec66f90b6c3dfd987" + +[[package]] +name = "ucd-trie" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9e79c4d996edb816c91e4308506774452e55e95c3c9de07b6729e17e15a5ef81" + [[package]] name = "unicode-bidi" version = "0.3.8" @@ -240,6 +3262,12 @@ dependencies = [ "tinyvec", ] +[[package]] +name = "unicode-segmentation" +version = "1.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0fdbf052a0783de01e944a6ce7a8cb939e295b1e7be835a1112c3b9a7f047a5a" + [[package]] name = "url" version = "2.3.1" @@ -249,8 +3277,89 @@ dependencies = [ "form_urlencoded", "idna", "percent-encoding", + "serde", ] +[[package]] +name = "utf-8" +version = "0.7.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9" + +[[package]] +name = "utf8-width" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5190c9442dcdaf0ddd50f37420417d219ae5261bbf5db120d0f9bab996c9cba1" + +[[package]] +name = "uuid" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bc5cf98d8186244414c848017f0e2676b3fcb46807f6668a97dfe67359a3c4b7" + +[[package]] +name = "uuid" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "feb41e78f93363bb2df8b0e86a2ca30eed7806ea16ea0c790d757cf93f79be83" +dependencies = [ + "getrandom 0.2.8", +] + +[[package]] +name = "valuable" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "830b7e5d4d90034032940e4ace0d9a9a057e7a45cd94e6c007832e39edb82f6d" + +[[package]] +name = "vcpkg" +version = "0.2.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426" + +[[package]] +name = "version-compare" +version = "0.0.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1c18c859eead79d8b95d09e4678566e8d70105c4e7b251f707a03df32442661b" + +[[package]] +name = "version-compare" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fe88247b92c1df6b6de80ddc290f3976dbdf2f5f5d3fd049a9fb598c6dd5ca73" + +[[package]] +name = "version_check" +version = "0.9.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f" + +[[package]] +name = "walkdir" +version = "2.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "808cf2735cd4b6866113f648b791c6adc5714537bc222d9347bb203386ffda56" +dependencies = [ + "same-file", + "winapi", + "winapi-util", +] + +[[package]] +name = "wasi" +version = "0.9.0+wasi-snapshot-preview1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cccddf32554fecc6acb585f82a32a72e28b48f8c4c1883ddfeeeaa96f7d8e519" + +[[package]] +name = "wasi" +version = "0.11.0+wasi-snapshot-preview1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423" + [[package]] name = "wasm-bindgen" version = "0.2.83" @@ -351,3 +3460,462 @@ dependencies = [ "js-sys", "wasm-bindgen", ] + +[[package]] +name = "webkit2gtk" +version = "0.18.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8f859735e4a452aeb28c6c56a852967a8a76c8eb1cc32dbf931ad28a13d6370" +dependencies = [ + "bitflags", + "cairo-rs", + "gdk", + "gdk-sys", + "gio", + "gio-sys", + "glib", + "glib-sys", + "gobject-sys", + "gtk", + "gtk-sys", + "javascriptcore-rs", + "libc", + "once_cell", + "soup2", + "webkit2gtk-sys", +] + +[[package]] +name = "webkit2gtk-sys" +version = "0.18.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4d76ca6ecc47aeba01ec61e480139dda143796abcae6f83bcddf50d6b5b1dcf3" +dependencies = [ + "atk-sys", + "bitflags", + "cairo-sys-rs", + "gdk-pixbuf-sys", + "gdk-sys", + "gio-sys", + "glib-sys", + "gobject-sys", + "gtk-sys", + "javascriptcore-rs-sys", + "libc", + "pango-sys", + "pkg-config", + "soup2-sys", + "system-deps 6.0.3", +] + +[[package]] +name = "webview2-com" +version = "0.19.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b4a769c9f1a64a8734bde70caafac2b96cada12cd4aefa49196b3a386b8b4178" +dependencies = [ + "webview2-com-macros", + "webview2-com-sys", + "windows 0.39.0", + "windows-implement", +] + +[[package]] +name = "webview2-com-macros" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eaebe196c01691db62e9e4ca52c5ef1e4fd837dcae27dae3ada599b5a8fd05ac" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "webview2-com-sys" +version = "0.19.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aac48ef20ddf657755fdcda8dfed2a7b4fc7e4581acce6fe9b88c3d64f29dee7" +dependencies = [ + "regex", + "serde", + "serde_json", + "thiserror", + "windows 0.39.0", + "windows-bindgen", + "windows-metadata", +] + +[[package]] +name = "winapi" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" +dependencies = [ + "winapi-i686-pc-windows-gnu", + "winapi-x86_64-pc-windows-gnu", +] + +[[package]] +name = "winapi-i686-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" + +[[package]] +name = "winapi-util" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178" +dependencies = [ + "winapi", +] + +[[package]] +name = "winapi-x86_64-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" + +[[package]] +name = "windows" +version = "0.32.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fbedf6db9096bc2364adce0ae0aa636dcd89f3c3f2cd67947062aaf0ca2a10ec" +dependencies = [ + "windows_aarch64_msvc 0.32.0", + "windows_i686_gnu 0.32.0", + "windows_i686_msvc 0.32.0", + "windows_x86_64_gnu 0.32.0", + "windows_x86_64_msvc 0.32.0", +] + +[[package]] +name = "windows" +version = "0.37.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "57b543186b344cc61c85b5aab0d2e3adf4e0f99bc076eff9aa5927bcc0b8a647" +dependencies = [ + "windows_aarch64_msvc 0.37.0", + "windows_i686_gnu 0.37.0", + "windows_i686_msvc 0.37.0", + "windows_x86_64_gnu 0.37.0", + "windows_x86_64_msvc 0.37.0", +] + +[[package]] +name = "windows" +version = "0.39.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f1c4bd0a50ac6020f65184721f758dba47bb9fbc2133df715ec74a237b26794a" +dependencies = [ + "windows-implement", + "windows_aarch64_msvc 0.39.0", + "windows_i686_gnu 0.39.0", + "windows_i686_msvc 0.39.0", + "windows_x86_64_gnu 0.39.0", + "windows_x86_64_msvc 0.39.0", +] + +[[package]] +name = "windows-bindgen" +version = "0.39.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "68003dbd0e38abc0fb85b939240f4bce37c43a5981d3df37ccbaaa981b47cb41" +dependencies = [ + "windows-metadata", + "windows-tokens", +] + +[[package]] +name = "windows-implement" +version = "0.39.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ba01f98f509cb5dc05f4e5fc95e535f78260f15fea8fe1a8abdd08f774f1cee7" +dependencies = [ + "syn", + "windows-tokens", +] + +[[package]] +name = "windows-metadata" +version = "0.39.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9ee5e275231f07c6e240d14f34e1b635bf1faa1c76c57cfd59a5cdb9848e4278" + +[[package]] +name = "windows-sys" +version = "0.36.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ea04155a16a59f9eab786fe12a4a450e75cdb175f9e0d80da1e17db09f55b8d2" +dependencies = [ + "windows_aarch64_msvc 0.36.1", + "windows_i686_gnu 0.36.1", + "windows_i686_msvc 0.36.1", + "windows_x86_64_gnu 0.36.1", + "windows_x86_64_msvc 0.36.1", +] + +[[package]] +name = "windows-sys" +version = "0.42.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5a3e1820f08b8513f676f7ab6c1f99ff312fb97b553d30ff4dd86f9f15728aa7" +dependencies = [ + "windows_aarch64_gnullvm", + "windows_aarch64_msvc 0.42.0", + "windows_i686_gnu 0.42.0", + "windows_i686_msvc 0.42.0", + "windows_x86_64_gnu 0.42.0", + "windows_x86_64_gnullvm", + "windows_x86_64_msvc 0.42.0", +] + +[[package]] +name = "windows-tokens" +version = "0.39.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f838de2fe15fe6bac988e74b798f26499a8b21a9d97edec321e79b28d1d7f597" + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.42.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41d2aa71f6f0cbe00ae5167d90ef3cfe66527d6f613ca78ac8024c3ccab9a19e" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.32.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d8e92753b1c443191654ec532f14c199742964a061be25d77d7a96f09db20bf5" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.36.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9bb8c3fd39ade2d67e9874ac4f3db21f0d710bee00fe7cab16949ec184eeaa47" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.37.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2623277cb2d1c216ba3b578c0f3cf9cdebeddb6e66b1b218bb33596ea7769c3a" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.39.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec7711666096bd4096ffa835238905bb33fb87267910e154b18b44eaabb340f2" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.42.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dd0f252f5a35cac83d6311b2e795981f5ee6e67eb1f9a7f64eb4500fbc4dcdb4" + +[[package]] +name = "windows_i686_gnu" +version = "0.32.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6a711c68811799e017b6038e0922cb27a5e2f43a2ddb609fe0b6f3eeda9de615" + +[[package]] +name = "windows_i686_gnu" +version = "0.36.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "180e6ccf01daf4c426b846dfc66db1fc518f074baa793aa7d9b9aaeffad6a3b6" + +[[package]] +name = "windows_i686_gnu" +version = "0.37.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d3925fd0b0b804730d44d4b6278c50f9699703ec49bcd628020f46f4ba07d9e1" + +[[package]] +name = "windows_i686_gnu" +version = "0.39.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "763fc57100a5f7042e3057e7e8d9bdd7860d330070251a73d003563a3bb49e1b" + +[[package]] +name = "windows_i686_gnu" +version = "0.42.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fbeae19f6716841636c28d695375df17562ca208b2b7d0dc47635a50ae6c5de7" + +[[package]] +name = "windows_i686_msvc" +version = "0.32.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "146c11bb1a02615db74680b32a68e2d61f553cc24c4eb5b4ca10311740e44172" + +[[package]] +name = "windows_i686_msvc" +version = "0.36.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e2e7917148b2812d1eeafaeb22a97e4813dfa60a3f8f78ebe204bcc88f12f024" + +[[package]] +name = "windows_i686_msvc" +version = "0.37.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ce907ac74fe331b524c1298683efbf598bb031bc84d5e274db2083696d07c57c" + +[[package]] +name = "windows_i686_msvc" +version = "0.39.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7bc7cbfe58828921e10a9f446fcaaf649204dcfe6c1ddd712c5eebae6bda1106" + +[[package]] +name = "windows_i686_msvc" +version = "0.42.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "84c12f65daa39dd2babe6e442988fc329d6243fdce47d7d2d155b8d874862246" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.32.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c912b12f7454c6620635bbff3450962753834be2a594819bd5e945af18ec64bc" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.36.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4dcd171b8776c41b97521e5da127a2d86ad280114807d0b2ab1e462bc764d9e1" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.37.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2babfba0828f2e6b32457d5341427dcbb577ceef556273229959ac23a10af33d" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.39.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6868c165637d653ae1e8dc4d82c25d4f97dd6605eaa8d784b5c6e0ab2a252b65" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.42.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bf7b1b21b5362cbc318f686150e5bcea75ecedc74dd157d874d754a2ca44b0ed" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.42.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09d525d2ba30eeb3297665bd434a54297e4170c7f1a44cad4ef58095b4cd2028" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.32.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "504a2476202769977a040c6364301a3f65d0cc9e3fb08600b2bda150a0488316" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.36.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c811ca4a8c853ef420abd8592ba53ddbbac90410fab6903b3e79972a631f7680" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.37.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f4dd6dc7df2d84cf7b33822ed5b86318fb1781948e9663bacd047fc9dd52259d" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.39.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5e4d40883ae9cae962787ca76ba76390ffa29214667a111db9e0a1ad8377e809" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.42.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f40009d85759725a34da6d89a94e63d7bdc50a862acf0dbc7c8e488f1edcb6f5" + +[[package]] +name = "winres" +version = "0.1.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b68db261ef59e9e52806f688020631e987592bd83619edccda9c47d42cde4f6c" +dependencies = [ + "toml", +] + +[[package]] +name = "wry" +version = "0.21.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ff5c1352b4266fdf92c63479d2f58ab4cd29dc4e78fbc1b62011ed1227926945" +dependencies = [ + "base64", + "block", + "cocoa", + "core-graphics", + "crossbeam-channel", + "gdk", + "gio", + "glib", + "gtk", + "html5ever", + "http", + "kuchiki", + "libc", + "log", + "objc", + "objc_id", + "once_cell", + "serde", + "serde_json", + "sha2", + "tao", + "thiserror", + "url", + "webkit2gtk", + "webkit2gtk-sys", + "webview2-com", + "windows 0.39.0", + "windows-implement", +] + +[[package]] +name = "x11" +version = "2.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f7ae97874a928d821b061fce3d1fc52f08071dd53c89a6102bc06efcac3b2908" +dependencies = [ + "libc", + "pkg-config", +] + +[[package]] +name = "x11-dl" +version = "2.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c83627bc137605acc00bb399c7b908ef460b621fc37c953db2b09f88c449ea6" +dependencies = [ + "lazy_static", + "libc", + "pkg-config", +] + +[[package]] +name = "xattr" +version = "0.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6d1526bbe5aaeb5eb06885f4d987bcdfa5e23187055de9b83fe00156a821fabc" +dependencies = [ + "libc", +] + +[[package]] +name = "xml-rs" +version = "0.8.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d2d7d3948613f75c98fd9328cfdcc45acc4d360655289d0a7d4ec931392200a3" diff --git a/Cargo.toml b/Cargo.toml index 6c3aecd..32bf093 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -18,15 +18,20 @@ semver = { version = "1.0.14", optional = true } [dev-dependencies] wasm-bindgen-test = "0.3.33" tauri-sys = { path = ".", features = ["all"] } +tauri = "1.1.1" [package.metadata.docs.rs] all-features = true [features] -all = ["app", "clipboard", "event", "mocks", "tauri", "window"] +all = ["app", "clipboard", "event", "mocks", "tauri", "window", "process"] app = ["dep:semver"] clipboard = [] event = [] mocks = [] tauri = ["dep:url"] -window = [] \ No newline at end of file +window = [] +process = [] + +[workspace] +members = ["examples/test", "examples/test/src-tauri"] \ No newline at end of file diff --git a/build.rs b/build.rs index edbc302..e8baf46 100644 --- a/build.rs +++ b/build.rs @@ -11,7 +11,8 @@ fn main() { "tauri/tooling/api/src/tauri.ts", "tauri/tooling/api/src/event.ts", "tauri/tooling/api/src/mocks.ts", - "tauri/tooling/api/src/window.ts" + "tauri/tooling/api/src/window.ts", + "tauri/tooling/api/src/process.ts" ]; if cfg!(windows) { diff --git a/dist/process.js b/dist/process.js new file mode 100644 index 0000000..9356313 --- /dev/null +++ b/dist/process.js @@ -0,0 +1,65 @@ +// tauri/tooling/api/src/tauri.ts +function uid() { + return window.crypto.getRandomValues(new Uint32Array(1))[0]; +} +function transformCallback(callback, once = false) { + const identifier = uid(); + const prop = `_${identifier}`; + Object.defineProperty(window, prop, { + value: (result) => { + if (once) { + Reflect.deleteProperty(window, prop); + } + return callback?.(result); + }, + writable: false, + configurable: true + }); + return identifier; +} +async function invoke(cmd, args = {}) { + return new Promise((resolve, reject) => { + const callback = transformCallback((e) => { + resolve(e); + Reflect.deleteProperty(window, `_${error}`); + }, true); + const error = transformCallback((e) => { + reject(e); + Reflect.deleteProperty(window, `_${callback}`); + }, true); + window.__TAURI_IPC__({ + cmd, + callback, + error, + ...args + }); + }); +} + +// tauri/tooling/api/src/helpers/tauri.ts +async function invokeTauriCommand(command) { + return invoke("tauri", command); +} + +// tauri/tooling/api/src/process.ts +async function exit(exitCode = 0) { + return invokeTauriCommand({ + __tauriModule: "Process", + message: { + cmd: "exit", + exitCode + } + }); +} +async function relaunch() { + return invokeTauriCommand({ + __tauriModule: "Process", + message: { + cmd: "relaunch" + } + }); +} +export { + exit, + relaunch +}; diff --git a/src/lib.rs b/src/lib.rs index 83deaf5..f65d708 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -12,6 +12,8 @@ pub mod mocks; pub mod tauri; #[cfg(feature = "window")] pub mod window; +#[cfg(feature = "process")] +pub mod process; #[derive(Debug, thiserror::Error)] pub enum Error { diff --git a/src/process.rs b/src/process.rs new file mode 100644 index 0000000..0a725d7 --- /dev/null +++ b/src/process.rs @@ -0,0 +1,18 @@ +pub fn exit(exit_code: u32) -> ! { + inner::exit(exit_code); + unreachable!() +} + +pub fn relaunch() { + inner::relaunch(); +} + +mod inner { + use wasm_bindgen::prelude::wasm_bindgen; + + #[wasm_bindgen(module = "/dist/process.js")] + extern "C" { + pub fn exit(exitCode: u32); + pub fn relaunch(); + } +} From 6af422ad37f7c1a5e9a2f64d5c68b3b3159d8278 Mon Sep 17 00:00:00 2001 From: Jonas Kruckenberg Date: Thu, 3 Nov 2022 18:52:57 +0100 Subject: [PATCH 6/6] add label method --- src/window.rs | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/window.rs b/src/window.rs index 7ca5385..3bec133 100644 --- a/src/window.rs +++ b/src/window.rs @@ -131,6 +131,10 @@ impl WebviewWindow { inner::WebviewWindow::getByLabel(label).map(Self) } + pub fn label(&self) -> String { + self.0.label() + } + pub async fn scale_factor(&self) -> f64 { self.0.scaleFactor().await.as_f64().unwrap() } @@ -632,6 +636,8 @@ mod inner { pub type WindowManager; #[wasm_bindgen(constructor)] pub fn new(label: &str) -> WindowManager; + #[wasm_bindgen(method, getter)] + pub fn label(this: &WindowManager) -> String; #[wasm_bindgen(method)] pub async fn scaleFactor(this: &WindowManager) -> JsValue; #[wasm_bindgen(method)]