@ansight/capacitor 1.0.2-preview.6

package/dist/standalone.js

@@ -0,0 +1,1764 @@
+(function () {
+    'use strict';
+
+    /*! Capacitor: https://capacitorjs.com/ - MIT License */
+    var ExceptionCode;
+    (function (ExceptionCode) {
+        /**
+         * API is not implemented.
+         *
+         * This usually means the API can't be used because it is not implemented for
+         * the current platform.
+         */
+        ExceptionCode["Unimplemented"] = "UNIMPLEMENTED";
+        /**
+         * API is not available.
+         *
+         * This means the API can't be used right now because:
+         *   - it is currently missing a prerequisite, such as network connectivity
+         *   - it requires a particular platform or browser version
+         */
+        ExceptionCode["Unavailable"] = "UNAVAILABLE";
+    })(ExceptionCode || (ExceptionCode = {}));
+    class CapacitorException extends Error {
+        constructor(message, code, data) {
+            super(message);
+            this.message = message;
+            this.code = code;
+            this.data = data;
+        }
+    }
+    const getPlatformId = (win) => {
+        var _a, _b;
+        if (win === null || win === void 0 ? void 0 : win.androidBridge) {
+            return 'android';
+        }
+        else if ((_b = (_a = win === null || win === void 0 ? void 0 : win.webkit) === null || _a === void 0 ? void 0 : _a.messageHandlers) === null || _b === void 0 ? void 0 : _b.bridge) {
+            return 'ios';
+        }
+        else {
+            return 'web';
+        }
+    };
+
+    const createCapacitor = (win) => {
+        const capCustomPlatform = win.CapacitorCustomPlatform || null;
+        const cap = win.Capacitor || {};
+        const Plugins = (cap.Plugins = cap.Plugins || {});
+        const getPlatform = () => {
+            return capCustomPlatform !== null ? capCustomPlatform.name : getPlatformId(win);
+        };
+        const isNativePlatform = () => getPlatform() !== 'web';
+        const isPluginAvailable = (pluginName) => {
+            const plugin = registeredPlugins.get(pluginName);
+            if (plugin === null || plugin === void 0 ? void 0 : plugin.platforms.has(getPlatform())) {
+                // JS implementation available for the current platform.
+                return true;
+            }
+            if (getPluginHeader(pluginName)) {
+                // Native implementation available.
+                return true;
+            }
+            return false;
+        };
+        const getPluginHeader = (pluginName) => { var _a; return (_a = cap.PluginHeaders) === null || _a === void 0 ? void 0 : _a.find((h) => h.name === pluginName); };
+        const handleError = (err) => win.console.error(err);
+        const registeredPlugins = new Map();
+        const registerPlugin = (pluginName, jsImplementations = {}) => {
+            const registeredPlugin = registeredPlugins.get(pluginName);
+            if (registeredPlugin) {
+                console.warn(`Capacitor plugin "${pluginName}" already registered. Cannot register plugins twice.`);
+                return registeredPlugin.proxy;
+            }
+            const platform = getPlatform();
+            const pluginHeader = getPluginHeader(pluginName);
+            let jsImplementation;
+            const loadPluginImplementation = async () => {
+                if (!jsImplementation && platform in jsImplementations) {
+                    jsImplementation =
+                        typeof jsImplementations[platform] === 'function'
+                            ? (jsImplementation = await jsImplementations[platform]())
+                            : (jsImplementation = jsImplementations[platform]);
+                }
+                else if (capCustomPlatform !== null && !jsImplementation && 'web' in jsImplementations) {
+                    jsImplementation =
+                        typeof jsImplementations['web'] === 'function'
+                            ? (jsImplementation = await jsImplementations['web']())
+                            : (jsImplementation = jsImplementations['web']);
+                }
+                return jsImplementation;
+            };
+            const createPluginMethod = (impl, prop) => {
+                var _a, _b;
+                if (pluginHeader) {
+                    const methodHeader = pluginHeader === null || pluginHeader === void 0 ? void 0 : pluginHeader.methods.find((m) => prop === m.name);
+                    if (methodHeader) {
+                        if (methodHeader.rtype === 'promise') {
+                            return (options) => cap.nativePromise(pluginName, prop.toString(), options);
+                        }
+                        else {
+                            return (options, callback) => cap.nativeCallback(pluginName, prop.toString(), options, callback);
+                        }
+                    }
+                    else if (impl) {
+                        return (_a = impl[prop]) === null || _a === void 0 ? void 0 : _a.bind(impl);
+                    }
+                }
+                else if (impl) {
+                    return (_b = impl[prop]) === null || _b === void 0 ? void 0 : _b.bind(impl);
+                }
+                else {
+                    throw new CapacitorException(`"${pluginName}" plugin is not implemented on ${platform}`, ExceptionCode.Unimplemented);
+                }
+            };
+            const createPluginMethodWrapper = (prop) => {
+                let remove;
+                const wrapper = (...args) => {
+                    const p = loadPluginImplementation().then((impl) => {
+                        const fn = createPluginMethod(impl, prop);
+                        if (fn) {
+                            const p = fn(...args);
+                            remove = p === null || p === void 0 ? void 0 : p.remove;
+                            return p;
+                        }
+                        else {
+                            throw new CapacitorException(`"${pluginName}.${prop}()" is not implemented on ${platform}`, ExceptionCode.Unimplemented);
+                        }
+                    });
+                    if (prop === 'addListener') {
+                        p.remove = async () => remove();
+                    }
+                    return p;
+                };
+                // Some flair ✨
+                wrapper.toString = () => `${prop.toString()}() { [capacitor code] }`;
+                Object.defineProperty(wrapper, 'name', {
+                    value: prop,
+                    writable: false,
+                    configurable: false,
+                });
+                return wrapper;
+            };
+            const addListener = createPluginMethodWrapper('addListener');
+            const removeListener = createPluginMethodWrapper('removeListener');
+            const addListenerNative = (eventName, callback) => {
+                const call = addListener({ eventName }, callback);
+                const remove = async () => {
+                    const callbackId = await call;
+                    removeListener({
+                        eventName,
+                        callbackId,
+                    }, callback);
+                };
+                const p = new Promise((resolve) => call.then(() => resolve({ remove })));
+                p.remove = async () => {
+                    console.warn(`Using addListener() without 'await' is deprecated.`);
+                    await remove();
+                };
+                return p;
+            };
+            const proxy = new Proxy({}, {
+                get(_, prop) {
+                    switch (prop) {
+                        // https://github.com/facebook/react/issues/20030
+                        case '$$typeof':
+                            return undefined;
+                        case 'toJSON':
+                            return () => ({});
+                        case 'addListener':
+                            return pluginHeader ? addListenerNative : addListener;
+                        case 'removeListener':
+                            return removeListener;
+                        default:
+                            return createPluginMethodWrapper(prop);
+                    }
+                },
+            });
+            Plugins[pluginName] = proxy;
+            registeredPlugins.set(pluginName, {
+                name: pluginName,
+                proxy,
+                platforms: new Set([...Object.keys(jsImplementations), ...(pluginHeader ? [platform] : [])]),
+            });
+            return proxy;
+        };
+        // Add in convertFileSrc for web, it will already be available in native context
+        if (!cap.convertFileSrc) {
+            cap.convertFileSrc = (filePath) => filePath;
+        }
+        cap.getPlatform = getPlatform;
+        cap.handleError = handleError;
+        cap.isNativePlatform = isNativePlatform;
+        cap.isPluginAvailable = isPluginAvailable;
+        cap.registerPlugin = registerPlugin;
+        cap.Exception = CapacitorException;
+        cap.DEBUG = !!cap.DEBUG;
+        cap.isLoggingEnabled = !!cap.isLoggingEnabled;
+        return cap;
+    };
+    const initCapacitorGlobal = (win) => (win.Capacitor = createCapacitor(win));
+
+    const Capacitor = /*#__PURE__*/ initCapacitorGlobal(typeof globalThis !== 'undefined'
+        ? globalThis
+        : typeof self !== 'undefined'
+            ? self
+            : typeof window !== 'undefined'
+                ? window
+                : typeof global !== 'undefined'
+                    ? global
+                    : {});
+    const registerPlugin = Capacitor.registerPlugin;
+
+    /**
+     * Base class web plugins should extend.
+     */
+    class WebPlugin {
+        constructor() {
+            this.listeners = {};
+            this.retainedEventArguments = {};
+            this.windowListeners = {};
+        }
+        addListener(eventName, listenerFunc) {
+            let firstListener = false;
+            const listeners = this.listeners[eventName];
+            if (!listeners) {
+                this.listeners[eventName] = [];
+                firstListener = true;
+            }
+            this.listeners[eventName].push(listenerFunc);
+            // If we haven't added a window listener for this event and it requires one,
+            // go ahead and add it
+            const windowListener = this.windowListeners[eventName];
+            if (windowListener && !windowListener.registered) {
+                this.addWindowListener(windowListener);
+            }
+            if (firstListener) {
+                this.sendRetainedArgumentsForEvent(eventName);
+            }
+            const remove = async () => this.removeListener(eventName, listenerFunc);
+            const p = Promise.resolve({ remove });
+            return p;
+        }
+        async removeAllListeners() {
+            this.listeners = {};
+            for (const listener in this.windowListeners) {
+                this.removeWindowListener(this.windowListeners[listener]);
+            }
+            this.windowListeners = {};
+        }
+        notifyListeners(eventName, data, retainUntilConsumed) {
+            const listeners = this.listeners[eventName];
+            if (!listeners) {
+                if (retainUntilConsumed) {
+                    let args = this.retainedEventArguments[eventName];
+                    if (!args) {
+                        args = [];
+                    }
+                    args.push(data);
+                    this.retainedEventArguments[eventName] = args;
+                }
+                return;
+            }
+            listeners.forEach((listener) => listener(data));
+        }
+        hasListeners(eventName) {
+            var _a;
+            return !!((_a = this.listeners[eventName]) === null || _a === void 0 ? void 0 : _a.length);
+        }
+        registerWindowListener(windowEventName, pluginEventName) {
+            this.windowListeners[pluginEventName] = {
+                registered: false,
+                windowEventName,
+                pluginEventName,
+                handler: (event) => {
+                    this.notifyListeners(pluginEventName, event);
+                },
+            };
+        }
+        unimplemented(msg = 'not implemented') {
+            return new Capacitor.Exception(msg, ExceptionCode.Unimplemented);
+        }
+        unavailable(msg = 'not available') {
+            return new Capacitor.Exception(msg, ExceptionCode.Unavailable);
+        }
+        async removeListener(eventName, listenerFunc) {
+            const listeners = this.listeners[eventName];
+            if (!listeners) {
+                return;
+            }
+            const index = listeners.indexOf(listenerFunc);
+            this.listeners[eventName].splice(index, 1);
+            // If there are no more listeners for this type of event,
+            // remove the window listener
+            if (!this.listeners[eventName].length) {
+                this.removeWindowListener(this.windowListeners[eventName]);
+            }
+        }
+        addWindowListener(handle) {
+            window.addEventListener(handle.windowEventName, handle.handler);
+            handle.registered = true;
+        }
+        removeWindowListener(handle) {
+            if (!handle) {
+                return;
+            }
+            window.removeEventListener(handle.windowEventName, handle.handler);
+            handle.registered = false;
+        }
+        sendRetainedArgumentsForEvent(eventName) {
+            const args = this.retainedEventArguments[eventName];
+            if (!args) {
+                return;
+            }
+            delete this.retainedEventArguments[eventName];
+            args.forEach((arg) => {
+                this.notifyListeners(eventName, arg);
+            });
+        }
+    }
+    /******** END WEB VIEW PLUGIN ********/
+    /******** COOKIES PLUGIN ********/
+    /**
+     * Safely web encode a string value (inspired by js-cookie)
+     * @param str The string value to encode
+     */
+    const encode = (str) => encodeURIComponent(str)
+        .replace(/%(2[346B]|5E|60|7C)/g, decodeURIComponent)
+        .replace(/[()]/g, escape);
+    /**
+     * Safely web decode a string value (inspired by js-cookie)
+     * @param str The string value to decode
+     */
+    const decode = (str) => str.replace(/(%[\dA-F]{2})+/gi, decodeURIComponent);
+    class CapacitorCookiesPluginWeb extends WebPlugin {
+        async getCookies() {
+            const cookies = document.cookie;
+            const cookieMap = {};
+            cookies.split(';').forEach((cookie) => {
+                if (cookie.length <= 0)
+                    return;
+                // Replace first "=" with CAP_COOKIE to prevent splitting on additional "="
+                let [key, value] = cookie.replace(/=/, 'CAP_COOKIE').split('CAP_COOKIE');
+                key = decode(key).trim();
+                value = decode(value).trim();
+                cookieMap[key] = value;
+            });
+            return cookieMap;
+        }
+        async setCookie(options) {
+            try {
+                // Safely Encoded Key/Value
+                const encodedKey = encode(options.key);
+                const encodedValue = encode(options.value);
+                // Clean & sanitize options
+                const expires = options.expires ? `; expires=${options.expires.replace('expires=', '')}` : '';
+                const path = (options.path || '/').replace('path=', ''); // Default is "path=/"
+                const domain = options.url != null && options.url.length > 0 ? `domain=${options.url}` : '';
+                document.cookie = `${encodedKey}=${encodedValue || ''}${expires}; path=${path}; ${domain};`;
+            }
+            catch (error) {
+                return Promise.reject(error);
+            }
+        }
+        async deleteCookie(options) {
+            try {
+                document.cookie = `${options.key}=; Max-Age=0`;
+            }
+            catch (error) {
+                return Promise.reject(error);
+            }
+        }
+        async clearCookies() {
+            try {
+                const cookies = document.cookie.split(';') || [];
+                for (const cookie of cookies) {
+                    document.cookie = cookie.replace(/^ +/, '').replace(/=.*/, `=;expires=${new Date().toUTCString()};path=/`);
+                }
+            }
+            catch (error) {
+                return Promise.reject(error);
+            }
+        }
+        async clearAllCookies() {
+            try {
+                await this.clearCookies();
+            }
+            catch (error) {
+                return Promise.reject(error);
+            }
+        }
+    }
+    registerPlugin('CapacitorCookies', {
+        web: () => new CapacitorCookiesPluginWeb(),
+    });
+    // UTILITY FUNCTIONS
+    /**
+     * Read in a Blob value and return it as a base64 string
+     * @param blob The blob value to convert to a base64 string
+     */
+    const readBlobAsBase64 = async (blob) => new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onload = () => {
+            const base64String = reader.result;
+            // remove prefix "data:application/pdf;base64,"
+            resolve(base64String.indexOf(',') >= 0 ? base64String.split(',')[1] : base64String);
+        };
+        reader.onerror = (error) => reject(error);
+        reader.readAsDataURL(blob);
+    });
+    /**
+     * Normalize an HttpHeaders map by lowercasing all of the values
+     * @param headers The HttpHeaders object to normalize
+     */
+    const normalizeHttpHeaders = (headers = {}) => {
+        const originalKeys = Object.keys(headers);
+        const loweredKeys = Object.keys(headers).map((k) => k.toLocaleLowerCase());
+        const normalized = loweredKeys.reduce((acc, key, index) => {
+            acc[key] = headers[originalKeys[index]];
+            return acc;
+        }, {});
+        return normalized;
+    };
+    /**
+     * Builds a string of url parameters that
+     * @param params A map of url parameters
+     * @param shouldEncode true if you should encodeURIComponent() the values (true by default)
+     */
+    const buildUrlParams = (params, shouldEncode = true) => {
+        if (!params)
+            return null;
+        const output = Object.entries(params).reduce((accumulator, entry) => {
+            const [key, value] = entry;
+            let encodedValue;
+            let item;
+            if (Array.isArray(value)) {
+                item = '';
+                value.forEach((str) => {
+                    encodedValue = shouldEncode ? encodeURIComponent(str) : str;
+                    item += `${key}=${encodedValue}&`;
+                });
+                // last character will always be "&" so slice it off
+                item.slice(0, -1);
+            }
+            else {
+                encodedValue = shouldEncode ? encodeURIComponent(value) : value;
+                item = `${key}=${encodedValue}`;
+            }
+            return `${accumulator}&${item}`;
+        }, '');
+        // Remove initial "&" from the reduce
+        return output.substr(1);
+    };
+    /**
+     * Build the RequestInit object based on the options passed into the initial request
+     * @param options The Http plugin options
+     * @param extra Any extra RequestInit values
+     */
+    const buildRequestInit = (options, extra = {}) => {
+        const output = Object.assign({ method: options.method || 'GET', headers: options.headers }, extra);
+        // Get the content-type
+        const headers = normalizeHttpHeaders(options.headers);
+        const type = headers['content-type'] || '';
+        // If body is already a string, then pass it through as-is.
+        if (typeof options.data === 'string') {
+            output.body = options.data;
+        }
+        // Build request initializers based off of content-type
+        else if (type.includes('application/x-www-form-urlencoded')) {
+            const params = new URLSearchParams();
+            for (const [key, value] of Object.entries(options.data || {})) {
+                params.set(key, value);
+            }
+            output.body = params.toString();
+        }
+        else if (type.includes('multipart/form-data') || options.data instanceof FormData) {
+            const form = new FormData();
+            if (options.data instanceof FormData) {
+                options.data.forEach((value, key) => {
+                    form.append(key, value);
+                });
+            }
+            else {
+                for (const key of Object.keys(options.data)) {
+                    form.append(key, options.data[key]);
+                }
+            }
+            output.body = form;
+            const headers = new Headers(output.headers);
+            headers.delete('content-type'); // content-type will be set by `window.fetch` to includy boundary
+            output.headers = headers;
+        }
+        else if (type.includes('application/json') || typeof options.data === 'object') {
+            output.body = JSON.stringify(options.data);
+        }
+        return output;
+    };
+    // WEB IMPLEMENTATION
+    class CapacitorHttpPluginWeb extends WebPlugin {
+        /**
+         * Perform an Http request given a set of options
+         * @param options Options to build the HTTP request
+         */
+        async request(options) {
+            const requestInit = buildRequestInit(options, options.webFetchExtra);
+            const urlParams = buildUrlParams(options.params, options.shouldEncodeUrlParams);
+            const url = urlParams ? `${options.url}?${urlParams}` : options.url;
+            const response = await fetch(url, requestInit);
+            const contentType = response.headers.get('content-type') || '';
+            // Default to 'text' responseType so no parsing happens
+            let { responseType = 'text' } = response.ok ? options : {};
+            // If the response content-type is json, force the response to be json
+            if (contentType.includes('application/json')) {
+                responseType = 'json';
+            }
+            let data;
+            let blob;
+            switch (responseType) {
+                case 'arraybuffer':
+                case 'blob':
+                    blob = await response.blob();
+                    data = await readBlobAsBase64(blob);
+                    break;
+                case 'json':
+                    data = await response.json();
+                    break;
+                case 'document':
+                case 'text':
+                default:
+                    data = await response.text();
+            }
+            // Convert fetch headers to Capacitor HttpHeaders
+            const headers = {};
+            response.headers.forEach((value, key) => {
+                headers[key] = value;
+            });
+            return {
+                data,
+                headers,
+                status: response.status,
+                url: response.url,
+            };
+        }
+        /**
+         * Perform an Http GET request given a set of options
+         * @param options Options to build the HTTP request
+         */
+        async get(options) {
+            return this.request(Object.assign(Object.assign({}, options), { method: 'GET' }));
+        }
+        /**
+         * Perform an Http POST request given a set of options
+         * @param options Options to build the HTTP request
+         */
+        async post(options) {
+            return this.request(Object.assign(Object.assign({}, options), { method: 'POST' }));
+        }
+        /**
+         * Perform an Http PUT request given a set of options
+         * @param options Options to build the HTTP request
+         */
+        async put(options) {
+            return this.request(Object.assign(Object.assign({}, options), { method: 'PUT' }));
+        }
+        /**
+         * Perform an Http PATCH request given a set of options
+         * @param options Options to build the HTTP request
+         */
+        async patch(options) {
+            return this.request(Object.assign(Object.assign({}, options), { method: 'PATCH' }));
+        }
+        /**
+         * Perform an Http DELETE request given a set of options
+         * @param options Options to build the HTTP request
+         */
+        async delete(options) {
+            return this.request(Object.assign(Object.assign({}, options), { method: 'DELETE' }));
+        }
+    }
+    registerPlugin('CapacitorHttp', {
+        web: () => new CapacitorHttpPluginWeb(),
+    });
+    /******** END HTTP PLUGIN ********/
+    /******** SYSTEM BARS PLUGIN ********/
+    /**
+     * Available status bar styles.
+     */
+    var SystemBarsStyle;
+    (function (SystemBarsStyle) {
+        /**
+         * Light system bar content on a dark background.
+         *
+         * @since 8.0.0
+         */
+        SystemBarsStyle["Dark"] = "DARK";
+        /**
+         * For dark system bar content on a light background.
+         *
+         * @since 8.0.0
+         */
+        SystemBarsStyle["Light"] = "LIGHT";
+        /**
+         * The style is based on the device appearance or the underlying content.
+         * If the device is using Dark mode, the system bars content will be light.
+         * If the device is using Light mode, the system bars content will be dark.
+         *
+         * @since 8.0.0
+         */
+        SystemBarsStyle["Default"] = "DEFAULT";
+    })(SystemBarsStyle || (SystemBarsStyle = {}));
+    /**
+     * Available system bar types.
+     */
+    var SystemBarType;
+    (function (SystemBarType) {
+        /**
+         * The top status bar on both Android and iOS.
+         *
+         * @since 8.0.0
+         */
+        SystemBarType["StatusBar"] = "StatusBar";
+        /**
+         * The navigation bar (or gesture bar on iOS) on both Android and iOS.
+         *
+         * @since 8.0.0
+         */
+        SystemBarType["NavigationBar"] = "NavigationBar";
+    })(SystemBarType || (SystemBarType = {}));
+    class SystemBarsPluginWeb extends WebPlugin {
+        async setStyle() {
+            this.unavailable('not available for web');
+        }
+        async setAnimation() {
+            this.unavailable('not available for web');
+        }
+        async show() {
+            this.unavailable('not available for web');
+        }
+        async hide() {
+            this.unavailable('not available for web');
+        }
+    }
+    registerPlugin('SystemBars', {
+        web: () => new SystemBarsPluginWeb(),
+    });
+
+    const nodeIds = new WeakMap();
+    let nextNodeId = 1;
+    function nodeId(element) {
+        const existing = nodeIds.get(element);
+        if (existing)
+            return existing;
+        const id = `dom.${nextNodeId++}`;
+        nodeIds.set(element, id);
+        return id;
+    }
+    function isVisible(element, style, bounds) {
+        return (style.display !== "none" &&
+            style.visibility !== "hidden" &&
+            style.opacity !== "0" &&
+            bounds.width > 0 &&
+            bounds.height > 0);
+    }
+    function accessibleLabel(element, includeText) {
+        const labelledBy = element.getAttribute("aria-labelledby");
+        const referenced = labelledBy
+            ?.split(/\s+/)
+            .map((id) => document.getElementById(id)?.textContent?.trim())
+            .filter(Boolean)
+            .join(" ");
+        const label = element.getAttribute("aria-label") ??
+            referenced ??
+            element.getAttribute("alt") ??
+            element.getAttribute("title") ??
+            (includeText
+                ? element.textContent?.replace(/\s+/g, " ").trim().slice(0, 240)
+                : undefined);
+        return label || undefined;
+    }
+    function attributes(element) {
+        return Object.fromEntries(Array.from(element.attributes, ({ name, value }) => [
+            name,
+            value.slice(0, 500),
+        ]));
+    }
+    function captureNode(element, options, depth, limits) {
+        if (limits.count >= limits.maxNodes || depth > limits.maxDepth)
+            return null;
+        const style = getComputedStyle(element);
+        const rect = element.getBoundingClientRect();
+        const visible = isVisible(element, style, rect);
+        if (!visible && !options.includeHidden)
+            return null;
+        limits.count += 1;
+        const children = Array.from(element.children)
+            .map((child) => captureNode(child, options, depth + 1, limits))
+            .filter((child) => child !== null);
+        const htmlElement = element;
+        const disabled = element.hasAttribute("disabled") ||
+            element.getAttribute("aria-disabled") === "true";
+        return {
+            id: nodeId(element),
+            type: element.tagName.toLowerCase(),
+            label: accessibleLabel(element, options.includeText),
+            visible,
+            enabled: !disabled,
+            focusable: htmlElement.tabIndex >= 0 ||
+                ["A", "BUTTON", "INPUT", "SELECT", "TEXTAREA", "SUMMARY"].includes(element.tagName),
+            childCount: children.length,
+            bounds: {
+                x: rect.x,
+                y: rect.y,
+                width: rect.width,
+                height: rect.height,
+            },
+            properties: {
+                id: element.id || undefined,
+                role: element.getAttribute("role") ?? undefined,
+                className: element.getAttribute("class") ?? undefined,
+                value: element instanceof HTMLInputElement ||
+                    element instanceof HTMLSelectElement ||
+                    element instanceof HTMLTextAreaElement
+                    ? element.value
+                    : undefined,
+                checked: element instanceof HTMLInputElement ? element.checked : undefined,
+                attributes: options.includeAttributes ? attributes(element) : undefined,
+            },
+            children,
+        };
+    }
+    function findElement(id) {
+        return Array.from(document.querySelectorAll("*")).find((element) => nodeId(element) === id);
+    }
+    function successful(result, message) {
+        return { success: true, message, result };
+    }
+    function installDomTools$1(registerTool, input = {}) {
+        const options = {
+            source: input.source ?? "capacitor-dom",
+            includeHidden: input.includeHidden ?? false,
+            maxDepth: input.maxDepth ?? 30,
+            maxNodes: input.maxNodes ?? 1500,
+            includeText: input.includeText ?? true,
+            includeAttributes: input.includeAttributes ?? true,
+            allowActions: input.allowActions ?? false,
+        };
+        const registrations = [
+            registerTool({
+                id: "dom.get_document",
+                name: "Get DOM document",
+                description: "Returns the accessible HTML DOM tree rendered inside the Capacitor WebView.",
+                category: "UI",
+                scope: "read",
+                security: { level: "low", summary: "Reads the current app DOM." },
+            }, async () => {
+                const root = document.documentElement;
+                const limits = {
+                    maxDepth: options.maxDepth,
+                    maxNodes: options.maxNodes,
+                    count: 0,
+                };
+                const tree = captureNode(root, options, 0, limits);
+                return successful({
+                    platform: "web",
+                    source: options.source,
+                    adapter: "@ansight/capacitor",
+                    capturedAtUtc: new Date().toISOString(),
+                    truncated: limits.count >= limits.maxNodes,
+                    root: tree,
+                }, "DOM document captured.");
+            }),
+            registerTool({
+                id: "dom.inspect_node",
+                name: "Inspect DOM node",
+                description: "Returns the current state of a DOM node captured by dom.get_document.",
+                category: "UI",
+                scope: "read",
+                argumentsSchema: {
+                    type: "object",
+                    required: ["nodeId"],
+                    properties: { nodeId: { type: "string" } },
+                },
+            }, ({ nodeId: id }) => {
+                const element = findElement(id);
+                if (!element) {
+                    return {
+                        success: false,
+                        message: `DOM node '${id}' was not found.`,
+                        errorCode: "dom_node_not_found",
+                    };
+                }
+                const limits = { maxDepth: 0, maxNodes: 1, count: 0 };
+                return successful(captureNode(element, options, 0, limits), "DOM node captured.");
+            }),
+            registerTool({
+                id: "dom.query_selector",
+                name: "Query DOM",
+                description: "Finds DOM nodes using a CSS selector.",
+                category: "UI",
+                scope: "read",
+                argumentsSchema: {
+                    type: "object",
+                    required: ["selector"],
+                    properties: { selector: { type: "string" } },
+                },
+            }, ({ selector }) => {
+                try {
+                    const matches = Array.from(document.querySelectorAll(selector)).slice(0, 200);
+                    return successful(matches.map((element) => ({
+                        id: nodeId(element),
+                        type: element.tagName.toLowerCase(),
+                        label: accessibleLabel(element, true),
+                    })), `Matched ${matches.length} DOM node(s).`);
+                }
+                catch (error) {
+                    return {
+                        success: false,
+                        message: error instanceof Error ? error.message : "Invalid CSS selector.",
+                        errorCode: "dom_selector_invalid",
+                    };
+                }
+            }),
+        ];
+        if (options.allowActions) {
+            registrations.push(registerTool({
+                id: "dom.invoke_action",
+                name: "Invoke DOM action",
+                description: "Clicks, focuses, blurs, or changes a DOM node.",
+                category: "UI",
+                scope: "write",
+                argumentsSchema: {
+                    type: "object",
+                    required: ["nodeId", "action"],
+                    properties: {
+                        nodeId: { type: "string" },
+                        action: { enum: ["click", "focus", "blur", "setValue"] },
+                        value: { type: "string" },
+                    },
+                },
+                security: {
+                    level: "high",
+                    summary: "Can interact with controls inside the app WebView.",
+                },
+            }, ({ nodeId: id, action, value }) => {
+                const element = findElement(id);
+                if (!element) {
+                    return {
+                        success: false,
+                        message: `DOM node '${id}' was not found.`,
+                        errorCode: "dom_node_not_found",
+                    };
+                }
+                if (action === "click")
+                    element.click();
+                else if (action === "focus")
+                    element.focus();
+                else if (action === "blur")
+                    element.blur();
+                else if (action === "setValue" &&
+                    (element instanceof HTMLInputElement ||
+                        element instanceof HTMLTextAreaElement ||
+                        element instanceof HTMLSelectElement)) {
+                    element.value = value ?? "";
+                    element.dispatchEvent(new Event("input", { bubbles: true }));
+                    element.dispatchEvent(new Event("change", { bubbles: true }));
+                }
+                else {
+                    return {
+                        success: false,
+                        message: `Unsupported action '${action}'.`,
+                        errorCode: "dom_action_unsupported",
+                    };
+                }
+                return successful({ nodeId: id, action }, `DOM action '${action}' invoked.`);
+            }));
+        }
+        return {
+            ids: registrations.map(({ id }) => id),
+            ready: Promise.all(registrations.map(({ ready }) => ready)),
+            unregister: () => Promise.all(registrations.map((registration) => registration.unregister())),
+        };
+    }
+
+    function cloneOptions(options) {
+        return JSON.parse(JSON.stringify(options));
+    }
+    class AnsightOptionsBuilder {
+        options;
+        constructor(options = {}) {
+            this.options = cloneOptions(options);
+        }
+        withAnsightDefaults() {
+            this.options = {
+                ...this.options,
+                useNativeAllInOneDefaults: true,
+                sampleFrequencyMilliseconds: 400,
+                retentionPeriodSeconds: 120,
+                enableFramesPerSecond: true,
+                enableBatteryLevel: false,
+                sessionJpegCapture: {
+                    intervalMilliseconds: 2000,
+                    quality: 60,
+                    maxWidth: 480,
+                },
+                touchCapture: {},
+                toolGuard: "readOnly",
+                hostAutoProbe: {
+                    ...this.options.hostAutoProbe,
+                    enabled: true,
+                },
+            };
+            return this;
+        }
+        withNativeAllInOneDefaults() {
+            return this.withAnsightDefaults();
+        }
+        withAnsightSdk(configure) {
+            this.withAnsightDefaults().withAllToolAccess();
+            configure?.(this);
+            return this;
+        }
+        withSampleFrequencyMilliseconds(value) {
+            this.options.sampleFrequencyMilliseconds = value;
+            return this;
+        }
+        withFramesPerSecond() {
+            this.options.enableFramesPerSecond = true;
+            return this;
+        }
+        withoutFramesPerSecond() {
+            this.options.enableFramesPerSecond = false;
+            return this;
+        }
+        withBatteryLevel() {
+            this.options.enableBatteryLevel = true;
+            return this;
+        }
+        withoutBatteryLevel() {
+            this.options.enableBatteryLevel = false;
+            return this;
+        }
+        withRetentionPeriodSeconds(value) {
+            this.options.retentionPeriodSeconds = value;
+            return this;
+        }
+        withAdditionalChannels(channels) {
+            this.options.additionalChannels = channels.map((channel) => ({
+                ...channel,
+            }));
+            return this;
+        }
+        addAdditionalChannel(channel) {
+            this.options.additionalChannels = [
+                ...(this.options.additionalChannels ?? []),
+                { ...channel },
+            ];
+            return this;
+        }
+        withDefaultMemoryChannels(channels) {
+            this.options.defaultMemoryChannels = { ...channels };
+            return this;
+        }
+        withoutDefaultMemoryChannels(channels) {
+            const current = {
+                managedHeap: true,
+                javaHeap: true,
+                nativeHeap: true,
+                residentSetSize: true,
+                rss: true,
+                physicalFootprint: true,
+                ...this.options.defaultMemoryChannels,
+            };
+            for (const [key, disabled] of Object.entries(channels)) {
+                if (disabled)
+                    current[key] = false;
+            }
+            this.options.defaultMemoryChannels = current;
+            return this;
+        }
+        withSessionJpegCapture(optionsOrIntervalMilliseconds = {}, quality = 60, maxWidth = 480, captureGpuBackedSurfaces = true) {
+            this.options.sessionJpegCapture =
+                typeof optionsOrIntervalMilliseconds === "number"
+                    ? {
+                        intervalMilliseconds: optionsOrIntervalMilliseconds,
+                        quality,
+                        maxWidth,
+                        captureGpuBackedSurfaces,
+                    }
+                    : {
+                        intervalMilliseconds: 2000,
+                        quality: 60,
+                        maxWidth: 480,
+                        ...optionsOrIntervalMilliseconds,
+                    };
+            return this;
+        }
+        withoutSessionJpegCapture() {
+            this.options.sessionJpegCapture = false;
+            return this;
+        }
+        withTouchCapture(options = {}) {
+            this.options.touchCapture = { ...options };
+            return this;
+        }
+        withoutTouchCapture() {
+            this.options.touchCapture = false;
+            return this;
+        }
+        withLifecycleCapture(options = {}) {
+            this.options.lifecycleCapture = {
+                ...options,
+                enabled: options.enabled ?? true,
+            };
+            return this;
+        }
+        withToolGuard(toolGuard) {
+            this.options.toolGuard = toolGuard;
+            return this;
+        }
+        withToolsDisabled() {
+            return this.withToolGuard("disabled");
+        }
+        withReadOnlyToolAccess() {
+            return this.withToolGuard("readOnly");
+        }
+        withReadWriteToolAccess() {
+            return this.withToolGuard("readWrite");
+        }
+        withAllToolAccess() {
+            return this.withToolGuard("fullAccess");
+        }
+        withHostAutoProbe(options = {}) {
+            this.options.hostAutoProbe = {
+                ...options,
+                enabled: options.enabled ?? true,
+            };
+            return this;
+        }
+        withoutHostAutoProbe() {
+            this.options.hostAutoProbe = {
+                ...this.options.hostAutoProbe,
+                enabled: false,
+            };
+            return this;
+        }
+        withHostConnection(options = {}) {
+            this.options.hostConnection = { ...options };
+            return this;
+        }
+        configureHostConnection(configure) {
+            const current = { ...this.options.hostConnection };
+            this.options.hostConnection = configure(current) ?? current;
+            return this;
+        }
+        withBundledHostConnection(options = {}) {
+            return this.configureHostConnection((current) => ({
+                ...current,
+                bundledDeveloperConfigJson: options.bundledDeveloperConfigJson,
+                bundledConfigJson: options.bundledConfigJson,
+            }));
+        }
+        withHostConnectionDiscoveryPort(discoveryPort) {
+            return this.configureHostConnection((current) => ({
+                ...current,
+                discoveryPort,
+            }));
+        }
+        withHostConnectionProfileRetentionSeconds(connectionProfileRetentionSeconds) {
+            return this.configureHostConnection((current) => ({
+                ...current,
+                connectionProfileRetentionSeconds,
+            }));
+        }
+        withSecureStorage(options = {}) {
+            this.options.secureStorage = {
+                ...options,
+                allowedKeys: options.allowedKeys ? [...options.allowedKeys] : undefined,
+                allowedPrefixes: options.allowedPrefixes
+                    ? [...options.allowedPrefixes]
+                    : undefined,
+            };
+            return this;
+        }
+        withRemoteTools(options = {}) {
+            this.options.remoteTools = cloneOptions({
+                remoteTools: options,
+            }).remoteTools;
+            return this;
+        }
+        withVisualTreeTools(options = {}) {
+            this.options.remoteTools = {
+                ...this.options.remoteTools,
+                visualTree: typeof options === "boolean"
+                    ? options
+                    : { ...options, enabled: options.enabled ?? true },
+            };
+            return this;
+        }
+        withoutVisualTreeTools() {
+            this.options.remoteTools = {
+                ...this.options.remoteTools,
+                visualTree: false,
+            };
+            return this;
+        }
+        withFileSystemTools(options = {}) {
+            this.options.remoteTools = {
+                ...this.options.remoteTools,
+                fileSystem: cloneOptions({ remoteTools: { fileSystem: options } })
+                    .remoteTools?.fileSystem,
+            };
+            return this;
+        }
+        withDatabaseTools(options = {}) {
+            this.options.remoteTools = {
+                ...this.options.remoteTools,
+                database: cloneOptions({ remoteTools: { database: options } }).remoteTools
+                    ?.database,
+            };
+            return this;
+        }
+        withPreferencesTools(options = {}) {
+            this.options.remoteTools = {
+                ...this.options.remoteTools,
+                preferences: cloneOptions({ remoteTools: { preferences: options } })
+                    .remoteTools?.preferences,
+            };
+            return this;
+        }
+        withReflectionTools(options = {}) {
+            this.options.remoteTools = {
+                ...this.options.remoteTools,
+                reflection: cloneOptions({ remoteTools: { reflection: options } })
+                    .remoteTools?.reflection,
+            };
+            return this;
+        }
+        withDomTools(options = {}) {
+            this.options.domTools = { ...options };
+            return this;
+        }
+        withErrorCapture(options = {}) {
+            this.options.errorCapture = { ...options };
+            return this;
+        }
+        registerCustomProperty(group, key, value) {
+            this.options.customProperties = {
+                ...this.options.customProperties,
+                [group]: {
+                    ...this.options.customProperties?.[group],
+                    [key]: String(value),
+                },
+            };
+            return this;
+        }
+        removeCustomProperty(group, key) {
+            const groups = cloneOptions({ customProperties: this.options.customProperties })
+                .customProperties ?? {};
+            delete groups[group]?.[key];
+            if (groups[group] && Object.keys(groups[group]).length === 0) {
+                delete groups[group];
+            }
+            this.options.customProperties = groups;
+            return this;
+        }
+        clearCustomProperties() {
+            this.options.customProperties = {};
+            return this;
+        }
+        build() {
+            return cloneOptions(this.options);
+        }
+    }
+    function createOptionsBuilder(options = {}) {
+        return new AnsightOptionsBuilder(options);
+    }
+
+    const AnsightNative = registerPlugin("Ansight");
+    const toolHandlers = new Map();
+    const artifactProviders = new Map();
+    const hostConnectionListeners = new Set();
+    const logListeners = new Set();
+    let toolListener;
+    let logListener;
+    let lifecycleCleanup;
+    let artifactToolRegistrations = [];
+    let domToolRegistration;
+    function normalizePairingPayload(payload) {
+        if (payload == null)
+            return payload;
+        return typeof payload === "string" ? payload : JSON.stringify(payload);
+    }
+    function normalizeOptions(input) {
+        const options = JSON.parse(JSON.stringify(input));
+        if (options.pairingConfig != null) {
+            options.pairingConfigJson =
+                normalizePairingPayload(options.pairingConfig) ?? undefined;
+            delete options.pairingConfig;
+        }
+        if (options.bundledPairingConfig != null) {
+            options.pairingConfigJson =
+                normalizePairingPayload(options.bundledPairingConfig) ?? undefined;
+            delete options.bundledPairingConfig;
+        }
+        delete options.domTools;
+        delete options.errorCapture;
+        delete options.lifecycle;
+        return options;
+    }
+    function normalizeToolResult(value) {
+        if (value && typeof value === "object" && "success" in value) {
+            return value;
+        }
+        return { success: true, result: value };
+    }
+    function errorToolResult(error) {
+        return {
+            success: false,
+            message: error instanceof Error ? error.message : String(error),
+            errorCode: "javascript_tool_failed",
+        };
+    }
+    async function ensureToolListener() {
+        toolListener ??= AnsightNative.addListener("ansightToolCall", (call) => {
+            const handler = toolHandlers.get(call.toolId);
+            void Promise.resolve(handler
+                ? handler(call.arguments ?? {}, call)
+                : {
+                    success: false,
+                    message: `No JavaScript handler is registered for '${call.toolId}'.`,
+                    errorCode: "javascript_tool_not_registered",
+                })
+                .then(normalizeToolResult)
+                .catch(errorToolResult)
+                .then((result) => AnsightNative.resolveToolCall({ requestId: call.requestId, result }))
+                .catch(() => undefined);
+        });
+        return toolListener;
+    }
+    async function ensureLogListener() {
+        logListener ??= AnsightNative.addListener("ansightLog", (entry) => {
+            for (const listener of logListeners)
+                listener(entry);
+        });
+        return logListener;
+    }
+    async function emitHostConnectionStatus() {
+        if (hostConnectionListeners.size === 0)
+            return;
+        const [status, capabilities] = await Promise.all([
+            AnsightNative.hostConnectionStatus(),
+            AnsightNative.hostConnectionCapabilities(),
+        ]);
+        for (const listener of hostConnectionListeners)
+            listener(status, capabilities);
+    }
+    async function afterConnectionChange(operation) {
+        const result = await operation();
+        await emitHostConnectionStatus();
+        return result;
+    }
+    async function initialize(options = {}) {
+        const result = await AnsightNative.initialize(normalizeOptions(options));
+        if (options.lifecycle !== false)
+            startLifecycleTracking();
+        if (options.errorCapture) {
+            installErrorHandlers(typeof options.errorCapture === "object" ? options.errorCapture : {});
+        }
+        if (options.domTools) {
+            installDomTools(typeof options.domTools === "object" ? options.domTools : {});
+        }
+        await emitHostConnectionStatus();
+        return result;
+    }
+    async function initializeAndActivate(options = {}) {
+        const result = await AnsightNative.initializeAndActivate(normalizeOptions(options));
+        if (options.lifecycle !== false)
+            startLifecycleTracking();
+        if (options.errorCapture) {
+            installErrorHandlers(typeof options.errorCapture === "object" ? options.errorCapture : {});
+        }
+        if (options.domTools) {
+            installDomTools(typeof options.domTools === "object" ? options.domTools : {});
+        }
+        await emitHostConnectionStatus();
+        return result;
+    }
+    const activate = () => afterConnectionChange(() => AnsightNative.activate());
+    async function deactivate() {
+        stopLifecycleTracking();
+        return afterConnectionChange(() => AnsightNative.deactivate());
+    }
+    const clear = () => afterConnectionChange(() => AnsightNative.clear());
+    const registerMetricChannel = (channel) => AnsightNative.registerMetricChannel({ channel });
+    const metric = (value, channel = 255) => AnsightNative.recordMetric({ value, channel });
+    const recordMetric = metric;
+    function event(input) {
+        return AnsightNative.recordEvent(typeof input === "string" ? { label: input } : input);
+    }
+    const recordEvent = event;
+    const screenViewed = (name, details = {}) => AnsightNative.screenViewed({ name, details });
+    const trackRoute = screenViewed;
+    const setAppLifecycleState = (state) => AnsightNative.setAppLifecycleState({ state });
+    function connect(pairingPayload, options = {}) {
+        return afterConnectionChange(() => AnsightNative.connect({
+            ...options,
+            pairingPayload: normalizePairingPayload(pairingPayload),
+        }));
+    }
+    function scanPairingQrCode(options = {}) {
+        return afterConnectionChange(() => AnsightNative.scanPairingQrCode(options));
+    }
+    function openSession(pairingPayload, options = {}) {
+        return afterConnectionChange(() => AnsightNative.openSession({
+            ...options,
+            pairingPayload: normalizePairingPayload(pairingPayload) ?? "",
+        }));
+    }
+    const disconnect = () => afterConnectionChange(() => AnsightNative.disconnect());
+    const completeSession = () => afterConnectionChange(() => AnsightNative.completeSession());
+    const closeSession = () => afterConnectionChange(() => AnsightNative.closeSession());
+    const savePairingConfig = (pairingPayload, options = {}) => afterConnectionChange(() => AnsightNative.savePairingConfig({
+        ...options,
+        pairingPayload: normalizePairingPayload(pairingPayload) ?? "",
+    }));
+    const clearSavedPairing = () => afterConnectionChange(() => AnsightNative.clearSavedPairing());
+    const clearSavedPairingConfig = clearSavedPairing;
+    const clearCachedSession = () => afterConnectionChange(() => AnsightNative.clearCachedSession());
+    const notifyHostConnectionConfigChanged = () => afterConnectionChange(() => AnsightNative.notifyHostConnectionConfigChanged());
+    const status = () => AnsightNative.status();
+    const snapshot = () => AnsightNative.snapshot();
+    const hostConnectionStatus = () => AnsightNative.hostConnectionStatus();
+    const hostConnectionCapabilities = () => AnsightNative.hostConnectionCapabilities();
+    const currentOptions = () => AnsightNative.currentOptions();
+    async function recordedMetrics(limit = 0) {
+        return (await AnsightNative.recordedMetrics({ limit })).items;
+    }
+    async function recordedEvents(limit = 0) {
+        return (await AnsightNative.recordedEvents({ limit })).items;
+    }
+    const sendClientLog = (line) => AnsightNative.sendClientLog({ line });
+    const captureBuiltInTelemetrySample = () => AnsightNative.captureBuiltInTelemetrySample();
+    async function isFramesPerSecondEnabled() {
+        return (await AnsightNative.isFramesPerSecondEnabled()).value;
+    }
+    const enableFramesPerSecond = () => AnsightNative.enableFramesPerSecond();
+    const disableFramesPerSecond = () => AnsightNative.disableFramesPerSecond();
+    const captureScreenFrame = (options = {}) => AnsightNative.captureScreenFrame(options);
+    const enableTouchCapture = () => AnsightNative.enableTouchCapture();
+    const disableTouchCapture = () => AnsightNative.disableTouchCapture();
+    const updateSessionProperties = (properties) => AnsightNative.updateSessionProperties({ properties });
+    const updateCustomProperties = updateSessionProperties;
+    const clearSessionProperties = () => AnsightNative.clearSessionProperties();
+    const clearCustomProperties = clearSessionProperties;
+    const registerCustomProperty = (group, key, value) => AnsightNative.registerCustomProperty({ group, key, value });
+    const removeCustomProperty = (group, key) => AnsightNative.removeCustomProperty({ group, key });
+    function addHostConnectionStatusListener(listener, options = {}) {
+        hostConnectionListeners.add(listener);
+        if (options.emitCurrent !== false)
+            void emitHostConnectionStatus();
+        return {
+            remove: () => {
+                hostConnectionListeners.delete(listener);
+            },
+        };
+    }
+    function addLogListener(listener) {
+        logListeners.add(listener);
+        void ensureLogListener();
+        return {
+            remove: () => {
+                logListeners.delete(listener);
+            },
+        };
+    }
+    function registerTool(definition, handler) {
+        if (!definition?.id?.trim())
+            throw new TypeError("registerTool requires a stable string id.");
+        if (typeof handler !== "function")
+            throw new TypeError("registerTool requires a handler function.");
+        toolHandlers.set(definition.id, handler);
+        const ready = ensureToolListener()
+            .then(() => AnsightNative.registerCustomTool({ definition }))
+            .catch((error) => {
+            toolHandlers.delete(definition.id);
+            throw error;
+        });
+        return {
+            id: definition.id,
+            ready,
+            unregister: async () => {
+                toolHandlers.delete(definition.id);
+                return AnsightNative.unregisterCustomTool({ id: definition.id });
+            },
+        };
+    }
+    function unregisterTool(id) {
+        toolHandlers.delete(id);
+        return AnsightNative.unregisterCustomTool({ id });
+    }
+    const listRegisteredTools = () => [...toolHandlers.keys()];
+    async function clearRegisteredTools() {
+        toolHandlers.clear();
+        artifactProviders.clear();
+        artifactToolRegistrations = [];
+        domToolRegistration = undefined;
+        return AnsightNative.clearRegisteredCustomTools();
+    }
+    function bytesToBase64(bytes) {
+        let binary = "";
+        for (let offset = 0; offset < bytes.length; offset += 0x8000) {
+            binary += String.fromCharCode(...bytes.subarray(offset, offset + 0x8000));
+        }
+        return btoa(binary);
+    }
+    function payloadBytes(payload) {
+        if (payload instanceof Uint8Array)
+            return payload;
+        if (payload instanceof ArrayBuffer)
+            return new Uint8Array(payload);
+        if (Array.isArray(payload))
+            return Uint8Array.from(payload);
+        if (typeof payload === "object" && payload) {
+            const candidate = payload.bytes ?? payload.data;
+            if (candidate instanceof Uint8Array)
+                return candidate;
+            if (candidate instanceof ArrayBuffer)
+                return new Uint8Array(candidate);
+            if (Array.isArray(candidate))
+                return Uint8Array.from(candidate);
+        }
+        return undefined;
+    }
+    function installArtifactTools() {
+        if (artifactToolRegistrations.length > 0)
+            return artifactToolRegistrations;
+        artifactToolRegistrations = [
+            registerTool({
+                id: "artifacts.query",
+                name: "Query JavaScript artifacts",
+                description: "Lists artifacts exposed by Capacitor JavaScript providers.",
+                category: "Artifacts",
+                scope: "read",
+            }, async (_args, context) => {
+                const definitions = [];
+                for (const provider of artifactProviders.values()) {
+                    const query = provider.queryArtifacts ?? provider.query;
+                    const artifacts = query
+                        ? await query({
+                            toolRequestId: context.nativeRequestId ?? context.requestId,
+                            sessionId: context.sessionId,
+                            queriedAtUtc: new Date().toISOString(),
+                        })
+                        : [];
+                    definitions.push(...artifacts.map((artifact) => ({
+                        ...artifact,
+                        providerId: provider.descriptor.id,
+                    })));
+                }
+                return {
+                    success: true,
+                    message: `Found ${definitions.length} artifact(s).`,
+                    result: {
+                        providers: [...artifactProviders.values()].map(({ descriptor }) => descriptor),
+                        artifacts: definitions,
+                    },
+                };
+            }),
+            registerTool({
+                id: "artifacts.request",
+                name: "Request JavaScript artifact",
+                description: "Creates an artifact through a Capacitor JavaScript provider.",
+                category: "Artifacts",
+                scope: "read",
+                argumentsSchema: {
+                    type: "object",
+                    required: ["providerId", "artifactId"],
+                    properties: {
+                        providerId: { type: "string" },
+                        artifactId: { type: "string" },
+                    },
+                },
+            }, async (args, context) => {
+                const provider = artifactProviders.get(args.providerId);
+                const create = provider && (provider.createArtifact ?? provider.create);
+                if (!provider || !create) {
+                    return {
+                        success: false,
+                        message: `Artifact provider '${args.providerId}' is unavailable.`,
+                        errorCode: "artifact_provider_not_found",
+                    };
+                }
+                const result = await create({
+                    providerId: args.providerId,
+                    artifactId: args.artifactId,
+                    arguments: args,
+                    context: {
+                        toolRequestId: context.nativeRequestId ?? context.requestId,
+                        sessionId: context.sessionId,
+                        requestedAtUtc: new Date().toISOString(),
+                    },
+                });
+                const bytes = payloadBytes(result.payload);
+                if (bytes) {
+                    const transfer = await AnsightNative.queueBinaryTransfer({
+                        requestId: context.nativeRequestId ?? context.requestId,
+                        base64Data: bytesToBase64(bytes),
+                        chunkBytes: 64 * 1024,
+                    });
+                    return {
+                        success: transfer.success,
+                        message: transfer.message,
+                        result: { metadata: result.metadata, transfer },
+                        ...(!transfer.success && {
+                            errorCode: "artifact_transfer_unavailable",
+                        }),
+                    };
+                }
+                const payload = typeof result.payload === "object" &&
+                    result.payload &&
+                    "text" in result.payload
+                    ? result.payload.text
+                    : result.payload;
+                return {
+                    success: true,
+                    message: `Artifact '${args.artifactId}' created.`,
+                    result: { metadata: result.metadata, payload },
+                };
+            }),
+        ];
+        return artifactToolRegistrations;
+    }
+    function registerArtifactProvider(provider) {
+        const id = provider?.descriptor?.id?.trim();
+        if (!id)
+            throw new TypeError("registerArtifactProvider requires descriptor.id.");
+        artifactProviders.set(id, provider);
+        const registrations = installArtifactTools();
+        return {
+            id,
+            ready: Promise.all(registrations.map(({ ready }) => ready)).then(() => ({
+                success: true,
+                message: `Artifact provider '${id}' registered.`,
+            })),
+            unregister: () => unregisterArtifactProvider(id),
+        };
+    }
+    const registerArtifactProviders = (providers) => providers.map(registerArtifactProvider);
+    async function unregisterArtifactProvider(id) {
+        artifactProviders.delete(id);
+        if (artifactProviders.size === 0) {
+            const registrations = artifactToolRegistrations;
+            artifactToolRegistrations = [];
+            await Promise.all(registrations.map(({ unregister }) => unregister()));
+        }
+        return { success: true, message: `Artifact provider '${id}' unregistered.` };
+    }
+    const listRegisteredArtifactProviders = () => [...artifactProviders.values()].map(({ descriptor }) => descriptor);
+    async function clearArtifactProviders() {
+        artifactProviders.clear();
+        const registrations = artifactToolRegistrations;
+        artifactToolRegistrations = [];
+        await Promise.all(registrations.map(({ unregister }) => unregister()));
+        return { success: true, message: "JavaScript artifact providers cleared." };
+    }
+    function installDomTools(options = {}) {
+        domToolRegistration ??= installDomTools$1(registerTool, options);
+        return domToolRegistration;
+    }
+    async function uninstallDomTools() {
+        const registration = domToolRegistration;
+        domToolRegistration = undefined;
+        return registration ? registration.unregister() : [];
+    }
+    function startLifecycleTracking() {
+        if (lifecycleCleanup || typeof document === "undefined")
+            return;
+        const update = () => void setAppLifecycleState(document.visibilityState === "visible" ? "foreground" : "background");
+        document.addEventListener("visibilitychange", update);
+        window.addEventListener("pageshow", update);
+        window.addEventListener("pagehide", update);
+        lifecycleCleanup = () => {
+            document.removeEventListener("visibilitychange", update);
+            window.removeEventListener("pageshow", update);
+            window.removeEventListener("pagehide", update);
+        };
+        update();
+    }
+    function stopLifecycleTracking() {
+        lifecycleCleanup?.();
+        lifecycleCleanup = undefined;
+    }
+    const startAppStateTracking = startLifecycleTracking;
+    const stopAppStateTracking = stopLifecycleTracking;
+    function installErrorHandlers(options = {}) {
+        const captureErrors = options.errors ?? true;
+        const captureRejections = options.unhandledRejections ?? true;
+        const captureConsole = options.consoleErrors ?? false;
+        const onError = (eventValue) => {
+            if (!captureErrors)
+                return;
+            void event({
+                label: eventValue.message || "Unhandled JavaScript error",
+                type: "Exception",
+                details: JSON.stringify({
+                    filename: eventValue.filename,
+                    line: eventValue.lineno,
+                    column: eventValue.colno,
+                    stack: eventValue.error instanceof Error
+                        ? eventValue.error.stack
+                        : undefined,
+                }),
+            }).catch(() => undefined);
+        };
+        const onRejection = (eventValue) => {
+            if (!captureRejections)
+                return;
+            const reason = eventValue.reason;
+            void event({
+                label: reason instanceof Error
+                    ? reason.message
+                    : "Unhandled JavaScript rejection",
+                type: "Exception",
+                details: JSON.stringify({
+                    reason: reason instanceof Error ? reason.stack : String(reason),
+                }),
+            }).catch(() => undefined);
+        };
+        window.addEventListener("error", onError);
+        window.addEventListener("unhandledrejection", onRejection);
+        const originalConsoleError = console.error;
+        if (captureConsole) {
+            console.error = (...args) => {
+                originalConsoleError(...args);
+                void event({
+                    label: "console.error",
+                    type: "Exception",
+                    details: args.map(String).join(" "),
+                }).catch(() => undefined);
+            };
+        }
+        return () => {
+            window.removeEventListener("error", onError);
+            window.removeEventListener("unhandledrejection", onRejection);
+            if (captureConsole)
+                console.error = originalConsoleError;
+        };
+    }
+    function createRouteTracker(options = {}) {
+        const resolveName = options.resolveName ?? ((url) => url.pathname + url.search + url.hash);
+        const record = () => void screenViewed(resolveName(new URL(location.href)), options.details);
+        const originalPushState = history.pushState.bind(history);
+        const originalReplaceState = history.replaceState.bind(history);
+        const onPopState = () => record();
+        window.addEventListener("popstate", onPopState);
+        window.addEventListener("hashchange", onPopState);
+        if (options.observeHistory !== false) {
+            history.pushState = (...args) => {
+                originalPushState(...args);
+                record();
+            };
+            history.replaceState = (...args) => {
+                originalReplaceState(...args);
+                record();
+            };
+        }
+        record();
+        return {
+            remove: () => {
+                window.removeEventListener("popstate", onPopState);
+                window.removeEventListener("hashchange", onPopState);
+                history.pushState = originalPushState;
+                history.replaceState = originalReplaceState;
+            },
+        };
+    }
+    const Ansight = {
+        initialize,
+        initializeAndActivate,
+        activate,
+        deactivate,
+        clear,
+        registerMetricChannel,
+        metric,
+        recordMetric,
+        event,
+        recordEvent,
+        screenViewed,
+        trackRoute,
+        setAppLifecycleState,
+        connect,
+        scanPairingQrCode,
+        openSession,
+        disconnect,
+        completeSession,
+        closeSession,
+        savePairingConfig,
+        clearSavedPairing,
+        clearSavedPairingConfig,
+        clearCachedSession,
+        notifyHostConnectionConfigChanged,
+        status,
+        snapshot,
+        hostConnectionStatus,
+        hostConnectionCapabilities,
+        addHostConnectionStatusListener,
+        currentOptions,
+        recordedMetrics,
+        recordedEvents,
+        sendClientLog,
+        addLogListener,
+        captureBuiltInTelemetrySample,
+        isFramesPerSecondEnabled,
+        enableFramesPerSecond,
+        disableFramesPerSecond,
+        captureScreenFrame,
+        enableTouchCapture,
+        disableTouchCapture,
+        updateSessionProperties,
+        updateCustomProperties,
+        clearSessionProperties,
+        registerCustomProperty,
+        removeCustomProperty,
+        clearCustomProperties,
+        registerTool,
+        unregisterTool,
+        listRegisteredTools,
+        clearRegisteredTools,
+        registerArtifactProvider,
+        registerArtifactProviders,
+        unregisterArtifactProvider,
+        listRegisteredArtifactProviders,
+        clearArtifactProviders,
+        installDomTools,
+        uninstallDomTools,
+        installErrorHandlers,
+        createRouteTracker,
+        startLifecycleTracking,
+        stopLifecycleTracking,
+        startAppStateTracking,
+        stopAppStateTracking,
+        createOptionsBuilder,
+        AnsightOptionsBuilder,
+        native: AnsightNative,
+        platform: Capacitor.getPlatform(),
+    };
+
+    if (typeof window !== "undefined") {
+        const options = Ansight.createOptionsBuilder(globalThis.__ANSIGHT_CAPACITOR_STANDALONE_OPTIONS__ ?? {})
+            .withAnsightDefaults()
+            .withAllToolAccess()
+            .withVisualTreeTools()
+            .withFileSystemTools()
+            .withDatabaseTools()
+            .withPreferencesTools()
+            .withReflectionTools()
+            .withDomTools()
+            .withErrorCapture()
+            .build();
+        void Ansight.initializeAndActivate(options).catch((error) => {
+            console.error("[Ansight Capacitor]", error);
+        });
+    }
+
+})();
+//# sourceMappingURL=standalone.js.map