@capgo/capacitor-fast-sql 8.2.11 → 8.2.12

package/README.md

@@ -2,7 +2,7 @@
 
 Run SQLite fast in your Capacitor app: queries go through a local HTTP channel instead of the bridge, so large result sets and sync jobs stay quick. A practical replacement for IndexedDB, with optional encryption.
 
-<a href="https://capgo.app/?ref=plugin_fast_sql"><img src="https://capgo.app/readme-banner.svg?repo=Cap-go/capacitor-fast-sql" alt="Capgo - Instant updates for Capacitor" /></a>
+<a href="https://capgo.app/?ref=plugin_fast_sql"><img src="https://capgo.app/readme-banner.svg?repo=Cap-go/capacitor-fast-sql" alt="Capgo - Build Capacitor apps with AI, ship updates instantly" /></a>
 
 <div align="center">
   <p><b>Capgo</b>: push fixes to your Capacitor users in minutes, build signed iOS and Android apps without a Mac, and roll back in one click.</p>
@@ -10,6 +10,8 @@ Run SQLite fast in your Capacitor app: queries go through a local HTTP channel i
   <p>14-day unlimited free trial. No credit card required</p>
   <p><a href="https://capgo.app/consulting/?ref=plugin_fast_sql">Missing a feature? We'll build the plugin for you 💪</a></p>
 </div>
