@bitgo-beta/key-card 0.0.1-beta.201 → 0.0.1-beta.2011

package/dist/src/parseKeycard.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseVaultKeycardBox = parseVaultKeycardBox;
+exports.buildLinesFromPDFNodes = buildLinesFromPDFNodes;
+exports.parseKeycardFromLines = parseKeycardFromLines;
+const types_1 = require("./types");
+/**
+ * Parses a vault keycard box value — the JSON packed by `generateVaultQrData`, e.g.
+ * `{"secp256k1Multisig":"…","ecdsaMpc":"…",…}` — into its four roots. Validates that all four
+ * roots are present. Recovery tooling calls this on the A/B/C box value returned by
+ * {@link parseKeycardFromLines}, then decrypts each root value with the wallet password.
+ */
+function parseVaultKeycardBox(data) {
+    let parsed;
+    try {
+        parsed = JSON.parse(data);
+    }
+    catch {
+        throw new Error('parseVaultKeycardBox: value is not valid JSON');
+    }
+    if (typeof parsed !== 'object' || parsed === null) {
+        throw new Error('parseVaultKeycardBox: value is not an object');
+    }
+    const roots = parsed;
+    for (const slot of types_1.VAULT_ROOT_ORDER) {
+        if (typeof roots[slot] !== 'string') {
+            throw new Error(`parseVaultKeycardBox: missing or invalid root ${slot}`);
+        }
+    }
+    return parsed;
+}
+const sectionHeaderRegex = /^([A-D])\s*[:.)-]\s*(.+?)\s*$/i;
+const dataLineRegex = /^data\s*:\s*(.*)$/i;
+const faqHeaderRegex = /^BitGo\s+KeyCard\s+FAQ$/i;
+// PDF coordinate tolerance in points. Nodes within this distance on the Y-axis
+// are treated as belonging to the same line; nodes further apart are separate lines.
+const PDF_LINE_Y_TOLERANCE = 2;
+// Horizontal gap in points above which a space is inserted between adjacent nodes.
+const PDF_NODE_GAP_THRESHOLD = 2;
+function sanitizeText(input) {
+    return input.replace(/\s+/g, ' ').trim();
+}
+function normalizeSectionValue(rawValue) {
+    // Two-pass removal of "Part N" page-continuation labels:
+    // 1. Line filter: removes labels that appear as standalone lines.
+    // 2. Regex replace: removes labels embedded mid-line when
+    //    buildLinesFromPDFNodes merges them with adjacent content at the same
+    //    y-coordinate (e.g. "...X88bPart 2 lFPMd...").
+    // join('') intentionally uses no separator — section values are continuous
+    // strings (base64 / xpub) that wrap across PDF lines without spaces.
+    return rawValue
+        .split('\n')
+        .filter((line) => !/^Part\s+\d+$/i.test(line.trim()))
+        .join('')
+        .replace(/\s*Part\s+\d+\s*/gi, '')
+        .trim();
+}
+function countChar(input, char) {
+    return input.split(char).length - 1;
+}
+function isEncryptedWalletPasswordSectionTitle(title) {
+    return title.toLowerCase().includes('encrypted wallet password');
+}
+/**
+ * Reconstructs logical text lines from an unordered set of PDF text nodes.
+ *
+ * PDF text extraction returns individual positioned fragments. This function
+ * sorts them by page then Y-coordinate (top-to-bottom), groups fragments
+ * within PDF_LINE_Y_TOLERANCE points of each other onto the same line, and
+ * inserts a space between fragments that are separated by more than
+ * PDF_NODE_GAP_THRESHOLD points horizontally.
+ */
+function buildLinesFromPDFNodes(nodes) {
+    const sortedNodes = [...nodes].sort((a, b) => {
+        if (a.page !== b.page) {
+            return a.page - b.page;
+        }
+        const yDiff = Math.abs(a.y - b.y);
+        if (yDiff > PDF_LINE_Y_TOLERANCE) {
+            return b.y - a.y;
+        }
+        return a.x - b.x;
+    });
+    const lines = [];
+    let currentLineNodes = [];
+    let currentPage = -1;
+    let currentY = Number.NaN;
+    function flushLine() {
+        if (currentLineNodes.length === 0) {
+            return;
+        }
+        const sortedLineNodes = [...currentLineNodes].sort((a, b) => a.x - b.x);
+        let line = '';
+        let previousRightEdge = null;
+        for (const node of sortedLineNodes) {
+            const piece = sanitizeText(node.text);
+            if (!piece) {
+                continue;
+            }
+            if (previousRightEdge !== null && node.x - previousRightEdge > PDF_NODE_GAP_THRESHOLD) {
+                line += ' ';
+            }
+            line += piece;
+            previousRightEdge = node.x + node.width;
+        }
+        const normalizedLine = line.trim();
+        if (normalizedLine) {
+            lines.push(normalizedLine);
+        }
+    }
+    for (const node of sortedNodes) {
+        const pageChanged = node.page !== currentPage;
+        const lineChanged = Number.isNaN(currentY) || Math.abs(node.y - currentY) > PDF_LINE_Y_TOLERANCE;
+        if (pageChanged || lineChanged) {
+            flushLine();
+            currentLineNodes = [node];
+            currentPage = node.page;
+            currentY = node.y;
+            continue;
+        }
+        currentLineNodes.push(node);
+    }
+    flushLine();
+    return lines;
+}
+function parseKeycardFromLines(lines) {
+    const sections = [];
+    let currentSectionIndex = -1;
+    for (const line of lines) {
+        const labelMatch = line.match(sectionHeaderRegex);
+        if (labelMatch) {
+            const section = labelMatch[1]?.toUpperCase();
+            const title = sanitizeText(labelMatch[2] ?? '');
+            if (section && title) {
+                sections.push({
+                    section,
+                    title,
+                    values: [],
+                    isCapturingData: false,
+                    openCurlyCount: 0,
+                });
+                currentSectionIndex = sections.length - 1;
+                continue;
+            }
+        }
+        if (currentSectionIndex < 0) {
+            continue;
+        }
+        const currentSection = sections[currentSectionIndex];
+        if (!currentSection) {
+            continue;
+        }
+        const dataLineMatch = line.match(dataLineRegex);
+        if (dataLineMatch) {
+            currentSection.isCapturingData = true;
+            const inlineValue = sanitizeText(dataLineMatch[1] ?? '');
+            if (inlineValue) {
+                currentSection.values.push(inlineValue);
+                currentSection.openCurlyCount += countChar(inlineValue, '{') - countChar(inlineValue, '}');
+            }
+            continue;
+        }
+        if (currentSection.isCapturingData) {
+            if (faqHeaderRegex.test(line)) {
+                currentSection.isCapturingData = false;
+                continue;
+            }
+            currentSection.values.push(line);
+            // For encrypted wallet password, data is a single JSON object. Stop as
+            // soon as the object closes so footer/FAQ content is not appended.
+            if (isEncryptedWalletPasswordSectionTitle(currentSection.title)) {
+                currentSection.openCurlyCount += countChar(line, '{') - countChar(line, '}');
+                if (currentSection.values.length > 0 && currentSection.openCurlyCount <= 0) {
+                    currentSection.isCapturingData = false;
+                }
+            }
+        }
+    }
+    return sections
+        .filter(({ section, values }) => ['A', 'B', 'C', 'D'].includes(section) && values.length > 0)
+        .map(({ section, title, values }) => ({
+        label: `${section}: ${title}`,
+        value: normalizeSectionValue(values.join('\n')),
+    }));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"parseKeycard.js","sourceRoot":"","sources":["../../src/parseKeycard.ts"],"names":[],"mappings":"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","sourcesContent":["import { VaultKeycardRoots, VAULT_ROOT_ORDER } from './types';\n\nexport type PDFTextNode = {\n  text: string;\n  x: number;\n  y: number;\n  page: number;\n  width: number;\n};\n\nexport type KeycardEntry = {\n  label: string;\n  value: string;\n};\n\n/**\n * Parses a vault keycard box value — the JSON packed by `generateVaultQrData`, e.g.\n * `{\"secp256k1Multisig\":\"…\",\"ecdsaMpc\":\"…\",…}` — into its four roots. Validates that all four\n * roots are present. Recovery tooling calls this on the A/B/C box value returned by\n * {@link parseKeycardFromLines}, then decrypts each root value with the wallet password.\n */\nexport function parseVaultKeycardBox(data: string): VaultKeycardRoots {\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(data);\n  } catch {\n    throw new Error('parseVaultKeycardBox: value is not valid JSON');\n  }\n  if (typeof parsed !== 'object' || parsed === null) {\n    throw new Error('parseVaultKeycardBox: value is not an object');\n  }\n  const roots = parsed as Record<string, unknown>;\n  for (const slot of VAULT_ROOT_ORDER) {\n    if (typeof roots[slot] !== 'string') {\n      throw new Error(`parseVaultKeycardBox: missing or invalid root ${slot}`);\n    }\n  }\n  return parsed as VaultKeycardRoots;\n}\n\nconst sectionHeaderRegex = /^([A-D])\\s*[:.)-]\\s*(.+?)\\s*$/i;\nconst dataLineRegex = /^data\\s*:\\s*(.*)$/i;\nconst faqHeaderRegex = /^BitGo\\s+KeyCard\\s+FAQ$/i;\n\n// PDF coordinate tolerance in points. Nodes within this distance on the Y-axis\n// are treated as belonging to the same line; nodes further apart are separate lines.\nconst PDF_LINE_Y_TOLERANCE = 2;\n// Horizontal gap in points above which a space is inserted between adjacent nodes.\nconst PDF_NODE_GAP_THRESHOLD = 2;\n\nfunction sanitizeText(input: string): string {\n  return input.replace(/\\s+/g, ' ').trim();\n}\n\nfunction normalizeSectionValue(rawValue: string): string {\n  // Two-pass removal of \"Part N\" page-continuation labels:\n  // 1. Line filter: removes labels that appear as standalone lines.\n  // 2. Regex replace: removes labels embedded mid-line when\n  //    buildLinesFromPDFNodes merges them with adjacent content at the same\n  //    y-coordinate (e.g. \"...X88bPart 2 lFPMd...\").\n  // join('') intentionally uses no separator — section values are continuous\n  // strings (base64 / xpub) that wrap across PDF lines without spaces.\n  return rawValue\n    .split('\\n')\n    .filter((line) => !/^Part\\s+\\d+$/i.test(line.trim()))\n    .join('')\n    .replace(/\\s*Part\\s+\\d+\\s*/gi, '')\n    .trim();\n}\n\nfunction countChar(input: string, char: string): number {\n  return input.split(char).length - 1;\n}\n\nfunction isEncryptedWalletPasswordSectionTitle(title: string): boolean {\n  return title.toLowerCase().includes('encrypted wallet password');\n}\n\n/**\n * Reconstructs logical text lines from an unordered set of PDF text nodes.\n *\n * PDF text extraction returns individual positioned fragments. This function\n * sorts them by page then Y-coordinate (top-to-bottom), groups fragments\n * within PDF_LINE_Y_TOLERANCE points of each other onto the same line, and\n * inserts a space between fragments that are separated by more than\n * PDF_NODE_GAP_THRESHOLD points horizontally.\n */\nexport function buildLinesFromPDFNodes(nodes: PDFTextNode[]): string[] {\n  const sortedNodes = [...nodes].sort((a, b) => {\n    if (a.page !== b.page) {\n      return a.page - b.page;\n    }\n    const yDiff = Math.abs(a.y - b.y);\n    if (yDiff > PDF_LINE_Y_TOLERANCE) {\n      return b.y - a.y;\n    }\n    return a.x - b.x;\n  });\n\n  const lines: string[] = [];\n  let currentLineNodes: PDFTextNode[] = [];\n  let currentPage = -1;\n  let currentY = Number.NaN;\n\n  function flushLine() {\n    if (currentLineNodes.length === 0) {\n      return;\n    }\n\n    const sortedLineNodes = [...currentLineNodes].sort((a, b) => a.x - b.x);\n    let line = '';\n    let previousRightEdge: number | null = null;\n    for (const node of sortedLineNodes) {\n      const piece = sanitizeText(node.text);\n      if (!piece) {\n        continue;\n      }\n\n      if (previousRightEdge !== null && node.x - previousRightEdge > PDF_NODE_GAP_THRESHOLD) {\n        line += ' ';\n      }\n      line += piece;\n      previousRightEdge = node.x + node.width;\n    }\n\n    const normalizedLine = line.trim();\n    if (normalizedLine) {\n      lines.push(normalizedLine);\n    }\n  }\n\n  for (const node of sortedNodes) {\n    const pageChanged = node.page !== currentPage;\n    const lineChanged = Number.isNaN(currentY) || Math.abs(node.y - currentY) > PDF_LINE_Y_TOLERANCE;\n    if (pageChanged || lineChanged) {\n      flushLine();\n      currentLineNodes = [node];\n      currentPage = node.page;\n      currentY = node.y;\n      continue;\n    }\n\n    currentLineNodes.push(node);\n  }\n\n  flushLine();\n  return lines;\n}\n\nexport function parseKeycardFromLines(lines: string[]): KeycardEntry[] {\n  const sections: Array<{\n    section: string;\n    title: string;\n    values: string[];\n    isCapturingData: boolean;\n    openCurlyCount: number;\n  }> = [];\n  let currentSectionIndex = -1;\n\n  for (const line of lines) {\n    const labelMatch = line.match(sectionHeaderRegex);\n    if (labelMatch) {\n      const section = labelMatch[1]?.toUpperCase();\n      const title = sanitizeText(labelMatch[2] ?? '');\n      if (section && title) {\n        sections.push({\n          section,\n          title,\n          values: [],\n          isCapturingData: false,\n          openCurlyCount: 0,\n        });\n        currentSectionIndex = sections.length - 1;\n        continue;\n      }\n    }\n\n    if (currentSectionIndex < 0) {\n      continue;\n    }\n\n    const currentSection = sections[currentSectionIndex];\n    if (!currentSection) {\n      continue;\n    }\n\n    const dataLineMatch = line.match(dataLineRegex);\n    if (dataLineMatch) {\n      currentSection.isCapturingData = true;\n      const inlineValue = sanitizeText(dataLineMatch[1] ?? '');\n      if (inlineValue) {\n        currentSection.values.push(inlineValue);\n        currentSection.openCurlyCount += countChar(inlineValue, '{') - countChar(inlineValue, '}');\n      }\n      continue;\n    }\n\n    if (currentSection.isCapturingData) {\n      if (faqHeaderRegex.test(line)) {\n        currentSection.isCapturingData = false;\n        continue;\n      }\n\n      currentSection.values.push(line);\n\n      // For encrypted wallet password, data is a single JSON object. Stop as\n      // soon as the object closes so footer/FAQ content is not appended.\n      if (isEncryptedWalletPasswordSectionTitle(currentSection.title)) {\n        currentSection.openCurlyCount += countChar(line, '{') - countChar(line, '}');\n        if (currentSection.values.length > 0 && currentSection.openCurlyCount <= 0) {\n          currentSection.isCapturingData = false;\n        }\n      }\n    }\n  }\n\n  return sections\n    .filter(({ section, values }) => ['A', 'B', 'C', 'D'].includes(section) && values.length > 0)\n    .map(({ section, title, values }) => ({\n      label: `${section}: ${title}`,\n      value: normalizeSectionValue(values.join('\\n')),\n    }));\n}\n"]}

