@crossbind/extension-page-dialogs 0.0.0-stage → 2.0.0-beta.69

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Buğra Sarı and crossbind contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,20 @@
-# Temporary Holding Version
+# @crossbind/extension-page-dialogs
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+A page's alert, confirm and prompt, as the system's dialogs.
+
+An app has it by having `@crossbind/core-app-host`, which lists it as a dependency: there is nothing to install or list.
+
+## What it does
+
+The page's `alert()`, `confirm()` and `prompt()` show as the system's own dialogs, under the app's name, and the page
+waits for their answer, as in a browser.
+
+## Platforms
+
+macOS, iOS, Linux, Windows and Android.
+
+## Replace or leave out
+
+It holds the role `page-dialogs`. An extension that gives `replaces: 'page-dialogs'` takes it; `app: { without: ['page-dialogs'] }` in `crossbind.config.js` leaves it out. [The guide](https://crossbind.dev/guide/extensions/#replace) shows how, and [extensions.md](https://github.com/crossbind/crossbind/blob/main/docs/api/extensions.md#the-hosts-own-extensions) what a replacement answers.
+
+[extensions.md](https://github.com/crossbind/crossbind/blob/main/docs/api/extensions.md#the-pages-requests) has the hooks a replacement answers.

package/crossbind.extension.js

@@ -0,0 +1,14 @@
+export default function pageDialogs() {
+    return {
+        name: 'page-dialogs',
+        contract: 1,
+        root: import.meta.dirname,
+        app: {
+            macos: { sources: ['native/dialogs.cpp', 'native/darwin.mm'] },
+            ios: { sources: ['native/dialogs.cpp', 'native/ios.mm'] },
+            linux: { sources: ['native/dialogs.cpp', 'native/linux.cpp'] },
+            windows: { sources: ['native/dialogs.cpp', 'native/windows.cpp'], libraries: ['comctl32'] },
+            android: { java: 'native/android', class: 'dev.crossbind.extension.pagedialogs.PageDialogsExtension' },
+        },
+    };
+}

package/native/android/dev/crossbind/extension/pagedialogs/PageDialogsExtension.java

@@ -0,0 +1,42 @@
+package dev.crossbind.extension.pagedialogs;
+
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.widget.EditText;
+
+import org.json.JSONObject;
+
+import dev.crossbind.app.Extension;
+import dev.crossbind.app.ExtensionHost;
+
+// The host's page-dialogs on Android: the page's alert(), confirm() and prompt() as the system's dialog in the activity,
+// titled with the app's name. A dialog its user dismisses answers as cancelled.
+public final class PageDialogsExtension implements Extension {
+    @Override
+    public void call(ExtensionHost host, String function, JSONObject options, Call call) {
+        call.reject("crossbind: page-dialogs has no function " + function);
+    }
+
+    @Override
+    public void onPageDialog(ExtensionHost host, PageDialog dialog) {
+        Activity activity = host.activity();
+        if (activity.isFinishing() || activity.isDestroyed()) {
+            dialog.useDefault();
+            return;
+        }
+        EditText field = dialog.kind() == PageDialog.Kind.PROMPT ? new EditText(activity) : null;
+        if (field != null) {
+            field.setText(dialog.defaultText());
+            field.setSingleLine(true);
+            field.selectAll();
+        }
+        AlertDialog.Builder builder = new AlertDialog.Builder(activity)
+                .setTitle(activity.getApplicationInfo().loadLabel(activity.getPackageManager()))
+                .setMessage(dialog.message())
+                .setPositiveButton(android.R.string.ok, (shown, which) -> dialog.accept(field == null ? "" : field.getText().toString()))
+                .setOnCancelListener((shown) -> dialog.cancel());
+        if (field != null) builder.setView(field);
+        if (dialog.kind() != PageDialog.Kind.ALERT) builder.setNegativeButton(android.R.string.cancel, (shown, which) -> dialog.cancel());
+        builder.show();
+    }
+}

package/native/darwin.mm

@@ -0,0 +1,57 @@
+#import <Cocoa/Cocoa.h>
+
+#include "dialogs.h"
+
+using crossbind::PageDialog;
+
+namespace {
+
+NSString *ns(const std::string &text) { return [NSString stringWithUTF8String:text.c_str()] ?: @""; }
+
+NSAlert *alertOf(const PageDialog &dialog, NSArray<NSString *> *buttons) {
+    NSAlert *alert = [NSAlert new];
+    alert.messageText = ns(crossbind::appName());
+    alert.informativeText = ns(dialog.message());
+    for (NSString *button in buttons) [alert addButtonWithTitle:button];
+    return alert;
+}
+
+// A sheet on the page's window, as Safari shows them; without one, a dialog of its own.
+void show(NSAlert *alert, const PageDialog &dialog, void (^done)(NSModalResponse)) {
+    NSWindow *window = (__bridge NSWindow *)windowOf(dialog);
+    if (window) {
+        [alert beginSheetModalForWindow:window completionHandler:done];
+    } else {
+        done([alert runModal]);
+    }
+}
+
+}  // namespace
+
+void showPageDialog(PageDialog dialog) {
+    switch (dialog.kind()) {
+    case PageDialog::Kind::alert: {
+        show(alertOf(dialog, @[ @"OK" ]), dialog, ^(NSModalResponse) { dialog.accept(); });
+        return;
+    }
+    case PageDialog::Kind::confirm: {
+        show(alertOf(dialog, @[ @"OK", @"Cancel" ]), dialog, ^(NSModalResponse response) {
+            if (response == NSAlertFirstButtonReturn) dialog.accept();
+            else dialog.cancel();
+        });
+        return;
+    }
+    case PageDialog::Kind::prompt: {
+        NSAlert *alert = alertOf(dialog, @[ @"OK", @"Cancel" ]);
+        NSTextField *field = [NSTextField textFieldWithString:ns(dialog.defaultText())];
+        field.frame = NSMakeRect(0, 0, 260, 24);
+        alert.accessoryView = field;
+        alert.window.initialFirstResponder = field;
+        show(alert, dialog, ^(NSModalResponse response) {
+            if (response == NSAlertFirstButtonReturn) dialog.accept(field.stringValue.UTF8String ?: "");
+            else dialog.cancel();
+        });
+        return;
+    }
+    }
+}

package/native/dialogs.cpp

@@ -0,0 +1,5 @@
+#include "dialogs.h"
+
+// The host's page-dialogs: the page's alert(), confirm() and prompt() in the platform's own dialog, as an app's
+// extension of this name may show them otherwise.
+void crossbind_extension_page_dialogs(crossbind::Registry &registry) { registry.onPageDialog(showPageDialog); }

package/native/dialogs.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include "crossbind/extension.h"
+
+// The page's dialog in the platform's own, titled with the app's name, over the page's window; the page waits for its
+// answer.
+void showPageDialog(crossbind::PageDialog dialog);
+
+// The platform's window of the page that asks, on the main thread: the app's oldest for a page whose window went.
+inline void *windowOf(const crossbind::PageDialog &dialog) {
+    const std::optional<crossbind::Window> open = crossbind::windowOf(dialog.page().windowId());
+    return open ? open->native() : crossbind::appWindow();
+}

package/native/ios.mm

@@ -0,0 +1,37 @@
+#import <UIKit/UIKit.h>
+
+#include "dialogs.h"
+
+using crossbind::PageDialog;
+
+namespace {
+
+NSString *ns(const std::string &text) { return [NSString stringWithUTF8String:text.c_str()] ?: @""; }
+
+// Over what the page's window shows on top, if it shows anything.
+void presentOnTop(UIViewController *controller, const PageDialog &dialog) {
+    UIViewController *top = ((__bridge UIWindow *)windowOf(dialog)).rootViewController;
+    while (top.presentedViewController) top = top.presentedViewController;
+    if (top && !top.isBeingDismissed) [top presentViewController:controller animated:YES completion:nil];
+}
+
+}  // namespace
+
+// An alert that goes without an action, or that nothing shows, lets go of the dialog, which then answers as cancelled:
+// WebKit wants an answer to every one.
+void showPageDialog(PageDialog dialog) {
+    UIAlertController *alert = [UIAlertController alertControllerWithTitle:ns(crossbind::appName()) message:ns(dialog.message())
+                                                            preferredStyle:UIAlertControllerStyleAlert];
+    const PageDialog::Kind kind = dialog.kind();
+    if (kind == PageDialog::Kind::prompt) {
+        [alert addTextFieldWithConfigurationHandler:^(UITextField *field) { field.text = ns(dialog.defaultText()); }];
+    }
+    if (kind != PageDialog::Kind::alert) {
+        [alert addAction:[UIAlertAction actionWithTitle:@"Cancel" style:UIAlertActionStyleCancel handler:^(UIAlertAction *) { dialog.cancel(); }]];
+    }
+    __weak UIAlertController *shown = alert;
+    [alert addAction:[UIAlertAction actionWithTitle:@"OK" style:UIAlertActionStyleDefault handler:^(UIAlertAction *) {
+               dialog.accept(kind == PageDialog::Kind::prompt ? (shown.textFields.firstObject.text.UTF8String ?: "") : "");
+           }]];
+    presentOnTop(alert, dialog);
+}

package/native/linux.cpp

@@ -0,0 +1,42 @@
+#include "dialogs.h"
+
+#include <gtk/gtk.h>
+
+using crossbind::PageDialog;
+
+namespace {
+
+// The dialog holds the page's until it goes, which then answers it as cancelled unless its user answered.
+void forget(gpointer dialog, GClosure *) { delete static_cast<PageDialog *>(dialog); }
+
+void responded(GtkDialog *box, gint response, gpointer data) {
+    const auto *dialog = static_cast<const PageDialog *>(data);
+    auto *entry = static_cast<GtkEntry *>(g_object_get_data(G_OBJECT(box), "crossbind-entry"));
+    if (response == GTK_RESPONSE_OK) dialog->accept(entry ? gtk_entry_get_text(entry) : "");
+    else dialog->cancel();
+    gtk_widget_destroy(GTK_WIDGET(box));
+}
+
+}  // namespace
+
+// A dialog of the page's window, with the app's name over the message, as GTK shows its own.
+void showPageDialog(PageDialog dialog) {
+    const std::string title = crossbind::appName();
+    GtkWidget *box = gtk_message_dialog_new(static_cast<GtkWindow *>(windowOf(dialog)), GtkDialogFlags(GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT),
+                                            GTK_MESSAGE_OTHER, dialog.kind() == PageDialog::Kind::alert ? GTK_BUTTONS_OK : GTK_BUTTONS_OK_CANCEL, "%s",
+                                            title.c_str());
+    gtk_window_set_title(GTK_WINDOW(box), title.c_str());
+    gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(box), "%s", dialog.message().c_str());
+    if (dialog.kind() == PageDialog::Kind::prompt) {
+        GtkWidget *entry = gtk_entry_new();
+        gtk_entry_set_text(GTK_ENTRY(entry), dialog.defaultText().c_str());
+        gtk_entry_set_activates_default(GTK_ENTRY(entry), TRUE);
+        gtk_container_add(GTK_CONTAINER(gtk_message_dialog_get_message_area(GTK_MESSAGE_DIALOG(box))), entry);
+        gtk_widget_show(entry);
+        gtk_widget_grab_focus(entry);
+        g_object_set_data(G_OBJECT(box), "crossbind-entry", entry);
+    }
+    gtk_dialog_set_default_response(GTK_DIALOG(box), GTK_RESPONSE_OK);
+    g_signal_connect_data(box, "response", G_CALLBACK(responded), new PageDialog(std::move(dialog)), forget, GConnectFlags(0));
+    gtk_window_present(GTK_WINDOW(box));
+}

package/native/windows.cpp

@@ -0,0 +1,212 @@
+#include "dialogs.h"
+
+#include <windows.h>
+#include <commctrl.h>
+
+#include <algorithm>
+#include <optional>
+#include <string>
+#include <vector>
+
+using crossbind::PageDialog;
+
+namespace {
+
+constexpr WORD MESSAGE_ID = 100;
+constexpr WORD TEXT_ID = 101;
+// A prompt's layout in dialog units, which Windows scales with the window's font and DPI.
+constexpr short WIDTH = 260;
+constexpr short MARGIN = 7;
+constexpr short LINE = 8;
+constexpr short EDIT_HEIGHT = 14;
+constexpr short BUTTON_WIDTH = 50;
+constexpr short BUTTON_HEIGHT = 14;
+
+std::wstring wide(const std::string &text) {
+    const int length = MultiByteToWideChar(CP_UTF8, 0, text.data(), static_cast<int>(text.size()), nullptr, 0);
+    std::wstring out(static_cast<size_t>(length), L'\0');
+    MultiByteToWideChar(CP_UTF8, 0, text.data(), static_cast<int>(text.size()), out.data(), length);
+    return out;
+}
+
+std::string utf8(const std::wstring &text) {
+    const int length = WideCharToMultiByte(CP_UTF8, 0, text.data(), static_cast<int>(text.size()), nullptr, 0, nullptr, nullptr);
+    std::string out(static_cast<size_t>(length), '\0');
+    WideCharToMultiByte(CP_UTF8, 0, text.data(), static_cast<int>(text.size()), out.data(), length, nullptr, nullptr);
+    return out;
+}
+
+// An alert or a confirm as the system's task dialog, modal to the page's window, as a message box is.
+bool confirmed(const PageDialog &dialog) {
+    const std::wstring title = wide(crossbind::appName());
+    const std::wstring message = wide(dialog.message());
+    TASKDIALOGCONFIG config{};
+    config.cbSize = sizeof config;
+    config.hwndParent = static_cast<HWND>(windowOf(dialog));
+    // Escape and closing the dialog answer IDCANCEL.
+    config.dwFlags = TDF_ALLOW_DIALOG_CANCELLATION | TDF_POSITION_RELATIVE_TO_WINDOW;
+    config.dwCommonButtons = dialog.kind() == PageDialog::Kind::alert ? TDCBF_OK_BUTTON : TDCBF_OK_BUTTON | TDCBF_CANCEL_BUTTON;
+    config.pszWindowTitle = title.c_str();
+    config.pszContent = message.c_str();
+    int clicked = IDCANCEL;
+    return SUCCEEDED(TaskDialogIndirect(&config, &clicked, nullptr, nullptr)) && clicked == IDOK;
+}
+
+// A dialog template in memory, as a resource file would hold it: words, a string after each item's class, and each item
+// on a 4-byte boundary.
+class Template {
+public:
+    void word(WORD value) { words_.push_back(value); }
+    void dword(DWORD value) {
+        word(LOWORD(value));
+        word(HIWORD(value));
+    }
+    void text(const wchar_t *value) {
+        for (; *value; ++value) word(*value);
+        word(0);
+    }
+    void align() {
+        if (words_.size() % 2) word(0);
+    }
+    void item(DWORD style, short x, short y, short cx, short cy, WORD id, WORD atom, const wchar_t *title) {
+        align();
+        dword(style | WS_CHILD | WS_VISIBLE);
+        dword(0);
+        for (const short value : {x, y, cx, cy}) word(static_cast<WORD>(value));
+        word(id);
+        word(0xFFFF);
+        word(atom);
+        text(title);
+        word(0);
+    }
+    const DLGTEMPLATE *data() const { return reinterpret_cast<const DLGTEMPLATE *>(words_.data()); }
+
+private:
+    std::vector<WORD> words_;
+};
+
+struct Prompt {
+    std::wstring message;
+    std::wstring text;
+    bool isAnswered = false;
+};
+
+// Grows the message to the lines its text takes, as far as the screen lets it, with the text box and the buttons below
+// it, and centers the prompt on the app's window, as the task dialog is.
+void fit(HWND box) {
+    HWND message = GetDlgItem(box, MESSAGE_ID);
+    RECT area{};
+    GetWindowRect(message, &area);
+    const int width = area.right - area.left;
+    const int length = GetWindowTextLengthW(message);
+    std::wstring text(static_cast<size_t>(length) + 1, L'\0');
+    GetWindowTextW(message, text.data(), length + 1);
+    HDC dc = GetDC(message);
+    HGDIOBJ font = SelectObject(dc, reinterpret_cast<HFONT>(SendMessageW(box, WM_GETFONT, 0, 0)));
+    RECT needed{0, 0, width, 0};
+    DrawTextW(dc, text.c_str(), length, &needed, DT_CALCRECT | DT_WORDBREAK | DT_NOPREFIX);
+    SelectObject(dc, font);
+    ReleaseDC(message, dc);
+    RECT frame{};
+    GetWindowRect(box, &frame);
+    MONITORINFO monitor{};
+    monitor.cbSize = sizeof monitor;
+    GetMonitorInfoW(MonitorFromWindow(box, MONITOR_DEFAULTTONEAREST), &monitor);
+    const RECT &work = monitor.rcWork;
+    const LONG room = std::max(0L, (work.bottom - work.top) - (frame.bottom - frame.top));
+    const LONG grow = std::clamp((needed.bottom - needed.top) - (area.bottom - area.top), 0L, room);
+    if (grow > 0) {
+        SetWindowPos(message, nullptr, 0, 0, width, area.bottom - area.top + grow, SWP_NOMOVE | SWP_NOZORDER);
+        for (const int id : {static_cast<int>(TEXT_ID), IDOK, IDCANCEL}) {
+            HWND child = GetDlgItem(box, id);
+            RECT place{};
+            GetWindowRect(child, &place);
+            POINT at{place.left, place.top};
+            ScreenToClient(box, &at);
+            SetWindowPos(child, nullptr, at.x, at.y + grow, 0, 0, SWP_NOSIZE | SWP_NOZORDER);
+        }
+    }
+    const LONG boxWidth = frame.right - frame.left;
+    const LONG boxHeight = frame.bottom - frame.top + grow;
+    RECT over = work;
+    if (HWND owner = GetWindow(box, GW_OWNER)) GetWindowRect(owner, &over);
+    const LONG x = std::clamp((over.left + over.right - boxWidth) / 2, work.left, std::max(work.left, work.right - boxWidth));
+    const LONG y = std::clamp((over.top + over.bottom - boxHeight) / 2, work.top, std::max(work.top, work.bottom - boxHeight));
+    SetWindowPos(box, nullptr, x, y, boxWidth, boxHeight, SWP_NOZORDER);
+}
+
+INT_PTR CALLBACK promptProc(HWND box, UINT message, WPARAM w, LPARAM l) {
+    auto *prompt = reinterpret_cast<Prompt *>(GetWindowLongPtrW(box, DWLP_USER));
+    switch (message) {
+    case WM_INITDIALOG:
+        SetWindowLongPtrW(box, DWLP_USER, l);
+        prompt = reinterpret_cast<Prompt *>(l);
+        SetWindowTextW(box, wide(crossbind::appName()).c_str());
+        SetDlgItemTextW(box, MESSAGE_ID, prompt->message.c_str());
+        SetDlgItemTextW(box, TEXT_ID, prompt->text.c_str());
+        fit(box);
+        SendDlgItemMessageW(box, TEXT_ID, EM_SETSEL, 0, -1);
+        SetFocus(GetDlgItem(box, TEXT_ID));
+        // The text box has the focus.
+        return FALSE;
+    case WM_COMMAND:
+        if (LOWORD(w) == IDOK) {
+            HWND edit = GetDlgItem(box, TEXT_ID);
+            const int length = GetWindowTextLengthW(edit);
+            std::wstring text(static_cast<size_t>(length) + 1, L'\0');
+            GetWindowTextW(edit, text.data(), length + 1);
+            text.resize(static_cast<size_t>(length));
+            prompt->text = std::move(text);
+            prompt->isAnswered = true;
+            EndDialog(box, IDOK);
+            return TRUE;
+        }
+        if (LOWORD(w) == IDCANCEL) {
+            EndDialog(box, IDCANCEL);
+            return TRUE;
+        }
+        return FALSE;
+    default:
+        return FALSE;
+    }
+}
+
+// A prompt as a dialog of the system's controls, which Windows has no ready one of: its message, a text box with the
+// prompt's text, and OK and Cancel, in the task dialog's font. Enter is OK and Escape is Cancel.
+std::optional<std::string> prompted(const PageDialog &dialog) {
+    constexpr short TEXT_Y = MARGIN + 2 * LINE + 4;
+    constexpr short BUTTONS_Y = TEXT_Y + EDIT_HEIGHT + MARGIN;
+    constexpr short HEIGHT = BUTTONS_Y + BUTTON_HEIGHT + MARGIN;
+    Template layout;
+    layout.dword(DS_MODALFRAME | DS_SETFONT | DS_CENTER | WS_POPUP | WS_CAPTION | WS_SYSMENU);
+    layout.dword(0);
+    layout.word(4);
+    for (const short value : {short(0), short(0), WIDTH, HEIGHT}) layout.word(static_cast<WORD>(value));
+    layout.word(0);
+    layout.word(0);
+    layout.text(L"");
+    layout.word(9);
+    layout.text(L"Segoe UI");
+    layout.item(SS_LEFT | SS_NOPREFIX, MARGIN, MARGIN, WIDTH - 2 * MARGIN, 2 * LINE, MESSAGE_ID, 0x0082, L"");
+    layout.item(ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP, MARGIN, TEXT_Y, WIDTH - 2 * MARGIN, EDIT_HEIGHT, TEXT_ID, 0x0081, L"");
+    layout.item(BS_DEFPUSHBUTTON | WS_TABSTOP, WIDTH - MARGIN - 2 * BUTTON_WIDTH - 4, BUTTONS_Y, BUTTON_WIDTH, BUTTON_HEIGHT, IDOK, 0x0080, L"OK");
+    layout.item(BS_PUSHBUTTON | WS_TABSTOP, WIDTH - MARGIN - BUTTON_WIDTH, BUTTONS_Y, BUTTON_WIDTH, BUTTON_HEIGHT, IDCANCEL, 0x0080, L"Cancel");
+    Prompt prompt{wide(dialog.message()), wide(dialog.defaultText())};
+    DialogBoxIndirectParamW(GetModuleHandleW(nullptr), layout.data(), static_cast<HWND>(windowOf(dialog)), promptProc, reinterpret_cast<LPARAM>(&prompt));
+    if (!prompt.isAnswered) return std::nullopt;
+    return utf8(prompt.text);
+}
+
+}  // namespace
+
+// Each modal to the app's window, as the host hands it over once the webview's event that asked has returned.
+void showPageDialog(PageDialog dialog) {
+    if (dialog.kind() != PageDialog::Kind::prompt) {
+        if (confirmed(dialog)) dialog.accept();
+        else dialog.cancel();
+        return;
+    }
+    const std::optional<std::string> text = prompted(dialog);
+    if (text) dialog.accept(*text);
+    else dialog.cancel();
+}

package/package.json

@@ -1,6 +1,29 @@
 {
   "name": "@crossbind/extension-page-dialogs",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "2.0.0-beta.69",
+  "description": "crossbind app extension: a page's alert, confirm and prompt, as the system's dialogs.",
+  "homepage": "https://github.com/crossbind/crossbind/tree/main/extensions/page-dialogs#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/crossbind/crossbind.git"
+  },
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    "./crossbind.extension.js": "./crossbind.extension.js"
+  },
+  "files": [
+    "crossbind.extension.js",
+    "native"
+  ],
+  "crossbind": {
+    "extension": "./crossbind.extension.js"
+  },
+  "keywords": [
+    "crossbind-extension",
+    "crossbind",
+    "page",
+    "dialogs",
+    "app"
+  ]
 }