html2apk 0.8.0 → 0.9.0

package/src/templates/html2apk-early-bridge.js

@@ -19,6 +19,8 @@
     "link:opened": "link:aberto",
     "network:changed": "rede:mudou",
     "battery:changed": "bateria:mudou",
+    "location:changed": "localizacao:mudou",
+    "biometric:failed": "biometria:falhou",
     "notification:received": "notificacao:recebida",
     "notification:clicked": "notificacao:clicada"
   };
@@ -406,6 +408,268 @@
     });
   }
 
+  function hasOwn(object, key) {
+    return Object.prototype.hasOwnProperty.call(object || {}, key);
+  }
+
+  function storedFileOptions(nameOrOptions, value, options) {
+    var normalized;
+    if (nameOrOptions && typeof nameOrOptions === "object" && !Array.isArray(nameOrOptions)) {
+      return cloneSerializable(nameOrOptions) || {};
+    }
+
+    normalized = cloneSerializable(options || {}) || {};
+    normalized.name = String(nameOrOptions || "");
+    normalized.nome = normalized.name;
+    normalized.value = cloneSerializable(value);
+    normalized.valor = normalized.value;
+    if (typeof value !== "string" && !hasOwn(normalized, "json")) {
+      normalized.json = true;
+    }
+    return normalized;
+  }
+
+  function storedFileNameOptions(nameOrOptions, options) {
+    var normalized;
+    if (nameOrOptions && typeof nameOrOptions === "object" && !Array.isArray(nameOrOptions)) {
+      return cloneSerializable(nameOrOptions) || {};
+    }
+    normalized = cloneSerializable(options || {}) || {};
+    normalized.name = String(nameOrOptions || "");
+    normalized.nome = normalized.name;
+    return normalized;
+  }
+
+  function applyDownloadName(normalized, nameOrOptions) {
+    if (typeof nameOrOptions === "string") {
+      normalized.name = nameOrOptions;
+      normalized.nome = nameOrOptions;
+      normalized.fileName = nameOrOptions;
+      normalized.nomeArquivo = nameOrOptions;
+    } else if (nameOrOptions && typeof nameOrOptions === "object" && !Array.isArray(nameOrOptions)) {
+      Object.assign(normalized, cloneSerializable(nameOrOptions) || {});
+    }
+    return normalized;
+  }
+
+  function applyBase64DownloadSource(normalized, value) {
+    var source = String(value || "");
+    var comma;
+    var header;
+    var mimeType;
+
+    if (source.indexOf("data:") === 0) {
+      comma = source.indexOf(",");
+      header = comma >= 0 ? source.slice(5, comma) : "";
+      mimeType = header.split(";")[0];
+      normalized.base64 = comma >= 0 ? source.slice(comma + 1) : source;
+      if (mimeType) {
+        normalized.mimeType = normalized.mimeType || mimeType;
+        normalized.tipoMime = normalized.tipoMime || mimeType;
+      }
+      return normalized;
+    }
+
+    normalized.base64 = source;
+    return normalized;
+  }
+
+  function downloadFileOptions(urlOrOptions, nameOrOptions) {
+    var normalized;
+    var source;
+
+    if (urlOrOptions && typeof urlOrOptions === "object" && !Array.isArray(urlOrOptions)) {
+      normalized = cloneSerializable(urlOrOptions) || {};
+      return applyDownloadName(normalized, nameOrOptions);
+    }
+
+    normalized = {};
+    source = String(urlOrOptions || "").trim();
+    if (source.indexOf("data:") === 0) {
+      applyBase64DownloadSource(normalized, source);
+    } else {
+      normalized.url = source;
+    }
+    return applyDownloadName(normalized, nameOrOptions);
+  }
+
+  function downloadBase64Options(nameOrOptions, base64, options) {
+    var normalized;
+    if (nameOrOptions && typeof nameOrOptions === "object" && !Array.isArray(nameOrOptions)) {
+      normalized = cloneSerializable(nameOrOptions) || {};
+      if (typeof base64 === "string") {
+        applyBase64DownloadSource(normalized, base64);
+      } else if (base64 && typeof base64 === "object" && !Array.isArray(base64)) {
+        Object.assign(normalized, cloneSerializable(base64) || {});
+      }
+      return normalized;
+    }
+
+    normalized = cloneSerializable(options || {}) || {};
+    applyDownloadName(normalized, String(nameOrOptions || ""));
+    return applyBase64DownloadSource(normalized, base64);
+  }
+
+  function downloadLocalFileOptions(fileOrOptions, nameOrOptions) {
+    var normalized;
+    var source;
+
+    if (fileOrOptions && typeof fileOrOptions === "object" && !Array.isArray(fileOrOptions)) {
+      normalized = cloneSerializable(fileOrOptions) || {};
+      return applyDownloadName(normalized, nameOrOptions);
+    }
+
+    normalized = {};
+    source = String(fileOrOptions || "").trim();
+    if (/^(content|file):\/\//.test(source)) {
+      normalized.uri = source;
+      normalized.contentUri = source;
+    } else if (/^[A-Za-z]:[\\/]/.test(source) || source.charAt(0) === "/" || source.charAt(0) === "\\") {
+      normalized.path = source;
+      normalized.caminho = source;
+    } else {
+      normalized.sourceName = source;
+      normalized.arquivoOrigem = source;
+    }
+    return applyDownloadName(normalized, nameOrOptions);
+  }
+
+  function wallpaperOptions(sourceOrOptions, options) {
+    var normalized;
+    var source;
+    var comma;
+    var header;
+    var mimeType;
+
+    if (sourceOrOptions && typeof sourceOrOptions === "object" && !Array.isArray(sourceOrOptions)) {
+      normalized = cloneSerializable(sourceOrOptions) || {};
+    } else {
+      normalized = cloneSerializable(options || {}) || {};
+      source = String(sourceOrOptions || "").trim();
+      if (source.indexOf("data:") === 0) {
+        comma = source.indexOf(",");
+        header = comma >= 0 ? source.slice(5, comma) : "";
+        mimeType = header.split(";")[0];
+        normalized.base64 = comma >= 0 ? source.slice(comma + 1) : source;
+        if (mimeType) {
+          normalized.mimeType = normalized.mimeType || mimeType;
+          normalized.tipoMime = normalized.tipoMime || mimeType;
+        }
+      } else if (/^(content|file):\/\//.test(source)) {
+        normalized.uri = source;
+        normalized.contentUri = source;
+      } else if (/^[A-Za-z]:[\\/]/.test(source) || source.charAt(0) === "/" || source.charAt(0) === "\\") {
+        normalized.path = source;
+        normalized.caminho = source;
+      } else {
+        normalized.name = source;
+        normalized.nome = source;
+        normalized.fileName = source;
+        normalized.nomeArquivo = source;
+      }
+    }
+
+    if (normalized.alvo && !normalized.target) {
+      normalized.target = normalized.alvo;
+    }
+    if (normalized.target && !normalized.alvo) {
+      normalized.alvo = normalized.target;
+    }
+    return normalized;
+  }
+
+  function secureItemOptions(keyOrOptions, value, options) {
+    var normalized;
+    if (keyOrOptions && typeof keyOrOptions === "object" && !Array.isArray(keyOrOptions)) {
+      return cloneSerializable(keyOrOptions) || {};
+    }
+    normalized = cloneSerializable(options || {}) || {};
+    normalized.key = String(keyOrOptions || "");
+    normalized.chave = normalized.key;
+    normalized.value = cloneSerializable(value);
+    normalized.valor = normalized.value;
+    if (typeof value !== "string" && !hasOwn(normalized, "json")) {
+      normalized.json = true;
+    }
+    return normalized;
+  }
+
+  function secureKeyOptions(keyOrOptions, options) {
+    var normalized;
+    if (keyOrOptions && typeof keyOrOptions === "object" && !Array.isArray(keyOrOptions)) {
+      return cloneSerializable(keyOrOptions) || {};
+    }
+    normalized = cloneSerializable(options || {}) || {};
+    normalized.key = String(keyOrOptions || "");
+    normalized.chave = normalized.key;
+    return normalized;
+  }
+
+  function unwrapStoredValue(result) {
+    if (!result || result.exists === false || result.existe === false) {
+      return null;
+    }
+    if (hasOwn(result, "value")) {
+      return result.value;
+    }
+    if (hasOwn(result, "valor")) {
+      return result.valor;
+    }
+    if (hasOwn(result, "base64")) {
+      return result.base64;
+    }
+    if (hasOwn(result, "content")) {
+      return result.content;
+    }
+    if (hasOwn(result, "conteudo")) {
+      return result.conteudo;
+    }
+    return result;
+  }
+
+  function detectQRCodeFromPhoto(photo) {
+    var source;
+    var detector;
+
+    if (!photo || !photo.base64) {
+      return null;
+    }
+    if (typeof BarcodeDetector !== "function" || typeof createImageBitmap !== "function" || typeof fetch !== "function") {
+      throw new Error("QR code scanning requires BarcodeDetector support in this Android WebView.");
+    }
+
+    detector = new BarcodeDetector({ formats: ["qr_code"] });
+    source = "data:" + (photo.mimeType || "image/jpeg") + ";base64," + photo.base64;
+    return fetch(source)
+      .then(function (response) {
+        return response.blob();
+      })
+      .then(function (blob) {
+        return createImageBitmap(blob);
+      })
+      .then(function (image) {
+        return detector.detect(image);
+      })
+      .then(function (codes) {
+        var first = codes && codes[0];
+        if (!first) {
+          return null;
+        }
+        return {
+          text: first.rawValue || "",
+          texto: first.rawValue || "",
+          rawValue: first.rawValue || "",
+          valorBruto: first.rawValue || "",
+          format: first.format || "qr_code",
+          formato: first.format || "qr_code",
+          codes: codes,
+          codigos: codes,
+          photo: photo,
+          foto: photo
+        };
+      });
+  }
+
   function normalizeEventType(type) {
     var eventType = String(type || "");
     return eventAliases[eventType] || eventType;
@@ -577,6 +841,15 @@
     statusLanterna: function () {
       return call("flashlightStatus");
     },
+    tirarFoto: function (options) {
+      return call("capturePhoto", [options || {}]);
+    },
+    capturarVideo: function (options) {
+      return call("captureVideo", [options || {}]);
+    },
+    escanearQRCode: function (options) {
+      return api.tirarFoto(Object.assign({ base64: true }, options || {})).then(detectQRCodeFromPhoto);
+    },
     solicitarPermissaoCamera: function () {
       return call("requestCameraPermission");
     },
@@ -640,8 +913,55 @@
     escolherPasta: function () {
       return call("pickFolder");
     },
-    salvarArquivo: function (options) {
-      return call("saveFile", [options || {}]);
+    salvarArquivo: function (nameOrOptions, value, options) {
+      if (typeof nameOrOptions === "string") {
+        return call("saveStoredFile", [storedFileOptions(nameOrOptions, value, options)]);
+      }
+      return call("saveFile", [nameOrOptions || {}]);
+    },
+    lerArquivo: function (nameOrOptions, options) {
+      return call("readStoredFile", [storedFileNameOptions(nameOrOptions, options)]).then(unwrapStoredValue);
+    },
+    lerArquivoCompleto: function (nameOrOptions, options) {
+      return call("readStoredFile", [storedFileNameOptions(nameOrOptions, options)]);
+    },
+    excluirArquivo: function (nameOrOptions, options) {
+      return call("deleteStoredFile", [storedFileNameOptions(nameOrOptions, options)]);
+    },
+    infoArquivo: function (nameOrOptions, options) {
+      return call("storedFileInfo", [storedFileNameOptions(nameOrOptions, options)]);
+    },
+    arquivoExiste: function (nameOrOptions, options) {
+      return api.infoArquivo(nameOrOptions, options).then(function (info) {
+        return Boolean(info && (info.exists || info.existe));
+      });
+    },
+    listarArquivos: function () {
+      return call("listStoredFiles");
+    },
+    abrirArquivo: function (nameOrOptions, options) {
+      return call("openStoredFile", [storedFileNameOptions(nameOrOptions, options)]);
+    },
+    compartilharArquivo: function (nameOrOptions, options) {
+      return call("shareStoredFile", [storedFileNameOptions(nameOrOptions, options)]);
+    },
+    baixarArquivo: function (urlOrOptions, nameOrOptions) {
+      return call("downloadFile", [downloadFileOptions(urlOrOptions, nameOrOptions)]);
+    },
+    baixarBase64: function (nameOrOptions, base64, options) {
+      return call("downloadFile", [downloadBase64Options(nameOrOptions, base64, options)]);
+    },
+    baixarArquivoLocal: function (fileOrOptions, nameOrOptions) {
+      return call("downloadFile", [downloadLocalFileOptions(fileOrOptions, nameOrOptions)]);
+    },
+    definirPapelParede: function (sourceOrOptions, options) {
+      return call("setWallpaper", [wallpaperOptions(sourceOrOptions, options)]);
+    },
+    infoPapelParede: function () {
+      return call("wallpaperInfo");
+    },
+    abrirConfiguracaoPapelParede: function () {
+      return call("openWallpaperSettings");
     },
     infoDispositivo: function () {
       return call("deviceInfo");
@@ -667,6 +987,39 @@
     infoAppsAbertos: function () {
       return call("openAppsMemory");
     },
+    obterLocalizacao: function (options) {
+      return call("getLocation", [options || {}]);
+    },
+    acompanharLocalizacao: function (options) {
+      return call("watchLocation", [options || {}]);
+    },
+    pararLocalizacao: function (id) {
+      return call("stopLocationWatch", [id || ""]);
+    },
+    aoMudarLocalizacao: function (listener) {
+      return onEvent("localizacao:mudou", listener);
+    },
+    autenticarBiometria: function (options) {
+      return call("authenticateBiometric", [options || {}]);
+    },
+    salvarSeguro: function (keyOrOptions, value, options) {
+      return call("saveSecureItem", [secureItemOptions(keyOrOptions, value, options)]);
+    },
+    lerSeguro: function (keyOrOptions, options) {
+      return call("readSecureItem", [secureKeyOptions(keyOrOptions, options)]).then(unwrapStoredValue);
+    },
+    lerSeguroCompleto: function (keyOrOptions, options) {
+      return call("readSecureItem", [secureKeyOptions(keyOrOptions, options)]);
+    },
+    removerSeguro: function (keyOrOptions, options) {
+      return call("deleteSecureItem", [secureKeyOptions(keyOrOptions, options)]);
+    },
+    listarSeguro: function () {
+      return call("listSecureKeys");
+    },
+    limparSeguro: function () {
+      return call("clearSecureStorage");
+    },
     statusPermissoes: function (permissions) {
       return call("permissionStatus", [permissions || []]);
     },
@@ -763,6 +1116,11 @@
     flashlight: api.lanterna,
     toggleFlashlight: api.alternarLanterna,
     flashlightStatus: api.statusLanterna,
+    takePhoto: api.tirarFoto,
+    capturePhoto: api.tirarFoto,
+    captureVideo: api.capturarVideo,
+    scanQRCode: api.escanearQRCode,
+    scanQrCode: api.escanearQRCode,
     requestCameraPermission: api.solicitarPermissaoCamera,
     requestMicrophonePermission: api.solicitarPermissaoMicrofone,
     microphoneStatus: api.statusMicrofone,
@@ -791,6 +1149,35 @@
     pickVideo: api.escolherVideo,
     pickFolder: api.escolherPasta,
     saveFile: api.salvarArquivo,
+    readFile: api.lerArquivo,
+    readStoredFile: api.lerArquivo,
+    readStoredFileInfo: api.lerArquivoCompleto,
+    deleteFile: api.excluirArquivo,
+    removeFile: api.excluirArquivo,
+    excluirArquivoArmazenado: api.excluirArquivo,
+    removerArquivo: api.excluirArquivo,
+    apagarArquivo: api.excluirArquivo,
+    fileInfo: api.infoArquivo,
+    storedFileInfo: api.infoArquivo,
+    fileExists: api.arquivoExiste,
+    listFiles: api.listarArquivos,
+    listStoredFiles: api.listarArquivos,
+    openFile: api.abrirArquivo,
+    openStoredFile: api.abrirArquivo,
+    shareFile: api.compartilharArquivo,
+    shareStoredFile: api.compartilharArquivo,
+    downloadFile: api.baixarArquivo,
+    downloadBase64: api.baixarBase64,
+    downloadFromBase64: api.baixarBase64,
+    baixarArquivoBase64: api.baixarBase64,
+    downloadLocalFile: api.baixarArquivoLocal,
+    downloadFromFile: api.baixarArquivoLocal,
+    baixarArquivoNormal: api.baixarArquivoLocal,
+    setWallpaper: api.definirPapelParede,
+    setPhoneWallpaper: api.definirPapelParede,
+    wallpaper: api.definirPapelParede,
+    wallpaperInfo: api.infoPapelParede,
+    openWallpaperSettings: api.abrirConfiguracaoPapelParede,
     deviceInfo: api.infoDispositivo,
     networkInfo: api.infoRede,
     batteryInfo: api.infoBateria,
@@ -799,6 +1186,21 @@
     performanceInfo: api.infoDesempenho,
     openAppsMemory: api.appsAbertos,
     openAppsInfo: api.infoAppsAbertos,
+    getLocation: api.obterLocalizacao,
+    watchLocation: api.acompanharLocalizacao,
+    stopLocationWatch: api.pararLocalizacao,
+    onLocationChange: api.aoMudarLocalizacao,
+    authenticateBiometric: api.autenticarBiometria,
+    saveSecure: api.salvarSeguro,
+    secureSet: api.salvarSeguro,
+    readSecure: api.lerSeguro,
+    secureGet: api.lerSeguro,
+    readSecureItem: api.lerSeguroCompleto,
+    deleteSecure: api.removerSeguro,
+    removeSecure: api.removerSeguro,
+    secureDelete: api.removerSeguro,
+    listSecureKeys: api.listarSeguro,
+    clearSecureStorage: api.limparSeguro,
     permissionStatus: api.statusPermissoes,
     requestNotificationPermission: api.solicitarPermissaoNotificacoes,
     notificationPermissionStatus: api.statusPermissaoNotificacoes,

package/src/templates/html2apk-runtime-console.js

@@ -29,6 +29,9 @@
     "cancelarNotificacao", "cancelNotification",
     "lanterna", "flashlight",
     "alternarLanterna", "toggleFlashlight",
+    "tirarFoto", "takePhoto", "capturePhoto",
+    "capturarVideo", "captureVideo",
+    "escanearQRCode", "scanQRCode", "scanQrCode",
     "ouvirMic", "listenMic", "startMic",
     "pararMic", "stopMic",
     "solicitarPermissaoCamera", "requestCameraPermission",
@@ -36,9 +39,28 @@
     "solicitarPermissaoNotificacoes", "requestNotificationPermission",
     "escolherArquivo", "pickFile",
     "escolherImagem", "pickImage",
+    "salvarArquivo", "saveFile",
+    "lerArquivo", "readFile", "readStoredFile",
+    "excluirArquivo", "deleteFile", "removeFile",
+    "listarArquivos", "listFiles",
+    "abrirArquivo", "openFile",
+    "compartilharArquivo", "shareFile",
+    "baixarArquivo", "downloadFile",
+    "baixarBase64", "downloadBase64", "downloadFromBase64",
+    "baixarArquivoLocal", "downloadLocalFile", "downloadFromFile",
+    "definirPapelParede", "setWallpaper", "setPhoneWallpaper",
+    "infoPapelParede", "wallpaperInfo",
+    "abrirConfiguracaoPapelParede", "openWallpaperSettings",
     "abrirNoApp", "openInApp",
     "abrirForaDoApp", "openOutsideApp",
     "abrirUrl", "openUrl",
+    "obterLocalizacao", "getLocation",
+    "acompanharLocalizacao", "watchLocation",
+    "pararLocalizacao", "stopLocationWatch",
+    "autenticarBiometria", "authenticateBiometric",
+    "salvarSeguro", "saveSecure", "secureSet",
+    "lerSeguro", "readSecure", "secureGet",
+    "removerSeguro", "deleteSecure", "removeSecure",
     "vibrar", "vibrate",
     "toast",
     "statusPermissoes", "permissionStatus",
@@ -177,10 +199,11 @@
   }
 
   function add(kind, message, detail) {
+    var hasDetail = arguments.length > 2 && typeof detail !== "undefined";
     var entry = {
       kind: kind || "info",
       time: now(),
-      message: detail ? message + "\n" + short(detail, MAX_DETAIL) : String(message || "")
+      message: hasDetail ? String(message || "") + "\n" + short(detail, MAX_DETAIL) : String(message || "")
     };
 
     keepEntry(entries, entry);
@@ -204,6 +227,114 @@
     }
   }
 
+  function consoleEntryText(entry) {
+    return "[" + (entry.time || "") + "] " + String(entry.kind || "info").toUpperCase() + "\n" + String(entry.message || "");
+  }
+
+  function networkEntryText(entry) {
+    var status = entry.status || "ERR";
+    var method = entry.method || "GET";
+    var title = method + " " + entry.url + " -> " + status + " (" + (entry.durationMs || 0) + "ms)";
+    var detail = {
+      type: entry.type,
+      ok: entry.ok,
+      status: entry.status,
+      statusText: entry.statusText,
+      durationMs: entry.durationMs,
+      requestBody: entry.requestBody,
+      responseBody: entry.responseBody,
+      error: entry.error
+    };
+
+    return "[" + (entry.time || "") + "] " + (entry.ok ? "NETWORK" : "ERROR") + "\n" + title + "\n" + short(detail, MAX_DETAIL);
+  }
+
+  function runtimeConsoleText(onlyErrors) {
+    var output = [];
+    entries.forEach(function (entry) {
+      if (!onlyErrors || entry.kind === "error") {
+        output.push(consoleEntryText(entry));
+      }
+    });
+    networkEntries.forEach(function (entry) {
+      if (!onlyErrors || !entry.ok) {
+        output.push(networkEntryText(entry));
+      }
+    });
+    if (!output.length) {
+      return onlyErrors ? "Nenhum erro registrado." : "Console vazio.";
+    }
+    return output.join("\n\n");
+  }
+
+  function fallbackCopyText(text) {
+    return new Promise(function (resolve, reject) {
+      var target = document.body || document.documentElement;
+      var textarea;
+      var copied = false;
+
+      if (!target || !document.createElement) {
+        reject(new Error("Clipboard indisponivel."));
+        return;
+      }
+
+      textarea = document.createElement("textarea");
+      textarea.value = text;
+      textarea.setAttribute("readonly", "readonly");
+      textarea.style.position = "fixed";
+      textarea.style.left = "-9999px";
+      textarea.style.top = "0";
+      textarea.style.opacity = "0";
+      target.appendChild(textarea);
+      textarea.focus();
+      textarea.select();
+
+      try {
+        copied = document.execCommand("copy");
+      } catch (error) {
+        copied = false;
+      }
+
+      target.removeChild(textarea);
+      if (copied) {
+        resolve();
+      } else {
+        reject(new Error("Nao foi possivel copiar."));
+      }
+    });
+  }
+
+  function copyTextToClipboard(text) {
+    if (typeof navigator !== "undefined" && navigator.clipboard && typeof navigator.clipboard.writeText === "function") {
+      return navigator.clipboard.writeText(text).catch(function () {
+        return fallbackCopyText(text);
+      });
+    }
+    return fallbackCopyText(text);
+  }
+
+  function copyConsole() {
+    var text = runtimeConsoleText(false);
+    return copyTextToClipboard(text).then(function () {
+      add("info", "Console copiado.");
+      return { ok: true, copied: "console" };
+    }, function (error) {
+      add("error", "Falha ao copiar console", error);
+      return { ok: false, copied: "console", message: error && error.message ? error.message : String(error) };
+    });
+  }
+
+  function copyErrors() {
+    var text = runtimeConsoleText(true);
+    return copyTextToClipboard(text).then(function () {
+      add("info", "Erros copiados.");
+      return { ok: true, copied: "errors" };
+    }, function (error) {
+      add("error", "Falha ao copiar erros", error);
+      return { ok: false, copied: "errors", message: error && error.message ? error.message : String(error) };
+    });
+  }
+
   function setActiveTab(tab) {
     activeTab = tab === "network" ? "network" : "console";
     if (!modal) {
@@ -359,6 +490,8 @@
     var consoleTab;
     var networkTab;
     var actions;
+    var copyButton;
+    var copyErrorsButton;
     var clearButton;
     var closeButton;
     var body;
@@ -375,14 +508,15 @@
       ".html2apk-console-modal{position:fixed;inset:0;z-index:2147483641;display:none;background:rgba(8,13,22,.42);padding:16px}",
       ".html2apk-console-modal.open{display:flex;align-items:flex-end;justify-content:center}",
       ".html2apk-console-panel{width:min(980px,calc(100vw - 24px));max-height:min(74vh,700px);background:#10141b;color:#edf4ff;border:1px solid rgba(255,255,255,.14);border-radius:14px;box-shadow:0 28px 90px rgba(0,0,0,.42);overflow:hidden;font-family:system-ui,Segoe UI,Arial}",
-      ".html2apk-console-header{display:grid;grid-template-columns:auto minmax(0,1fr) auto;align-items:center;gap:12px;padding:12px 14px;border-bottom:1px solid rgba(255,255,255,.12);background:#161d27;touch-action:none}",
-      ".html2apk-console-header strong{font-size:15px}.html2apk-console-tabs{display:flex;gap:8px}.html2apk-console-actions{display:flex;gap:8px}",
+      ".html2apk-console-header{display:grid;grid-template-columns:auto minmax(0,1fr);align-items:center;gap:12px;padding:12px 14px;border-bottom:1px solid rgba(255,255,255,.12);background:#161d27;touch-action:none}",
+      ".html2apk-console-header strong{font-size:15px}.html2apk-console-tabs{display:flex;gap:8px;flex-wrap:wrap}.html2apk-console-actions{grid-column:1/-1;display:flex;gap:8px;flex-wrap:wrap;justify-content:flex-end}",
       ".html2apk-console-header button{border:1px solid rgba(255,255,255,.18);background:#202b3a;color:#edf4ff;border-radius:8px;padding:7px 10px;font:700 12px system-ui,Segoe UI,Arial}",
       ".html2apk-console-header button.active{background:#126fff;border-color:#126fff;color:#fff}",
       ".html2apk-console-body{height:min(59vh,570px);background:#0d1118}.html2apk-console-list{display:none;height:100%;overflow:auto;padding:10px}.html2apk-console-list.active{display:block}",
       ".html2apk-console-entry{border:1px solid rgba(255,255,255,.1);border-radius:10px;padding:8px 10px;margin-bottom:8px;background:#141b25}",
       ".html2apk-console-entry.error{border-color:rgba(255,110,123,.65)}.html2apk-console-entry.warn{border-color:rgba(231,173,76,.6)}.html2apk-console-entry.call,.html2apk-console-entry.network{border-color:rgba(98,160,255,.55)}.html2apk-console-entry.ok{border-color:rgba(67,201,133,.55)}",
-      ".html2apk-console-meta{color:#9baabd;font-size:11px;font-weight:800;margin-bottom:4px}.html2apk-console-entry pre{white-space:pre-wrap;word-break:break-word;margin:0;font:12px ui-monospace,SFMono-Regular,Consolas,monospace;line-height:1.45}"
+      ".html2apk-console-meta{color:#9baabd;font-size:11px;font-weight:800;margin-bottom:4px}.html2apk-console-entry pre{white-space:pre-wrap;word-break:break-word;margin:0;font:12px ui-monospace,SFMono-Regular,Consolas,monospace;line-height:1.45}",
+      "@media (min-width:700px){.html2apk-console-header{grid-template-columns:auto minmax(0,1fr) auto}.html2apk-console-actions{grid-column:auto}}"
     ].join("");
     document.head.appendChild(style);
 
@@ -446,6 +580,14 @@
 
     actions = document.createElement("div");
     actions.className = "html2apk-console-actions";
+    copyButton = document.createElement("button");
+    copyButton.type = "button";
+    copyButton.textContent = "Copiar console";
+    copyButton.addEventListener("click", copyConsole);
+    copyErrorsButton = document.createElement("button");
+    copyErrorsButton.type = "button";
+    copyErrorsButton.textContent = "Copiar apenas erros";
+    copyErrorsButton.addEventListener("click", copyErrors);
     clearButton = document.createElement("button");
     clearButton.type = "button";
     clearButton.textContent = "Limpar";
@@ -454,6 +596,8 @@
     closeButton.type = "button";
     closeButton.textContent = "Fechar";
     closeButton.addEventListener("click", closeConsole);
+    actions.appendChild(copyButton);
+    actions.appendChild(copyErrorsButton);
     actions.appendChild(clearButton);
     actions.appendChild(closeButton);
 
@@ -766,6 +910,14 @@
     open: openConsole,
     close: closeConsole,
     clear: clearActiveTab,
+    copy: copyConsole,
+    copyErrors: copyErrors,
+    text: function (onlyErrors) {
+      return runtimeConsoleText(!!onlyErrors);
+    },
+    errorText: function () {
+      return runtimeConsoleText(true);
+    },
     log: add,
     network: addNetwork,
     entries: function () {