package/dist/src/types.d.ts

@@ -0,0 +1,87 @@
+import { EncryptionVersion, Keychain, KeychainsTriplet } from '@bitgo-beta/sdk-core';
+import { BaseCoin, KeyCurve } from '@bitgo-beta/statics';
+export interface GenerateQrDataBaseParams {
+    activationCode?: string;
+    keyCardImage?: HTMLImageElement;
+    walletLabel: string;
+}
+export interface GenerateQrDataForKeychainParams {
+    bitgoKeychain: Keychain;
+    curve: KeyCurve;
+}
+export interface GenerateQrDataCoinParams {
+    coin: Readonly<BaseCoin>;
+    passcodeEncryptionCode?: string;
+    passphrase?: string;
+    encryptionVersion?: EncryptionVersion;
+}
+export interface GenerateQrDataParams extends GenerateQrDataCoinParams {
+    backupKeychain: Keychain;
+    backupKeyProvider?: string;
+    backupMasterKey?: string;
+    /**
+     * @description The key used to derive the backup key using {@link backupMasterKey} as the seed.
+     */
+    backupMasterPublicKey?: string;
+    bitgoKeychain: Keychain;
+    userKeychain: Keychain;
+    userMasterKey?: string;
+    /**
+     * @description The key used to derive the user key using {@link userMasterKey} as the seed.
+     */
+    userMasterPublicKey?: string;
+}
+export interface GenerateLightningQrDataParams extends GenerateQrDataCoinParams {
+    userAuthKeychain: Keychain;
+}
+/**
+ * Identifier for one of a vault's four roots (one per signing scheme). Each value is the
+ * root's `rootKeyType`, which is also the key used in the keycard's per-box JSON.
+ */
+export type VaultRootKeyType = 'secp256k1Multisig' | 'ecdsaMpc' | 'eddsaMpc' | 'ed25519Multisig';
+/**
+ * Fixed render/scan order of the four roots on the vault keycard. Kept stable so a
+ * generated keycard and a re-scanned one line up slot-for-slot.
+ */
+export declare const VAULT_ROOT_ORDER: VaultRootKeyType[];
+/**
+ * The JSON object encoded in a vault keycard box (A/B/C): the four roots keyed by
+ * {@link VaultRootKeyType}. Values are per-root ciphertext for A/B (encryptedPrv or
+ * reducedEncryptedPrv) or public keys for C. The root-key-type keys are self-identifying, so a
+ * consumer parses by key rather than by size/offset.
+ */
+export type VaultKeycardRoots = Record<VaultRootKeyType, string>;
+export interface GenerateVaultQrDataParams extends GenerateQrDataCoinParams {
+    roots: Record<VaultRootKeyType, KeychainsTriplet>;
+}
+export type GenerateKeycardParams = GenerateQrDataBaseParams & (GenerateQrDataForKeychainParams | GenerateQrDataParams | GenerateLightningQrDataParams);
+export interface IDrawKeyCard {
+    activationCode?: string;
+    keyCardImage?: HTMLImageElement;
+    qrData: QrData;
+    questions: FAQ[];
+    walletLabel?: string;
+    curve?: KeyCurve;
+    pageBreakBeforeIndices?: number[];
+}
+export interface FAQ {
+    question: string;
+    answer: string[];
+}
+export interface QrDataEntry {
+    data: string;
+    description: string;
+    title: string;
+    publicMasterKey?: string;
+}
+export type MasterPublicKeyQrDataEntry = Omit<QrDataEntry, 'publicMasterKey'>;
+export interface QrData {
+    backup?: QrDataEntry;
+    backupMasterPublicKey?: MasterPublicKeyQrDataEntry;
+    bitgo?: QrDataEntry;
+    passcode?: QrDataEntry;
+    curve?: KeyCurve;
+    user: QrDataEntry;
+    userMasterPublicKey?: MasterPublicKeyQrDataEntry;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"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"}

