@ovok/native 0.4.6 → 0.4.7

package/lib/commonjs/modules/bt-management/services/devices/lepu/lepu.commands.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LepuCommand = void 0;
+/**
+ * The commands every Lepu device understands.
+ *
+ * These are the generic opcodes, shared across the whole family. Device-specific opcodes live
+ * below 0x40 and belong with their driver, because the same number means different things on
+ * different hardware - 0x08 polls realtime data on a BP2 and starts a measurement on others.
+ * That collision is why this module holds only the opcodes that are genuinely common, and why
+ * a driver must never assume a low opcode is safe to send to an unidentified device.
+ */
+const LepuCommand = exports.LepuCommand = {
+  /** Link keepalive and round-trip test. Inert. */
+  ECHO: 0xe0,
+  /**
+   * Device information, including the model string.
+   *
+   * Inert and identical family-wide, which makes it the one command safe to send before a
+   * device has been identified - and therefore the way to confirm what something is before
+   * addressing it with an opcode that means something else on the wrong hardware.
+   */
+  GET_INFO: 0xe1,
+  GET_BATTERY: 0xe4,
+  /** Enumerate the records stored on the device. */
+  GET_FILE_LIST: 0xf1,
+  /** Begin a read: a 20-byte payload of file name plus a 32-bit offset. */
+  READ_FILE_START: 0xf2,
+  /** Fetch the next chunk of the file being read. */
+  READ_FILE_DATA: 0xf3,
+  /** End the read and release the device's file handle. */
+  READ_FILE_END: 0xf4
+};
+//# sourceMappingURL=lepu.commands.js.map

package/lib/commonjs/modules/bt-management/services/devices/lepu/lepu.commands.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["LepuCommand","exports","ECHO","GET_INFO","GET_BATTERY","GET_FILE_LIST","READ_FILE_START","READ_FILE_DATA","READ_FILE_END"],"sourceRoot":"../../../../../../../src","sources":["modules/bt-management/services/devices/lepu/lepu.commands.ts"],"mappings":";;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMA,WAAW,GAAAC,OAAA,CAAAD,WAAA,GAAG;EACzB;EACAE,IAAI,EAAE,IAAI;EAEV;AACF;AACA;AACA;AACA;AACA;AACA;EACEC,QAAQ,EAAE,IAAI;EAEdC,WAAW,EAAE,IAAI;EAEjB;EACAC,aAAa,EAAE,IAAI;EAEnB;EACAC,eAAe,EAAE,IAAI;EAErB;EACAC,cAAc,EAAE,IAAI;EAEpB;EACAC,aAAa,EAAE;AACjB,CAAU","ignoreList":[]}

package/lib/commonjs/modules/bt-management/services/devices/lepu/lepu.device-info.js

@@ -0,0 +1,83 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseLepuDeviceInfo = void 0;
+var _hexToByte = require("../../../utils/hex-to-byte.js");
+var _le16FromHex = require("../../../utils/le-16-from-hex.js");
+var _lepuCommands = require("./lepu.commands.js");
+var _lepuResponseType = require("./lepu.response-type.js");
+const COMMAND_INDEX = 1;
+const HEADER_BYTES = 7;
+
+/** Offsets within the payload, per the vendor's own `Bp2DeviceInfo` layout. */
+const BRANCH_CODE_OFFSET = 9;
+const BRANCH_CODE_BYTES = 8;
+const DEVICE_TYPE_OFFSET = 20;
+const PROTOCOL_MAX_LENGTH_OFFSET = 31;
+const SERIAL_LENGTH_OFFSET = 37;
+const SERIAL_OFFSET = 38;
+
+/** The vendor clamps the reported serial length, implying firmware has overstated it. */
+const MAX_SERIAL_BYTES = 18;
+
+/** Everything up to and including the serial length. Less than this is not device info. */
+const MIN_PAYLOAD_BYTES = SERIAL_OFFSET;
+const NUL = 0;
+
+/**
+ * Reads a zero-padded ASCII field.
+ *
+ * These fields are fixed width rather than length-prefixed, so the padding is where the
+ * value ends. Reading the full width would append NULs to every string.
+ */
+const asciiAt = (frame, start, length) => {
+  let text = "";
+  for (let index = start; index < start + length; index++) {
+    const byte = (0, _hexToByte.hexToByte)(frame[index] ?? "0");
+    if (byte === NUL) {
+      return text;
+    }
+    text += String.fromCharCode(byte);
+  }
+  return text;
+};
+
+/** What a Lepu device says it is, in answer to `GET_INFO`. */
+
+/**
+ * Reads the reply to `GET_INFO`, or nothing if the frame is not one.
+ *
+ * The command byte is checked rather than assumed, because this is the answer a driver
+ * decides its identity on: parsing some other frame as device info would produce a model
+ * number out of whatever bytes happened to sit at offset 20, and the gate would then pass
+ * on a coincidence.
+ *
+ * A frame too short to hold the layout is refused for the same reason, as is one whose
+ * response type is anything but success: an error reply carries a reason where the device
+ * information would be, and reading it as a model number would identify the hardware from
+ * an error code. The vendor's own struct is at least 56 bytes; anything shorter than the
+ * serial length field cannot be read without inventing the parts that are missing.
+ */
+const parseLepuDeviceInfo = frame => {
+  if ((0, _hexToByte.hexToByte)(frame[COMMAND_INDEX] ?? "0") !== _lepuCommands.LepuCommand.GET_INFO) {
+    return undefined;
+  }
+  if (!(0, _lepuResponseType.isLepuSuccess)(frame)) {
+    return undefined;
+  }
+  if (frame.length < HEADER_BYTES + MIN_PAYLOAD_BYTES) {
+    return undefined;
+  }
+  const payload = HEADER_BYTES;
+  const serialLength = Math.min((0, _hexToByte.hexToByte)(frame[payload + SERIAL_LENGTH_OFFSET] ?? "0"), MAX_SERIAL_BYTES);
+  return {
+    deviceType: (0, _le16FromHex.le16FromHex)(frame, payload + DEVICE_TYPE_OFFSET),
+    protocolMaxLength: (0, _le16FromHex.le16FromHex)(frame, payload + PROTOCOL_MAX_LENGTH_OFFSET),
+    branchCode: asciiAt(frame, payload + BRANCH_CODE_OFFSET, BRANCH_CODE_BYTES),
+    serialNumber: asciiAt(frame, payload + SERIAL_OFFSET, serialLength)
+  };
+};
+exports.parseLepuDeviceInfo = parseLepuDeviceInfo;
+//# sourceMappingURL=lepu.device-info.js.map

