@kaeawc/auto-mobile 0.0.88 → 0.0.90

package/mcp-skills/auto-mobile-usage/SKILL.md

@@ -0,0 +1,45 @@
+---
+name: auto-mobile-usage
+description: How to drive Android and iOS devices with AutoMobile MCP tools. Use before acquiring a device, observing a screen, or acting on one, and when a call fails with device_owned_by_other_session, device_service_disabled or capacity_exhausted.
+---
+
+# Driving devices with AutoMobile
+
+## 1. Get a session first
+
+- Acquire a device with `getAndroid` or `getApple`. It finds or boots one and returns a `sessionUuid`.
+- A connection that acquired a device is bound to it, so later calls route to that session without repeating it. A different connection, or a CLI call, passes `sessionUuid` on every call.
+- A device that a session holds takes control calls only from that session (`device_owned_by_other_session` otherwise). Naming someone else's `sessionUuid` never takes the device over.
+- `setActiveDevice` and acquisition are the only calls that change which session an untargeted call uses. With several sessions, pass `sessionUuid` or `deviceId` (`ambiguous_session_selector`).
+- `session_ownership_lost` and `no_active_device_session` are permanent for that session: acquire a new one.
+
+## 2. Observe before you act
+
+- Call `observe` before the first action and again after each action that can change the screen. Coordinates and Android synthetic `s2-` element ids are valid only for the observation that returned them.
+- Act on what `observe` returned: `tapOn` takes a `selector` (`text`, `elementId`, `testTag`), `swipeOn` scrolls the screen or a container (`lookFor` scrolls until an element appears), `tapAt` takes coordinates, `sendKeys` types into the focused field. Do not guess coordinates.
+- `skeleton` lists only rows you can act on. Static text (a status label, a validation error, a result message) is in `context`; read it there to verify a result. `waitFor` with `text` or `textAny`, or `for: "appear"`/`"textEquals"` with only `text`, matches text in either array.
+- Ask `observe` for a screenshot only when the hierarchy is not enough; images are the largest part of a result.
+
+## 3. Resources versus tools
+
+- Tools act or run a computation. Resources (`automobile:` URIs) are cheap read-only state: `automobile:tools` lists every tool and whether it is enabled, `automobile:devices/booted` lists booted devices, `automobile:observation/latest` is the latest observation.
+- Read a resource instead of calling a tool when you only need state. A sessionless read never takes a held device.
+- A tool that is gated off does not appear in `tools/list`. Enable it with `setToolEnabled` or the `enableTools` argument of `getAndroid` and `getApple`.
+
+## 4. Long operations and Tasks
+
+- `executePlan`, `installApp` and `videoRecording` with `action: "stop"` can run as a task when your client declares the Tasks extension. You get a task handle, poll it with `tasks/get`, and cancel with `tasks/cancel`; the work survives a client reconnect.
+- Do not wrap short interaction calls (`tapOn`, `sendKeys`, `pressButton`) in tasks. Without Tasks support the same calls simply block until done.
+
+## 5. Typed errors
+
+An error result carries a stable `code`. Read `code` and `retryable` instead of the message text.
+
+| Code                            | Meaning and next step                                                                                                                                                                       |
+| ------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `capacity_exhausted`            | The platform is at its booted-device limit. Retryable: wait `retryAfterMs`, or shut down a device you hold, then repeat the acquisition. Do not loop faster than `retryAfterMs`.            |
+| `device_service_disabled`       | A simulator service the tool needs is switched off. Not retryable until you act: follow `howToEnable` in the error (enable it with `setDeviceResources`) or start the simulator without it. |
+| `device_owned_by_other_session` | Another session holds the device. Acquire your own device or pass the right `sessionUuid`.                                                                                                  |
+| `plan_execution_in_progress`    | A plan is running on the session. Retry when it finishes; reads stay allowed.                                                                                                               |
+
+Release a device you no longer need so other sessions can use it.

package/node_modules/@borewit/text-codec/LICENSE.txt