package/dist/src/types.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VAULT_ROOT_ORDER = void 0;
+/**
+ * Fixed render/scan order of the four roots on the vault keycard. Kept stable so a
+ * generated keycard and a re-scanned one line up slot-for-slot.
+ */
+exports.VAULT_ROOT_ORDER = ['secp256k1Multisig', 'ecdsaMpc', 'eddsaMpc', 'ed25519Multisig'];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBZ0VBOzs7R0FHRztBQUNVLFFBQUEsZ0JBQWdCLEdBQXVCLENBQUMsbUJBQW1CLEVBQUUsVUFBVSxFQUFFLFVBQVUsRUFBRSxpQkFBaUIsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRW5jcnlwdGlvblZlcnNpb24sIEtleWNoYWluLCBLZXljaGFpbnNUcmlwbGV0IH0gZnJvbSAnQGJpdGdvLWJldGEvc2RrLWNvcmUnO1xuaW1wb3J0IHsgQmFzZUNvaW4sIEtleUN1cnZlIH0gZnJvbSAnQGJpdGdvLWJldGEvc3RhdGljcyc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgR2VuZXJhdGVRckRhdGFCYXNlUGFyYW1zIHtcbiAgYWN0aXZhdGlvbkNvZGU/OiBzdHJpbmc7XG4gIGtleUNhcmRJbWFnZT86IEhUTUxJbWFnZUVsZW1lbnQ7XG4gIHdhbGxldExhYmVsOiBzdHJpbmc7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgR2VuZXJhdGVRckRhdGFGb3JLZXljaGFpblBhcmFtcyB7XG4gIC8vIFRoZSBCaXRHbyBrZXljaGFpbiBhcyBpdCBpcyByZXR1cm5lZCBmcm9tIHRoZSBCaXRHbyBBUEkgdXBvbiBjcmVhdGlvblxuICBiaXRnb0tleWNoYWluOiBLZXljaGFpbjtcbiAgLy8gVGhlIGN1cnZlIHVzZWQgZm9yIHRoZSBrZXlcbiAgY3VydmU6IEtleUN1cnZlO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIEdlbmVyYXRlUXJEYXRhQ29pblBhcmFtcyB7XG4gIC8vIFRoZSBjb2luIG9mIHRoZSB3YWxsZXQgdGhhdCB3YXMvIGlzIGFib3V0IHRvIGJlIGNyZWF0ZWRcbiAgY29pbjogUmVhZG9ubHk8QmFzZUNvaW4+O1xuICAvLyBBIGNvZGUgdGhhdCBjYW4gYmUgdXNlZCB0byBlbmNyeXB0IHRoZSB3YWxsZXQgcGFzc3dvcmQgdG8uXG4gIC8vIElmIGJvdGggdGhlIHBhc3NwaHJhc2UgYW5kIHBhc3Njb2RlRW5jcnlwdGlvbkNvZGUgYXJlIHBhc3NlZCwgdGhlbiB0aGlzIGNvZGUgZW5jcnlwdHMgdGhlIHBhc3NwaHJhc2Ugd2l0aCB0aGVcbiAgLy8gcGFzc2NvZGVFbmNyeXB0aW9uQ29kZSBhbmQgcHV0cyB0aGUgcmVzdWx0IGludG8gQm94IEQuIEFsbG93cyByZWNvdmVyaWVzIG9mIHRoZSB3YWxsZXQgcGFzc3dvcmQuXG4gIHBhc3Njb2RlRW5jcnlwdGlvbkNvZGU/OiBzdHJpbmc7XG4gIC8vIFRoZSB3YWxsZXQgcGFzc3dvcmRcbiAgLy8gSWYgYm90aCB0aGUgcGFzc3BocmFzZSBhbmQgcGFzc2NvZGVFbmNyeXB0aW9uQ29kZSBhcmUgcGFzc2VkLCB0aGVuIHRoaXMgY29kZSBlbmNyeXB0cyB0aGUgcGFzc3BocmFzZSB3aXRoIHRoZVxuICAvLyBwYXNzY29kZUVuY3J5cHRpb25Db2RlIGFuZCBwdXRzIHRoZSByZXN1bHQgaW50byBCb3ggRC4gQWxsb3dzIHJlY292ZXJpZXMgb2YgdGhlIHdhbGxldCBwYXNzd29yZC5cbiAgcGFzc3BocmFzZT86IHN0cmluZztcbiAgZW5jcnlwdGlvblZlcnNpb24/OiBFbmNyeXB0aW9uVmVyc2lvbjtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBHZW5lcmF0ZVFyRGF0YVBhcmFtcyBleHRlbmRzIEdlbmVyYXRlUXJEYXRhQ29pblBhcmFtcyB7XG4gIC8vIFRoZSBiYWNrdXAga2V5Y2hhaW4gYXMgaXQgaXMgcmV0dXJuZWQgZnJvbSB0aGUgQml0R28gQVBJIHVwb24gY3JlYXRpb25cbiAgYmFja3VwS2V5Y2hhaW46IEtleWNoYWluO1xuICAvLyBUaGUgbmFtZSBvZiB0aGUgM3JkIHBhcnR5IHByb3ZpZGVyIG9mIHRoZSBiYWNrdXAga2V5IGlmIG5laXRoZXIgdGhlIHVzZXIgbm9yIEJpdEdvIHN0b3JlcyBpdFxuICBiYWNrdXBLZXlQcm92aWRlcj86IHN0cmluZztcbiAgLy8gVGhlIGtleSBpZCBvZiB0aGUgYmFja3VwIGtleSwgb25seSB1c2VkIGZvciBjb2xkIGtleXNcbiAgYmFja3VwTWFzdGVyS2V5Pzogc3RyaW5nO1xuICAvKipcbiAgICogQGRlc2NyaXB0aW9uIFRoZSBrZXkgdXNlZCB0byBkZXJpdmUgdGhlIGJhY2t1cCBrZXkgdXNpbmcge0BsaW5rIGJhY2t1cE1hc3RlcktleX0gYXMgdGhlIHNlZWQuXG4gICAqL1xuICBiYWNrdXBNYXN0ZXJQdWJsaWNLZXk/OiBzdHJpbmc7XG4gIC8vIFRoZSBCaXRHbyBrZXljaGFpbiBhcyBpdCBpcyByZXR1cm5lZCBmcm9tIHRoZSBCaXRHbyBBUEkgdXBvbiBjcmVhdGlvblxuICBiaXRnb0tleWNoYWluOiBLZXljaGFpbjtcbiAgLy8gVGhlIHVzZXIga2V5Y2hhaW4gYXMgaXQgaXMgcmV0dXJuZWQgZnJvbSB0aGUgQml0R28gQVBJIHVwb24gY3JlYXRpb25cbiAgdXNlcktleWNoYWluOiBLZXljaGFpbjtcbiAgLy8gVGhlIGtleSBpZCBvZiB0aGUgdXNlciBrZXksIG9ubHkgdXNlZCBmb3IgY29sZCBrZXlzXG4gIHVzZXJNYXN0ZXJLZXk/OiBzdHJpbmc7XG4gIC8qKlxuICAgKiBAZGVzY3JpcHRpb24gVGhlIGtleSB1c2VkIHRvIGRlcml2ZSB0aGUgdXNlciBrZXkgdXNpbmcge0BsaW5rIHVzZXJNYXN0ZXJLZXl9IGFzIHRoZSBzZWVkLlxuICAgKi9cbiAgdXNlck1hc3RlclB1YmxpY0tleT86IHN0cmluZztcbn1cblxuZXhwb3J0IGludGVyZmFjZSBHZW5lcmF0ZUxpZ2h0bmluZ1FyRGF0YVBhcmFtcyBleHRlbmRzIEdlbmVyYXRlUXJEYXRhQ29pblBhcmFtcyB7XG4gIC8vIFRoZSB1c2VyIGF1dGhlbnRpY2F0aW9uIGtleWNoYWluLCB1c2VkIHRvIHNpZ24gcGF5bWVudCByZXF1ZXN0cyBhbmQgd2FsbGV0IGNvbmZpZ3VyYXRpb24gdXBkYXRlc1xuICB1c2VyQXV0aEtleWNoYWluOiBLZXljaGFpbjtcbn1cblxuLyoqXG4gKiBJZGVudGlmaWVyIGZvciBvbmUgb2YgYSB2YXVsdCdzIGZvdXIgcm9vdHMgKG9uZSBwZXIgc2lnbmluZyBzY2hlbWUpLiBFYWNoIHZhbHVlIGlzIHRoZVxuICogcm9vdCdzIGByb290S2V5VHlwZWAsIHdoaWNoIGlzIGFsc28gdGhlIGtleSB1c2VkIGluIHRoZSBrZXljYXJkJ3MgcGVyLWJveCBKU09OLlxuICovXG5leHBvcnQgdHlwZSBWYXVsdFJvb3RLZXlUeXBlID0gJ3NlY3AyNTZrMU11bHRpc2lnJyB8ICdlY2RzYU1wYycgfCAnZWRkc2FNcGMnIHwgJ2VkMjU1MTlNdWx0aXNpZyc7XG5cbi8qKlxuICogRml4ZWQgcmVuZGVyL3NjYW4gb3JkZXIgb2YgdGhlIGZvdXIgcm9vdHMgb24gdGhlIHZhdWx0IGtleWNhcmQuIEtlcHQgc3RhYmxlIHNvIGFcbiAqIGdlbmVyYXRlZCBrZXljYXJkIGFuZCBhIHJlLXNjYW5uZWQgb25lIGxpbmUgdXAgc2xvdC1mb3Itc2xvdC5cbiAqL1xuZXhwb3J0IGNvbnN0IFZBVUxUX1JPT1RfT1JERVI6IFZhdWx0Um9vdEtleVR5cGVbXSA9IFsnc2VjcDI1NmsxTXVsdGlzaWcnLCAnZWNkc2FNcGMnLCAnZWRkc2FNcGMnLCAnZWQyNTUxOU11bHRpc2lnJ107XG5cbi8qKlxuICogVGhlIEpTT04gb2JqZWN0IGVuY29kZWQgaW4gYSB2YXVsdCBrZXljYXJkIGJveCAoQS9CL0MpOiB0aGUgZm91ciByb290cyBrZXllZCBieVxuICoge0BsaW5rIFZhdWx0Um9vdEtleVR5cGV9LiBWYWx1ZXMgYXJlIHBlci1yb290IGNpcGhlcnRleHQgZm9yIEEvQiAoZW5jcnlwdGVkUHJ2IG9yXG4gKiByZWR1Y2VkRW5jcnlwdGVkUHJ2KSBvciBwdWJsaWMga2V5cyBmb3IgQy4gVGhlIHJvb3Qta2V5LXR5cGUga2V5cyBhcmUgc2VsZi1pZGVudGlmeWluZywgc28gYVxuICogY29uc3VtZXIgcGFyc2VzIGJ5IGtleSByYXRoZXIgdGhhbiBieSBzaXplL29mZnNldC5cbiAqL1xuZXhwb3J0IHR5cGUgVmF1bHRLZXljYXJkUm9vdHMgPSBSZWNvcmQ8VmF1bHRSb290S2V5VHlwZSwgc3RyaW5nPjtcblxuZXhwb3J0IGludGVyZmFjZSBHZW5lcmF0ZVZhdWx0UXJEYXRhUGFyYW1zIGV4dGVuZHMgR2VuZXJhdGVRckRhdGFDb2luUGFyYW1zIHtcbiAgLy8gVGhlIGZvdXIgcm9vdCB0cmlwbGV0cyAodXNlci9iYWNrdXAvYml0Z28ga2V5Y2hhaW5zKSwga2V5ZWQgYnkgcm9vdEtleVR5cGUuXG4gIHJvb3RzOiBSZWNvcmQ8VmF1bHRSb290S2V5VHlwZSwgS2V5Y2hhaW5zVHJpcGxldD47XG59XG5cbmV4cG9ydCB0eXBlIEdlbmVyYXRlS2V5Y2FyZFBhcmFtcyA9IEdlbmVyYXRlUXJEYXRhQmFzZVBhcmFtcyAmXG4gIChHZW5lcmF0ZVFyRGF0YUZvcktleWNoYWluUGFyYW1zIHwgR2VuZXJhdGVRckRhdGFQYXJhbXMgfCBHZW5lcmF0ZUxpZ2h0bmluZ1FyRGF0YVBhcmFtcyk7XG5cbmV4cG9ydCBpbnRlcmZhY2UgSURyYXdLZXlDYXJkIHtcbiAgYWN0aXZhdGlvbkNvZGU/OiBzdHJpbmc7XG4gIGtleUNhcmRJbWFnZT86IEhUTUxJbWFnZUVsZW1lbnQ7XG4gIHFyRGF0YTogUXJEYXRhO1xuICBxdWVzdGlvbnM6IEZBUVtdO1xuICB3YWxsZXRMYWJlbD86IHN0cmluZztcbiAgY3VydmU/OiBLZXlDdXJ2ZTtcbiAgLy8gQm94IGluZGljZXMgdG8gc3RhcnQgYSBuZXcgcGFnZSBiZWZvcmUuIE9taXQgZm9yIHRoZSBkZWZhdWx0IHdhbGxldCBsYXlvdXQuXG4gIHBhZ2VCcmVha0JlZm9yZUluZGljZXM/OiBudW1iZXJbXTtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBGQVEge1xuICBxdWVzdGlvbjogc3RyaW5nO1xuICAvLyB0aGUgYW5zd2VyIHRvIHRoZSBxdWVzdGlvbiwgYWxyZWFkeSBzcGxpdCBpbnRvIGluZGl2aWR1YWwgbGluZXMgb2YgdGV4dFxuICBhbnN3ZXI6IHN0cmluZ1tdO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIFFyRGF0YUVudHJ5IHtcbiAgZGF0YTogc3RyaW5nO1xuICBkZXNjcmlwdGlvbjogc3RyaW5nO1xuICB0aXRsZTogc3RyaW5nO1xuICBwdWJsaWNNYXN0ZXJLZXk/OiBzdHJpbmc7XG59XG5cbmV4cG9ydCB0eXBlIE1hc3RlclB1YmxpY0tleVFyRGF0YUVudHJ5ID0gT21pdDxRckRhdGFFbnRyeSwgJ3B1YmxpY01hc3RlcktleSc+O1xuXG5leHBvcnQgaW50ZXJmYWNlIFFyRGF0YSB7XG4gIGJhY2t1cD86IFFyRGF0YUVudHJ5O1xuICBiYWNrdXBNYXN0ZXJQdWJsaWNLZXk/OiBNYXN0ZXJQdWJsaWNLZXlRckRhdGFFbnRyeTtcbiAgYml0Z28/OiBRckRhdGFFbnRyeTtcbiAgcGFzc2NvZGU/OiBRckRhdGFFbnRyeTtcbiAgY3VydmU/OiBLZXlDdXJ2ZTtcbiAgdXNlcjogUXJEYXRhRW50cnk7XG4gIHVzZXJNYXN0ZXJQdWJsaWNLZXk/OiBNYXN0ZXJQdWJsaWNLZXlRckRhdGFFbnRyeTtcbn1cbiJdfQ==