package/lib/commonjs/modules/bt-management/services/devices/lepu/lepu.device-info.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_hexToByte","require","_le16FromHex","_lepuCommands","_lepuResponseType","COMMAND_INDEX","HEADER_BYTES","BRANCH_CODE_OFFSET","BRANCH_CODE_BYTES","DEVICE_TYPE_OFFSET","PROTOCOL_MAX_LENGTH_OFFSET","SERIAL_LENGTH_OFFSET","SERIAL_OFFSET","MAX_SERIAL_BYTES","MIN_PAYLOAD_BYTES","NUL","asciiAt","frame","start","length","text","index","byte","hexToByte","String","fromCharCode","parseLepuDeviceInfo","LepuCommand","GET_INFO","undefined","isLepuSuccess","payload","serialLength","Math","min","deviceType","le16FromHex","protocolMaxLength","branchCode","serialNumber","exports"],"sourceRoot":"../../../../../../../src","sources":["modules/bt-management/services/devices/lepu/lepu.device-info.ts"],"mappings":";;;;;;AAAA,IAAAA,UAAA,GAAAC,OAAA;AACA,IAAAC,YAAA,GAAAD,OAAA;AAEA,IAAAE,aAAA,GAAAF,OAAA;AACA,IAAAG,iBAAA,GAAAH,OAAA;AAEA,MAAMI,aAAa,GAAG,CAAC;AACvB,MAAMC,YAAY,GAAG,CAAC;;AAEtB;AACA,MAAMC,kBAAkB,GAAG,CAAC;AAC5B,MAAMC,iBAAiB,GAAG,CAAC;AAC3B,MAAMC,kBAAkB,GAAG,EAAE;AAC7B,MAAMC,0BAA0B,GAAG,EAAE;AACrC,MAAMC,oBAAoB,GAAG,EAAE;AAC/B,MAAMC,aAAa,GAAG,EAAE;;AAExB;AACA,MAAMC,gBAAgB,GAAG,EAAE;;AAE3B;AACA,MAAMC,iBAAiB,GAAGF,aAAa;AAEvC,MAAMG,GAAG,GAAG,CAAC;;AAEb;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,OAAO,GAAGA,CACdC,KAAwB,EACxBC,KAAa,EACbC,MAAc,KACH;EACX,IAAIC,IAAI,GAAG,EAAE;EAEb,KAAK,IAAIC,KAAK,GAAGH,KAAK,EAAEG,KAAK,GAAGH,KAAK,GAAGC,MAAM,EAAEE,KAAK,EAAE,EAAE;IACvD,MAAMC,IAAI,GAAG,IAAAC,oBAAS,EAACN,KAAK,CAACI,KAAK,CAAC,IAAI,GAAG,CAAC;IAE3C,IAAIC,IAAI,KAAKP,GAAG,EAAE;MAChB,OAAOK,IAAI;IACb;IAEAA,IAAI,IAAII,MAAM,CAACC,YAAY,CAACH,IAAI,CAAC;EACnC;EAEA,OAAOF,IAAI;AACb,CAAC;;AAED;;AAaA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMM,mBAAmB,GACvBT,KAAwB,IACO;EAC/B,IAAI,IAAAM,oBAAS,EAACN,KAAK,CAACZ,aAAa,CAAC,IAAI,GAAG,CAAC,KAAKsB,yBAAW,CAACC,QAAQ,EAAE;IACnE,OAAOC,SAAS;EAClB;EAEA,IAAI,CAAC,IAAAC,+BAAa,EAACb,KAAK,CAAC,EAAE;IACzB,OAAOY,SAAS;EAClB;EAEA,IAAIZ,KAAK,CAACE,MAAM,GAAGb,YAAY,GAAGQ,iBAAiB,EAAE;IACnD,OAAOe,SAAS;EAClB;EAEA,MAAME,OAAO,GAAGzB,YAAY;EAE5B,MAAM0B,YAAY,GAAGC,IAAI,CAACC,GAAG,CAC3B,IAAAX,oBAAS,EAACN,KAAK,CAACc,OAAO,GAAGpB,oBAAoB,CAAC,IAAI,GAAG,CAAC,EACvDE,gBACF,CAAC;EAED,OAAO;IACLsB,UAAU,EAAE,IAAAC,wBAAW,EAACnB,KAAK,EAAEc,OAAO,GAAGtB,kBAAkB,CAAC;IAC5D4B,iBAAiB,EAAE,IAAAD,wBAAW,EAACnB,KAAK,EAAEc,OAAO,GAAGrB,0BAA0B,CAAC;IAC3E4B,UAAU,EAAEtB,OAAO,CAACC,KAAK,EAAEc,OAAO,GAAGxB,kBAAkB,EAAEC,iBAAiB,CAAC;IAC3E+B,YAAY,EAAEvB,OAAO,CAACC,KAAK,EAAEc,OAAO,GAAGnB,aAAa,EAAEoB,YAAY;EACpE,CAAC;AACH,CAAC;AAACQ,OAAA,CAAAd,mBAAA,GAAAA,mBAAA","ignoreList":[]}