+
+> 🤖 **Building with an AI coding agent?** Install [Capgo skills](https://capgo.app/skills/?ref=plugin_fast_sql) so Claude Code, Codex, Cursor, Copilot, or Gemini CLI know how to install and use `@capgo/capacitor-fast-sql` in your Capacitor app: `npx skills add Cap-go/capgo-skills`. Then ask your agent: *"Add @capgo/capacitor-fast-sql to my Capacitor app and wire it up."* [Agent setup guides](https://capgo.app/agents/?ref=plugin_fast_sql) · [Hosted MCP](https://capgo.app/docs/ai/mcp/?ref=plugin_fast_sql)
 
 <p align="center">
   <img src="https://raw.githubusercontent.com/Cap-go/capacitor-fast-sql/main/assets/github-social-preview.png" alt="@capgo/capacitor-fast-sql for Capacitor apps" width="300" />

package/android/build.gradle

@@ -40,6 +40,9 @@ android {
         sourceCompatibility JavaVersion.VERSION_21
         targetCompatibility JavaVersion.VERSION_21
     }
+    testOptions {
+        unitTests.includeAndroidResources = true
+    }
 }
 
 repositories {
@@ -52,10 +55,10 @@ dependencies {
     implementation project(':capacitor-android')
     implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
     implementation 'androidx.sqlite:sqlite:2.7.1'
-    implementation 'com.google.code.gson:gson:2.14.0'
     implementation 'org.nanohttpd:nanohttpd:2.3.1'
     compileOnly 'net.zetetic:sqlcipher-android:4.19.1'
     testImplementation "junit:junit:$junitVersion"
+    testImplementation 'org.robolectric:robolectric:4.16'
     androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion"
     androidTestImplementation "androidx.test.espresso:espresso-core:$androidxEspressoCoreVersion"
 }

package/android/src/main/java/app/capgo/capacitor/fastsql/CapgoCapacitorFastSqlPlugin.java

@@ -19,7 +19,7 @@ import java.util.Map;
 @CapacitorPlugin(name = "CapgoCapacitorFastSql")
 public class CapgoCapacitorFastSqlPlugin extends Plugin {
 
-    private final String pluginVersion = "8.2.11";
+    private final String pluginVersion = "8.2.12";
 
     private Map<String, DatabaseConnection> databases = new HashMap<>();
     private SQLHTTPServer server;

package/android/src/main/java/app/capgo/capacitor/fastsql/HttpRequestJsonParams.java

@@ -0,0 +1,413 @@
+package app.capgo.capacitor.fastsql;
+
+import com.getcapacitor.JSArray;
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+import org.json.JSONTokener;
+
+/**
+ * Converts HTTP request JSON parameter arrays to {@link JSArray} values with the same
+ * semantics as the previous Gson-based parsing in {@link SQLHTTPServer}.
+ */
+final class HttpRequestJsonParams {
+
+    private static final int MAX_NUMBER_STRING_LENGTH = 10_000;
+
+    private HttpRequestJsonParams() {}
+
+    static void populateJsArrayFromParamsJson(JSONArray paramsJson, JSArray params) throws JSONException {
+        populateJsArrayFromParamsJson(paramsJson, params, null);
+    }
+
+    static void populateJsArrayFromParamsJson(JSONArray paramsJson, JSArray params, String rawParamsArrayJson) throws JSONException {
+        List<String> rawElements = rawParamsArrayJson != null ? splitTopLevelJsonArrayElements(rawParamsArrayJson) : null;
+        for (int i = 0; i < paramsJson.length(); i++) {
+            String rawElement = rawElements != null && i < rawElements.size() ? rawElements.get(i) : null;
+            Object converted =
+                rawElement != null ? convertRequestParamFromRawJson(rawElement, paramsJson.get(i)) : convertRequestParam(paramsJson.get(i));
+            if (converted != null) {
+                params.put(converted);
+            }
+        }
+    }
+
+    static String extractJsonArrayAfterKey(String json, String key) throws JSONException {
+        int i = skipWhitespace(json, 0);
+        if (i >= json.length() || json.charAt(i) != '{') {
+            throw new JSONException("Expected JSON object");
+        }
+        i++;
+        String found = null;
+        boolean sawMatchingKey = false;
+        while (i < json.length()) {
+            i = skipWhitespace(json, i);
+            if (json.charAt(i) == '}') {
+                if (found != null) {
+                    return found;
+                }
+                if (sawMatchingKey) {
+                    throw new JSONException("No array for key: " + key);
+                }
+                throw new JSONException("No key: " + key);
+            }
+            int keyEnd = endOfJsonString(json, i);
+            String memberKey = parseQuotedStringToken(json, i, keyEnd);
+            i = skipWhitespace(json, keyEnd);
+            if (json.charAt(i) != ':') {
+                throw new JSONException("Expected ':' after object key");
+            }
+            i = skipWhitespace(json, i + 1);
+            if (memberKey.equals(key)) {
+                sawMatchingKey = true;
+                i = skipWhitespace(json, i);
+                if (i < json.length() && json.charAt(i) == '[') {
+                    int end = indexOfMatchingBracket(json, i, '[', ']');
+                    found = json.substring(i, end + 1);
+                    i = end + 1;
+                } else {
+                    found = null;
+                    i = endOfJsonValue(json, i);
+                }
+            } else {
+                i = endOfJsonValue(json, i);
+            }
+            i = skipWhitespace(json, i);
+            if (i < json.length() && json.charAt(i) == ',') {
+                i++;
+            }
+        }
+        if (found != null) {
+            return found;
+        }
+        if (sawMatchingKey) {
+            throw new JSONException("No array for key: " + key);
+        }
+        throw new JSONException("No key: " + key);
+    }
+
+    /**
+     * Converts one JSON param value for {@link JSArray#put(Object)}.
+     *
+     * @return converted value, or {@code null} to skip unsupported values (e.g. nested arrays)
+     */
+    static Object convertRequestParam(Object param) {
+        if (param == JSONObject.NULL) {
+            return JSONObject.NULL;
+        }
+        if (param instanceof Boolean) {
+            return param;
+        }
+        if (param instanceof Number) {
+            return convertNumberLikeGson((Number) param);
+        }
+        if (param instanceof String) {
+            return param;
+        }
+        if (param instanceof JSONObject) {
+            JSONObject obj = (JSONObject) param;
+            JSONObject jsonObj = new JSONObject();
+            Iterator<String> keys = obj.keys();
+            while (keys.hasNext()) {
+                String key = keys.next();
+                try {
+                    jsonObj.put(key, elementGetAsString(obj.get(key)));
+                } catch (JSONException e) {
+                    throw new IllegalStateException(e);
+                }
+            }
+            return jsonObj;
+        }
+        return null;
+    }
+
+    static Object convertRequestParamFromRawJson(String rawElement, Object parsedFallback) {
+        String raw = rawElement.trim();
+        if (raw.startsWith("{")) {
+            return convertFlatObjectParamFromRawJson(raw);
+        }
+        if (raw.startsWith("[")) {
+            return null;
+        }
+        if (raw.equals("null")) {
+            return JSONObject.NULL;
+        }
+        if (raw.equals("true") || raw.equals("false")) {
+            return Boolean.parseBoolean(raw);
+        }
+        if (raw.startsWith("\"")) {
+            try {
+                return new JSONTokener(raw).nextValue();
+            } catch (JSONException e) {
+                throw new IllegalStateException(e);
+            }
+        }
+        return convertNumberLikeGsonFromLiteral(raw);
+    }
+
+    /** Mirrors Gson {@code JsonElement#getAsString()} for object field values. */
+    static String elementGetAsString(Object value) {
+        if (value == null || value == JSONObject.NULL) {
+            throw new IllegalStateException("Cannot get string from null");
+        }
+        if (value instanceof String) {
+            return (String) value;
+        }
+        if (value instanceof Number) {
+            try {
+                return JSONObject.numberToString((Number) value);
+            } catch (JSONException e) {
+                throw new IllegalStateException(e);
+            }
+        }
+        if (value instanceof Boolean) {
+            return value.toString();
+        }
+        if (value instanceof JSONObject || value instanceof JSONArray) {
+            throw new IllegalStateException("Cannot get string from non-primitive");
+        }
+        return String.valueOf(value);
+    }
+
+    static String elementGetAsStringFromRawToken(String token) {
+        String raw = token.trim();
+        if (raw.equals("null")) {
+            throw new IllegalStateException("Cannot get string from null");
+        }
+        if (raw.startsWith("{") || raw.startsWith("[")) {
+            throw new IllegalStateException("Cannot get string from non-primitive");
+        }
+        if (raw.startsWith("\"")) {
+            try {
+                Object value = new JSONTokener(raw).nextValue();
+                if (value instanceof String) {
+                    return (String) value;
+                }
+            } catch (JSONException e) {
+                throw new IllegalStateException(e);
+            }
+        }
+        if (raw.equals("true") || raw.equals("false")) {
+            return raw;
+        }
+        return raw;
+    }
+
+    /**
+     * Mirrors Gson {@code JsonPrimitive#getAsLong()} with {@code getAsDouble()} fallback on
+     * {@link NumberFormatException}, using LazilyParsedNumber-style parsing on the number's text.
+     */
+    static Number convertNumberLikeGson(Number number) {
+        return convertNumberLikeGsonFromLiteral(numberToJsonNumberString(number));
+    }
+
+    static Number convertNumberLikeGsonFromLiteral(String literal) {
+        try {
+            return gsonStyleLongFromNumberString(literal);
+        } catch (NumberFormatException e) {
+            return gsonStyleDoubleFromNumberString(literal, Double.parseDouble(literal));
+        }
+    }
+
+    static long gsonStyleLongFromNumberString(String s) {
+        checkNumberStringLength(s);
+        try {
+            return Long.parseLong(s);
+        } catch (NumberFormatException e) {
+            return parseBigDecimalLikeGson(s).longValue();
+        }
+    }
+
+    static double gsonStyleDoubleFromNumberString(String s, Number number) {
+        try {
+            return Double.parseDouble(s);
+        } catch (NumberFormatException e) {
+            return number.doubleValue();
+        }
+    }
+
+    static String numberToJsonNumberString(Number number) {
+        if (number instanceof BigDecimal) {
+            return ((BigDecimal) number).toPlainString();
+        }
+        return number.toString();
+    }
+
+    static JSONObject convertFlatObjectParamFromRawJson(String raw) {
+        JSONObject out = new JSONObject();
+        int i = skipWhitespace(raw, 1);
+        while (true) {
+            i = skipWhitespace(raw, i);
+            if (raw.charAt(i) == '}') {
+                break;
+            }
+            int keyEnd = endOfJsonString(raw, i);
+            String key;
+            try {
+                key = (String) new JSONTokener(raw.substring(i, keyEnd)).nextValue();
+            } catch (JSONException e) {
+                throw new IllegalStateException(e);
+            }
+            i = skipWhitespace(raw, keyEnd);
+            if (raw.charAt(i) != ':') {
+                throw new IllegalStateException("Expected ':' after object key");
+            }
+            i = skipWhitespace(raw, i + 1);
+            int valueEnd = endOfJsonValue(raw, i);
+            String valueToken = raw.substring(i, valueEnd);
+            try {
+                out.put(key, elementGetAsStringFromRawToken(valueToken));
+            } catch (JSONException e) {
+                throw new IllegalStateException(e);
+            }
+            i = skipWhitespace(raw, valueEnd);
+            if (i < raw.length() && raw.charAt(i) == ',') {
+                i++;
+            }
+        }
+        return out;
+    }
+
+    static List<String> splitTopLevelJsonArrayElements(String arrayJson) {
+        String trimmed = arrayJson.trim();
+        if (trimmed.length() < 2 || trimmed.charAt(0) != '[') {
+            throw new IllegalStateException("Not a JSON array");
+        }
+        List<String> elements = new ArrayList<>();
+        int i = skipWhitespace(trimmed, 1);
+        while (true) {
+            i = skipWhitespace(trimmed, i);
+            if (trimmed.charAt(i) == ']') {
+                break;
+            }
+            int end = endOfJsonValue(trimmed, i);
+            elements.add(trimmed.substring(i, end));
+            i = skipWhitespace(trimmed, end);
+            if (trimmed.charAt(i) == ',') {
+                i++;
+            }
+        }
+        return elements;
+    }
+
+    static int endOfJsonValue(String s, int start) {
+        start = skipWhitespace(s, start);
+        char c = s.charAt(start);
+        if (c == '"') {
+            return endOfJsonString(s, start);
+        }
+        if (c == '{') {
+            return indexOfMatchingBracket(s, start, '{', '}') + 1;
+        }
+        if (c == '[') {
+            return indexOfMatchingBracket(s, start, '[', ']') + 1;
+        }
+        if (s.startsWith("null", start)) {
+            return start + 4;
+        }
+        if (s.startsWith("true", start)) {
+            return start + 4;
+        }
+        if (s.startsWith("false", start)) {
+            return start + 5;
+        }
+        int i = start;
+        while (i < s.length()) {
+            char ch = s.charAt(i);
+            if (ch == ',' || ch == ']' || ch == '}' || Character.isWhitespace(ch)) {
+                break;
+            }
+            i++;
+        }
+        return i;
+    }
+
+    static int endOfJsonString(String s, int start) {
+        if (s.charAt(start) != '"') {
+            throw new IllegalStateException("Expected string");
+        }
+        boolean escape = false;
+        for (int i = start + 1; i < s.length(); i++) {
+            char c = s.charAt(i);
+            if (escape) {
+                escape = false;
+                continue;
+            }
+            if (c == '\\') {
+                escape = true;
+                continue;
+            }
+            if (c == '"') {
+                return i + 1;
+            }
+        }
+        throw new IllegalStateException("Unterminated string");
+    }
+
+    static int indexOfMatchingBracket(String s, int openIdx, char open, char close) {
+        int depth = 0;
+        boolean inString = false;
+        boolean escape = false;
+        for (int i = openIdx; i < s.length(); i++) {
+            char c = s.charAt(i);
+            if (escape) {
+                escape = false;
+                continue;
+            }
+            if (inString && c == '\\') {
+                escape = true;
+                continue;
+            }
+            if (c == '"') {
+                inString = !inString;
+                continue;
+            }
+            if (inString) {
+                continue;
+            }
+            if (c == open) {
+                depth++;
+            } else if (c == close) {
+                depth--;
+                if (depth == 0) {
+                    return i;
+                }
+            }
+        }
+        throw new IllegalStateException("Unbalanced brackets");
+    }
+
+    static int skipWhitespace(String s, int index) {
+        while (index < s.length() && Character.isWhitespace(s.charAt(index))) {
+            index++;
+        }
+        return index;
+    }
+
+    static String parseQuotedStringToken(String json, int start, int end) throws JSONException {
+        try {
+            return (String) new JSONTokener(json.substring(start, end)).nextValue();
+        } catch (JSONException e) {
+            throw new JSONException("Invalid object key", e);
+        }
+    }
+
+    private static void checkNumberStringLength(String s) {
+        if (s.length() > MAX_NUMBER_STRING_LENGTH) {
+            throw new NumberFormatException("Number string too large");
+        }
+    }
+
+    private static BigDecimal parseBigDecimalLikeGson(String s) {
+        checkNumberStringLength(s);
+        BigDecimal decimal = new BigDecimal(s);
+        if (Math.abs((long) decimal.scale()) >= 10_000) {
+            throw new NumberFormatException("Number has unsupported scale");
+        }
+        return decimal;
+    }
+}

package/android/src/main/java/app/capgo/capacitor/fastsql/SQLHTTPServer.java

@@ -2,16 +2,12 @@ package app.capgo.capacitor.fastsql;
 
 import com.getcapacitor.JSArray;
 import com.getcapacitor.JSObject;
-import com.google.gson.Gson;
-import com.google.gson.JsonArray;
-import com.google.gson.JsonElement;
-import com.google.gson.JsonObject;
-import com.google.gson.JsonParser;
 import fi.iki.elonen.NanoHTTPD; // Note: org.nanohttpd:nanohttpd:2.3.1 still uses fi.iki.elonen package
 import java.io.DataInputStream;
 import java.io.IOException;
 import java.nio.charset.StandardCharsets;
 import java.security.SecureRandom;
+import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
@@ -29,7 +25,6 @@ public class SQLHTTPServer extends NanoHTTPD {
 
     private final String token;
     private final Map<String, DatabaseConnection> databases;
-    private final Gson gson = new Gson();
     private final ExecutorService requestExecutor = Executors.newSingleThreadExecutor((runnable) -> {
         Thread thread = new Thread(runnable);
         thread.setName("FastSQL-DB");
@@ -120,37 +115,14 @@ public class SQLHTTPServer extends NanoHTTPD {
     private Response handleExecute(IHTTPSession session, DatabaseConnection db) throws Exception {
         // Read request body
         String body = readRequestBody(session);
-        JsonObject request = JsonParser.parseString(body).getAsJsonObject();
+        JSONObject request = new JSONObject(body);
 
-        String statement = request.get("statement").getAsString();
-        JsonArray paramsJson = request.has("params") ? request.getAsJsonArray("params") : new JsonArray();
+        String statement = request.getString("statement");
+        JSONArray paramsJson = request.has("params") ? request.getJSONArray("params") : new JSONArray();
 
-        // Convert to JSArray
         JSArray params = new JSArray();
-        for (JsonElement param : paramsJson) {
-            if (param.isJsonNull()) {
-                params.put(JSONObject.NULL);
-            } else if (param.isJsonPrimitive()) {
-                if (param.getAsJsonPrimitive().isNumber()) {
-                    try {
-                        params.put(param.getAsLong());
-                    } catch (NumberFormatException e) {
-                        params.put(param.getAsDouble());
-                    }
-                } else if (param.getAsJsonPrimitive().isBoolean()) {
-                    params.put(param.getAsBoolean());
-                } else {
-                    params.put(param.getAsString());
-                }
-            } else if (param.isJsonObject()) {
-                JsonObject obj = param.getAsJsonObject();
-                JSONObject jsonObj = new JSONObject();
-                for (String key : obj.keySet()) {
-                    jsonObj.put(key, obj.get(key).getAsString());
-                }
-                params.put(jsonObj);
-            }
-        }
+        String rawParamsArray = request.has("params") ? HttpRequestJsonParams.extractJsonArrayAfterKey(body, "params") : null;
+        HttpRequestJsonParams.populateJsArrayFromParamsJson(paramsJson, params, rawParamsArray);
 
         // Execute query
         JSObject result = db.execute(statement, params);
@@ -163,41 +135,21 @@ public class SQLHTTPServer extends NanoHTTPD {
     private Response handleBatch(IHTTPSession session, DatabaseConnection db) throws Exception {
         // Read request body
         String body = readRequestBody(session);
-        JsonObject request = JsonParser.parseString(body).getAsJsonObject();
-        JsonArray operations = request.getAsJsonArray("operations");
+        JSONObject request = new JSONObject(body);
+        JSONArray operations = request.getJSONArray("operations");
 
         JSONArray results = new JSONArray();
-        for (JsonElement opElement : operations) {
-            JsonObject operation = opElement.getAsJsonObject();
-            String statement = operation.get("statement").getAsString();
-            JsonArray paramsJson = operation.has("params") ? operation.getAsJsonArray("params") : new JsonArray();
+        String rawOperationsArray = HttpRequestJsonParams.extractJsonArrayAfterKey(body, "operations");
+        List<String> rawOperations = HttpRequestJsonParams.splitTopLevelJsonArrayElements(rawOperationsArray);
+        for (int i = 0; i < operations.length(); i++) {
+            JSONObject operation = operations.getJSONObject(i);
+            String statement = operation.getString("statement");
+            JSONArray paramsJson = operation.has("params") ? operation.getJSONArray("params") : new JSONArray();
 
-            // Convert to JSArray
             JSArray params = new JSArray();
-            for (JsonElement param : paramsJson) {
-                if (param.isJsonNull()) {
-                    params.put(JSONObject.NULL);
-                } else if (param.isJsonPrimitive()) {
-                    if (param.getAsJsonPrimitive().isNumber()) {
-                        try {
-                            params.put(param.getAsLong());
-                        } catch (NumberFormatException e) {
-                            params.put(param.getAsDouble());
-                        }
-                    } else if (param.getAsJsonPrimitive().isBoolean()) {
-                        params.put(param.getAsBoolean());
-                    } else {
-                        params.put(param.getAsString());
-                    }
-                } else if (param.isJsonObject()) {
-                    JsonObject obj = param.getAsJsonObject();
-                    JSONObject jsonObj = new JSONObject();
-                    for (String key : obj.keySet()) {
-                        jsonObj.put(key, obj.get(key).getAsString());
-                    }
-                    params.put(jsonObj);
-                }
-            }
+            String rawOperation = rawOperations.get(i);
+            String rawParamsArray = operation.has("params") ? HttpRequestJsonParams.extractJsonArrayAfterKey(rawOperation, "params") : null;
+            HttpRequestJsonParams.populateJsArrayFromParamsJson(paramsJson, params, rawParamsArray);
 
             JSObject result = db.execute(statement, params);
             results.put(new JSONObject(result.toString()));

package/ios/Sources/CapgoCapacitorFastSqlPlugin/CapgoCapacitorFastSqlPlugin.swift

@@ -10,7 +10,7 @@ import SQLite3
  */
 @objc(CapgoCapacitorFastSqlPlugin)
 public class CapgoCapacitorFastSqlPlugin: CAPPlugin, CAPBridgedPlugin {
-    private let pluginVersion: String = "8.2.11"
+    private let pluginVersion: String = "8.2.12"
     public let identifier = "CapgoCapacitorFastSqlPlugin"
     public let jsName = "CapgoCapacitorFastSql"
     public let pluginMethods: [CAPPluginMethod] = [

package/ios/Sources/CapgoCapacitorFastSqlPlugin/SQLDatabase.swift

@@ -50,12 +50,11 @@ class SQLDatabase {
                 throw SQLError.encryptionKeyMissing
             }
             #if canImport(SQLCipher)
-            guard let keyData = key.data(using: .utf8) else {
-                throw SQLError.encryptionFailed(message: "Invalid encryption key encoding")
-            }
-            let keyResult = keyData.withUnsafeBytes { bytes in
-                sqlite3_key(db, bytes.baseAddress, Int32(keyData.count))
-            }
+            // `PRAGMA key` is SQLCipher's SQL interface to sqlite3_key(). It avoids
+            // calling sqlite3_key() directly, which SQLCipher's headers only declare
+            // when SQLITE_HAS_CODEC is defined for the importing target.
+            let escapedKey = key.replacingOccurrences(of: "'", with: "''")
+            let keyResult = sqlite3_exec(db, "PRAGMA key = '\(escapedKey)'", nil, nil, nil)
             if keyResult != SQLITE_OK {
                 let error = String(cString: sqlite3_errmsg(db))
                 throw SQLError.encryptionFailed(message: error)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capgo/capacitor-fast-sql",
-  "version": "8.2.11",
+  "version": "8.2.12",
   "description": "High-performance native SQLite plugin with custom protocol for efficient sync operations and IndexedDB replacement",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",