package/dist/src/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.splitKeys = void 0;
+exports.splitKeys = splitKeys;
 function splitKeys(key, limit) {
     if (key.length <= limit) {
         return [key];
@@ -13,5 +13,4 @@ function splitKeys(key, limit) {
     }
     return keys;
 }
-exports.splitKeys = splitKeys;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsU0FBZ0IsU0FBUyxDQUFDLEdBQVcsRUFBRSxLQUFhO0lBQ2xELElBQUksR0FBRyxDQUFDLE1BQU0sSUFBSSxLQUFLLEVBQUU7UUFDdkIsT0FBTyxDQUFDLEdBQUcsQ0FBQyxDQUFDO0tBQ2Q7SUFFRCxNQUFNLElBQUksR0FBYSxFQUFFLENBQUM7SUFFMUIsSUFBSSxVQUFVLEdBQUcsS0FBSyxDQUFDO0lBQ3ZCLEtBQUssSUFBSSxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUMsR0FBRyxHQUFHLENBQUMsTUFBTSxFQUFFLENBQUMsSUFBSSxLQUFLLEVBQUU7UUFDMUMsSUFBSSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsU0FBUyxDQUFDLENBQUMsRUFBRSxVQUFVLENBQUMsQ0FBQyxDQUFDO1FBQ3hDLFVBQVUsR0FBRyxJQUFJLENBQUMsR0FBRyxDQUFDLFVBQVUsR0FBRyxLQUFLLEVBQUUsR0FBRyxDQUFDLE1BQU0sQ0FBQyxDQUFDO0tBQ3ZEO0lBRUQsT0FBTyxJQUFJLENBQUM7QUFDZCxDQUFDO0FBZEQsOEJBY0MiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZnVuY3Rpb24gc3BsaXRLZXlzKGtleTogc3RyaW5nLCBsaW1pdDogbnVtYmVyKTogc3RyaW5nW10ge1xuICBpZiAoa2V5Lmxlbmd0aCA8PSBsaW1pdCkge1xuICAgIHJldHVybiBba2V5XTtcbiAgfVxuXG4gIGNvbnN0IGtleXM6IHN0cmluZ1tdID0gW107XG5cbiAgbGV0IHJpZ2h0SW5kZXggPSBsaW1pdDtcbiAgZm9yIChsZXQgaSA9IDA7IGkgPCBrZXkubGVuZ3RoOyBpICs9IGxpbWl0KSB7XG4gICAga2V5cy5wdXNoKGtleS5zdWJzdHJpbmcoaSwgcmlnaHRJbmRleCkpO1xuICAgIHJpZ2h0SW5kZXggPSBNYXRoLm1pbihyaWdodEluZGV4ICsgbGltaXQsIGtleS5sZW5ndGgpO1xuICB9XG5cbiAgcmV0dXJuIGtleXM7XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQSw4QkFjQztBQWRELFNBQWdCLFNBQVMsQ0FBQyxHQUFXLEVBQUUsS0FBYTtJQUNsRCxJQUFJLEdBQUcsQ0FBQyxNQUFNLElBQUksS0FBSyxFQUFFLENBQUM7UUFDeEIsT0FBTyxDQUFDLEdBQUcsQ0FBQyxDQUFDO0lBQ2YsQ0FBQztJQUVELE1BQU0sSUFBSSxHQUFhLEVBQUUsQ0FBQztJQUUxQixJQUFJLFVBQVUsR0FBRyxLQUFLLENBQUM7SUFDdkIsS0FBSyxJQUFJLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxHQUFHLEdBQUcsQ0FBQyxNQUFNLEVBQUUsQ0FBQyxJQUFJLEtBQUssRUFBRSxDQUFDO1FBQzNDLElBQUksQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLFNBQVMsQ0FBQyxDQUFDLEVBQUUsVUFBVSxDQUFDLENBQUMsQ0FBQztRQUN4QyxVQUFVLEdBQUcsSUFBSSxDQUFDLEdBQUcsQ0FBQyxVQUFVLEdBQUcsS0FBSyxFQUFFLEdBQUcsQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUN4RCxDQUFDO0lBRUQsT0FBTyxJQUFJLENBQUM7QUFDZCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGZ1bmN0aW9uIHNwbGl0S2V5cyhrZXk6IHN0cmluZywgbGltaXQ6IG51bWJlcik6IHN0cmluZ1tdIHtcbiAgaWYgKGtleS5sZW5ndGggPD0gbGltaXQpIHtcbiAgICByZXR1cm4gW2tleV07XG4gIH1cblxuICBjb25zdCBrZXlzOiBzdHJpbmdbXSA9IFtdO1xuXG4gIGxldCByaWdodEluZGV4ID0gbGltaXQ7XG4gIGZvciAobGV0IGkgPSAwOyBpIDwga2V5Lmxlbmd0aDsgaSArPSBsaW1pdCkge1xuICAgIGtleXMucHVzaChrZXkuc3Vic3RyaW5nKGksIHJpZ2h0SW5kZXgpKTtcbiAgICByaWdodEluZGV4ID0gTWF0aC5taW4ocmlnaHRJbmRleCArIGxpbWl0LCBrZXkubGVuZ3RoKTtcbiAgfVxuXG4gIHJldHVybiBrZXlzO1xufVxuIl19