package/lib/commonjs/modules/bt-management/services/devices/lepu/lepu.device-names.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LEPU_DEVICE_NAMES = void 0;
+/**
+ * The names the Lepu/Viatom family advertises, as its own SDK matches them.
+ *
+ * Taken from the vendor's `getDeviceModel`, a 732-line cascade of substring checks that is
+ * the whole of how that SDK decides which product it is talking to. The order there matters,
+ * because 27 of these names are a prefix of another - `BP2` of `BP2A`, `BP2T`, `BP2W` and
+ * three more - so a check that ran in the wrong order would bind a BP2W as a BP2 and poll it
+ * with an opcode written for different hardware.
+ *
+ * It is that function's vocabulary, not a catalogue of everything the vendor sells: a few
+ * products - the ER3 and the M12 among them - are identified elsewhere in that app and never
+ * reach this list. `lepuNameMatch` accepts a name that is absent, and derives no exclusions
+ * for it, which is correct exactly when no name here extends it.
+ *
+ * They are held here as a flat vocabulary rather than an ordered cascade, because
+ * `lepuNameMatch` derives the exclusions from the list itself. Adding a name automatically
+ * narrows every name it extends, which an ordered list would leave to whoever inserted it.
+ */
+const LEPU_DEVICE_NAMES = exports.LEPU_DEVICE_NAMES = ["AI-S100", "AITele", "AIView VS", "AP-20", "AP-20-WPS", "AirBP", "Aura_BP2", "BBSM BS1", "BBSM P1", "BBSM S1", "BBSM S2", "BBSM S3", "BM10", "BP2", "BP2A", "BP2A Nexus", "BP2B", "BP2T", "BP2V", "BP2W", "BP3", "BP3-B", "BP3-C1", "BP3-C2", "BP3A", "BP3B", "BP3C", "BP3D", "BP3E", "BP3F", "BP3G", "BP3H", "BP3K", "BP3L", "BP3Z", "BP4 Flex", "BPWATCH", "BUZUD-CML", "Band-WU", "Bioland-BGM", "CB1L-1", "CMB590611", "CMB590840", "CMB592254", "CMI_PC303", "CMRing", "CMTouch", "CPR Feedback", "CPR-01", "CPR-02", "CheckADV", "Checkme", "Checkme EX", "Checkme Pod", "Checkme Pod-WPS", "Checkme lite A", "CheckmeLE", "CheckmeLP", "DUAL-SPP", "EM-B", "EM-W", "ER1", "ER1-H", "ER1-L", "ER1-S", "ER1-SP", "ER1-W", "ER1S", "ER2", "ER2-S", "EZY-HB-01", "EZY-HBB-02", "GM_300SNT", "GM_300SNT-BLE", "Genial-T31", "HDM3D", "HDM3G", "HHM1", "HHM2", "HHM3", "HHM4", "JFK1001", "JFR1001", "KCA", "KCB", "KS-60FW", "KardiaBP", "KidsO2-WPS", "LBM-1", "LEPU AED", "LEPU ER1", "LEPU-ER2", "LP ER2", "LP-BP2W", "LPM311", "LPRE", "Le S5", "Le-F2 Pro", "Le-W", "LeRes", "Lepod", "LepodPro", "Lepu PO6", "Lescale F3", "Lescale F4L", "Lescale F4P", "Lescale P3", "M5", "MY-SS2501", "N9+BP2", "O2 Intg", "O2M-WPS", "O2R WAVE", "O2RMed S", "O2Ring", "O2Ring S", "O2Ring SC", "O2Ring SF", "O2Ring SP", "O2Ring-RE", "O2RingF", "OxyU", "OxyU SE", "Oxyfit", "Oxyfit-WPS", "PC-100", "PC-200", "PC-200-BLE", "PC-60B_SN", "PC-60F_SN", "PC-60NW", "PC-60NW-1_SN", "PC-60NW-WPS", "PC-60NW_BLE", "PC-60NW_SN", "PC-66B", "PC-68B", "PC66B-VE", "PC80B", "PC80B-BLE", "PC80B_BLE:", "PC_300SNT", "PC_300SNT-BLE", "PF-10", "PF-10AW", "PF-10AW-1", "PF-10AW1", "PF-10BW", "PF-10BW1", "PF-10BWS", "PF-20", "PF-20AW", "PF-20B", "PF10AW-ME", "PF10BW-VE", "PM10", "PO6B-WE", "POD-1W-WU", "POD-1_SN", "POD-2B_SN", "PoctorM3102", "QC-200", "R10", "R11", "R20", "R200", "R21", "S5W-VU", "S5W_SN", "S6W", "S6W1", "S7BW", "S7W", "S8-AW", "SA10AW-PU", "SHQFlex", "SHQO2Pro", "SI PO2", "SI PO4", "SI PO6", "SP-20", "SP-20-BLE", "SP-20-WPS", "T-201", "TMB-2288", "TMB_2088", "VCOMIN", "VTM AD5", "W12c", "WBP-02", "ZH-SG", "ZH-SG-A606", "aed_box", "iGate", "int-ER2", "le B1", "le S1"];
+//# sourceMappingURL=lepu.device-names.js.map

package/lib/commonjs/modules/bt-management/services/devices/lepu/lepu.device-names.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["LEPU_DEVICE_NAMES","exports"],"sourceRoot":"../../../../../../../src","sources":["modules/bt-management/services/devices/lepu/lepu.device-names.ts"],"mappings":"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","ignoreList":[]}

package/lib/commonjs/modules/bt-management/services/devices/lepu/lepu.file-names.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.lepuNamesFrom = exports.lepuNameBytes = exports.NAME_BYTES = void 0;
+var _hexToByte = require("../../../utils/hex-to-byte.js");
+/** Names are a fixed sixteen bytes, zero padded, in both the listing and the request. */
+const NAME_BYTES = exports.NAME_BYTES = 16;
+const BYTE_MASK = 0xff;
+const NUL = 0;
+
+/**
+ * A file name as the device expects it: sixteen bytes, zero padded, truncated.
+ *
+ * The truncation is the device's, not ours - it copies at most sixteen bytes and pads the
+ * rest - so two names that agree in their first sixteen bytes are the same file as far as
+ * the protocol is concerned.
+ */
+const lepuNameBytes = name => Array.from({
+  length: NAME_BYTES
+}, (_, index) => index < name.length ? name.charCodeAt(index) & BYTE_MASK : NUL);
+
+/** The names in a file listing: a count, then that many fixed-width padded names. */
+exports.lepuNameBytes = lepuNameBytes;
+const lepuNamesFrom = payload => {
+  const count = (0, _hexToByte.hexToByte)(payload[0] ?? "0");
+  return Array.from({
+    length: count
+  }, (_, index) => {
+    const start = 1 + index * NAME_BYTES;
+    return payload.slice(start, start + NAME_BYTES).map(byte => (0, _hexToByte.hexToByte)(byte)).filter(byte => byte !== NUL).map(byte => String.fromCharCode(byte)).join("").trim();
+  }).filter(name => name.length > 0);
+};
+exports.lepuNamesFrom = lepuNamesFrom;
+//# sourceMappingURL=lepu.file-names.js.map

