@spencerls/react-native-nfc 1.0.8 → 1.0.10

package/dist/index.mjs

@@ -4,21 +4,149 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/nfc/a/index.ts
-var a_exports = {};
-__export(a_exports, {
-  operations: () => operations,
-  utils: () => utils
+// src/nfc/ndef/builder.ts
+import {
+  Ndef
+} from "react-native-nfc-manager";
+var mimeTypes = {
+  TEXT: "text/plain",
+  JSON: "application/json"
+};
+var Builder = class _Builder {
+  static records(b) {
+    return b(_Builder);
+  }
+  static message(b) {
+    return Ndef.encodeMessage(b(_Builder));
+  }
+  static record(init) {
+    const { tnf, type, id = [], payload = [] } = init;
+    const toBytes = (v) => typeof v === "string" ? Array.from(Buffer.from(v, "utf8")) : v;
+    return {
+      tnf,
+      type: toBytes(type),
+      id: toBytes(id),
+      payload: toBytes(payload)
+    };
+  }
+  static textRecord(text, lang = "en", encoding = "utf8", id) {
+    const record = Ndef.textRecord(text, lang, encoding);
+    if (id) record.id = Array.from(Buffer.from(id, "utf8"));
+    return record;
+  }
+  static uriRecord(uri, id) {
+    return Ndef.uriRecord(uri, id);
+  }
+  static jsonRecord(payload, id) {
+    return _Builder.mimeRecord(mimeTypes.JSON, payload, id);
+  }
+  static mimeRecord(mimeType, payload, id) {
+    const payloadBytes = typeof payload === "string" ? Array.from(Buffer.from(payload, "utf8")) : payload instanceof Uint8Array ? Array.from(payload) : payload;
+    const idBytes = id ? Array.from(Buffer.from(id, "utf8")) : [];
+    return _Builder.record({
+      tnf: Ndef.TNF_MIME_MEDIA,
+      type: mimeType,
+      id: idBytes,
+      payload: payloadBytes
+    });
+  }
+  static externalRecord(domain, type, payload, id) {
+    const recordType = `${domain}:${type}`;
+    const payloadBytes = typeof payload === "string" ? Array.from(Buffer.from(payload, "utf8")) : payload instanceof Uint8Array ? Array.from(payload) : payload;
+    const idBytes = id ? Array.from(Buffer.from(id, "utf8")) : [];
+    return _Builder.record({
+      tnf: Ndef.TNF_EXTERNAL_TYPE,
+      type: recordType,
+      id: idBytes,
+      payload: payloadBytes
+    });
+  }
+  static createEmpty() {
+    return _Builder.record({
+      tnf: Ndef.TNF_EMPTY,
+      type: [],
+      id: [],
+      payload: []
+    });
+  }
+};
+
+// src/nfc/ndef/internal/operations.ts
+var operations_exports = {};
+__export(operations_exports, {
+  readMessage: () => readMessage,
+  write: () => write
 });
+import nfcManager, { Ndef as Ndef2 } from "react-native-nfc-manager";
 
-// src/nfc/a/operations.ts
-import NfcManager2, { NfcTech } from "react-native-nfc-manager";
+// src/nfc/ndef/error.ts
+var NdefError = class extends Error {
+  constructor(message) {
+    super(`[NDEF] ${message}`);
+  }
+};
 
-// src/nfc/service.ts
+// src/nfc/ndef/internal/operations.ts
+function assertMessage(msg) {
+  if (!msg.ndefMessage || msg.ndefMessage.length === 0) {
+    throw new NdefError("NDEF message contains no NDEF records");
+  }
+}
+async function readMessage() {
+  const msg = await nfcManager.ndefHandler.getNdefMessage();
+  if (!msg) throw new NdefError("No NDEF message detected");
+  assertMessage(msg);
+  return msg;
+}
+async function write(records) {
+  if (records.length === 0) {
+    throw new NdefError("Cannot write an empty records array");
+  }
+  const bytes = Ndef2.encodeMessage(records);
+  await nfcManager.ndefHandler.writeNdefMessage(bytes);
+}
+
+// src/nfc/ndef/internal/tech.ts
 import { Platform } from "react-native";
-import NfcManager, {
+import { NfcTech } from "react-native-nfc-manager";
+var tech = Platform.OS === "android" ? [NfcTech.Ndef, NfcTech.NfcA] : [NfcTech.Ndef];
+
+// src/nfc/ndef/internal/index.ts
+var nfcNdefTag = {
+  ...operations_exports,
+  tech
+};
+
+// src/nfc/ndef/operations.ts
+var operations_exports4 = {};
+__export(operations_exports4, {
+  getStatus: () => getStatus,
+  makeReadOnly: () => makeReadOnly,
+  readFull: () => readFull,
+  readMessage: () => readMessage2,
+  write: () => write2,
+  writeExternal: () => writeExternal,
+  writeJson: () => writeJson,
+  writeMime: () => writeMime,
+  writeText: () => writeText,
+  writeUri: () => writeUri
+});
+import nfcManager4 from "react-native-nfc-manager";
+
+// src/nfc/service.ts
+import { Platform as Platform2 } from "react-native";
+import nfcManager2, {
   NfcEvents
 } from "react-native-nfc-manager";
+
+// src/nfc/error.ts
+var NfcError = class extends Error {
+  constructor(message) {
+    super(`[NFC] ${message}`);
+  }
+};
+
+// src/nfc/service.ts
 var NfcService = class {
   constructor() {
     this.state = { mode: "idle", tag: null };
@@ -26,10 +154,10 @@ var NfcService = class {
     this.isProcessingTag = false;
     this.currentCooldownMs = 1500;
     this.readerModeFlags_ANDROID = null;
-    NfcManager.start();
+    nfcManager2.start();
   }
   enableReaderMode_ANDROID(flags) {
-    if (Platform.OS !== "android") return;
+    if (Platform2.OS !== "android") return;
     this.readerModeFlags_ANDROID = flags;
   }
   // -----------------------------
@@ -62,7 +190,7 @@ var NfcService = class {
     this.currentCooldownMs = (_a = options == null ? void 0 : options.cooldownMs) != null ? _a : 1500;
     this.isProcessingTag = false;
     this.setState({ mode: "starting", tag: null });
-    NfcManager.setEventListener(
+    nfcManager2.setEventListener(
       NfcEvents.DiscoverTag,
       async (tag) => {
         var _a2;
@@ -89,12 +217,12 @@ var NfcService = class {
     );
     try {
       if (this.readerModeFlags_ANDROID) {
-        await NfcManager.registerTagEvent({
+        await nfcManager2.registerTagEvent({
           isReaderModeEnabled: true,
           readerModeFlags: this.readerModeFlags_ANDROID
         });
       } else {
-        await NfcManager.registerTagEvent();
+        await nfcManager2.registerTagEvent();
       }
       if (this.state.mode === "starting") {
         this.setState({ mode: "active" });
@@ -110,14 +238,14 @@ var NfcService = class {
   async stopReader() {
     if (["idle", "stopping"].includes(this.state.mode)) return;
     this.setState({ mode: "stopping" });
-    NfcManager.setEventListener(NfcEvents.DiscoverTag, () => {
+    nfcManager2.setEventListener(NfcEvents.DiscoverTag, () => {
     });
     if (this.cooldownTimer) {
       clearTimeout(this.cooldownTimer);
       this.cooldownTimer = void 0;
     }
     try {
-      await NfcManager.unregisterTagEvent();
+      await nfcManager2.unregisterTagEvent();
     } catch (err) {
       console.warn("[NFC] unregisterTagEvent error:", err);
     }
@@ -135,13 +263,13 @@ var NfcService = class {
   // -----------------------------
   // Technology sessions (NDEF, NfcV, etc.)
   // -----------------------------
-  async withTechnology(tech, handler) {
+  async withTechnology(tech3, handler) {
     if (this.state.mode === "technology") {
-      throw new Error("[NFC] Technology is already in use!");
+      throw new NfcError("Technology is already in use!");
     }
     if (this.readerModeFlags_ANDROID) {
       return this.withTechnologyReaderMode_ANDROID(
-        tech,
+        tech3,
         handler,
         this.readerModeFlags_ANDROID
       );
@@ -155,26 +283,26 @@ var NfcService = class {
       await this.stopReader();
     }
     if (this.state.mode !== "idle") {
-      throw new Error(
-        `[NFC] Cannot start technology session in mode ${this.state.mode}`
+      throw new NfcError(
+        `Cannot start technology session in mode ${this.state.mode}`
       );
     }
     this.setState({ mode: "technology" });
     try {
-      await NfcManager.requestTechnology(tech, {
+      await nfcManager2.requestTechnology(tech3, {
         alertMessage: "Hold near NFC tag"
       });
       const result = await handler();
-      if (Platform.OS === "ios") {
-        await NfcManager.setAlertMessageIOS("Success!");
+      if (Platform2.OS === "ios") {
+        await nfcManager2.setAlertMessageIOS("Success!");
       }
       return result;
     } catch (err) {
       const message = typeof err === "string" ? err : (err == null ? void 0 : err.message) || "Unknown NFC error";
-      throw new Error(`[NFC] withTechnology error: ${message}`);
+      throw new NfcError(`withTechnology error: ${message}`);
     } finally {
       try {
-        await NfcManager.cancelTechnologyRequest();
+        await nfcManager2.cancelTechnologyRequest();
       } catch {
       }
       this.setState({ mode: "idle", tag: null });
@@ -190,26 +318,24 @@ var NfcService = class {
       }
     }
   }
-  async withTechnologyReaderMode_ANDROID(tech, handler, flags) {
+  async withTechnologyReaderMode_ANDROID(tech3, handler, flags) {
     const readerWasActive = ["starting", "active", "stopping"].includes(
       this.state.mode
     );
     this.isProcessingTag = true;
     this.setState({ mode: "technology" });
     try {
-      await NfcManager.requestTechnology(tech, {
+      await nfcManager2.requestTechnology(tech3, {
         isReaderModeEnabled: true,
         readerModeFlags: flags
       });
       return await handler();
     } catch (err) {
       const message = typeof err === "string" ? err : (err == null ? void 0 : err.message) || "Unknown NFC error";
-      throw new Error(
-        `[NFC] withTechnologyReaderMode_ANDROID error: ${message}`
-      );
+      throw new NfcError(`withTechnologyReaderMode_ANDROID error: ${message}`);
     } finally {
       try {
-        await NfcManager.cancelTechnologyRequest();
+        await nfcManager2.cancelTechnologyRequest();
       } catch {
       }
       this.isProcessingTag = false;
@@ -219,311 +345,355 @@ var NfcService = class {
 };
 var nfcService = new NfcService();
 
-// src/nfc/a/operations.ts
-var operations = {
-  async transceive(data) {
-    return nfcService.withTechnology(NfcTech.NfcA, async () => {
-      return await NfcManager2.transceive(data);
-    });
-  }
-};
+// src/nfc/tag/internal/operations.ts
+var operations_exports2 = {};
+__export(operations_exports2, {
+  getTag: () => getTag
+});
+import nfcManager3 from "react-native-nfc-manager";
+async function getTag() {
+  const tagEvent = await nfcManager3.getTag();
+  if (!tagEvent) throw new Error("No tag detected");
+  return tagEvent;
+}
 
-// src/nfc/a/utils.ts
-var utils = {};
+// src/nfc/tag/internal/index.ts
+var nfcTag = {
+  ...operations_exports2
+};
 
-// src/nfc/v/index.ts
-var v_exports = {};
-__export(v_exports, {
-  operations: () => operations2,
-  utils: () => utils2
+// src/nfc/tag/operations.ts
+var operations_exports3 = {};
+__export(operations_exports3, {
+  getTag: () => getTag2
 });
+async function getTag2(tech3) {
+  return nfcService.withTechnology(tech3, nfcTag.getTag);
+}
 
-// src/nfc/v/operations.ts
-import NfcManager4 from "react-native-nfc-manager";
+// src/nfc/ndef/operations.ts
+async function getStatus() {
+  return await nfcManager4.ndefHandler.getNdefStatus();
+}
+async function readMessage2() {
+  return await nfcService.withTechnology(
+    nfcNdefTag.tech,
+    nfcNdefTag.readMessage
+  );
+}
+async function readFull() {
+  return await nfcService.withTechnology(nfcNdefTag.tech, async () => {
+    const tag = await nfcTag.getTag();
+    const message = await nfcNdefTag.readMessage();
+    return { message, tag };
+  });
+}
+async function write2(records) {
+  if (!records || records.length === 0) {
+    throw new NdefError("write: no NDEF records provided");
+  }
+  await nfcService.withTechnology(
+    nfcNdefTag.tech,
+    async () => await nfcNdefTag.write(records)
+  );
+}
+async function writeText(text, lang, encoding, id) {
+  const rec = Builder.textRecord(text, lang, encoding, id);
+  await write2([rec]);
+}
+async function writeUri(uri, id) {
+  const rec = Builder.uriRecord(uri, id);
+  await write2([rec]);
+}
+async function writeJson(data, id) {
+  let json;
+  try {
+    json = JSON.stringify(data);
+  } catch (e) {
+    throw new NdefError(`writeJson: value is not JSON serializable: ${e}`);
+  }
+  const rec = Builder.jsonRecord(json, id);
+  await write2([rec]);
+}
+async function writeMime(mimeType, payload, id) {
+  if (!mimeType || typeof mimeType !== "string") {
+    throw new NdefError("writeMime: mimeType must be a non-empty string");
+  }
+  const rec = Builder.mimeRecord(mimeType, payload, id);
+  await write2([rec]);
+}
+async function writeExternal(domain, type, payload, id) {
+  if (!domain || typeof domain !== "string") {
+    throw new NdefError("writeExternal: domain must be a non-empty string");
+  }
+  if (!type || typeof type !== "string") {
+    throw new NdefError("writeExternal: type must be a non-empty string");
+  }
+  const rec = Builder.externalRecord(domain, type, payload, id);
+  await write2([rec]);
+}
+async function makeReadOnly() {
+  await nfcService.withTechnology(
+    nfcNdefTag.tech,
+    nfcManager4.ndefHandler.makeReadOnly
+  );
+}
 
-// src/nfc/v/internal.ts
-import NfcManager3 from "react-native-nfc-manager";
+// src/nfc/v/internal/operations.ts
+var operations_exports5 = {};
+__export(operations_exports5, {
+  getSystemInfo: () => getSystemInfo,
+  readBlock: () => readBlock,
+  readBlocks: () => readBlocks,
+  transceive: () => transceive,
+  writeBlock: () => writeBlock,
+  writeBlocks: () => writeBlocks
+});
+import nfcManager5 from "react-native-nfc-manager";
 
-// src/nfc/v/utils.ts
-import { Platform as Platform2 } from "react-native";
-import { NfcTech as NfcTech2 } from "react-native-nfc-manager";
-var utils2 = {
-  tech: Platform2.OS === "ios" ? [NfcTech2.Iso15693IOS] : NfcTech2.NfcV,
-  Flags: {
-    HIGH_DATA_RATE: 2,
-    ADDRESSED: 32
-    // If needed later: OPTION: 0x40 (not commonly used)
-  },
-  Commands: {
-    READ_SINGLE_BLOCK: 32,
-    WRITE_SINGLE_BLOCK: 33,
-    GET_SYSTEM_INFO: 43
-  },
-  /**
-   * Combine multiple flag bits into one byte.
-   * Example: Flags.ADDRESSED | Flags.HIGH_DATA_RATE
-   */
-  flags(...bits) {
-    return bits.reduce((acc, bit) => acc | bit, 0);
-  },
-  /**
-   * Convert tag.id hex string (MSB->LSB) into reversed byte array (LSB->MSB)
-   * ISO15693 requires reversed UID for addressed commands.
-   */
-  reverseUid(tagIdHex) {
-    const bytes = [];
-    for (let i = 0; i < tagIdHex.length; i += 2) {
-      bytes.unshift(Number.parseInt(tagIdHex.substring(i, i + 2), 16));
-    }
-    return bytes;
-  },
-  /**
-   * Build READ_SINGLE_BLOCK command.
-   * FLAGS: addressed + high data rate by default.
-   */
-  buildReadBlock(uidReversed, blockNumber) {
-    const flags = this.flags(this.Flags.ADDRESSED, this.Flags.HIGH_DATA_RATE);
-    return [
-      flags,
-      this.Commands.READ_SINGLE_BLOCK,
-      ...uidReversed,
-      blockNumber
-    ];
-  },
-  /**
-   * Build WRITE_SINGLE_BLOCK command.
-   * Note: data must match the block size (usually 4 or 8 bytes).
-   */
-  buildWriteBlock(uidReversed, blockNumber, data) {
-    const flags = this.flags(this.Flags.ADDRESSED, this.Flags.HIGH_DATA_RATE);
-    return [
-      flags,
-      this.Commands.WRITE_SINGLE_BLOCK,
-      ...uidReversed,
-      blockNumber,
-      ...data
-    ];
-  },
-  /**
-   * Build GET_SYSTEM_INFO command.
-   */
-  buildGetSystemInfo(uidReversed) {
-    return [this.Flags.HIGH_DATA_RATE, this.Commands.GET_SYSTEM_INFO];
-  },
-  /**
-   * Parse a READ_SINGLE_BLOCK response.
-   * Response format:
-   *  - byte[0] = status (0x00 = success)
-   *  - byte[1..] = block payload bytes
-   */
-  parseReadResponse(resp) {
-    if (!resp || resp.length === 0) {
-      throw new Error("Empty NFC-V response");
-    }
-    const status = resp[0];
-    if (status === void 0) {
-      throw new Error("Invalid NFC-V response: missing status byte");
-    }
-    if (status !== 0) {
-      throw new Error(`Read failed. Status: 0x${status.toString(16)}`);
-    }
-    return new Uint8Array(resp.slice(1));
-  },
-  /**
-   * Parse WRITE_SINGLE_BLOCK response.
-   * Successful write has resp[0] === 0x00.
-   */
-  parseWriteResponse(resp) {
-    if (!resp || resp.length === 0) {
-      throw new Error("Empty NFC-V response");
-    }
-    const status = resp[0];
-    if (status === void 0) {
-      throw new Error("Invalid NFC-V response: missing status byte");
-    }
-    if (status !== 0) {
-      throw new Error(`Write failed. Status: 0x${status.toString(16)}`);
-    }
-  },
-  /**
-   * Parse GET_SYSTEM_INFO response.
-   * Returns: UID, DSFID, AFI, numberOfBlocks, blockSize, manufacturer
-   */
-  parseSystemInfo(resp) {
-    var _a;
-    if (!resp || resp.length < 2) {
-      throw new Error("Invalid System Info response");
-    }
-    const status = resp[0];
-    if (status === void 0 || status !== 0) {
-      throw new Error("Invalid System Info response");
-    }
-    const flagsByte = resp[1];
-    if (flagsByte === void 0) {
-      throw new Error("Invalid System Info response: missing flags byte");
-    }
-    const infoFlags = flagsByte & 15;
-    let offset = 2;
-    const result = {};
-    if (resp.length >= offset + 8) {
-      const uidBytes = resp.slice(offset, offset + 8);
-      result.uid = uidBytes.slice().reverse().map((b) => b.toString(16).padStart(2, "0")).join("").toUpperCase();
-      offset += 8;
-    }
-    if (infoFlags & 1 && resp.length > offset) {
-      result.dsfid = resp[offset++];
-    }
-    if (infoFlags & 2 && resp.length > offset) {
-      result.afi = resp[offset++];
-    }
-    if (infoFlags & 4 && resp.length >= offset + 2) {
-      const numBlocks = resp[offset++];
-      const blkSize = resp[offset++];
-      if (numBlocks !== void 0) {
-        result.numberOfBlocks = numBlocks + 1;
-      }
-      if (blkSize !== void 0) {
-        result.blockSize = blkSize + 1;
-      }
-    }
-    if (infoFlags & 8 && resp.length > offset) {
-      result.icReference = resp[offset++];
-    }
-    if (!result.blockSize) result.blockSize = 4;
-    result.manufacturer = this.detectManufacturer((_a = result.uid) != null ? _a : "");
-    return result;
-  },
-  /** Identify common manufacturers based on UID prefix */
-  detectManufacturer(uid) {
-    if (uid.startsWith("E004") || uid.startsWith("E006") || uid.startsWith("E016"))
-      return "EM Microelectronic";
-    if (uid.startsWith("E002")) return "STMicroelectronics";
-    if (uid.startsWith("E007")) return "Texas Instruments";
-    if (uid.startsWith("E010")) return "NXP";
-    return "Unknown";
+// src/nfc/v/error.ts
+var VError = class extends Error {
+  constructor(message) {
+    super(`[V] ${message}`);
   }
 };
 
-// src/nfc/v/internal.ts
-async function readBlockRaw(tag, blockNumber) {
-  const uid = utils2.reverseUid(tag.id);
-  const cmd = utils2.buildReadBlock(uid, blockNumber);
-  const resp = await NfcManager3.transceive(cmd);
-  return utils2.parseReadResponse(resp);
-}
-async function writeBlockRaw(tag, blockNumber, data) {
-  const uid = utils2.reverseUid(tag.id);
-  const cmd = utils2.buildWriteBlock(uid, blockNumber, data);
-  const resp = await NfcManager3.transceive(cmd);
-  return utils2.parseWriteResponse(resp);
-}
-async function getSystemInfoRaw(tag) {
-  const uid = utils2.reverseUid(tag.id);
-  const cmd = utils2.buildGetSystemInfo(uid);
-  const resp = await NfcManager3.transceive(cmd);
-  return utils2.parseSystemInfo(resp);
+// src/nfc/v/internal/utils.ts
+var utils_exports = {};
+__export(utils_exports, {
+  COMMANDS: () => COMMANDS,
+  FLAGS: () => FLAGS,
+  buildFlags: () => buildFlags,
+  buildGetSystemInfo: () => buildGetSystemInfo,
+  buildReadBlock: () => buildReadBlock,
+  buildWriteBlock: () => buildWriteBlock,
+  detectManufacturer: () => detectManufacturer,
+  parseReadResponse: () => parseReadResponse,
+  parseSystemInfo: () => parseSystemInfo,
+  parseWriteResponse: () => parseWriteResponse,
+  reverseUid: () => reverseUid
+});
+var FLAGS = {
+  HIGH_DATA_RATE: 2,
+  ADDRESSED: 32
+  // If needed later: OPTION: 0x40 (not commonly used)
+};
+var COMMANDS = {
+  READ_SINGLE_BLOCK: 32,
+  WRITE_SINGLE_BLOCK: 33,
+  GET_SYSTEM_INFO: 43
+};
+function buildFlags(...bits) {
+  return bits.reduce((acc, bit) => acc | bit, 0);
+}
+function reverseUid(tagIdHex) {
+  const bytes = [];
+  for (let i = 0; i < tagIdHex.length; i += 2) {
+    bytes.unshift(Number.parseInt(tagIdHex.substring(i, i + 2), 16));
+  }
+  return bytes;
+}
+function buildReadBlock(uidReversed, blockNumber) {
+  const flags = buildFlags(FLAGS.ADDRESSED, FLAGS.HIGH_DATA_RATE);
+  return [flags, COMMANDS.READ_SINGLE_BLOCK, ...uidReversed, blockNumber];
+}
+function buildWriteBlock(uidReversed, blockNumber, data) {
+  const flags = buildFlags(FLAGS.ADDRESSED, FLAGS.HIGH_DATA_RATE);
+  return [
+    flags,
+    COMMANDS.WRITE_SINGLE_BLOCK,
+    ...uidReversed,
+    blockNumber,
+    ...data
+  ];
+}
+function buildGetSystemInfo() {
+  return [FLAGS.HIGH_DATA_RATE, COMMANDS.GET_SYSTEM_INFO];
+}
+function parseReadResponse(resp) {
+  if (!resp || resp.length === 0) {
+    throw new Error("Empty NFC-V response");
+  }
+  const status = resp[0];
+  if (status === void 0) {
+    throw new Error("Invalid NFC-V response: missing status byte");
+  }
+  if (status !== 0) {
+    throw new Error(`Read failed. Status: 0x${status.toString(16)}`);
+  }
+  return new Uint8Array(resp.slice(1));
+}
+function parseWriteResponse(resp) {
+  if (!resp || resp.length === 0) {
+    throw new Error("Empty NFC-V response");
+  }
+  const status = resp[0];
+  if (status === void 0) {
+    throw new Error("Invalid NFC-V response: missing status byte");
+  }
+  if (status !== 0) {
+    throw new Error(`Write failed. Status: 0x${status.toString(16)}`);
+  }
+}
+function parseSystemInfo(resp) {
+  var _a;
+  if (!resp || resp.length < 2) {
+    throw new Error("Invalid System Info response");
+  }
+  const status = resp[0];
+  if (status === void 0 || status !== 0) {
+    throw new Error("Invalid System Info response");
+  }
+  const flagsByte = resp[1];
+  if (flagsByte === void 0) {
+    throw new Error("Invalid System Info response: missing flags byte");
+  }
+  const infoFlags = flagsByte & 15;
+  let offset = 2;
+  const result = {};
+  if (resp.length >= offset + 8) {
+    const uidBytes = resp.slice(offset, offset + 8);
+    result.uid = uidBytes.slice().reverse().map((b) => b.toString(16).padStart(2, "0")).join("").toUpperCase();
+    offset += 8;
+  }
+  if (infoFlags & 1 && resp.length > offset) {
+    result.dsfid = resp[offset++];
+  }
+  if (infoFlags & 2 && resp.length > offset) {
+    result.afi = resp[offset++];
+  }
+  if (infoFlags & 4 && resp.length >= offset + 2) {
+    const numBlocks = resp[offset++];
+    const blkSize = resp[offset++];
+    if (numBlocks !== void 0) {
+      result.numberOfBlocks = numBlocks + 1;
+    }
+    if (blkSize !== void 0) {
+      result.blockSize = blkSize + 1;
+    }
+  }
+  if (infoFlags & 8 && resp.length > offset) {
+    result.icReference = resp[offset++];
+  }
+  if (!result.blockSize) result.blockSize = 4;
+  result.manufacturer = detectManufacturer((_a = result.uid) != null ? _a : "");
+  return result;
+}
+function detectManufacturer(uid) {
+  if (uid.startsWith("E004") || uid.startsWith("E006") || uid.startsWith("E016"))
+    return "EM Microelectronic";
+  if (uid.startsWith("E002")) return "STMicroelectronics";
+  if (uid.startsWith("E007")) return "Texas Instruments";
+  if (uid.startsWith("E010")) return "NXP";
+  return "Unknown";
 }
 
-// src/nfc/v/operations.ts
-var operations2 = {
-  async withVTag(handler) {
-    return nfcService.withTechnology(utils2.tech, async () => {
-      const tag = await NfcManager4.getTag();
-      if (!(tag == null ? void 0 : tag.id)) throw new Error("No NFC-V tag detected");
-      return handler(tag);
-    });
-  },
-  async writeBlockNfcV(blockNumber, data) {
-    return this.withVTag((tag) => writeBlockRaw(tag, blockNumber, data));
-  },
-  async readBlockNfcV(blockNumber) {
-    return this.withVTag((tag) => readBlockRaw(tag, blockNumber));
-  },
-  async getSystemInfoNfcV() {
-    return this.withVTag((tag) => getSystemInfoRaw(tag));
+// src/nfc/v/internal/operations.ts
+async function transceive(bytes) {
+  return await nfcManager5.nfcVHandler.transceive(bytes);
+}
+async function readBlock(tagId, blockNumber) {
+  const uid = reverseUid(tagId);
+  const cmd = buildReadBlock(uid, blockNumber);
+  const resp = await transceive(cmd);
+  return parseReadResponse(resp);
+}
+async function readBlocks(tagId, startBlock, endBlock) {
+  const data = new Uint8Array();
+  let offset = 0;
+  for (let i = startBlock; i < endBlock; i++) {
+    const block = await readBlock(tagId, i);
+    data.set(block, offset);
+    offset += block.length;
   }
-};
+  return data;
+}
+async function writeBlock(tagId, blockNumber, data) {
+  const uid = reverseUid(tagId);
+  const cmd = buildWriteBlock(uid, blockNumber, data);
+  const resp = await transceive(cmd);
+  parseWriteResponse(resp);
+}
+async function writeBlocks(tagId, blockNumber, data) {
+  for (let i = 0; i < data.length; i++) {
+    const blockData = data[i];
+    if (blockData === void 0) {
+      throw new VError(`No data provided for block at index ${i}`);
+    }
+    await writeBlock(tagId, blockNumber + i, blockData);
+  }
+}
+async function getSystemInfo() {
+  const cmd = buildGetSystemInfo();
+  const resp = await transceive(cmd);
+  return parseSystemInfo(resp);
+}
 
-// src/nfc/ndef/index.ts
-var ndef_exports = {};
-__export(ndef_exports, {
-  operations: () => operations3,
-  utils: () => utils3
-});
+// src/nfc/v/internal/tech.ts
+import { Platform as Platform3 } from "react-native";
+import { NfcTech as NfcTech2 } from "react-native-nfc-manager";
+var tech2 = Platform3.OS === "ios" ? [NfcTech2.Iso15693IOS] : NfcTech2.NfcV;
 
-// src/nfc/ndef/operations.ts
-import NfcManager5, {
-  Ndef,
-  NfcTech as NfcTech3
-} from "react-native-nfc-manager";
-var operations3 = {
-  async writeNdef(records) {
-    await nfcService.withTechnology([NfcTech3.Ndef, NfcTech3.NfcA], async () => {
-      const bytes = Ndef.encodeMessage(records);
-      await NfcManager5.ndefHandler.writeNdefMessage(bytes);
-    });
-  },
-  writeTextNdef(text) {
-    const record = Ndef.textRecord(text);
-    return this.writeNdef([record]);
-  },
-  writeUriNdef(uri) {
-    const record = Ndef.uriRecord(uri);
-    return this.writeNdef([record]);
-  }
+// src/nfc/v/internal/index.ts
+var nfcVTag = {
+  ...operations_exports5,
+  tech: tech2,
+  utils: utils_exports
 };
 
-// src/nfc/ndef/utils.ts
-var utils3 = {};
+// src/nfc/v/operations.ts
+var operations_exports6 = {};
+__export(operations_exports6, {
+  getSystemInfo: () => getSystemInfo2,
+  readBlock: () => readBlock2,
+  readBlocks: () => readBlocks2,
+  writeBlock: () => writeBlock2,
+  writeBlocks: () => writeBlocks2
+});
+async function writeBlock2(blockNumber, data) {
+  await nfcService.withTechnology(nfcVTag.tech, async () => {
+    const tag = await nfcTag.getTag();
+    if (!(tag == null ? void 0 : tag.id)) throw new VError("No NFC-V tag id detected");
+    await nfcVTag.writeBlock(tag.id, blockNumber, data);
+  });
+}
+async function writeBlocks2(blockNumber, data) {
+  await nfcService.withTechnology(nfcVTag.tech, async () => {
+    const tag = await nfcTag.getTag();
+    if (!(tag == null ? void 0 : tag.id)) throw new VError("No NFC-V tag id detected");
+    nfcVTag.writeBlocks(tag.id, blockNumber, data);
+  });
+}
+async function readBlock2(blockNumber) {
+  return await nfcService.withTechnology(nfcVTag.tech, async () => {
+    const tag = await nfcTag.getTag();
+    if (!(tag == null ? void 0 : tag.id)) throw new VError("No NFC-V tag id detected");
+    return await nfcVTag.readBlock(tag.id, blockNumber);
+  });
+}
+async function readBlocks2(startBlock, endBlock) {
+  return await nfcService.withTechnology(nfcVTag.tech, async () => {
+    const tag = await nfcTag.getTag();
+    if (!(tag == null ? void 0 : tag.id)) throw new Error("No NFC-V tag id detected");
+    return await nfcVTag.readBlocks(tag.id, startBlock, endBlock);
+  });
+}
+async function getSystemInfo2() {
+  return await nfcService.withTechnology(nfcVTag.tech, nfcVTag.getSystemInfo);
+}
 
 // src/nfc/namespace.ts
 var nfc = {
   service: nfcService,
-  /** ISO15693 protocol helpers and high-level operations */
-  v: {
-    ...operations2,
-    // NfcVOperations, nfcV
-    utils: utils2
-  },
-  /** NFC-A / Type 2 helpers and operations */
-  a: {
-    ...operations,
-    utils
-  },
-  /** NDEF read/write utilities and operations */
-  ndef: {
-    ...operations3,
-    utils: utils3
-  }
+  v: { ...operations_exports6 },
+  ndef: { ...operations_exports4, Builder },
+  tag: { ...operations_exports3 }
 };
 
-// src/react/nfc-provider.tsx
-import {
-  createContext,
-  useContext,
-  useEffect,
-  useState
-} from "react";
-import { jsx } from "react/jsx-runtime";
-var NfcContext = createContext(null);
-function NfcProvider({ children }) {
-  const [state, setState] = useState(nfcService.getState());
-  useEffect(() => {
-    const unsubscribe = nfcService.subscribe(setState);
-    return unsubscribe;
-  }, []);
-  return /* @__PURE__ */ jsx(NfcContext.Provider, { value: { state, service: nfcService }, children });
-}
-function useNfcContext() {
-  const ctx = useContext(NfcContext);
-  if (!ctx) throw new Error("useNfcContext must be inside <NfcProvider>");
-  return ctx;
-}
-
 // src/react/use-nfc.ts
-import { useEffect as useEffect2 } from "react";
+import { useEffect } from "react";
 function useNfc(onTag, options) {
-  useEffect2(() => {
+  useEffect(() => {
     nfcService.startReader(
       async (tag) => {
         if (!tag.id) return;
@@ -553,27 +723,27 @@ function useNfcReader() {
 }
 
 // src/react/use-nfc-state.ts
-import { useEffect as useEffect3, useState as useState2 } from "react";
+import { useEffect as useEffect2, useState } from "react";
 function useNfcState() {
-  const [nfcState, setNfcState] = useState2(nfcService.getState());
-  useEffect3(() => nfcService.subscribe(setNfcState), []);
+  const [nfcState, setNfcState] = useState(nfcService.getState());
+  useEffect2(() => nfcService.subscribe(setNfcState), []);
   return nfcState;
 }
 
 // src/react/use-nfc-technology.ts
-import NfcManager6, {
-  Ndef as Ndef2,
-  NfcTech as NfcTech4
+import NfcManager, {
+  Ndef as Ndef3,
+  NfcTech as NfcTech3
 } from "react-native-nfc-manager";
 function useNfcTechnology() {
   async function writeNdef(records) {
-    return nfcService.withTechnology(NfcTech4.Ndef, async () => {
-      const bytes = Ndef2.encodeMessage(records);
-      await NfcManager6.ndefHandler.writeNdefMessage(bytes);
+    return nfcService.withTechnology(NfcTech3.Ndef, async () => {
+      const bytes = Ndef3.encodeMessage(records);
+      await NfcManager.ndefHandler.writeNdefMessage(bytes);
     });
   }
-  async function runWithTech(tech, fn) {
-    return nfcService.withTechnology(tech, fn);
+  async function runWithTech(tech3, fn) {
+    return nfcService.withTechnology(tech3, fn);
   }
   return {
     writeNdef,
@@ -581,14 +751,12 @@ function useNfcTechnology() {
   };
 }
 export {
-  NfcProvider,
   nfc,
-  a_exports as nfcA,
-  ndef_exports as nfcNdef,
+  nfcNdefTag,
   nfcService,
-  v_exports as nfcV,
+  nfcTag,
+  nfcVTag,
   useNfc,
-  useNfcContext,
   useNfcReader,
   useNfcState,
   useNfcTechnology