@ai-matrx/vault 0.0.0 → 0.1.1

package/dist/io/bitwarden-json.worker.js

@@ -0,0 +1,819 @@
+// ../../node_modules/.pnpm/lossless-json@4.3.1/node_modules/lossless-json/lib/esm/utils.js
+function isInteger(value) {
+  return INTEGER_REGEX.test(value);
+}
+var INTEGER_REGEX = /^-?[0-9]+$/;
+function isNumber(value) {
+  return NUMBER_REGEX.test(value);
+}
+var NUMBER_REGEX = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
+function isSafeNumber(value, config2) {
+  if (isInteger(value)) {
+    return Number.isSafeInteger(Number.parseInt(value, 10));
+  }
+  const num = Number.parseFloat(value);
+  const parsed = String(num);
+  if (value === parsed) {
+    return true;
+  }
+  const valueDigits = extractSignificantDigits(value);
+  const parsedDigits = extractSignificantDigits(parsed);
+  if (valueDigits === parsedDigits) {
+    return true;
+  }
+  if (config2?.approx === true) {
+    const requiredDigits = 14;
+    if (!isInteger(value) && parsedDigits.length >= requiredDigits && valueDigits.startsWith(parsedDigits.substring(0, requiredDigits))) {
+      return true;
+    }
+  }
+  return false;
+}
+var UnsafeNumberReason = /* @__PURE__ */ (function(UnsafeNumberReason2) {
+  UnsafeNumberReason2["underflow"] = "underflow";
+  UnsafeNumberReason2["overflow"] = "overflow";
+  UnsafeNumberReason2["truncate_integer"] = "truncate_integer";
+  UnsafeNumberReason2["truncate_float"] = "truncate_float";
+  return UnsafeNumberReason2;
+})({});
+function getUnsafeNumberReason(value) {
+  if (isSafeNumber(value, {
+    approx: false
+  })) {
+    return void 0;
+  }
+  if (isInteger(value)) {
+    return UnsafeNumberReason.truncate_integer;
+  }
+  const num = Number.parseFloat(value);
+  if (!Number.isFinite(num)) {
+    return UnsafeNumberReason.overflow;
+  }
+  if (num === 0) {
+    return UnsafeNumberReason.underflow;
+  }
+  return UnsafeNumberReason.truncate_float;
+}
+function extractSignificantDigits(value) {
+  const {
+    start,
+    end
+  } = getSignificantDigitRange(value);
+  const digits = value.substring(start, end);
+  const dot = digits.indexOf(".");
+  if (dot === -1) {
+    return digits;
+  }
+  return digits.substring(0, dot) + digits.substring(dot + 1);
+}
+function getSignificantDigitRange(value) {
+  let start = 0;
+  if (value[0] === "-") {
+    start++;
+  }
+  while (value[start] === "0" || value[start] === ".") {
+    start++;
+  }
+  let end = value.lastIndexOf("e");
+  if (end === -1) {
+    end = value.lastIndexOf("E");
+  }
+  if (end === -1) {
+    end = value.length;
+  }
+  while ((value[end - 1] === "0" || value[end - 1] === ".") && end > start) {
+    end--;
+  }
+  return {
+    start,
+    end
+  };
+}
+
+// ../../node_modules/.pnpm/lossless-json@4.3.1/node_modules/lossless-json/lib/esm/LosslessNumber.js
+var LosslessNumber = class {
+  // numeric value as string
+  // type information
+  isLosslessNumber = true;
+  constructor(value) {
+    if (!isNumber(value)) {
+      throw new Error(`Invalid number (value: "${value}")`);
+    }
+    this.value = value;
+  }
+  /**
+   * Get the value of the LosslessNumber as number or bigint.
+   *
+   * - a number is returned for safe numbers and decimal values that only lose some insignificant digits
+   * - a bigint is returned for big integer numbers
+   * - an Error is thrown for values that will overflow or underflow
+   *
+   * Note that you can implement your own strategy for conversion by just getting the value as string
+   * via .toString(), and using util functions like isInteger, isSafeNumber, getUnsafeNumberReason,
+   * and toSafeNumberOrThrow to convert it to a numeric value.
+   */
+  valueOf() {
+    const unsafeReason = getUnsafeNumberReason(this.value);
+    if (unsafeReason === void 0 || unsafeReason === UnsafeNumberReason.truncate_float) {
+      return Number.parseFloat(this.value);
+    }
+    if (isInteger(this.value)) {
+      return BigInt(this.value);
+    }
+    throw new Error(`Cannot safely convert to number: the value '${this.value}' would ${unsafeReason} and become ${Number.parseFloat(this.value)}`);
+  }
+  /**
+   * Get the value of the LosslessNumber as string.
+   */
+  toString() {
+    return this.value;
+  }
+  // Note: we do NOT implement a .toJSON() method, and you should not implement
+  // or use that, it cannot safely turn the numeric value in the string into
+  // stringified JSON since it has to be parsed into a number first.
+};
+function isLosslessNumber(value) {
+  return value && typeof value === "object" && value.isLosslessNumber || false;
+}
+
+// ../../node_modules/.pnpm/lossless-json@4.3.1/node_modules/lossless-json/lib/esm/numberParsers.js
+function parseLosslessNumber(value) {
+  return new LosslessNumber(value);
+}
+
+// ../../node_modules/.pnpm/lossless-json@4.3.1/node_modules/lossless-json/lib/esm/revive.js
+function revive(json, reviver) {
+  return reviveValue({
+    "": json
+  }, "", json, reviver);
+}
+function reviveValue(context, key, value, reviver) {
+  if (Array.isArray(value)) {
+    return reviver.call(context, key, reviveArray(value, reviver));
+  }
+  if (value && typeof value === "object" && !isLosslessNumber(value)) {
+    return reviver.call(context, key, reviveObject(value, reviver));
+  }
+  return reviver.call(context, key, value);
+}
+function reviveObject(object2, reviver) {
+  for (const key of Object.keys(object2)) {
+    const value = reviveValue(object2, key, object2[key], reviver);
+    if (value !== void 0) {
+      object2[key] = value;
+    } else {
+      delete object2[key];
+    }
+  }
+  return object2;
+}
+function reviveArray(array, reviver) {
+  for (let i = 0; i < array.length; i++) {
+    array[i] = reviveValue(array, String(i), array[i], reviver);
+  }
+  return array;
+}
+
+// ../../node_modules/.pnpm/lossless-json@4.3.1/node_modules/lossless-json/lib/esm/parse.js
+function parse(text, reviver, options) {
+  const optionsObj = typeof options === "function" ? {
+    parseNumber: options
+  } : options;
+  const parseNumber = optionsObj?.parseNumber ?? parseLosslessNumber;
+  const onDuplicateKey = optionsObj?.onDuplicateKey ?? throwDuplicateKey;
+  let i = 0;
+  const value = parseValue();
+  expectValue(value);
+  expectEndOfInput();
+  return reviver ? revive(value, reviver) : value;
+  function parseObject() {
+    if (text.charCodeAt(i) === codeOpeningBrace) {
+      i++;
+      skipWhitespace();
+      const object2 = {};
+      let initial = true;
+      while (i < text.length && text.charCodeAt(i) !== codeClosingBrace) {
+        if (!initial) {
+          eatComma();
+          skipWhitespace();
+        } else {
+          initial = false;
+        }
+        const start = i;
+        const key = parseString();
+        if (key === void 0) {
+          throwObjectKeyExpected();
+          return;
+        }
+        skipWhitespace();
+        eatColon();
+        const value2 = parseValue();
+        if (value2 === void 0) {
+          throwObjectValueExpected();
+          return;
+        }
+        if (Object.prototype.hasOwnProperty.call(object2, key) && !isDeepEqual(value2, object2[key])) {
+          const returnedValue = onDuplicateKey({
+            key,
+            position: start + 1,
+            oldValue: object2[key],
+            newValue: value2
+          });
+          if (returnedValue !== void 0) {
+            object2[key] = returnedValue;
+          }
+        } else {
+          object2[key] = value2;
+        }
+      }
+      if (text.charCodeAt(i) !== codeClosingBrace) {
+        throwObjectKeyOrEndExpected();
+      }
+      i++;
+      return object2;
+    }
+  }
+  function parseArray() {
+    if (text.charCodeAt(i) === codeOpeningBracket) {
+      i++;
+      skipWhitespace();
+      const array = [];
+      let initial = true;
+      while (i < text.length && text.charCodeAt(i) !== codeClosingBracket) {
+        if (!initial) {
+          eatComma();
+        } else {
+          initial = false;
+        }
+        const value2 = parseValue();
+        expectArrayItem(value2);
+        array.push(value2);
+      }
+      if (text.charCodeAt(i) !== codeClosingBracket) {
+        throwArrayItemOrEndExpected();
+      }
+      i++;
+      return array;
+    }
+  }
+  function parseValue() {
+    skipWhitespace();
+    const value2 = parseString() ?? parseNumeric() ?? parseObject() ?? parseArray() ?? parseKeyword("true", true) ?? parseKeyword("false", false) ?? parseKeyword("null", null);
+    skipWhitespace();
+    return value2;
+  }
+  function parseKeyword(name, value2) {
+    if (text.slice(i, i + name.length) === name) {
+      i += name.length;
+      return value2;
+    }
+  }
+  function skipWhitespace() {
+    while (isWhitespace(text.charCodeAt(i))) {
+      i++;
+    }
+  }
+  function parseString() {
+    if (text.charCodeAt(i) === codeDoubleQuote) {
+      i++;
+      let result = "";
+      while (i < text.length && text.charCodeAt(i) !== codeDoubleQuote) {
+        if (text.charCodeAt(i) === codeBackslash) {
+          const char = text[i + 1];
+          const escapeChar = escapeCharacters[char];
+          if (escapeChar !== void 0) {
+            result += escapeChar;
+            i++;
+          } else if (char === "u") {
+            if (isHex(text.charCodeAt(i + 2)) && isHex(text.charCodeAt(i + 3)) && isHex(text.charCodeAt(i + 4)) && isHex(text.charCodeAt(i + 5))) {
+              result += String.fromCharCode(Number.parseInt(text.slice(i + 2, i + 6), 16));
+              i += 5;
+            } else {
+              throwInvalidUnicodeCharacter(i);
+            }
+          } else {
+            throwInvalidEscapeCharacter(i);
+          }
+        } else {
+          if (isValidStringCharacter(text.charCodeAt(i))) {
+            result += text[i];
+          } else {
+            throwInvalidCharacter(text[i]);
+          }
+        }
+        i++;
+      }
+      expectEndOfString();
+      i++;
+      return result;
+    }
+  }
+  function parseNumeric() {
+    const start = i;
+    if (text.charCodeAt(i) === codeMinus) {
+      i++;
+      expectDigit(start);
+    }
+    if (text.charCodeAt(i) === codeZero) {
+      i++;
+    } else if (isNonZeroDigit(text.charCodeAt(i))) {
+      i++;
+      while (isDigit(text.charCodeAt(i))) {
+        i++;
+      }
+    }
+    if (text.charCodeAt(i) === codeDot) {
+      i++;
+      expectDigit(start);
+      while (isDigit(text.charCodeAt(i))) {
+        i++;
+      }
+    }
+    if (text.charCodeAt(i) === codeLowercaseE || text.charCodeAt(i) === codeUppercaseE) {
+      i++;
+      if (text.charCodeAt(i) === codeMinus || text.charCodeAt(i) === codePlus) {
+        i++;
+      }
+      expectDigit(start);
+      while (isDigit(text.charCodeAt(i))) {
+        i++;
+      }
+    }
+    if (i > start) {
+      return parseNumber(text.slice(start, i));
+    }
+  }
+  function eatComma() {
+    if (text.charCodeAt(i) !== codeComma) {
+      throw new SyntaxError(`Comma ',' expected after value ${gotAt()}`);
+    }
+    i++;
+  }
+  function eatColon() {
+    if (text.charCodeAt(i) !== codeColon) {
+      throw new SyntaxError(`Colon ':' expected after property name ${gotAt()}`);
+    }
+    i++;
+  }
+  function expectValue(value2) {
+    if (value2 === void 0) {
+      throw new SyntaxError(`JSON value expected ${gotAt()}`);
+    }
+  }
+  function expectArrayItem(value2) {
+    if (value2 === void 0) {
+      throw new SyntaxError(`Array item expected ${gotAt()}`);
+    }
+  }
+  function expectEndOfInput() {
+    if (i < text.length) {
+      throw new SyntaxError(`Expected end of input ${gotAt()}`);
+    }
+  }
+  function expectDigit(start) {
+    if (!isDigit(text.charCodeAt(i))) {
+      const numSoFar = text.slice(start, i);
+      throw new SyntaxError(`Invalid number '${numSoFar}', expecting a digit ${gotAt()}`);
+    }
+  }
+  function expectEndOfString() {
+    if (text.charCodeAt(i) !== codeDoubleQuote) {
+      throw new SyntaxError(`End of string '"' expected ${gotAt()}`);
+    }
+  }
+  function throwObjectKeyExpected() {
+    throw new SyntaxError(`Quoted object key expected ${gotAt()}`);
+  }
+  function throwDuplicateKey(_ref) {
+    let {
+      key,
+      position
+    } = _ref;
+    throw new SyntaxError(`Duplicate key '${key}' encountered at position ${position}`);
+  }
+  function throwObjectKeyOrEndExpected() {
+    throw new SyntaxError(`Quoted object key or end of object '}' expected ${gotAt()}`);
+  }
+  function throwArrayItemOrEndExpected() {
+    throw new SyntaxError(`Array item or end of array ']' expected ${gotAt()}`);
+  }
+  function throwInvalidCharacter(char) {
+    throw new SyntaxError(`Invalid character '${char}' ${pos()}`);
+  }
+  function throwInvalidEscapeCharacter(start) {
+    const chars = text.slice(start, start + 2);
+    throw new SyntaxError(`Invalid escape character '${chars}' ${pos()}`);
+  }
+  function throwObjectValueExpected() {
+    throw new SyntaxError(`Object value expected after ':' ${pos()}`);
+  }
+  function throwInvalidUnicodeCharacter(start) {
+    const chars = text.slice(start, start + 6);
+    throw new SyntaxError(`Invalid unicode character '${chars}' ${pos()}`);
+  }
+  function pos() {
+    return `at position ${i}`;
+  }
+  function got() {
+    return i < text.length ? `but got '${text[i]}'` : "but reached end of input";
+  }
+  function gotAt() {
+    return `${got()} ${pos()}`;
+  }
+}
+function isWhitespace(code) {
+  return code === codeSpace || code === codeNewline || code === codeTab || code === codeReturn;
+}
+function isHex(code) {
+  return code >= codeZero && code <= codeNine || code >= codeUppercaseA && code <= codeUppercaseF || code >= codeLowercaseA && code <= codeLowercaseF;
+}
+function isDigit(code) {
+  return code >= codeZero && code <= codeNine;
+}
+function isNonZeroDigit(code) {
+  return code >= codeOne && code <= codeNine;
+}
+function isValidStringCharacter(code) {
+  return code >= 32 && code <= 1114111;
+}
+function isDeepEqual(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (Array.isArray(a) && Array.isArray(b)) {
+    return a.length === b.length && a.every((item, index) => isDeepEqual(item, b[index]));
+  }
+  if (isObject(a) && isObject(b)) {
+    const keys = [.../* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)])];
+    return keys.every((key) => isDeepEqual(a[key], b[key]));
+  }
+  return false;
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+var escapeCharacters = {
+  '"': '"',
+  "\\": "\\",
+  "/": "/",
+  b: "\b",
+  f: "\f",
+  n: "\n",
+  r: "\r",
+  t: "	"
+  // note that \u is handled separately in parseString()
+};
+var codeBackslash = 92;
+var codeOpeningBrace = 123;
+var codeClosingBrace = 125;
+var codeOpeningBracket = 91;
+var codeClosingBracket = 93;
+var codeSpace = 32;
+var codeNewline = 10;
+var codeTab = 9;
+var codeReturn = 13;
+var codeDoubleQuote = 34;
+var codePlus = 43;
+var codeMinus = 45;
+var codeZero = 48;
+var codeOne = 49;
+var codeNine = 57;
+var codeComma = 44;
+var codeDot = 46;
+var codeColon = 58;
+var codeUppercaseA = 65;
+var codeLowercaseA = 97;
+var codeUppercaseE = 69;
+var codeLowercaseE = 101;
+var codeUppercaseF = 70;
+var codeLowercaseF = 102;
+
+// ../../node_modules/.pnpm/lossless-json@4.3.1/node_modules/lossless-json/lib/esm/stringify.js
+function stringify(value, replacer, space, numberStringifiers) {
+  const resolvedSpace = resolveSpace(space);
+  const replacedValue = typeof replacer === "function" ? replacer.call({
+    "": value
+  }, "", value) : value;
+  return stringifyValue(replacedValue, "");
+  function stringifyValue(value2, indent) {
+    if (Array.isArray(numberStringifiers)) {
+      const stringifier = numberStringifiers.find((item) => item.test(value2));
+      if (stringifier) {
+        const str = stringifier.stringify(value2);
+        if (typeof str !== "string" || !isNumber(str)) {
+          throw new Error(`Invalid JSON number: output of a number stringifier must be a string containing a JSON number (output: ${str})`);
+        }
+        return str;
+      }
+    }
+    if (typeof value2 === "boolean" || typeof value2 === "number" || typeof value2 === "string" || value2 === null || value2 instanceof Date || value2 instanceof Boolean || value2 instanceof Number || value2 instanceof String) {
+      return JSON.stringify(value2);
+    }
+    if (value2?.isLosslessNumber) {
+      return value2.toString();
+    }
+    if (typeof value2 === "bigint") {
+      return value2.toString();
+    }
+    if (Array.isArray(value2)) {
+      return stringifyArray(value2, indent);
+    }
+    if (value2 && typeof value2 === "object") {
+      return stringifyObject(value2, indent);
+    }
+    return void 0;
+  }
+  function stringifyArray(array, indent) {
+    if (array.length === 0) {
+      return "[]";
+    }
+    const childIndent = resolvedSpace ? indent + resolvedSpace : void 0;
+    let str = resolvedSpace ? "[\n" : "[";
+    for (let i = 0; i < array.length; i++) {
+      const item = typeof replacer === "function" ? replacer.call(array, String(i), array[i]) : array[i];
+      if (resolvedSpace) {
+        str += childIndent;
+      }
+      if (typeof item !== "undefined" && typeof item !== "function") {
+        str += stringifyValue(item, childIndent);
+      } else {
+        str += "null";
+      }
+      if (i < array.length - 1) {
+        str += resolvedSpace ? ",\n" : ",";
+      }
+    }
+    str += resolvedSpace ? `
+${indent}]` : "]";
+    return str;
+  }
+  function stringifyObject(object2, indent) {
+    if (typeof object2.toJSON === "function") {
+      return stringify(object2.toJSON(), replacer, space, void 0);
+    }
+    const keys = Array.isArray(replacer) ? replacer.map(String) : Object.keys(object2);
+    if (keys.length === 0) {
+      return "{}";
+    }
+    const childIndent = resolvedSpace ? indent + resolvedSpace : void 0;
+    let first = true;
+    let str = resolvedSpace ? "{\n" : "{";
+    for (const key of keys) {
+      const value2 = typeof replacer === "function" ? replacer.call(object2, key, object2[key]) : object2[key];
+      if (includeProperty(key, value2)) {
+        if (first) {
+          first = false;
+        } else {
+          str += resolvedSpace ? ",\n" : ",";
+        }
+        const keyStr = JSON.stringify(key);
+        str += resolvedSpace ? `${childIndent + keyStr}: ` : `${keyStr}:`;
+        str += stringifyValue(value2, childIndent);
+      }
+    }
+    str += resolvedSpace ? `
+${indent}}` : "}";
+    return str;
+  }
+  function includeProperty(_key, value2) {
+    return typeof value2 !== "undefined" && typeof value2 !== "function" && typeof value2 !== "symbol";
+  }
+}
+function resolveSpace(space) {
+  if (typeof space === "number") {
+    return " ".repeat(space);
+  }
+  if (typeof space === "string" && space !== "") {
+    return space;
+  }
+  return void 0;
+}
+
+// src/io/strict-json.ts
+function assertNoDuplicateKeys(text) {
+  const stack = [];
+  let i = 0;
+  while (i < text.length) {
+    const ch = text[i];
+    if (ch === '"') {
+      const start = i;
+      i++;
+      while (i < text.length && text[i] !== '"') i += text[i] === "\\" ? 2 : 1;
+      const top = stack[stack.length - 1];
+      if (top?.keys && top.expectKey) {
+        const key = JSON.parse(text.slice(start, i + 1));
+        if (top.keys.has(key)) throw new SyntaxError(`Duplicate key '${key}' encountered at position ${start + 1}`);
+        top.keys.add(key);
+        top.expectKey = false;
+      }
+    } else if (ch === "{") stack.push({ keys: /* @__PURE__ */ new Set(), expectKey: true });
+    else if (ch === "[") stack.push({ keys: null, expectKey: false });
+    else if (ch === "}" || ch === "]") stack.pop();
+    else if (ch === ",") {
+      const top = stack[stack.length - 1];
+      if (top?.keys) top.expectKey = true;
+    }
+    i++;
+  }
+}
+var parse2 = (text, ...rest) => {
+  assertNoDuplicateKeys(text);
+  return parse(text, ...rest);
+};
+
+// src/io/csv-import.ts
+function safeDestination(raw) {
+  try {
+    const parsed = new URL(raw);
+    if (!/^https?:$/.test(parsed.protocol))
+      return { metadata: null, host: null };
+    if (parsed.username || parsed.password)
+      return { metadata: null, host: null };
+    return { metadata: parsed.origin, host: parsed.host };
+  } catch {
+    return { metadata: null, host: null };
+  }
+}
+
+// ../kit/src/uuid.ts
+var RFC_4122_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+function isRfc4122Uuid(value) {
+  return typeof value === "string" && RFC_4122_RE.test(value);
+}
+
+// src/io/bitwarden-json.ts
+var rootKeys = /* @__PURE__ */ new Set(["encrypted", "folders", "items"]);
+var folderKeys = /* @__PURE__ */ new Set(["id", "name"]);
+var itemKeys = /* @__PURE__ */ new Set(["id", "name", "type", "folderId", "organizationId", "collectionIds", "notes", "login", "secureNote", "card", "identity", "sshKey", "favorite", "reprompt", "fields", "passwordHistory", "revisionDate", "creationDate", "deletedDate", "attachments"]);
+var loginKeys = /* @__PURE__ */ new Set(["username", "password", "totp", "uris", "fido2Credentials"]);
+var uriKeys = /* @__PURE__ */ new Set(["uri", "match"]);
+var sshKeys = /* @__PURE__ */ new Set(["privateKey", "publicKey", "keyFingerprint"]);
+var fieldKeys = /* @__PURE__ */ new Set(["name", "value", "type", "linkedId"]);
+var noteKeys = /* @__PURE__ */ new Set(["type"]);
+var cardKeys = /* @__PURE__ */ new Set(["cardholderName", "expMonth", "expYear", "code", "brand", "number"]);
+var identityKeys = /* @__PURE__ */ new Set(["title", "firstName", "middleName", "lastName", "address1", "address2", "address3", "city", "state", "postalCode", "country", "company", "email", "phone", "ssn", "username", "passportNumber", "licenseNumber"]);
+function object(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function bytes(value) {
+  return typeof TextEncoder !== "undefined" ? new TextEncoder().encode(value).byteLength : unescape(encodeURIComponent(value)).length;
+}
+function only(value, allowed) {
+  return Object.keys(value).every((key) => allowed.has(key));
+}
+function stringOrNull(value) {
+  return value === null || typeof value === "string";
+}
+function exactInt(value, min, max) {
+  const text = value instanceof LosslessNumber ? value.value : "";
+  return /^(0|[1-9][0-9]*)$/.test(text) && Number(text) >= min && Number(text) <= max;
+}
+function timestamp(value) {
+  return typeof value === "string" && /^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d(?:\.\d+)?(?:Z|[+-]\d\d:\d\d)$/.test(value);
+}
+function jsonDepthOk(value, maxDepth) {
+  const stack = [[value, 1]];
+  while (stack.length) {
+    const [node, depth] = stack.pop();
+    if (depth > maxDepth) return false;
+    const record = object(node);
+    const children = Array.isArray(node) ? node : record ? Object.values(record) : [];
+    for (const child of children) stack.push([child, depth + 1]);
+  }
+  return true;
+}
+function allStringsWithin(value, maxBytes) {
+  if (typeof value === "string") return bytes(value) <= maxBytes;
+  if (Array.isArray(value)) return value.every((entry) => allStringsWithin(entry, maxBytes));
+  const record = object(value);
+  return !record || Object.values(record).every((entry) => allStringsWithin(entry, maxBytes));
+}
+function invalid(title, ordinal, reason) {
+  return { ordinal, title, status: "invalid", reason };
+}
+function unsupported(title, ordinal, reason) {
+  return { ordinal, title, status: "unsupported", reason };
+}
+function itemRecord(item, ordinal, maxCellBytes, maxJsonDepth, folders) {
+  const candidateTitle = typeof item.name === "string" ? item.name : `Item ${ordinal + 1}`;
+  const title = bytes(candidateTitle) <= maxCellBytes ? candidateTitle : `Item ${ordinal + 1}`;
+  if (!only(item, itemKeys)) return unsupported(title, ordinal, "The item has an unsupported field.");
+  if (!isRfc4122Uuid(item.id) || typeof item.name !== "string" || !exactInt(item.type, 1, 5)) return exactInt(item.type, 0, Number.MAX_SAFE_INTEGER) ? unsupported(title, ordinal, "The item type is unsupported.") : invalid(title, ordinal, "The item shape is not supported.");
+  if (!["folderId", "organizationId", "notes"].every((key) => item[key] === void 0 || stringOrNull(item[key])) || ["revisionDate", "creationDate", "deletedDate"].some((key) => item[key] !== void 0 && item[key] !== null && !timestamp(item[key])) || item.folderId != null && !isRfc4122Uuid(item.folderId) || item.organizationId != null && !isRfc4122Uuid(item.organizationId) || item.collectionIds != null && (!Array.isArray(item.collectionIds) || !item.collectionIds.every(isRfc4122Uuid)) || item.favorite != null && typeof item.favorite !== "boolean" || item.reprompt != null && !exactInt(item.reprompt, 0, 1)) return invalid(title, ordinal, "The item metadata is invalid.");
+  if (item.fields != null && (!Array.isArray(item.fields) || !item.fields.every((field) => {
+    const row = object(field);
+    return !!row && only(row, fieldKeys) && exactInt(row.type, 0, 3) && (row.name === void 0 || stringOrNull(row.name)) && (row.value === void 0 || stringOrNull(row.value)) && (row.linkedId === void 0 || row.linkedId === null || exactInt(row.linkedId, 0, 4294967295));
+  }))) return invalid(title, ordinal, "The custom fields are invalid.");
+  if (item.passwordHistory != null && (!Array.isArray(item.passwordHistory) || !item.passwordHistory.every((entry) => {
+    const row = object(entry);
+    return !!row && Object.keys(row).length === 2 && typeof row.password === "string" && timestamp(row.lastUsedDate);
+  }))) return invalid(title, ordinal, "The password history is invalid.");
+  if (item.attachments !== void 0 && item.attachments !== null && !Array.isArray(item.attachments)) return invalid(title, ordinal, "The attachment fields are invalid.");
+  if (!jsonDepthOk(item, maxJsonDepth) || !allStringsWithin(item, maxCellBytes)) return invalid(title, ordinal, "The item exceeds the import limits.");
+  const type = Number(item.type.value);
+  const matching = type === 1 ? "login" : type === 2 ? "secureNote" : type === 3 ? "card" : type === 4 ? "identity" : "sshKey";
+  for (const component2 of ["login", "secureNote", "card", "identity", "sshKey"]) if (component2 !== matching && item[component2] != null) return unsupported(title, ordinal, "The item has an unclassified component.");
+  if (Array.isArray(item.attachments) && item.attachments.length) return unsupported(title, ordinal, "Attachments require a later import path.");
+  const sourceRecord = stringify({ source_vendor: "bitwarden", format: "bitwarden-json-export-v1", item, folders: typeof item.folderId === "string" ? folders.filter((folder) => folder.id === item.folderId) : [] }) ?? "";
+  if (type === 1) {
+    const login = object(item.login);
+    if (!login) return invalid(title, ordinal, "The login fields are invalid.");
+    if (!only(login, loginKeys)) return unsupported(title, ordinal, "The login has an unsupported field.");
+    if (!["username", "password", "totp"].every((key) => login[key] === void 0 || stringOrNull(login[key])) || login.uris !== void 0 && !Array.isArray(login.uris) || login.fido2Credentials !== void 0 && !Array.isArray(login.fido2Credentials)) return invalid(title, ordinal, "The login fields are invalid.");
+    if (Array.isArray(login.fido2Credentials) && login.fido2Credentials.length) return unsupported(title, ordinal, "Passkeys require a later import path.");
+    const rawUrls = [];
+    for (const uri of login.uris ?? []) {
+      const row = object(uri);
+      if (!row || !only(row, uriKeys)) return unsupported(title, ordinal, "The login has an unsupported URL field.");
+      if (row.uri !== void 0 && !stringOrNull(row.uri) || row.match !== void 0 && row.match !== null && !exactInt(row.match, 0, 5)) return invalid(title, ordinal, "The login URL fields are invalid.");
+      if (typeof row.uri === "string") rawUrls.push(row.uri);
+    }
+    return { ordinal, title, kind: "website_login", status: "supported", sourceState: item.deletedDate ? "deleted" : "active", sourceRecord, urls: rawUrls.map(safeDestination).flatMap((x) => x.metadata ? [x.metadata] : []), username: typeof login.username === "string" ? login.username : null, password: typeof login.password === "string" ? login.password : null, hasOtp: typeof login.totp === "string" && login.totp.length > 0 };
+  }
+  if (type === 5) {
+    const key = object(item.sshKey);
+    if (!key || !only(key, sshKeys) || typeof key.privateKey !== "string" || !key.privateKey || typeof key.publicKey !== "string" || typeof key.keyFingerprint !== "string") return invalid(title, ordinal, "The SSH key fields are invalid.");
+    return { ordinal, title, kind: "ssh_key", status: "supported", sourceState: item.deletedDate ? "deleted" : "active", sourceRecord, hasOtp: false, privateKey: key.privateKey, publicKey: key.publicKey };
+  }
+  const component = object(item[matching]);
+  const allowed = type === 2 ? noteKeys : type === 3 ? cardKeys : identityKeys;
+  if (!component) return invalid(title, ordinal, "The item fields are invalid.");
+  if (!only(component, allowed)) return unsupported(title, ordinal, "The item has an unsupported field.");
+  if (type === 2 && !exactInt(component.type, 0, 0)) return invalid(title, ordinal, "The secure note type is invalid.");
+  if (Object.entries(component).some(([key, value]) => key !== "type" && !stringOrNull(value))) return invalid(title, ordinal, "The item fields are invalid.");
+  return { ordinal, title, kind: "custom", status: "supported", sourceState: item.deletedDate ? "deleted" : "active", sourceRecord, hasOtp: false };
+}
+function parseBitwardenExport(text, limits) {
+  if (bytes(text) > limits.maxFileBytes) throw new Error("The file exceeds this organization\u2019s import size limit.");
+  let root;
+  try {
+    root = object(parse2(text)) ?? {};
+  } catch {
+    throw new Error("The JSON export has duplicate keys or could not be read safely.");
+  }
+  if (!jsonDepthOk(root, limits.maxJsonDepth) || !only(root, rootKeys) || root.encrypted !== false || !Array.isArray(root.folders) || !Array.isArray(root.items)) throw new Error(root.encrypted === true ? "Encrypted Bitwarden exports need local decryption support before they can be imported." : "This is not a supported plain Bitwarden JSON export.");
+  if (root.items.length > limits.maxRecords) throw new Error("The export has more records than this organization allows.");
+  if (!root.folders.every((folder) => {
+    const row = object(folder);
+    return !!row && only(row, folderKeys) && isRfc4122Uuid(row.id) && typeof row.name === "string" && allStringsWithin(row, limits.maxCellBytes);
+  })) throw new Error("The export folders are not supported.");
+  return root.items.map((item, ordinal) => object(item) ? itemRecord(item, ordinal, limits.maxCellBytes, limits.maxJsonDepth, root.folders) : invalid(`Item ${ordinal + 1}`, ordinal, "The item is invalid."));
+}
+
+// src/io/bitwarden-json.worker.ts
+function createBitwardenJsonWorkerMessageHandler(post) {
+  let active;
+  return async (request) => {
+    if (request.type === "cancel") {
+      if (active?.requestId === request.requestId) {
+        active.controller.abort();
+        active = void 0;
+      }
+      return;
+    }
+    active?.controller.abort();
+    const operation = {
+      requestId: request.requestId,
+      controller: new AbortController()
+    };
+    active = operation;
+    try {
+      if (request.file.size > request.limits.maxFileBytes)
+        throw new Error(
+          "The file exceeds this organization\u2019s import size limit."
+        );
+      const bytes2 = await request.file.arrayBuffer();
+      if (operation.controller.signal.aborted) return;
+      const text = new TextDecoder("utf-8", { fatal: true }).decode(bytes2);
+      const records = parseBitwardenExport(text, request.limits);
+      if (active !== operation || operation.controller.signal.aborted) return;
+      post({
+        ok: true,
+        requestId: request.requestId,
+        records,
+        fileNotices: []
+      });
+    } catch {
+      if (active !== operation || operation.controller.signal.aborted) return;
+      post({
+        ok: false,
+        requestId: request.requestId,
+        error: "The JSON export could not be read."
+      });
+    } finally {
+      if (active === operation) active = void 0;
+    }
+  };
+}
+if (typeof self !== "undefined") {
+  const handle = createBitwardenJsonWorkerMessageHandler(
+    (response) => self.postMessage(response)
+  );
+  self.onmessage = (event) => {
+    void handle(event.data);
+  };
+}
+export {
+  createBitwardenJsonWorkerMessageHandler
+};
+//# sourceMappingURL=bitwarden-json.worker.js.map