package/lib/commonjs/modules/bt-management/services/devices/lepu/lepu.file-names.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_hexToByte","require","NAME_BYTES","exports","BYTE_MASK","NUL","lepuNameBytes","name","Array","from","length","_","index","charCodeAt","lepuNamesFrom","payload","count","hexToByte","start","slice","map","byte","filter","String","fromCharCode","join","trim"],"sourceRoot":"../../../../../../../src","sources":["modules/bt-management/services/devices/lepu/lepu.file-names.ts"],"mappings":";;;;;;AAAA,IAAAA,UAAA,GAAAC,OAAA;AAEA;AACA,MAAMC,UAAU,GAAAC,OAAA,CAAAD,UAAA,GAAG,EAAE;AACrB,MAAME,SAAS,GAAG,IAAI;AACtB,MAAMC,GAAG,GAAG,CAAC;;AAEb;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,aAAa,GAAIC,IAAY,IACjCC,KAAK,CAACC,IAAI,CAAC;EAAEC,MAAM,EAAER;AAAW,CAAC,EAAE,CAACS,CAAC,EAAEC,KAAK,KAC1CA,KAAK,GAAGL,IAAI,CAACG,MAAM,GAAGH,IAAI,CAACM,UAAU,CAACD,KAAK,CAAC,GAAGR,SAAS,GAAGC,GAC7D,CAAC;;AAEH;AAAAF,OAAA,CAAAG,aAAA,GAAAA,aAAA;AACA,MAAMQ,aAAa,GAAIC,OAA0B,IAAe;EAC9D,MAAMC,KAAK,GAAG,IAAAC,oBAAS,EAACF,OAAO,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC;EAE1C,OAAOP,KAAK,CAACC,IAAI,CAAC;IAAEC,MAAM,EAAEM;EAAM,CAAC,EAAE,CAACL,CAAC,EAAEC,KAAK,KAAK;IACjD,MAAMM,KAAK,GAAG,CAAC,GAAGN,KAAK,GAAGV,UAAU;IAEpC,OAAOa,OAAO,CACXI,KAAK,CAACD,KAAK,EAAEA,KAAK,GAAGhB,UAAU,CAAC,CAChCkB,GAAG,CAAEC,IAAI,IAAK,IAAAJ,oBAAS,EAACI,IAAI,CAAC,CAAC,CAC9BC,MAAM,CAAED,IAAI,IAAKA,IAAI,KAAKhB,GAAG,CAAC,CAC9Be,GAAG,CAAEC,IAAI,IAAKE,MAAM,CAACC,YAAY,CAACH,IAAI,CAAC,CAAC,CACxCI,IAAI,CAAC,EAAE,CAAC,CACRC,IAAI,CAAC,CAAC;EACX,CAAC,CAAC,CAACJ,MAAM,CAAEf,IAAI,IAAKA,IAAI,CAACG,MAAM,GAAG,CAAC,CAAC;AACtC,CAAC;AAACP,OAAA,CAAAW,aAAA,GAAAA,aAAA","ignoreList":[]}

package/lib/commonjs/modules/bt-management/services/devices/lepu/lepu.file-transfer.js

