one 2.6.20 → 2.6.22

package/cpp/HybridOneCrypto.cpp

@@ -1,11 +1,14 @@
 #include "HybridOneCrypto.hpp"
 
 #include <algorithm>
+#include <array>
+#include <optional>
 #include <cstring>
 #include <vector>
 #ifdef __ANDROID__
 #include <fbjni/fbjni.h>
 #else
+#include <CommonCrypto/CommonCryptor.h>
 #include <CommonCrypto/CommonDigest.h>
 #endif
 #include <cmath>
@@ -54,6 +57,94 @@ std::shared_ptr<ArrayBuffer> hash(const std::string& algorithm, const std::vecto
   digest->getRegion(0, digest->size(), reinterpret_cast<jbyte*>(output->data()));
   return output;
 }
+
+// jni resolves methods by exact descriptor, so Cipher.init's parameters are
+// declared as the api's own types, Key and AlgorithmParameterSpec, and the
+// concrete specs derive from them so they pass without a cast.
+class Key : public facebook::jni::JavaClass<Key> {
+ public:
+  static constexpr auto kJavaDescriptor = "Ljava/security/Key;";
+};
+
+class AlgorithmParameterSpec : public facebook::jni::JavaClass<AlgorithmParameterSpec> {
+ public:
+  static constexpr auto kJavaDescriptor = "Ljava/security/spec/AlgorithmParameterSpec;";
+};
+
+class SecretKeySpec : public facebook::jni::JavaClass<SecretKeySpec, Key> {
+ public:
+  static constexpr auto kJavaDescriptor = "Ljavax/crypto/spec/SecretKeySpec;";
+
+  static facebook::jni::local_ref<SecretKeySpec> create(facebook::jni::alias_ref<facebook::jni::JArrayByte> key) {
+    return newInstance(key, facebook::jni::make_jstring("AES"));
+  }
+};
+
+class GCMParameterSpec : public facebook::jni::JavaClass<GCMParameterSpec, AlgorithmParameterSpec> {
+ public:
+  static constexpr auto kJavaDescriptor = "Ljavax/crypto/spec/GCMParameterSpec;";
+
+  static facebook::jni::local_ref<GCMParameterSpec> create(jint tagBits, facebook::jni::alias_ref<facebook::jni::JArrayByte> iv) {
+    return newInstance(tagBits, iv);
+  }
+};
+
+class Cipher : public facebook::jni::JavaClass<Cipher> {
+ public:
+  static constexpr auto kJavaDescriptor = "Ljavax/crypto/Cipher;";
+  static constexpr jint ENCRYPT_MODE = 1;
+  static constexpr jint DECRYPT_MODE = 2;
+
+  static facebook::jni::local_ref<Cipher> create() {
+    static const auto method = javaClassStatic()->getStaticMethod<facebook::jni::local_ref<Cipher>(facebook::jni::alias_ref<facebook::jni::JString>)>("getInstance");
+    return method(javaClassStatic(), facebook::jni::make_jstring("AES/GCM/NoPadding"));
+  }
+
+  void init(jint mode, facebook::jni::alias_ref<SecretKeySpec> key, facebook::jni::alias_ref<GCMParameterSpec> spec) {
+    static const auto method = javaClassStatic()->getMethod<void(jint, facebook::jni::alias_ref<Key>, facebook::jni::alias_ref<AlgorithmParameterSpec>)>("init");
+    method(self(), mode, key, spec);
+  }
+
+  void updateAAD(facebook::jni::alias_ref<facebook::jni::JArrayByte> aad) {
+    static const auto method = javaClassStatic()->getMethod<void(facebook::jni::alias_ref<facebook::jni::JArrayByte>)>("updateAAD");
+    method(self(), aad);
+  }
+
+  facebook::jni::local_ref<facebook::jni::JArrayByte> doFinal(facebook::jni::alias_ref<facebook::jni::JArrayByte> input) {
+    static const auto method = javaClassStatic()->getMethod<facebook::jni::local_ref<facebook::jni::JArrayByte>(facebook::jni::alias_ref<facebook::jni::JArrayByte>)>("doFinal");
+    return method(self(), input);
+  }
+};
+
+facebook::jni::local_ref<facebook::jni::JArrayByte> toJavaBytes(const std::vector<uint8_t>& bytes) {
+  auto out = facebook::jni::JArrayByte::newArray(bytes.size());
+  if (!bytes.empty()) out->setRegion(0, static_cast<jint>(bytes.size()), reinterpret_cast<const jbyte*>(bytes.data()));
+  return out;
+}
+
+std::shared_ptr<ArrayBuffer> fromJavaBytes(facebook::jni::alias_ref<facebook::jni::JArrayByte> bytes) {
+  auto out = ArrayBuffer::allocate(bytes->size());
+  if (bytes->size() > 0) bytes->getRegion(0, bytes->size(), reinterpret_cast<jbyte*>(out->data()));
+  return out;
+}
+
+// javax.crypto does the whole AEAD: seal appends the tag, open verifies it
+// and throws AEADBadTagException, which surfaces here as a jni exception.
+std::shared_ptr<ArrayBuffer> aesGcm(bool encrypt, const std::vector<uint8_t>& key, const std::vector<uint8_t>& iv,
+                                    const std::vector<uint8_t>& input, const std::optional<std::vector<uint8_t>>& aad,
+                                    size_t tagLength) {
+  facebook::jni::ThreadScope scope;
+  auto cipher = Cipher::create();
+  auto spec = GCMParameterSpec::create(static_cast<jint>(tagLength * 8), toJavaBytes(iv));
+  cipher->init(encrypt ? Cipher::ENCRYPT_MODE : Cipher::DECRYPT_MODE, SecretKeySpec::create(toJavaBytes(key)), spec);
+  if (aad && !aad->empty()) cipher->updateAAD(toJavaBytes(*aad));
+  try {
+    return fromJavaBytes(cipher->doFinal(toJavaBytes(input)));
+  } catch (const std::exception&) {
+    if (!encrypt) throw std::runtime_error("aesDecrypt: authentication failed");
+    throw;
+  }
+}
 #else
 template <typename Context, auto Init, auto Update, auto Final>
 std::shared_ptr<ArrayBuffer> hashApple(const std::vector<uint8_t>& input, size_t size) {
@@ -72,18 +163,186 @@ std::shared_ptr<ArrayBuffer> hashApple(const std::vector<uint8_t>& input, size_t
 }
 
 std::shared_ptr<ArrayBuffer> hash(const std::string& algorithm, const std::vector<uint8_t>& input) {
+  if (algorithm == "MD5") return hashApple<CC_MD5_CTX, CC_MD5_Init, CC_MD5_Update, CC_MD5_Final>(input, CC_MD5_DIGEST_LENGTH);
   if (algorithm == "SHA-1") return hashApple<CC_SHA1_CTX, CC_SHA1_Init, CC_SHA1_Update, CC_SHA1_Final>(input, CC_SHA1_DIGEST_LENGTH);
   if (algorithm == "SHA-256") return hashApple<CC_SHA256_CTX, CC_SHA256_Init, CC_SHA256_Update, CC_SHA256_Final>(input, CC_SHA256_DIGEST_LENGTH);
   if (algorithm == "SHA-384") return hashApple<CC_SHA512_CTX, CC_SHA384_Init, CC_SHA384_Update, CC_SHA384_Final>(input, CC_SHA384_DIGEST_LENGTH);
   if (algorithm == "SHA-512") return hashApple<CC_SHA512_CTX, CC_SHA512_Init, CC_SHA512_Update, CC_SHA512_Final>(input, CC_SHA512_DIGEST_LENGTH);
   throw std::runtime_error("unsupported digest algorithm");
 }
+
+// AES-GCM over CommonCrypto's public AES block primitive: the public headers
+// have no GCM helper, so CTR and GHASH are composed here per NIST SP
+// 800-38D. counter blocks are encrypted in one ECB pass (ECB over distinct
+// counters is exactly GCM's CTR keystream), and the tag is always 16 bytes,
+// as in expo-crypto on apple platforms.
+using Block = std::array<uint8_t, 16>;
+
+void aesEcb(const std::vector<uint8_t>& key, const uint8_t* input, size_t length, uint8_t* output) {
+  CCCryptorRef cryptor = nullptr;
+  auto status = CCCryptorCreateWithMode(kCCEncrypt, kCCModeECB, kCCAlgorithmAES, ccNoPadding, nullptr, key.data(),
+                                        key.size(), nullptr, 0, 0, 0, &cryptor);
+  if (status != kCCSuccess || cryptor == nullptr) throw std::runtime_error("aes: cipher creation failed");
+  size_t moved = 0;
+  status = CCCryptorUpdate(cryptor, input, length, output, length, &moved);
+  CCCryptorRelease(cryptor);
+  if (status != kCCSuccess || moved != length) throw std::runtime_error("aes: block encryption failed");
+}
+
+Block aesBlock(const std::vector<uint8_t>& key, const Block& input) {
+  Block output{};
+  aesEcb(key, input.data(), input.size(), output.data());
+  return output;
+}
+
+uint64_t load64(const uint8_t* at) {
+  uint64_t value = 0;
+  for (int i = 0; i < 8; i++) value = (value << 8) | at[i];
+  return value;
+}
+
+void store64(uint8_t* at, uint64_t value) {
+  for (int i = 7; i >= 0; i--) {
+    at[i] = static_cast<uint8_t>(value);
+    value >>= 8;
+  }
+}
+
+// GF(2^128) multiplication, NIST SP 800-38D algorithm 1, with the reduction
+// constant R = 11100001 || 0^120. both operands carry bits of the hash key,
+// so every step selects with masks instead of branching: the running time
+// never depends on the key.
+Block gfMultiply(const Block& x, const Block& y) {
+  uint64_t zh = 0, zl = 0;
+  uint64_t vh = load64(y.data()), vl = load64(y.data() + 8);
+  for (int i = 0; i < 16; i++) {
+    for (int bit = 7; bit >= 0; bit--) {
+      const uint64_t take = 0 - static_cast<uint64_t>((x[i] >> bit) & 1);
+      zh ^= vh & take;
+      zl ^= vl & take;
+      const uint64_t carry = 0 - (vl & 1);
+      vl = (vl >> 1) | (vh << 63);
+      vh = (vh >> 1) ^ (0xe100000000000000ULL & carry);
+    }
+  }
+  Block out{};
+  store64(out.data(), zh);
+  store64(out.data() + 8, zl);
+  return out;
+}
+
+Block ghash(const Block& h, const uint8_t* data, size_t length, Block state) {
+  for (size_t at = 0; at < length; at += 16) {
+    Block block{};
+    std::memcpy(block.data(), data + at, std::min<size_t>(16, length - at));
+    for (int i = 0; i < 16; i++) state[i] ^= block[i];
+    state = gfMultiply(state, h);
+  }
+  return state;
+}
+
+Block ghashAll(const Block& h, const std::optional<std::vector<uint8_t>>& aad, const std::vector<uint8_t>& ciphertext) {
+  Block state{};
+  if (aad && !aad->empty()) state = ghash(h, aad->data(), aad->size(), state);
+  if (!ciphertext.empty()) state = ghash(h, ciphertext.data(), ciphertext.size(), state);
+  Block lengths{};
+  store64(lengths.data(), static_cast<uint64_t>(aad ? aad->size() : 0) * 8);
+  store64(lengths.data() + 8, static_cast<uint64_t>(ciphertext.size()) * 8);
+  for (int i = 0; i < 16; i++) state[i] ^= lengths[i];
+  return gfMultiply(state, h);
+}
+
+Block initialCounter(const Block& h, const std::vector<uint8_t>& iv) {
+  if (iv.size() == 12) {
+    Block j0{};
+    std::memcpy(j0.data(), iv.data(), 12);
+    j0[15] = 1;
+    return j0;
+  }
+  Block state = ghash(h, iv.data(), iv.size(), Block{});
+  Block lengths{};
+  store64(lengths.data() + 8, static_cast<uint64_t>(iv.size()) * 8);
+  for (int i = 0; i < 16; i++) state[i] ^= lengths[i];
+  return gfMultiply(state, h);
+}
+
+void increment32(Block& counter) {
+  uint32_t low = (static_cast<uint32_t>(counter[12]) << 24) | (static_cast<uint32_t>(counter[13]) << 16) |
+                 (static_cast<uint32_t>(counter[14]) << 8) | counter[15];
+  low += 1;
+  counter[12] = static_cast<uint8_t>(low >> 24);
+  counter[13] = static_cast<uint8_t>(low >> 16);
+  counter[14] = static_cast<uint8_t>(low >> 8);
+  counter[15] = static_cast<uint8_t>(low);
+}
+
+std::vector<uint8_t> gctr(const std::vector<uint8_t>& key, Block j0, const std::vector<uint8_t>& input) {
+  std::vector<uint8_t> output(input.size());
+  if (input.empty()) return output;
+  const size_t blocks = (input.size() + 15) / 16;
+  std::vector<uint8_t> counters(blocks * 16);
+  Block counter = j0;
+  for (size_t i = 0; i < blocks; i++) {
+    increment32(counter);
+    std::memcpy(counters.data() + i * 16, counter.data(), 16);
+  }
+  std::vector<uint8_t> keystream(counters.size());
+  aesEcb(key, counters.data(), counters.size(), keystream.data());
+  for (size_t i = 0; i < input.size(); i++) output[i] = input[i] ^ keystream[i];
+  return output;
+}
+
+Block computeTag(const std::vector<uint8_t>& key, const Block& h, const Block& j0,
+                 const std::optional<std::vector<uint8_t>>& aad, const std::vector<uint8_t>& ciphertext) {
+  Block s = ghashAll(h, aad, ciphertext);
+  Block mask = aesBlock(key, j0);
+  for (int i = 0; i < 16; i++) s[i] ^= mask[i];
+  return s;
+}
+
+std::shared_ptr<ArrayBuffer> aesGcmOpen(const std::vector<uint8_t>& key, const std::vector<uint8_t>& iv,
+                                        const std::vector<uint8_t>& input, const std::optional<std::vector<uint8_t>>& aad,
+                                        size_t tagLength);
+
+std::shared_ptr<ArrayBuffer> aesGcm(bool encrypt, const std::vector<uint8_t>& key, const std::vector<uint8_t>& iv,
+                                    const std::vector<uint8_t>& input, const std::optional<std::vector<uint8_t>>& aad,
+                                    size_t tagLength) {
+  if (!encrypt) return aesGcmOpen(key, iv, input, aad, tagLength);
+  const Block h = aesBlock(key, Block{});
+  const Block j0 = initialCounter(h, iv);
+  if (encrypt) {
+    auto ciphertext = gctr(key, j0, input);
+    Block tag = computeTag(key, h, j0, aad, ciphertext);
+    auto out = ArrayBuffer::allocate(ciphertext.size() + 16);
+    if (!ciphertext.empty()) std::memcpy(out->data(), ciphertext.data(), ciphertext.size());
+    std::memcpy(out->data() + ciphertext.size(), tag.data(), 16);
+    return out;
+  }
+  throw std::runtime_error("aes: unreachable");
+}
+
+std::shared_ptr<ArrayBuffer> aesGcmOpen(const std::vector<uint8_t>& key, const std::vector<uint8_t>& iv,
+                                        const std::vector<uint8_t>& input, const std::optional<std::vector<uint8_t>>& aad,
+                                        size_t tagLength) {
+  if (input.size() < tagLength) throw std::runtime_error("aesDecrypt: authentication failed");
+  const Block h = aesBlock(key, Block{});
+  const Block j0 = initialCounter(h, iv);
+  std::vector<uint8_t> ciphertext(input.begin(), input.end() - static_cast<ptrdiff_t>(tagLength));
+  Block expected = computeTag(key, h, j0, aad, ciphertext);
+  uint8_t diff = 0;
+  for (size_t i = 0; i < tagLength; i++) diff |= expected[i] ^ input[ciphertext.size() + i];
+  if (diff != 0) throw std::runtime_error("aesDecrypt: authentication failed");
+  auto plain = gctr(key, j0, ciphertext);
+  auto out = ArrayBuffer::allocate(plain.size());
+  if (!plain.empty()) std::memcpy(out->data(), plain.data(), plain.size());
+  return out;
+}
 #endif
 } // namespace
 
 std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> HybridOneCrypto::digest(
     const std::string& algorithm, const std::shared_ptr<ArrayBuffer>& buffer, double offset, double length) {
-  if (algorithm != "SHA-1" && algorithm != "SHA-256" && algorithm != "SHA-384" && algorithm != "SHA-512") {
+  if (algorithm != "MD5" && algorithm != "SHA-1" && algorithm != "SHA-256" && algorithm != "SHA-384" && algorithm != "SHA-512") {
     throw std::runtime_error("unsupported digest algorithm");
   }
   if (!(offset >= 0 && length >= 0 && offset == std::floor(offset) && length == std::floor(length) &&
@@ -99,6 +358,73 @@ std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> HybridOneCrypto::digest(
   });
 }
 
+
+namespace {
+std::vector<uint8_t> snapshot(const std::shared_ptr<ArrayBuffer>& buffer) {
+  std::vector<uint8_t> out(buffer->size());
+  if (!out.empty()) std::memcpy(out.data(), buffer->data(), out.size());
+  return out;
+}
+
+std::optional<std::vector<uint8_t>> snapshot(const std::optional<std::shared_ptr<ArrayBuffer>>& buffer) {
+  if (!buffer) return std::nullopt;
+  return snapshot(*buffer);
+}
+
+void assertKeyAndIv(const std::vector<uint8_t>& key, const std::vector<uint8_t>& iv, const char* verb) {
+  if (key.size() != 16 && key.size() != 24 && key.size() != 32) {
+    throw std::runtime_error(std::string(verb) + ": key must be 128, 192, or 256 bits");
+  }
+  if (iv.empty()) throw std::runtime_error(std::string(verb) + ": iv must not be empty");
+}
+
+// gcm's allowed tag lengths in bytes. decrypt checks them too: a zero tag
+// would compare nothing and accept any ciphertext, and one over 16 would read
+// past the computed tag.
+void assertTagLength(double tagLength, const char* verb) {
+  for (double allowed : {16.0, 15.0, 14.0, 13.0, 12.0, 8.0, 4.0}) {
+    if (tagLength == allowed) return;
+  }
+  throw std::runtime_error(std::string(verb) + ": unsupported tag length");
+}
+} // namespace
+
+std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> HybridOneCrypto::aesEncrypt(
+    const std::shared_ptr<ArrayBuffer>& key, const std::shared_ptr<ArrayBuffer>& iv,
+    const std::shared_ptr<ArrayBuffer>& plaintext, const std::optional<std::shared_ptr<ArrayBuffer>>& additionalData,
+    double tagLength) {
+  // snapshot every input on the calling js thread, like digest: a borrowed
+  // jsi buffer must never be read on a worker or after the caller mutates it.
+  auto keyCopy = snapshot(key);
+  auto ivCopy = snapshot(iv);
+  auto plainCopy = snapshot(plaintext);
+  auto aadCopy = snapshot(additionalData);
+  assertKeyAndIv(keyCopy, ivCopy, "aesEncrypt");
+  assertTagLength(tagLength, "aesEncrypt");
+  return Promise<std::shared_ptr<ArrayBuffer>>::async(
+      [keyCopy = std::move(keyCopy), ivCopy = std::move(ivCopy), plainCopy = std::move(plainCopy),
+       aadCopy = std::move(aadCopy), tagLength]() {
+        return aesGcm(true, keyCopy, ivCopy, plainCopy, aadCopy, static_cast<size_t>(tagLength));
+      });
+}
+
+std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> HybridOneCrypto::aesDecrypt(
+    const std::shared_ptr<ArrayBuffer>& key, const std::shared_ptr<ArrayBuffer>& iv,
+    const std::shared_ptr<ArrayBuffer>& ciphertext, const std::optional<std::shared_ptr<ArrayBuffer>>& additionalData,
+    double tagLength) {
+  auto keyCopy = snapshot(key);
+  auto ivCopy = snapshot(iv);
+  auto cipherCopy = snapshot(ciphertext);
+  auto aadCopy = snapshot(additionalData);
+  assertKeyAndIv(keyCopy, ivCopy, "aesDecrypt");
+  assertTagLength(tagLength, "aesDecrypt");
+  return Promise<std::shared_ptr<ArrayBuffer>>::async(
+      [keyCopy = std::move(keyCopy), ivCopy = std::move(ivCopy), cipherCopy = std::move(cipherCopy),
+       aadCopy = std::move(aadCopy), tagLength]() {
+        return aesGcm(false, keyCopy, ivCopy, cipherCopy, aadCopy, static_cast<size_t>(tagLength));
+      });
+}
+
 void HybridOneCrypto::fillRandomBytes(const std::shared_ptr<ArrayBuffer>& buffer, double offset, double length) {
   double size = static_cast<double>(buffer->size());
   if (!(offset >= 0 && length >= 0 && offset == std::floor(offset) && length == std::floor(length) &&

package/cpp/HybridOneCrypto.hpp

@@ -16,6 +16,14 @@ class HybridOneCrypto : public HybridOneCryptoSpec {
   std::string randomUUID() override;
   std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> digest(
       const std::string& algorithm, const std::shared_ptr<ArrayBuffer>& buffer, double offset, double length) override;
+  std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> aesEncrypt(
+      const std::shared_ptr<ArrayBuffer>& key, const std::shared_ptr<ArrayBuffer>& iv,
+      const std::shared_ptr<ArrayBuffer>& plaintext, const std::optional<std::shared_ptr<ArrayBuffer>>& additionalData,
+      double tagLength) override;
+  std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> aesDecrypt(
+      const std::shared_ptr<ArrayBuffer>& key, const std::shared_ptr<ArrayBuffer>& iv,
+      const std::shared_ptr<ArrayBuffer>& ciphertext, const std::optional<std::shared_ptr<ArrayBuffer>>& additionalData,
+      double tagLength) override;
 };
 
 } // namespace margelo::nitro::one

package/dist/cjs/index.cjs

@@ -27,6 +27,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var index_exports = {};
 __export(index_exports, {
+	AESEncryptionKey: () => import_platform.AESEncryptionKey,
+	AESSealedData: () => import_platform.AESSealedData,
 	ErrorBoundary: () => import_ErrorBoundary.ErrorBoundary,
 	Head: () => import_head.Head,
 	Link: () => import_Link.Link,
@@ -51,11 +53,11 @@ __export(index_exports, {
 	createApp: () => import_createApp.createApp,
 	createMiddleware: () => import_createMiddleware.createMiddleware,
 	createRoute: () => import_createRoute.createRoute,
-	getHinge: () => import_platform.getHinge,
+	getHinge: () => import_platform2.getHinge,
 	getLinking: () => import_getLinking.getLinking,
 	getLoaderTimingHistory: () => import_useLoader.getLoaderTimingHistory,
 	getServerData: () => import_one_server_only.getServerData,
-	getSizeClass: () => import_platform.getSizeClass,
+	getSizeClass: () => import_platform2.getSizeClass,
 	getURL: () => import_getURL.getURL,
 	handleSkewError: () => import_dynamicImport.handleSkewError,
 	href: () => import_href.href,
@@ -65,7 +67,7 @@ __export(index_exports, {
 	lazyWithRetry: () => import_lazyWithRetry.lazyWithRetry,
 	loadWithRetry: () => import_dynamicImport.loadWithRetry,
 	onClientLoaderResolve: () => import_clientLoaderResolver.onClientLoaderResolve,
-	onHingeChange: () => import_platform.onHingeChange,
+	onHingeChange: () => import_platform2.onHingeChange,
 	redirect: () => import_redirect.redirect,
 	refetchLoader: () => import_useLoader.refetchLoader,
 	registerPreloadedRoute: () => import_useViteRoutes.registerPreloadedRoute,
@@ -78,39 +80,39 @@ __export(index_exports, {
 	setResponseHeaders: () => import_one_server_only.setResponseHeaders,
 	setServerData: () => import_one_server_only.setServerData,
 	useActiveParams: () => import_hooks.useActiveParams,
-	useAudioPlayer: () => import_platform.useAudioPlayer,
-	useAudioPlayerStatus: () => import_platform.useAudioPlayerStatus,
-	useBatteryLevel: () => import_platform.useBatteryLevel,
-	useBatteryState: () => import_platform.useBatteryState,
+	useAudioPlayer: () => import_platform2.useAudioPlayer,
+	useAudioPlayerStatus: () => import_platform2.useAudioPlayerStatus,
+	useBatteryLevel: () => import_platform2.useBatteryLevel,
+	useBatteryState: () => import_platform2.useBatteryState,
 	useBlocker: () => import_useBlocker.useBlocker,
-	useCalendars: () => import_platform.useCalendars,
+	useCalendars: () => import_platform2.useCalendars,
 	useDrawer: () => import_useDrawer.useDrawer,
 	useFocusEffect: () => import_useFocusEffect.useFocusEffect,
-	useFonts: () => import_platform.useFonts,
+	useFonts: () => import_platform2.useFonts,
 	useGlobalSearchParams: () => import_hooks.useGlobalSearchParams,
 	useHeaderHeight: () => import_useHeaderHeight.useHeaderHeight,
-	useHinge: () => import_platform.useHinge,
+	useHinge: () => import_platform2.useHinge,
 	useIsFocused: () => import_core.useIsFocused,
-	useKeepAwake: () => import_platform.useKeepAwake,
+	useKeepAwake: () => import_platform2.useKeepAwake,
 	useLinkTo: () => import_useLinkTo.useLinkTo,
 	useLoader: () => import_useLoader.useLoader,
 	useLoaderState: () => import_useLoader.useLoaderState,
 	useLocalSearchParams: () => import_hooks.useLocalSearchParams,
-	useLocales: () => import_platform.useLocales,
-	useLowPowerMode: () => import_platform.useLowPowerMode,
+	useLocales: () => import_platform2.useLocales,
+	useLowPowerMode: () => import_platform2.useLowPowerMode,
 	useMatch: () => import_useMatches.useMatch,
 	useMatches: () => import_useMatches.useMatches,
-	useNativeState: () => import_platform.useNativeState,
+	useNativeState: () => import_platform2.useNativeState,
 	useNavigation: () => import_useNavigation.useNavigation,
 	useNavigationContainerRef: () => import_hooks.useNavigationContainerRef,
-	useNetworkState: () => import_platform.useNetworkState,
+	useNetworkState: () => import_platform2.useNetworkState,
 	usePageMatch: () => import_useMatches.usePageMatch,
 	useParams: () => import_hooks.useParams,
 	usePathname: () => import_hooks.usePathname,
-	usePowerState: () => import_platform.usePowerState,
-	usePreventScreenCapture: () => import_platform.usePreventScreenCapture,
-	useReservedRegions: () => import_platform.useReservedRegions,
-	useReservedRegionsReady: () => import_platform.useReservedRegionsReady,
+	usePowerState: () => import_platform2.usePowerState,
+	usePreventScreenCapture: () => import_platform2.usePreventScreenCapture,
+	useReservedRegions: () => import_platform2.useReservedRegions,
+	useReservedRegionsReady: () => import_platform2.useReservedRegionsReady,
 	useRootNavigationState: () => import_hooks.useRootNavigationState,
 	useRouter: () => import_hooks.useRouter,
 	useSafeAreaFrame: () => import_safe_area_context.useSafeAreaFrame,
@@ -120,13 +122,13 @@ __export(index_exports, {
 	useSegments: () => import_hooks.useSegments,
 	useServerHeadInsertion: () => import_useServerHeadInsertion.useServerHeadInsertion,
 	useSitemap: () => import_sitemap.useSitemap,
-	useSizeClass: () => import_platform.useSizeClass,
-	useSpanning: () => import_platform.useSpanning,
+	useSizeClass: () => import_platform2.useSizeClass,
+	useSpanning: () => import_platform2.useSpanning,
 	useStack: () => import_useStack.useStack,
 	useTabs: () => import_useTabs.useTabs,
 	useUnstableGlobalHref: () => import_hooks.useUnstableGlobalHref,
 	useValidationState: () => import_router.useValidationState,
-	useWindowSegments: () => import_platform.useWindowSegments,
+	useWindowSegments: () => import_platform2.useWindowSegments,
 	validateParams: () => import_validateParams.validateParams,
 	watchFile: () => import_watchFile.watchFile,
 	withLayoutContext: () => import_withLayoutContext.withLayoutContext,
@@ -136,6 +138,7 @@ module.exports = __toCommonJS(index_exports);
 var import_createApp = require("./createApp.cjs");
 var import_one = require("./one.cjs");
 var import_platform = require("./platform/index.cjs");
+var import_platform2 = require("./platform/index.cjs");
 var import_core = require("@react-navigation/core");
 var import_useHeaderHeight = require("./useHeaderHeight.cjs");
 __reExport(index_exports, require("@vxrn/color-scheme"), module.exports);

package/dist/cjs/index.native.cjs

@@ -29,6 +29,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var index_exports = {};
 __export(index_exports, {
+	AESEncryptionKey: () => import_platform.AESEncryptionKey,
+	AESSealedData: () => import_platform.AESSealedData,
 	ErrorBoundary: () => import_ErrorBoundary.ErrorBoundary,
 	Head: () => import_head.Head,
 	Link: () => import_Link.Link,
@@ -53,11 +55,11 @@ __export(index_exports, {
 	createApp: () => import_createApp.createApp,
 	createMiddleware: () => import_createMiddleware.createMiddleware,
 	createRoute: () => import_createRoute.createRoute,
-	getHinge: () => import_platform.getHinge,
+	getHinge: () => import_platform2.getHinge,
 	getLinking: () => import_getLinking.getLinking,
 	getLoaderTimingHistory: () => import_useLoader.getLoaderTimingHistory,
 	getServerData: () => import_one_server_only.getServerData,
-	getSizeClass: () => import_platform.getSizeClass,
+	getSizeClass: () => import_platform2.getSizeClass,
 	getURL: () => import_getURL.getURL,
 	handleSkewError: () => import_dynamicImport.handleSkewError,
 	href: () => import_href.href,
@@ -67,7 +69,7 @@ __export(index_exports, {
 	lazyWithRetry: () => import_lazyWithRetry.lazyWithRetry,
 	loadWithRetry: () => import_dynamicImport.loadWithRetry,
 	onClientLoaderResolve: () => import_clientLoaderResolver.onClientLoaderResolve,
-	onHingeChange: () => import_platform.onHingeChange,
+	onHingeChange: () => import_platform2.onHingeChange,
 	redirect: () => import_redirect.redirect,
 	refetchLoader: () => import_useLoader.refetchLoader,
 	registerPreloadedRoute: () => import_useViteRoutes.registerPreloadedRoute,
@@ -80,39 +82,39 @@ __export(index_exports, {
 	setResponseHeaders: () => import_one_server_only.setResponseHeaders,
 	setServerData: () => import_one_server_only.setServerData,
 	useActiveParams: () => import_hooks.useActiveParams,
-	useAudioPlayer: () => import_platform.useAudioPlayer,
-	useAudioPlayerStatus: () => import_platform.useAudioPlayerStatus,
-	useBatteryLevel: () => import_platform.useBatteryLevel,
-	useBatteryState: () => import_platform.useBatteryState,
+	useAudioPlayer: () => import_platform2.useAudioPlayer,
+	useAudioPlayerStatus: () => import_platform2.useAudioPlayerStatus,
+	useBatteryLevel: () => import_platform2.useBatteryLevel,
+	useBatteryState: () => import_platform2.useBatteryState,
 	useBlocker: () => import_useBlocker.useBlocker,
-	useCalendars: () => import_platform.useCalendars,
+	useCalendars: () => import_platform2.useCalendars,
 	useDrawer: () => import_useDrawer.useDrawer,
 	useFocusEffect: () => import_useFocusEffect.useFocusEffect,
-	useFonts: () => import_platform.useFonts,
+	useFonts: () => import_platform2.useFonts,
 	useGlobalSearchParams: () => import_hooks.useGlobalSearchParams,
 	useHeaderHeight: () => import_useHeaderHeight.useHeaderHeight,
-	useHinge: () => import_platform.useHinge,
+	useHinge: () => import_platform2.useHinge,
 	useIsFocused: () => import_core.useIsFocused,
-	useKeepAwake: () => import_platform.useKeepAwake,
+	useKeepAwake: () => import_platform2.useKeepAwake,
 	useLinkTo: () => import_useLinkTo.useLinkTo,
 	useLoader: () => import_useLoader.useLoader,
 	useLoaderState: () => import_useLoader.useLoaderState,
 	useLocalSearchParams: () => import_hooks.useLocalSearchParams,
-	useLocales: () => import_platform.useLocales,
-	useLowPowerMode: () => import_platform.useLowPowerMode,
+	useLocales: () => import_platform2.useLocales,
+	useLowPowerMode: () => import_platform2.useLowPowerMode,
 	useMatch: () => import_useMatches.useMatch,
 	useMatches: () => import_useMatches.useMatches,
-	useNativeState: () => import_platform.useNativeState,
+	useNativeState: () => import_platform2.useNativeState,
 	useNavigation: () => import_useNavigation.useNavigation,
 	useNavigationContainerRef: () => import_hooks.useNavigationContainerRef,
-	useNetworkState: () => import_platform.useNetworkState,
+	useNetworkState: () => import_platform2.useNetworkState,
 	usePageMatch: () => import_useMatches.usePageMatch,
 	useParams: () => import_hooks.useParams,
 	usePathname: () => import_hooks.usePathname,
-	usePowerState: () => import_platform.usePowerState,
-	usePreventScreenCapture: () => import_platform.usePreventScreenCapture,
-	useReservedRegions: () => import_platform.useReservedRegions,
-	useReservedRegionsReady: () => import_platform.useReservedRegionsReady,
+	usePowerState: () => import_platform2.usePowerState,
+	usePreventScreenCapture: () => import_platform2.usePreventScreenCapture,
+	useReservedRegions: () => import_platform2.useReservedRegions,
+	useReservedRegionsReady: () => import_platform2.useReservedRegionsReady,
 	useRootNavigationState: () => import_hooks.useRootNavigationState,
 	useRouter: () => import_hooks.useRouter,
 	useSafeAreaFrame: () => import_safe_area_context.useSafeAreaFrame,
@@ -122,13 +124,13 @@ __export(index_exports, {
 	useSegments: () => import_hooks.useSegments,
 	useServerHeadInsertion: () => import_useServerHeadInsertion.useServerHeadInsertion,
 	useSitemap: () => import_sitemap.useSitemap,
-	useSizeClass: () => import_platform.useSizeClass,
-	useSpanning: () => import_platform.useSpanning,
+	useSizeClass: () => import_platform2.useSizeClass,
+	useSpanning: () => import_platform2.useSpanning,
 	useStack: () => import_useStack.useStack,
 	useTabs: () => import_useTabs.useTabs,
 	useUnstableGlobalHref: () => import_hooks.useUnstableGlobalHref,
 	useValidationState: () => import_router.useValidationState,
-	useWindowSegments: () => import_platform.useWindowSegments,
+	useWindowSegments: () => import_platform2.useWindowSegments,
 	validateParams: () => import_validateParams.validateParams,
 	watchFile: () => import_watchFile.watchFile,
 	withLayoutContext: () => import_withLayoutContext.withLayoutContext,
@@ -138,6 +140,7 @@ module.exports = __toCommonJS(index_exports);
 var import_createApp = require("./createApp.native.js");
 var import_one = require("./one.native.js");
 var import_platform = require("./platform/index.native.js");
+var import_platform2 = require("./platform/index.native.js");
 var import_core = require("@react-navigation/core");
 var import_useHeaderHeight = require("./useHeaderHeight.native.js");
 __reExport(index_exports, require("@vxrn/color-scheme"), module.exports);