@@ -1,9 +1,9 @@
-The MIT License (MIT)
-
-Copyright © 2025 Borewit
-
-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.
+The MIT License (MIT)
+
+Copyright © 2025 Borewit
+
+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/node_modules/@borewit/text-codec/README.md

@@ -1,87 +1,87 @@
-[![CI](https://github.com/Borewit/text-codec/actions/workflows/ci.yml/badge.svg)](https://github.com/Borewit/text-codec/actions/workflows/ci.yml)
-[![npm version](https://img.shields.io/npm/v/%40borewit%2Ftext-codec.svg)](https://www.npmjs.com/package/@borewit/text-codec)
-[![npm downloads](http://img.shields.io/npm/dm/@borewit/text-codec.svg)](https://npmcharts.com/compare/@borewit/text-codec?interval=30)
-![bundlejs](https://deno.bundlejs.com/?q=@borewit/text-codec&badge)
-[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg?logo=open-source-initiative&logoColor=white)](LICENSE.txt)
-
-# `@borewit/text-codec`
-
-A **lightweight polyfill for text encoders and decoders** covering a small set of commonly used encodings.
-
-Some JavaScript runtimes provide limited or inconsistent encoding support through `TextEncoder` and `TextDecoder`.  
-Examples include environments like **Hermes (React Native)** or certain **Node.js builds with limited ICU support**.
-
-This module provides **reliable encode/decode support for a small set of encodings that may be missing or unreliable in those environments**.
-
-- If a native UTF-8 `TextEncoder` / `TextDecoder` is available, it is used.
-- All other encodings are implemented by this library.
-
-## Supported encodings
-
-- `utf-8` / `utf8`
-- `utf-16le`
-- `ascii`
-- `latin1` / `iso-8859-1`
-- `windows-1252`
-
-These encodings are commonly encountered in metadata formats and legacy text data.
-
-## ✨ Features
-
-- Encoding and decoding utilities
-- Lightweight
-- Typed API
-
-## 📦 Installation
-
-```sh
-npm install @borewit/text-codec
-```
-
-# 📚 API Documentation
-
-## `textDecode(bytes, encoding): string`
-
-Decodes binary data into a JavaScript string.
-
-**Parameters**
-- `bytes` (`Uint8Array`) — The binary data to decode.
-- `encoding` (`SupportedEncoding`, optional) — Encoding type. Defaults to `"utf-8"`.  
-
-**Returns**
-- `string` — The decoded text.
-
-**Example**
-```js
-import { textDecode } from "@borewit/text-codec";
-
-const bytes = new Uint8Array([0x48, 0x65, 0x6c, 0x6c, 0x6f]);
-const text = textDecode(bytes, "ascii");
-console.log(text); // "Hello"
-```
-
-## `textEncode(input, encoding): Uint8Array`
-
-Encodes a JavaScript string into binary form using the specified encoding.
-
-**Parameters**
-
-- `input` (`string`) — The string to encode.
-- `encoding` (`SupportedEncoding`, optional) — Encoding type. Defaults to `"utf-8"`.
-
-**Returns**
-
-`Uint8Array` — The encoded binary data.
-
-Example:
-```js
-import { textEncode } from "@borewit/text-codec";
-
-const bytes = textEncode("Hello", "utf-16le");
-console.log(bytes); // Uint8Array([...])
-```
-
-## 📜 Licence
-
-This project is licensed under the [MIT License](LICENSE.txt). Feel free to use, modify, and distribute as needed.
+[![CI](https://github.com/Borewit/text-codec/actions/workflows/ci.yml/badge.svg)](https://github.com/Borewit/text-codec/actions/workflows/ci.yml)
+[![npm version](https://img.shields.io/npm/v/%40borewit%2Ftext-codec.svg)](https://www.npmjs.com/package/@borewit/text-codec)
+[![npm downloads](http://img.shields.io/npm/dm/@borewit/text-codec.svg)](https://npmcharts.com/compare/@borewit/text-codec?interval=30)
+![bundlejs](https://deno.bundlejs.com/?q=@borewit/text-codec&badge)
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg?logo=open-source-initiative&logoColor=white)](LICENSE.txt)
+
+# `@borewit/text-codec`
+
+A **lightweight polyfill for text encoders and decoders** covering a small set of commonly used encodings.
+
+Some JavaScript runtimes provide limited or inconsistent encoding support through `TextEncoder` and `TextDecoder`.  
+Examples include environments like **Hermes (React Native)** or certain **Node.js builds with limited ICU support**.
+
+This module provides **reliable encode/decode support for a small set of encodings that may be missing or unreliable in those environments**.
+
+- If a native UTF-8 `TextEncoder` / `TextDecoder` is available, it is used.
+- All other encodings are implemented by this library.
+
+## Supported encodings
+
+- `utf-8` / `utf8`
+- `utf-16le`
+- `ascii`
+- `latin1` / `iso-8859-1`
+- `windows-1252`
+
+These encodings are commonly encountered in metadata formats and legacy text data.
+
+## ✨ Features
+
+- Encoding and decoding utilities
+- Lightweight
+- Typed API
+
+## 📦 Installation
+
+```sh
+npm install @borewit/text-codec
+```
+
+# 📚 API Documentation
+
+## `textDecode(bytes, encoding): string`
+
+Decodes binary data into a JavaScript string.
+
+**Parameters**
+- `bytes` (`Uint8Array`) — The binary data to decode.
+- `encoding` (`SupportedEncoding`, optional) — Encoding type. Defaults to `"utf-8"`.  
+
+**Returns**
+- `string` — The decoded text.
+
+**Example**
+```js
+import { textDecode } from "@borewit/text-codec";
+
+const bytes = new Uint8Array([0x48, 0x65, 0x6c, 0x6c, 0x6f]);
+const text = textDecode(bytes, "ascii");
+console.log(text); // "Hello"
+```
+
+## `textEncode(input, encoding): Uint8Array`
+
+Encodes a JavaScript string into binary form using the specified encoding.
+
+**Parameters**
+
+- `input` (`string`) — The string to encode.
+- `encoding` (`SupportedEncoding`, optional) — Encoding type. Defaults to `"utf-8"`.
+
+**Returns**
+
+`Uint8Array` — The encoded binary data.
+
+Example:
+```js
+import { textEncode } from "@borewit/text-codec";
+
+const bytes = textEncode("Hello", "utf-16le");
+console.log(bytes); // Uint8Array([...])
+```
+
+## 📜 Licence
+
+This project is licensed under the [MIT License](LICENSE.txt). Feel free to use, modify, and distribute as needed.
  

package/node_modules/@borewit/text-codec/lib/index.js

@@ -1,9 +1,31 @@
 const WINDOWS_1252_EXTRA = {
-    0x80: "€", 0x82: "‚", 0x83: "ƒ", 0x84: "„", 0x85: "…", 0x86: "†",
-    0x87: "‡", 0x88: "ˆ", 0x89: "‰", 0x8a: "Š", 0x8b: "‹", 0x8c: "Œ",
-    0x8e: "Ž", 0x91: "‘", 0x92: "’", 0x93: "“", 0x94: "”", 0x95: "•",
-    0x96: "–", 0x97: "—", 0x98: "˜", 0x99: "™", 0x9a: "š", 0x9b: "›",
-    0x9c: "œ", 0x9e: "ž", 0x9f: "Ÿ",
+    0x80: '€',
+    0x82: '‚',
+    0x83: 'ƒ',
+    0x84: '„',
+    0x85: '…',
+    0x86: '†',
+    0x87: '‡',
+    0x88: 'ˆ',
+    0x89: '‰',
+    0x8a: 'Š',
+    0x8b: '‹',
+    0x8c: 'Œ',
+    0x8e: 'Ž',
+    0x91: '‘',
+    0x92: '’',
+    0x93: '“',
+    0x94: '”',
+    0x95: '•',
+    0x96: '–',
+    0x97: '—',
+    0x98: '˜',
+    0x99: '™',
+    0x9a: 'š',
+    0x9b: '›',
+    0x9c: 'œ',
+    0x9e: 'ž',
+    0x9f: 'Ÿ'
 };
 const WINDOWS_1252_REVERSE = {};
 for (const [code, char] of Object.entries(WINDOWS_1252_EXTRA)) {
@@ -12,80 +34,86 @@ for (const [code, char] of Object.entries(WINDOWS_1252_EXTRA)) {
 let _utf8Decoder;
 let _utf8Encoder;
 function utf8Decoder() {
-    if (typeof globalThis.TextDecoder === "undefined")
-        return undefined;
-    return (_utf8Decoder !== null && _utf8Decoder !== void 0 ? _utf8Decoder : (_utf8Decoder = new globalThis.TextDecoder("utf-8")));
+    if (_utf8Decoder === undefined) {
+        try {
+            _utf8Decoder = typeof globalThis.TextDecoder === 'undefined' ? null : new globalThis.TextDecoder('utf-8');
+        }
+        catch {
+            _utf8Decoder = null;
+        }
+    }
+    return _utf8Decoder !== null && _utf8Decoder !== void 0 ? _utf8Decoder : undefined;
 }
 function utf8Encoder() {
-    if (typeof globalThis.TextEncoder === "undefined")
-        return undefined;
-    return (_utf8Encoder !== null && _utf8Encoder !== void 0 ? _utf8Encoder : (_utf8Encoder = new globalThis.TextEncoder()));
+    if (_utf8Encoder === undefined) {
+        try {
+            _utf8Encoder = typeof globalThis.TextEncoder === 'undefined' ? null : new globalThis.TextEncoder();
+        }
+        catch {
+            _utf8Encoder = null;
+        }
+    }
+    return _utf8Encoder !== null && _utf8Encoder !== void 0 ? _utf8Encoder : undefined;
 }
 const CHUNK = 32 * 1024;
 const REPLACEMENT = 0xfffd;
 /**
  * Decode text from binary data
  */
-export function textDecode(bytes, encoding = "utf-8") {
+export function textDecode(bytes, encoding = 'utf-8') {
     switch (encoding.toLowerCase()) {
-        case "utf-8":
-        case "utf8": {
+        case 'utf-8':
+        case 'utf8': {
             const dec = utf8Decoder();
             return dec ? dec.decode(bytes) : decodeUTF8(bytes);
         }
-        case "utf-16le":
+        case 'utf-16le':
             return decodeUTF16LE(bytes);
-        case "us-ascii":
-        case "ascii":
+        case 'us-ascii':
+        case 'ascii':
             return decodeASCII(bytes);
-        case "latin1":
-        case "iso-8859-1":
+        case 'latin1':
+        case 'iso-8859-1':
             return decodeLatin1(bytes);
-        case "windows-1252":
+        case 'windows-1252':
             return decodeWindows1252(bytes);
         default:
             throw new RangeError(`Encoding '${encoding}' not supported`);
     }
 }
-export function textEncode(input = "", encoding = "utf-8") {
+export function textEncode(input = '', encoding = 'utf-8') {
     switch (encoding.toLowerCase()) {
-        case "utf-8":
-        case "utf8": {
+        case 'utf-8':
+        case 'utf8': {
             const enc = utf8Encoder();
             return enc ? enc.encode(input) : encodeUTF8(input);
         }
-        case "utf-16le":
+        case 'utf-16le':
             return encodeUTF16LE(input);
-        case "us-ascii":
-        case "ascii":
+        case 'us-ascii':
+        case 'ascii':
             return encodeASCII(input);
-        case "latin1":
-        case "iso-8859-1":
+        case 'latin1':
+        case 'iso-8859-1':
             return encodeLatin1(input);
-        case "windows-1252":
+        case 'windows-1252':
             return encodeWindows1252(input);
         default:
             throw new RangeError(`Encoding '${encoding}' not supported`);
     }
 }
-function appendCodePoint(out, cp) {
-    if (cp <= 0xffff) {
-        out.push(String.fromCharCode(cp));
-        return;
-    }
-    cp -= 0x10000;
-    out.push(String.fromCharCode(0xd800 + (cp >> 10), 0xdc00 + (cp & 0x3ff)));
-}
 function flushChunk(parts, chunk) {
-    if (chunk.length === 0)
+    if (chunk.length === 0) {
         return;
+    }
     parts.push(String.fromCharCode.apply(null, chunk));
     chunk.length = 0;
 }
 function pushCodeUnit(parts, chunk, codeUnit) {
     chunk.push(codeUnit);
-    if (chunk.length >= CHUNK)
+    if (chunk.length >= CHUNK) {
         flushChunk(parts, chunk);
+    }
 }
 function pushCodePoint(parts, chunk, cp) {
     if (cp <= 0xffff) {
@@ -101,10 +129,7 @@ function decodeUTF8(bytes) {
     const chunk = [];
     let i = 0;
     // Match TextDecoder("utf-8") default BOM handling
-    if (bytes.length >= 3 &&
-        bytes[0] === 0xef &&
-        bytes[1] === 0xbb &&
-        bytes[2] === 0xbf) {
+    if (bytes.length >= 3 && bytes[0] === 0xef && bytes[1] === 0xbb && bytes[2] === 0xbf) {
         i = 3;
     }
     while (i < bytes.length) {
@@ -120,83 +145,38 @@ function decodeUTF8(bytes) {
             i++;
             continue;
         }
-        // 2-byte sequence
-        if (b1 <= 0xdf) {
-            if (i + 1 >= bytes.length) {
-                pushCodeUnit(parts, chunk, REPLACEMENT);
-                i++;
-                continue;
-            }
-            const b2 = bytes[i + 1];
-            if ((b2 & 0xc0) !== 0x80) {
-                pushCodeUnit(parts, chunk, REPLACEMENT);
-                i++;
-                continue;
-            }
-            const cp = ((b1 & 0x1f) << 6) | (b2 & 0x3f);
-            pushCodeUnit(parts, chunk, cp);
-            i += 2;
-            continue;
-        }
-        // 3-byte sequence
-        if (b1 <= 0xef) {
-            if (i + 2 >= bytes.length) {
-                pushCodeUnit(parts, chunk, REPLACEMENT);
-                i++;
-                continue;
+        const length = b1 <= 0xdf ? 2 : b1 <= 0xef ? 3 : 4;
+        let cp = b1 & (0x7f >> length);
+        let lower = b1 === 0xe0 ? 0xa0 : b1 === 0xf0 ? 0x90 : 0x80;
+        let upper = b1 === 0xed ? 0x9f : b1 === 0xf4 ? 0x8f : 0xbf;
+        let consumed = 1;
+        i++;
+        // Consume only the valid prefix. An interrupting byte starts a new sequence.
+        while (consumed < length && i < bytes.length) {
+            const next = bytes[i];
+            if (next < lower || next > upper) {
+                break;
             }
-            const b2 = bytes[i + 1];
-            const b3 = bytes[i + 2];
-            const valid = (b2 & 0xc0) === 0x80 &&
-                (b3 & 0xc0) === 0x80 &&
-                !(b1 === 0xe0 && b2 < 0xa0) && // overlong
-                !(b1 === 0xed && b2 >= 0xa0); // surrogate range
-            if (!valid) {
-                pushCodeUnit(parts, chunk, REPLACEMENT);
-                i++;
-                continue;
-            }
-            const cp = ((b1 & 0x0f) << 12) |
-                ((b2 & 0x3f) << 6) |
-                (b3 & 0x3f);
-            pushCodeUnit(parts, chunk, cp);
-            i += 3;
-            continue;
-        }
-        // 4-byte sequence
-        if (i + 3 >= bytes.length) {
-            pushCodeUnit(parts, chunk, REPLACEMENT);
-            i++;
-            continue;
-        }
-        const b2 = bytes[i + 1];
-        const b3 = bytes[i + 2];
-        const b4 = bytes[i + 3];
-        const valid = (b2 & 0xc0) === 0x80 &&
-            (b3 & 0xc0) === 0x80 &&
-            (b4 & 0xc0) === 0x80 &&
-            !(b1 === 0xf0 && b2 < 0x90) && // overlong
-            !(b1 === 0xf4 && b2 > 0x8f); // > U+10FFFF
-        if (!valid) {
-            pushCodeUnit(parts, chunk, REPLACEMENT);
+            cp = (cp << 6) | (next & 0x3f);
+            consumed++;
             i++;
-            continue;
+            lower = 0x80;
+            upper = 0xbf;
         }
-        const cp = ((b1 & 0x07) << 18) |
-            ((b2 & 0x3f) << 12) |
-            ((b3 & 0x3f) << 6) |
-            (b4 & 0x3f);
-        pushCodePoint(parts, chunk, cp);
-        i += 4;
+        pushCodePoint(parts, chunk, consumed === length ? cp : REPLACEMENT);
     }
     flushChunk(parts, chunk);
-    return parts.join("");
+    return parts.join('');
 }
 function decodeUTF16LE(bytes) {
     const parts = [];
     const chunk = [];
     const len = bytes.length;
     let i = 0;
+    // Match TextDecoder("utf-16le") default BOM handling
+    if (len >= 2 && bytes[0] === 0xff && bytes[1] === 0xfe) {
+        i = 2;
+    }
     while (i + 1 < len) {
         const u1 = bytes[i] | (bytes[i + 1] << 8);
         i += 2;
@@ -230,7 +210,7 @@ function decodeUTF16LE(bytes) {
         pushCodeUnit(parts, chunk, REPLACEMENT);
     }
     flushChunk(parts, chunk);
-    return parts.join("");
+    return parts.join('');
 }
 function decodeASCII(bytes) {
     const parts = [];
@@ -242,7 +222,7 @@ function decodeASCII(bytes) {
         }
         parts.push(String.fromCharCode.apply(null, codes));
     }
-    return parts.join("");
+    return parts.join('');
 }
 function decodeLatin1(bytes) {
     const parts = [];
@@ -254,23 +234,24 @@ function decodeLatin1(bytes) {
         }
         parts.push(String.fromCharCode.apply(null, codes));
     }
-    return parts.join("");
+    return parts.join('');
 }
 function decodeWindows1252(bytes) {
     const parts = [];
-    let out = "";
+    let out = '';
     for (let i = 0; i < bytes.length; i++) {
         const b = bytes[i];
         const extra = b >= 0x80 && b <= 0x9f ? WINDOWS_1252_EXTRA[b] : undefined;
         out += extra !== null && extra !== void 0 ? extra : String.fromCharCode(b);
         if (out.length >= CHUNK) {
             parts.push(out);
-            out = "";
+            out = '';
         }
     }
-    if (out)
+    if (out) {
         parts.push(out);
-    return parts.join("");
+    }
+    return parts.join('');
 }
 function encodeUTF8(str) {
     const out = [];
@@ -350,14 +331,16 @@ function encodeUTF16LE(str) {
 }
 function encodeASCII(str) {
     const out = new Uint8Array(str.length);
-    for (let i = 0; i < str.length; i++)
+    for (let i = 0; i < str.length; i++) {
         out[i] = str.charCodeAt(i) & 0x7f;
+    }
     return out;
 }
 function encodeLatin1(str) {
     const out = new Uint8Array(str.length);
-    for (let i = 0; i < str.length; i++)
+    for (let i = 0; i < str.length; i++) {
         out[i] = str.charCodeAt(i) & 0xff;
+    }
     return out;
 }
 function encodeWindows1252(str) {
@@ -369,8 +352,7 @@ function encodeWindows1252(str) {
             out[i] = WINDOWS_1252_REVERSE[ch];
             continue;
         }
-        if ((code >= 0x00 && code <= 0x7f) ||
-            (code >= 0xa0 && code <= 0xff)) {
+        if ((code >= 0x00 && code <= 0x7f) || (code >= 0xa0 && code <= 0xff)) {
             out[i] = code;
             continue;
         }