@@ -0,0 +1,155 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LepuFileTransfer = void 0;
+var _le32FromHex = require("../../../utils/le-32-from-hex.js");
+var _le32ToBytes = require("../../../utils/le-32-to-bytes.js");
+var _lepuCommands = require("./lepu.commands.js");
+var _lepuFileNames = require("./lepu.file-names.js");
+var _lepuFrame = require("./lepu.frame.js");
+var _lepuResponseType = require("./lepu.response-type.js");
+const FILE_SIZE_OFFSET = 0;
+
+/**
+ * A hex-byte array costs far more memory than the file it describes, so the cap sits well
+ * below what a device could offer. A stored ECG is tens of kilobytes; a length near this one
+ * is a length to refuse rather than try to hold on a low-memory tablet.
+ */
+const MAX_FILE_BYTES = 262_144;
+const TRANSFER_COMMANDS = [_lepuCommands.LepuCommand.GET_FILE_LIST, _lepuCommands.LepuCommand.READ_FILE_START, _lepuCommands.LepuCommand.READ_FILE_DATA, _lepuCommands.LepuCommand.READ_FILE_END];
+/**
+ * Downloads the records a Lepu device has stored.
+ *
+ * Every opcode this uses is generic and inert - list, open, read, close - so unlike a
+ * realtime poll it is safe on hardware whose model is not known. That is what makes it the
+ * one thing the whole family can be asked for without identifying it first.
+ *
+ * The exchange is self-clocking and has no windowing: each reply decides the next request,
+ * and the device chooses how much to send, so the offset advances by what actually arrived
+ * rather than by an assumed chunk size. There is no retry in the protocol either - a single
+ * dropped reply stalls the transfer with nothing to resume it - which is what the data
+ * processor's stuck-data timeout is the watchdog for.
+ *
+ * A short read is an error, not a truncated success: the device is asked to close the file
+ * and the reading is discarded, because half an ECG that looks like a whole one is worse
+ * than none.
+ */
+class LepuFileTransfer {
+  files = [];
+  fileIndex = 0;
+  name = "";
+  totalBytes = 0;
+  content = [];
+  isSessionOpen = false;
+  isDone = false;
+  constructor(params) {
+    this.params = params;
+  }
+  initialCommands = () => [this.commandFor(_lepuCommands.LepuCommand.GET_FILE_LIST)];
+  nextCommand = frame => {
+    const command = (0, _lepuFrame.lepuCommandOf)(frame);
+    if (this.isDone || !TRANSFER_COMMANDS.includes(command)) {
+      return undefined;
+    }
+    if (!(0, _lepuResponseType.isLepuSuccess)(frame)) {
+      return this.fail(`the device refused it: ${(0, _lepuResponseType.describeLepuResponseType)(frame)}`);
+    }
+    if (command === _lepuCommands.LepuCommand.GET_FILE_LIST) {
+      this.files = (0, _lepuFileNames.lepuNamesFrom)((0, _lepuFrame.lepuPayloadOf)(frame));
+      this.fileIndex = 0;
+      return this.openNextFile();
+    }
+    if (command === _lepuCommands.LepuCommand.READ_FILE_START) {
+      return this.openedFile((0, _lepuFrame.lepuPayloadOf)(frame));
+    }
+    if (command === _lepuCommands.LepuCommand.READ_FILE_DATA) {
+      return this.appendChunk((0, _lepuFrame.lepuPayloadOf)(frame));
+    }
+    return this.closedFile();
+  };
+  openNextFile = () => {
+    const name = this.files[this.fileIndex];
+    if (name === undefined) {
+      this.isDone = true;
+      return undefined;
+    }
+    this.name = name;
+    this.totalBytes = 0;
+    this.content = [];
+    return [this.commandFor(_lepuCommands.LepuCommand.READ_FILE_START, [...(0, _lepuFileNames.lepuNameBytes)(name), ...(0, _le32ToBytes.le32ToBytes)(0)])];
+  };
+
+  /** The reply to opening a file states its whole length, which bounds everything after. */
+  openedFile = payload => {
+    this.isSessionOpen = true;
+    this.totalBytes = (0, _le32FromHex.le32FromHex)([...payload], FILE_SIZE_OFFSET);
+    const limit = this.params.maxFileBytes ?? MAX_FILE_BYTES;
+    if (this.totalBytes > limit) {
+      return this.fail(`"${this.name}" is ${this.totalBytes} bytes, more than the ${limit} this transfer will hold`);
+    }
+    if (this.totalBytes === 0) {
+      return this.closeFile();
+    }
+    return [this.commandFor(_lepuCommands.LepuCommand.READ_FILE_DATA, (0, _le32ToBytes.le32ToBytes)(0))];
+  };
+
+  /**
+   * A reply with no bytes in it ends the transfer rather than asking again from the same
+   * offset, which is a request the device would answer the same way for as long as the link
+   * stayed up.
+   */
+  appendChunk = payload => {
+    if (payload.length === 0) {
+      return this.fail(`"${this.name}" stopped sending at ${this.content.length} of ${this.totalBytes} bytes`);
+    }
+    this.content.push(...payload);
+    this.params.onProgress?.({
+      name: this.name,
+      receivedBytes: this.content.length,
+      totalBytes: this.totalBytes
+    });
+    if (this.content.length >= this.totalBytes) {
+      return this.closeFile();
+    }
+    return [this.commandFor(_lepuCommands.LepuCommand.READ_FILE_DATA, (0, _le32ToBytes.le32ToBytes)(this.content.length))];
+  };
+  closedFile = () => {
+    this.isSessionOpen = false;
+    if (this.totalBytes > 0 && this.content.length !== this.totalBytes) {
+      return this.fail(`"${this.name}" ended at ${this.content.length} of ${this.totalBytes} bytes`);
+    }
+    if (this.totalBytes > 0) {
+      this.params.onFile({
+        name: this.name,
+        content: this.content
+      });
+    }
+    this.fileIndex++;
+    return this.openNextFile();
+  };
+  closeFile = () => [this.commandFor(_lepuCommands.LepuCommand.READ_FILE_END)];
+
+  /**
+   * Stops, and releases the device's file handle if one is open.
+   *
+   * The device holds that handle from the moment a file is opened until it is closed, so
+   * walking away from a failed read can leave it open until the device times out or resets.
+   */
+  fail = reason => {
+    this.params.onError(reason);
+    this.isDone = true;
+    if (!this.isSessionOpen) {
+      return undefined;
+    }
+    this.isSessionOpen = false;
+    return this.closeFile();
+  };
+  commandFor = (command, payload = []) => ({
+    ...this.params.write,
+    frame: this.params.builder.build(command, payload)
+  });
+}
+exports.LepuFileTransfer = LepuFileTransfer;
+//# sourceMappingURL=lepu.file-transfer.js.map

package/lib/commonjs/modules/bt-management/services/devices/lepu/lepu.file-transfer.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_le32FromHex","require","_le32ToBytes","_lepuCommands","_lepuFileNames","_lepuFrame","_lepuResponseType","FILE_SIZE_OFFSET","MAX_FILE_BYTES","TRANSFER_COMMANDS","LepuCommand","GET_FILE_LIST","READ_FILE_START","READ_FILE_DATA","READ_FILE_END","LepuFileTransfer","files","fileIndex","name","totalBytes","content","isSessionOpen","isDone","constructor","params","initialCommands","commandFor","nextCommand","frame","command","lepuCommandOf","includes","undefined","isLepuSuccess","fail","describeLepuResponseType","lepuNamesFrom","lepuPayloadOf","openNextFile","openedFile","appendChunk","closedFile","lepuNameBytes","le32ToBytes","payload","le32FromHex","limit","maxFileBytes","closeFile","length","push","onProgress","receivedBytes","onFile","reason","onError","write","builder","build","exports"],"sourceRoot":"../../../../../../../src","sources":["modules/bt-management/services/devices/lepu/lepu.file-transfer.ts"],"mappings":"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","ignoreList":[]}

package/lib/commonjs/modules/bt-management/services/devices/lepu/lepu.frame-reader.js

@@ -0,0 +1,98 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LepuFrameReader = void 0;
+var _frameReadStatus = require("../../../types/frame-read-status.js");
+var _calculateCrc = require("../../../utils/calculate-crc-8.js");
+var _hexToByte = require("../../../utils/hex-to-byte.js");
+var _le16FromHex = require("../../../utils/le-16-from-hex.js");
+const COMMAND_INDEX = 1;
+const COMMAND_COMPLEMENT_INDEX = 2;
+const PAYLOAD_LENGTH_INDEX = 5;
+const HEADER_BYTES = 7;
+const CHECKSUM_BYTES = 1;
+const BYTE_MASK = 0xff;
+
+/** Start byte, command and its complement: the shortest run that can identify a start. */
+const START_PATTERN_BYTES = 3;
+
+/**
+ * Reads the frame every Lepu device shares.
+ *
+ * Layout: `start | cmd | ~cmd | type | seq | lenLow lenHigh | payload | crc8`, where the
+ * checksum covers every byte before it. The complement of the command byte only narrows the
+ * search for a start; the checksum is what actually decides a frame is trustworthy.
+ *
+ * The start byte is the only part that varies across the family. Most devices use `a5`, a
+ * smaller group uses `55`, and a few accept either and settle on one at runtime - so it is a
+ * list rather than a single value. Everything else is identical on every device speaking this
+ * protocol, which is why it is worth having once rather than once per device.
+ */
+class LepuFrameReader {
+  constructor(startBytes) {
+    this.startBytes = startBytes;
+  }
+  readFrame(buffer) {
+    const start = this.findFrameStart(buffer);
+    if (start === -1) {
+      return {
+        status: _frameReadStatus.FrameReadStatus.INCOMPLETE,
+        consumedBytes: this.droppableLeadingBytes(buffer)
+      };
+    }
+    const payloadLength = (0, _le16FromHex.le16FromHex)(buffer, start + PAYLOAD_LENGTH_INDEX);
+    const frameLength = HEADER_BYTES + payloadLength + CHECKSUM_BYTES;
+    if (start + frameLength > buffer.length) {
+      return {
+        status: _frameReadStatus.FrameReadStatus.INCOMPLETE,
+        consumedBytes: start
+      };
+    }
+    const frame = buffer.slice(start, start + frameLength);
+    if (!this.hasValidChecksum(frame)) {
+      return {
+        status: _frameReadStatus.FrameReadStatus.CORRUPT,
+        consumedBytes: start + START_PATTERN_BYTES
+      };
+    }
+    return {
+      status: _frameReadStatus.FrameReadStatus.COMPLETE,
+      consumedBytes: start + frameLength,
+      frame
+    };
+  }
+  isFrameStart(buffer, index) {
+    if (!this.startBytes.includes((buffer[index] || "").toLowerCase())) {
+      return false;
+    }
+    const command = (0, _hexToByte.hexToByte)(buffer[index + COMMAND_INDEX] || "0");
+    const complement = (0, _hexToByte.hexToByte)(buffer[index + COMMAND_COMPLEMENT_INDEX] || "0");
+    return command === (~complement & BYTE_MASK);
+  }
+  findFrameStart(buffer) {
+    const lastCandidate = buffer.length - START_PATTERN_BYTES;
+    for (let index = 0; index <= lastCandidate; index++) {
+      if (this.isFrameStart(buffer, index)) {
+        return index;
+      }
+    }
+    return -1;
+  }
+
+  /**
+   * Bytes that cannot begin a frame start, and are therefore safe to drop when no start was
+   * found. The trailing bytes are kept because a start pattern may still be arriving.
+   */
+  droppableLeadingBytes(buffer) {
+    return Math.max(0, buffer.length - (START_PATTERN_BYTES - 1));
+  }
+  hasValidChecksum(frame) {
+    const checksummedBytes = frame.length - CHECKSUM_BYTES;
+    const declared = (0, _hexToByte.hexToByte)(frame[checksummedBytes] || "0");
+    return declared === (0, _calculateCrc.calculateCrc8)(frame, checksummedBytes);
+  }
+}
+exports.LepuFrameReader = LepuFrameReader;
+//# sourceMappingURL=lepu.frame-reader.js.map

package/lib/commonjs/modules/bt-management/services/devices/lepu/lepu.frame-reader.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_frameReadStatus","require","_calculateCrc","_hexToByte","_le16FromHex","COMMAND_INDEX","COMMAND_COMPLEMENT_INDEX","PAYLOAD_LENGTH_INDEX","HEADER_BYTES","CHECKSUM_BYTES","BYTE_MASK","START_PATTERN_BYTES","LepuFrameReader","constructor","startBytes","readFrame","buffer","start","findFrameStart","status","FrameReadStatus","INCOMPLETE","consumedBytes","droppableLeadingBytes","payloadLength","le16FromHex","frameLength","length","frame","slice","hasValidChecksum","CORRUPT","COMPLETE","isFrameStart","index","includes","toLowerCase","command","hexToByte","complement","lastCandidate","Math","max","checksummedBytes","declared","calculateCrc8","exports"],"sourceRoot":"../../../../../../../src","sources":["modules/bt-management/services/devices/lepu/lepu.frame-reader.ts"],"mappings":"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","ignoreList":[]}

package/lib/commonjs/modules/bt-management/services/devices/lepu/lepu.frame.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.lepuPayloadOf = exports.lepuCommandOf = void 0;
+var _hexToByte = require("../../../utils/hex-to-byte.js");
+var _le16FromHex = require("../../../utils/le-16-from-hex.js");
+const COMMAND_INDEX = 1;
+const PAYLOAD_LENGTH_INDEX = 5;
+const HEADER_BYTES = 7;
+
+/** The opcode a frame answers, which is what correlates a reply to its request. */
+const lepuCommandOf = frame => (0, _hexToByte.hexToByte)(frame[COMMAND_INDEX] ?? "0");
+
+/**
+ * The bytes a frame carries, from its own declared length.
+ *
+ * Declared rather than derived from what arrived: the frame reader has already checked that
+ * the buffer holds the whole frame, so the length field is the payload's end, and trusting
+ * the array instead would fold the checksum byte into the data.
+ */
+exports.lepuCommandOf = lepuCommandOf;
+const lepuPayloadOf = frame => {
+  const length = (0, _le16FromHex.le16FromHex)(frame, PAYLOAD_LENGTH_INDEX);
+  return frame.slice(HEADER_BYTES, HEADER_BYTES + length);
+};
+exports.lepuPayloadOf = lepuPayloadOf;
+//# sourceMappingURL=lepu.frame.js.map

package/lib/commonjs/modules/bt-management/services/devices/lepu/lepu.frame.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_hexToByte","require","_le16FromHex","COMMAND_INDEX","PAYLOAD_LENGTH_INDEX","HEADER_BYTES","lepuCommandOf","frame","hexToByte","exports","lepuPayloadOf","length","le16FromHex","slice"],"sourceRoot":"../../../../../../../src","sources":["modules/bt-management/services/devices/lepu/lepu.frame.ts"],"mappings":";;;;;;AAAA,IAAAA,UAAA,GAAAC,OAAA;AACA,IAAAC,YAAA,GAAAD,OAAA;AAEA,MAAME,aAAa,GAAG,CAAC;AACvB,MAAMC,oBAAoB,GAAG,CAAC;AAC9B,MAAMC,YAAY,GAAG,CAAC;;AAEtB;AACA,MAAMC,aAAa,GAAIC,KAAwB,IAC7C,IAAAC,oBAAS,EAACD,KAAK,CAACJ,aAAa,CAAC,IAAI,GAAG,CAAC;;AAExC;AACA;AACA;AACA;AACA;AACA;AACA;AANAM,OAAA,CAAAH,aAAA,GAAAA,aAAA;AAOA,MAAMI,aAAa,GAAIH,KAAwB,IAAe;EAC5D,MAAMI,MAAM,GAAG,IAAAC,wBAAW,EAACL,KAAK,EAAEH,oBAAoB,CAAC;EAEvD,OAAOG,KAAK,CAACM,KAAK,CAACR,YAAY,EAAEA,YAAY,GAAGM,MAAM,CAAC;AACzD,CAAC;AAACF,OAAA,CAAAC,aAAA,GAAAA,aAAA","ignoreList":[]}

package/lib/commonjs/modules/bt-management/services/devices/lepu/lepu.identity-gate.js

@@ -0,0 +1,103 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LepuIdentityGate = void 0;
+var _hexToByte = require("../../../utils/hex-to-byte.js");
+var _lepuCommands = require("./lepu.commands.js");
+var _lepuDeviceInfo = require("./lepu.device-info.js");
+var _lepuResponseType = require("./lepu.response-type.js");
+const COMMAND_INDEX = 1;
+
+/**
+ * Asks a Lepu device what it is before sending it anything that acts.
+ *
+ * The family shares one frame format, one checksum and one opcode space, but not one
+ * meaning: `0x08` polls realtime data on a BP2, starts a blood-pressure measurement on an
+ * AirBp and starts an ECG on a Lepod. A frame built for the wrong device is therefore
+ * perfectly well-formed - the CRC is computed the same way on every one of them - so
+ * nothing in the protocol catches a driver bound to the wrong hardware. What comes back is
+ * a cuff inflating on someone's arm because a name matched during a scan.
+ *
+ * `GET_INFO` is the one command that cannot cause that: it is generic, inert, and answered
+ * identically family-wide. So it goes first, and everything else waits on its reply.
+ *
+ * A declaration that names the models it was written for is refused permanently when the
+ * device answers with a different one. A declaration that names none is identified by the
+ * advertised name it already matched, which is the basis the vendor's own SDK binds every
+ * one of its products on; it is asked what it is anyway, and the answer reported, because
+ * that is the only place these model numbers exist - the vendor never reads the field back,
+ * so there is no table of them to copy.
+ *
+ * A reply that never arrives leaves the gate closed and nothing sent, which the data
+ * processor's stuck-data timeout reports and disconnects on. That is the watchdog for this
+ * too - the protocol has no retry of its own, so a dropped reply is recovered by
+ * reconnecting rather than by asking again.
+ */
+class LepuIdentityGate {
+  isIdentified = false;
+  isRefused = false;
+  constructor(params) {
+    this.params = params;
+  }
+  initialCommands = () => [this.commandFor(_lepuCommands.LepuCommand.GET_INFO)];
+  nextCommand = frame => {
+    if (this.isRefused) {
+      return undefined;
+    }
+    if (this.isIdentified) {
+      return this.poll();
+    }
+    return this.admit(frame);
+  };
+
+  /**
+   * Decides on the reply to `GET_INFO`.
+   *
+   * A frame that is not that reply leaves the gate as it was rather than provoking another
+   * command, because the only command outstanding is the one still being waited on.
+   *
+   * A reply that is that command but carries an error type is refused rather than parsed.
+   * The payload of an error is the reason for it, so reading a model number out of it would
+   * identify the hardware from an error code.
+   */
+  admit = frame => {
+    if ((0, _hexToByte.hexToByte)(frame[COMMAND_INDEX] ?? "0") !== _lepuCommands.LepuCommand.GET_INFO) {
+      return undefined;
+    }
+    if (!(0, _lepuResponseType.isLepuSuccess)(frame)) {
+      return this.refuse(`the device would not say what it is: ${(0, _lepuResponseType.describeLepuResponseType)(frame)}`);
+    }
+    const info = (0, _lepuDeviceInfo.parseLepuDeviceInfo)(frame);
+    if (!info) {
+      return this.refuse("the device answered with a frame too short to hold its own model number");
+    }
+    this.params.onIdentified?.(info);
+    if (this.params.pollCommand === undefined) {
+      return undefined;
+    }
+    const isNarrowed = this.params.expectedDeviceTypes.length > 0;
+    if (isNarrowed && !this.params.expectedDeviceTypes.includes(info.deviceType)) {
+      return this.refuse(`the hardware reported model ${info.deviceType} (branch "${info.branchCode}"), which this declaration was not written for`);
+    }
+    this.isIdentified = true;
+    return this.poll();
+  };
+
+  /** Closes the gate for good. There is no state a refused device can be talked back from. */
+  refuse = reason => {
+    this.isRefused = true;
+    this.params.onRefused(reason);
+    return undefined;
+  };
+
+  /** Nothing, for a declaration that asks what the device is and stops there. */
+  poll = () => this.params.pollCommand === undefined ? undefined : [this.commandFor(this.params.pollCommand)];
+  commandFor = command => ({
+    ...this.params.write,
+    frame: this.params.builder.build(command)
+  });
+}
+exports.LepuIdentityGate = LepuIdentityGate;
+//# sourceMappingURL=lepu.identity-gate.js.map

package/lib/commonjs/modules/bt-management/services/devices/lepu/lepu.identity-gate.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_hexToByte","require","_lepuCommands","_lepuDeviceInfo","_lepuResponseType","COMMAND_INDEX","LepuIdentityGate","isIdentified","isRefused","constructor","params","initialCommands","commandFor","LepuCommand","GET_INFO","nextCommand","frame","undefined","poll","admit","hexToByte","isLepuSuccess","refuse","describeLepuResponseType","info","parseLepuDeviceInfo","onIdentified","pollCommand","isNarrowed","expectedDeviceTypes","length","includes","deviceType","branchCode","reason","onRefused","command","write","builder","build","exports"],"sourceRoot":"../../../../../../../src","sources":["modules/bt-management/services/devices/lepu/lepu.identity-gate.ts"],"mappings":";;;;;;AAEA,IAAAA,UAAA,GAAAC,OAAA;AAGA,IAAAC,aAAA,GAAAD,OAAA;AACA,IAAAE,eAAA,GAAAF,OAAA;AACA,IAAAG,iBAAA,GAAAH,OAAA;AAsCA,MAAMI,aAAa,GAAG,CAAC;;AAEvB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMC,gBAAgB,CAA6B;EAChDC,YAAY,GAAG,KAAK;EACpBC,SAAS,GAAG,KAAK;EAElBC,WAAWA,CAAkBC,MAA8B,EAAE;IAAA,KAAhCA,MAA8B,GAA9BA,MAA8B;EAAG;EAE9DC,eAAe,GAAGA,CAAA,KAAgC,CACvD,IAAI,CAACC,UAAU,CAACC,yBAAW,CAACC,QAAQ,CAAC,CACtC;EAEMC,WAAW,GAChBC,KAAwB,IACiB;IACzC,IAAI,IAAI,CAACR,SAAS,EAAE;MAClB,OAAOS,SAAS;IAClB;IAEA,IAAI,IAAI,CAACV,YAAY,EAAE;MACrB,OAAO,IAAI,CAACW,IAAI,CAAC,CAAC;IACpB;IAEA,OAAO,IAAI,CAACC,KAAK,CAACH,KAAK,CAAC;EAC1B,CAAC;;EAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACUG,KAAK,GACXH,KAAwB,IACiB;IACzC,IAAI,IAAAI,oBAAS,EAACJ,KAAK,CAACX,aAAa,CAAC,IAAI,GAAG,CAAC,KAAKQ,yBAAW,CAACC,QAAQ,EAAE;MACnE,OAAOG,SAAS;IAClB;IAEA,IAAI,CAAC,IAAAI,+BAAa,EAACL,KAAK,CAAC,EAAE;MACzB,OAAO,IAAI,CAACM,MAAM,CAChB,wCAAwC,IAAAC,0CAAwB,EAACP,KAAK,CAAC,EACzE,CAAC;IACH;IAEA,MAAMQ,IAAI,GAAG,IAAAC,mCAAmB,EAACT,KAAK,CAAC;IAEvC,IAAI,CAACQ,IAAI,EAAE;MACT,OAAO,IAAI,CAACF,MAAM,CAChB,yEACF,CAAC;IACH;IAEA,IAAI,CAACZ,MAAM,CAACgB,YAAY,GAAGF,IAAI,CAAC;IAEhC,IAAI,IAAI,CAACd,MAAM,CAACiB,WAAW,KAAKV,SAAS,EAAE;MACzC,OAAOA,SAAS;IAClB;IAEA,MAAMW,UAAU,GAAG,IAAI,CAAClB,MAAM,CAACmB,mBAAmB,CAACC,MAAM,GAAG,CAAC;IAE7D,IAAIF,UAAU,IAAI,CAAC,IAAI,CAAClB,MAAM,CAACmB,mBAAmB,CAACE,QAAQ,CAACP,IAAI,CAACQ,UAAU,CAAC,EAAE;MAC5E,OAAO,IAAI,CAACV,MAAM,CAChB,+BAA+BE,IAAI,CAACQ,UAAU,aAAaR,IAAI,CAACS,UAAU,gDAC5E,CAAC;IACH;IAEA,IAAI,CAAC1B,YAAY,GAAG,IAAI;IAExB,OAAO,IAAI,CAACW,IAAI,CAAC,CAAC;EACpB,CAAC;;EAED;EACQI,MAAM,GAAIY,MAAc,IAAgB;IAC9C,IAAI,CAAC1B,SAAS,GAAG,IAAI;IACrB,IAAI,CAACE,MAAM,CAACyB,SAAS,CAACD,MAAM,CAAC;IAE7B,OAAOjB,SAAS;EAClB,CAAC;;EAED;EACQC,IAAI,GAAGA,CAAA,KACb,IAAI,CAACR,MAAM,CAACiB,WAAW,KAAKV,SAAS,GACjCA,SAAS,GACT,CAAC,IAAI,CAACL,UAAU,CAAC,IAAI,CAACF,MAAM,CAACiB,WAAW,CAAC,CAAC;EAExCf,UAAU,GAAIwB,OAAe,KAAqB;IACxD,GAAG,IAAI,CAAC1B,MAAM,CAAC2B,KAAK;IACpBrB,KAAK,EAAE,IAAI,CAACN,MAAM,CAAC4B,OAAO,CAACC,KAAK,CAACH,OAAO;EAC1C,CAAC,CAAC;AACJ;AAACI,OAAA,CAAAlC,gBAAA,GAAAA,gBAAA","ignoreList":[]}