obsidian-encrypt-plugin/tools/offline-decrypt.js

(() => {
  // src/features/feature-inplace-encrypt/Decryptable.ts
  var Decryptable = class {
  };

  // src/features/feature-inplace-encrypt/FeatureInplaceConstants.ts
  var _PREFIX_B = "%%\u{1F510}\u03B2 ";
  var _PREFIX_B_VISIBLE = "\u{1F510}\u03B2 ";
  var _PREFIX_A = "%%\u{1F510}\u03B1 ";
  var _PREFIX_A_VISIBLE = "\u{1F510}\u03B1 ";
  var _PREFIX_OBSOLETE = "%%\u{1F510} ";
  var _PREFIX_OBSOLETE_VISIBLE = "\u{1F510} ";
  var _PREFIX_ENCODE_DEFAULT = _PREFIX_B;
  var _PREFIX_ENCODE_DEFAULT_VISIBLE = _PREFIX_B_VISIBLE;
  var _PREFIXES = [
    _PREFIX_B,
    _PREFIX_B_VISIBLE,
    _PREFIX_A,
    _PREFIX_A_VISIBLE,
    _PREFIX_OBSOLETE,
    _PREFIX_OBSOLETE_VISIBLE
  ];
  var _SUFFIX_WITH_COMMENT = " \u{1F510}%%";
  var _SUFFIX_NO_COMMENT = " \u{1F510}";
  var _SUFFIXES = [
    _SUFFIX_WITH_COMMENT,
    _SUFFIX_NO_COMMENT
  ];
  var _HINT = "\u{1F4A1}";

  // src/features/feature-inplace-encrypt/featureInplaceTextAnalysis.ts
  var FeatureInplaceTextAnalysis = class {
    constructor(text) {
      this.process(text);
    }
    process(text) {
      var _a, _b;
      this.processedText = text;
      this.isEmpty = text.length === 0;
      this.prefix = (_a = _PREFIXES.find((prefix) => text.startsWith(prefix))) != null ? _a : "";
      this.suffix = (_b = _SUFFIXES.find((suffix) => text.endsWith(suffix))) != null ? _b : "";
      this.hasEncryptedPrefix = this.prefix.length > 0;
      this.hasEncryptedSuffix = this.suffix.length > 0;
      this.hasObsoleteEncryptedPrefix = this.prefix === _PREFIX_OBSOLETE || this.prefix === _PREFIX_OBSOLETE_VISIBLE;
      this.containsEncryptedMarkers = [..._PREFIXES, ..._SUFFIXES].some((marker) => text.includes(marker));
      this.canDecrypt = this.hasEncryptedPrefix && this.hasEncryptedSuffix;
      this.canEncrypt = !this.hasEncryptedPrefix && !this.containsEncryptedMarkers;
      if (this.canDecrypt) {
        const decryptable = this.parseDecryptableContent(text);
        if (decryptable != null) {
          this.decryptable = decryptable;
        } else {
          this.canDecrypt = false;
        }
      }
    }
    parseDecryptableContent(text) {
      const result = new Decryptable();
      if (!this.hasEncryptedPrefix || !this.hasEncryptedSuffix) {
        return null;
      }
      if (this.hasObsoleteEncryptedPrefix) {
        result.version = 0;
      } else if (this.prefix == _PREFIX_B || this.prefix == _PREFIX_B_VISIBLE) {
        result.version = 2;
      } else if (this.prefix == _PREFIX_A || this.prefix == _PREFIX_A_VISIBLE) {
        result.version = 1;
      }
      const content = text.substring(this.prefix.length, text.length - this.suffix.length);
      if ([..._PREFIXES, ..._SUFFIXES].some((marker) => content.includes(marker))) {
        return null;
      }
      if (content.substring(0, _HINT.length) == _HINT) {
        const endHintMarker = content.indexOf(_HINT, _HINT.length);
        if (endHintMarker < 0) {
          return null;
        }
        result.hint = content.substring(_HINT.length, endHintMarker);
        result.base64CipherText = content.substring(endHintMarker + _HINT.length);
      } else {
        result.base64CipherText = content;
      }
      result.showInReadingView = !this.prefix.includes("%%");
      return result;
    }
  };

  // src/services/CryptoHelper.ts
  var vectorSize = 16;
  var utf8Encoder = new TextEncoder();
  var utf8Decoder = new TextDecoder();
  var iterations = 1e3;
  var salt = utf8Encoder.encode("XHWnDAT6ehMVY2zD");
  var CryptoHelper = class {
    // constructor(){
    // 	console.debug('new CryptoHelper');
    // }
    async deriveKey(password) {
      const buffer = utf8Encoder.encode(password);
      const key = await crypto.subtle.importKey("raw", buffer, { name: "PBKDF2" }, false, ["deriveKey"]);
      const privateKey = crypto.subtle.deriveKey(
        {
          name: "PBKDF2",
          hash: { name: "SHA-256" },
          iterations,
          salt
        },
        key,
        {
          name: "AES-GCM",
          length: 256
        },
        false,
        ["encrypt", "decrypt"]
      );
      return privateKey;
    }
    async encryptToBytes(text, password) {
      const key = await this.deriveKey(password);
      const textBytesToEncrypt = utf8Encoder.encode(text);
      const vector = crypto.getRandomValues(new Uint8Array(vectorSize));
      const encryptedBytes = new Uint8Array(
        await crypto.subtle.encrypt(
          { name: "AES-GCM", iv: vector },
          key,
          textBytesToEncrypt
        )
      );
      const finalBytes = new Uint8Array(vector.byteLength + encryptedBytes.byteLength);
      finalBytes.set(vector, 0);
      finalBytes.set(encryptedBytes, vector.byteLength);
      return finalBytes;
    }
    convertToString(bytes) {
      let result = "";
      for (let idx = 0; idx < bytes.length; idx++) {
        result += String.fromCharCode(bytes[idx]);
      }
      return result;
    }
    async encryptToBase64(text, password) {
      const finalBytes = await this.encryptToBytes(text, password);
      const base64Text = btoa(this.convertToString(finalBytes));
      return base64Text;
    }
    stringToArray(str) {
      const result = [];
      for (let i = 0; i < str.length; i++) {
        result.push(str.charCodeAt(i));
      }
      return new Uint8Array(result);
    }
    async decryptFromBytes(encryptedBytes, password) {
      try {
        const vector = encryptedBytes.slice(0, vectorSize);
        const encryptedTextBytes = encryptedBytes.slice(vectorSize);
        const key = await this.deriveKey(password);
        const decryptedBytes = await crypto.subtle.decrypt(
          { name: "AES-GCM", iv: vector },
          key,
          encryptedTextBytes
        );
        const decryptedText = utf8Decoder.decode(decryptedBytes);
        return decryptedText;
      } catch (e) {
        return null;
      }
    }
    async decryptFromBase64(base64Encoded, password) {
      try {
        const bytesToDecode = this.stringToArray(atob(base64Encoded));
        return await this.decryptFromBytes(bytesToDecode, password);
      } catch (e) {
        return null;
      }
    }
  };

  // src/services/CryptoHelper2304.ts
  var CryptoHelper2304 = class {
    constructor(vectorSize2, saltSize, iterations2) {
      this.vectorSize = vectorSize2;
      this.saltSize = saltSize;
      this.iterations = iterations2;
    }
    async deriveKey(password, salt2) {
      const utf8Encoder2 = new TextEncoder();
      const buffer = utf8Encoder2.encode(password);
      const key = await crypto.subtle.importKey(
        /*format*/
        "raw",
        /*keyData*/
        buffer,
        /*algorithm*/
        "PBKDF2",
        /*extractable*/
        false,
        /*keyUsages*/
        ["deriveKey"]
      );
      try {
        const privateKey = await crypto.subtle.deriveKey(
          /*algorithm*/
          {
            name: "PBKDF2",
            hash: "SHA-512",
            salt: salt2,
            iterations: this.iterations
          },
          /*baseKey*/
          key,
          /*derivedKeyAlgorithm*/
          {
            name: "AES-GCM",
            length: 256
          },
          /*extractable*/
          false,
          /*keyUsages*/
          ["encrypt", "decrypt"]
        );
        return privateKey;
      } finally {
      }
    }
    async encryptToBytes(text, password) {
      const salt2 = crypto.getRandomValues(new Uint8Array(this.saltSize));
      const key = await this.deriveKey(password, salt2);
      const utf8Encoder2 = new TextEncoder();
      const textBytesToEncrypt = utf8Encoder2.encode(text);
      const vector = crypto.getRandomValues(new Uint8Array(this.vectorSize));
      const encryptedBytes = new Uint8Array(
        await crypto.subtle.encrypt(
          /*algorithm*/
          {
            name: "AES-GCM",
            iv: vector
          },
          /*key*/
          key,
          /*data*/
          textBytesToEncrypt
        )
      );
      const finalBytes = new Uint8Array(vector.byteLength + salt2.byteLength + encryptedBytes.byteLength);
      finalBytes.set(vector, 0);
      finalBytes.set(salt2, vector.byteLength);
      finalBytes.set(encryptedBytes, vector.byteLength + salt2.byteLength);
      return finalBytes;
    }
    convertToString(bytes) {
      let result = "";
      for (let idx = 0; idx < bytes.length; idx++) {
        result += String.fromCharCode(bytes[idx]);
      }
      return result;
    }
    async encryptToBase64(text, password) {
      const finalBytes = await this.encryptToBytes(text, password);
      const base64Text = btoa(this.convertToString(finalBytes));
      return base64Text;
    }
    stringToArray(str) {
      const result = [];
      for (let i = 0; i < str.length; i++) {
        result.push(str.charCodeAt(i));
      }
      return new Uint8Array(result);
    }
    async decryptFromBytes(encryptedBytes, password) {
      try {
        let offset;
        let nextOffset;
        offset = 0;
        nextOffset = offset + this.vectorSize;
        const vector = encryptedBytes.slice(offset, nextOffset);
        offset = nextOffset;
        nextOffset = offset + this.saltSize;
        const salt2 = encryptedBytes.slice(offset, nextOffset);
        offset = nextOffset;
        nextOffset = void 0;
        const encryptedTextBytes = encryptedBytes.slice(offset);
        const key = await this.deriveKey(password, salt2);
        const decryptedBytes = await crypto.subtle.decrypt(
          /*algorithm*/
          {
            name: "AES-GCM",
            iv: vector
          },
          /*key*/
          key,
          /*data*/
          encryptedTextBytes
        );
        const utf8Decoder2 = new TextDecoder();
        const decryptedText = utf8Decoder2.decode(decryptedBytes);
        return decryptedText;
      } catch (e) {
        return null;
      }
    }
    async decryptFromBase64(base64Encoded, password) {
      try {
        const bytesToDecode = this.stringToArray(atob(base64Encoded));
        return await this.decryptFromBytes(bytesToDecode, password);
      } catch (e) {
        return null;
      }
    }
  };

  // src/services/CryptoHelperObsolete.ts
  var algorithmObsolete = {
    name: "AES-GCM",
    iv: new Uint8Array([196, 190, 240, 190, 188, 78, 41, 132, 15, 220, 84, 211]),
    tagLength: 128
  };
  var CryptoHelperObsolete = class {
    async buildKey(password) {
      const utf8Encode = new TextEncoder();
      const passwordBytes = utf8Encode.encode(password);
      const passwordDigest = await crypto.subtle.digest({ name: "SHA-256" }, passwordBytes);
      const key = await crypto.subtle.importKey(
        "raw",
        passwordDigest,
        algorithmObsolete,
        false,
        ["encrypt", "decrypt"]
      );
      return key;
    }
    /**
     	* @deprecated
    	*/
    async encryptToBase64(text, password) {
      const key = await this.buildKey(password);
      const utf8Encode = new TextEncoder();
      const bytesToEncrypt = utf8Encode.encode(text);
      const encryptedBytes = new Uint8Array(await crypto.subtle.encrypt(
        algorithmObsolete,
        key,
        bytesToEncrypt
      ));
      const base64Text = btoa(String.fromCharCode(...encryptedBytes));
      return base64Text;
    }
    stringToArray(str) {
      const result = [];
      for (let i = 0; i < str.length; i++) {
        result.push(str.charCodeAt(i));
      }
      return new Uint8Array(result);
    }
    async decryptFromBase64(base64Encoded, password) {
      try {
        const bytesToDecrypt = this.stringToArray(atob(base64Encoded));
        const key = await this.buildKey(password);
        const decryptedBytes = await crypto.subtle.decrypt(algorithmObsolete, key, bytesToDecrypt);
        const utf8Decode = new TextDecoder();
        const decryptedText = utf8Decode.decode(decryptedBytes);
        return decryptedText;
      } catch (e) {
        return null;
      }
    }
  };

  // src/services/CryptoHelperFactory.ts
  var _CryptoHelperFactory = class _CryptoHelperFactory {
    static BuildDefault() {
      return this.cryptoHelper2304_v2;
    }
    static BuildFromFileDataOrThrow(data) {
      const result = _CryptoHelperFactory.BuildFromFileDataOrNull(data);
      if (result != null) {
        return result;
      }
      throw new Error(`Unable to determine ICryptoHelper for File ver ${data.version}`);
    }
    static BuildFromFileDataOrNull(data) {
      if (data.version == "1.0") {
        return new CryptoHelper();
      }
      if (data.version == "2.0") {
        return this.cryptoHelper2304_v2;
      }
      return null;
    }
    static BuildFromDecryptableOrThrow(decryptable) {
      const result = _CryptoHelperFactory.BuildFromDecryptableOrNull(decryptable);
      if (result != null) {
        return result;
      }
      throw new Error(`Unable to determine ICryptoHelper for Decryptable ver ${decryptable.version}`);
    }
    static BuildFromDecryptableOrNull(decryptable) {
      if (decryptable.version == 0) {
        return new CryptoHelperObsolete();
      }
      if (decryptable.version == 1) {
        return new CryptoHelper();
      }
      if (decryptable.version == 2) {
        return this.cryptoHelper2304_v2;
      }
      return null;
    }
  };
  _CryptoHelperFactory.cryptoHelper2304_v2 = new CryptoHelper2304(16, 16, 21e4);
  var CryptoHelperFactory = _CryptoHelperFactory;

  // src/services/FileDataHelper.ts
  var FileData2 = class {
    constructor(version, hint, encodedData) {
      this.version = "1.0";
      this.version = version;
      this.hint = hint;
      this.encodedData = encodedData;
    }
  };
  var _FileDataHelper = class _FileDataHelper {
    static async encrypt(pass, hint, text) {
      const crypto2 = CryptoHelperFactory.BuildDefault();
      const encryptedData = await crypto2.encryptToBase64(text, pass);
      return new FileData2(_FileDataHelper.DEFAULT_VERSION, hint, encryptedData);
    }
    static async decrypt(data, pass) {
      if (data.encodedData == "") {
        return "";
      }
      const crypto2 = CryptoHelperFactory.BuildFromFileDataOrThrow(data);
      return await crypto2.decryptFromBase64(data.encodedData, pass);
    }
  };
  _FileDataHelper.DEFAULT_VERSION = "2.0";
  var FileDataHelper = _FileDataHelper;
  var JsonFileEncoding = class {
    static encode(data) {
      return JSON.stringify(data, null, 2);
    }
    static isEncoded(text) {
      try {
        JSON.parse(text);
        return true;
      } catch (error) {
        return false;
      }
    }
    static decode(encodedText) {
      if (encodedText === "") {
        return new FileData2(FileDataHelper.DEFAULT_VERSION, "", "");
      }
      return JSON.parse(encodedText);
    }
  };

  // src/tools/offline-decrypt.ts
  var OfflineDecrypt = class {
    async decrypt(content, password) {
      console.info("Trying the default decryption");
      const chDef = CryptoHelperFactory.BuildDefault();
      const result = await chDef.decryptFromBase64(content, password);
      if (result != null) {
        return result;
      }
      console.info("Trying marked inplace feature decryption");
      const ta = new FeatureInplaceTextAnalysis(content);
      if (ta.decryptable != null) {
        const ch = CryptoHelperFactory.BuildFromDecryptableOrNull(ta.decryptable);
        if (ch != null) {
          const result2 = await ch.decryptFromBase64(ta.decryptable.base64CipherText, password);
          if (result2 != null) {
            return result2;
          }
        }
      }
      for (let ver = 10; ver >= 0; ver--) {
        console.info("Trying non-marked inplace feature decryption", "ver", ver);
        const decryptable = { version: ver, base64CipherText: content, hint: "", showInReadingView: false };
        const ch = CryptoHelperFactory.BuildFromDecryptableOrNull(decryptable);
        const result2 = await (ch == null ? void 0 : ch.decryptFromBase64(decryptable.base64CipherText, password));
        if (result2 != null) {
          return result2;
        }
      }
      console.info("Trying whole note feature decryption");
      try {
        const fileData = JsonFileEncoding.decode(content);
        console.debug(fileData);
        const chFd = CryptoHelperFactory.BuildFromFileDataOrNull(fileData);
        const resultFd = await (chFd == null ? void 0 : chFd.decryptFromBase64(fileData.encodedData, password));
        if (resultFd != null) {
          return resultFd;
        }
      } catch (e) {
        console.info(e);
      }
      return null;
    }
  };
  window.$ = new OfflineDecrypt();
})();
//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/features/feature-inplace-encrypt/Decryptable.ts", "../src/features/feature-inplace-encrypt/FeatureInplaceConstants.ts", "../src/features/feature-inplace-encrypt/featureInplaceTextAnalysis.ts", "../src/services/CryptoHelper.ts", "../src/services/CryptoHelper2304.ts", "../src/services/CryptoHelperObsolete.ts", "../src/services/CryptoHelperFactory.ts", "../src/services/FileDataHelper.ts", "../src/tools/offline-decrypt.ts"],
  "sourcesContent": ["export class Decryptable{\r\n\tversion: number;\r\n\tbase64CipherText:string;\r\n\thint:string;\r\n\tshowInReadingView: boolean;\r\n}", "\r\nexport const _PREFIX_B = '%%\uD83D\uDD10\u03B2 ';\r\nexport const _PREFIX_B_VISIBLE = '\uD83D\uDD10\u03B2 ';\r\n\r\nexport const _PREFIX_A = '%%\uD83D\uDD10\u03B1 ';\r\nexport const _PREFIX_A_VISIBLE = '\uD83D\uDD10\u03B1 ';\r\nexport const _PREFIX_OBSOLETE = '%%\uD83D\uDD10 ';\r\nexport const _PREFIX_OBSOLETE_VISIBLE = '\uD83D\uDD10 ';\r\n\r\nexport const _PREFIX_ENCODE_DEFAULT = _PREFIX_B;\r\nexport const _PREFIX_ENCODE_DEFAULT_VISIBLE = _PREFIX_B_VISIBLE;\r\n\r\n// Should be listed by evaluation priority\r\nexport const _PREFIXES = [\r\n\t_PREFIX_B,\r\n\t_PREFIX_B_VISIBLE,\r\n\t_PREFIX_A,\r\n\t_PREFIX_A_VISIBLE,\r\n\t_PREFIX_OBSOLETE,\r\n\t_PREFIX_OBSOLETE_VISIBLE\r\n];\r\n\r\nexport const _SUFFIX_WITH_COMMENT = ' \uD83D\uDD10%%';\r\nexport const _SUFFIX_NO_COMMENT = ' \uD83D\uDD10';\r\n\r\n// Should be listed by evaluation priority\r\nexport const _SUFFIXES = [\r\n\t_SUFFIX_WITH_COMMENT,\r\n\t_SUFFIX_NO_COMMENT\r\n]\r\n\r\nexport const _HINT = '\uD83D\uDCA1';", "import { Decryptable } from \"./Decryptable.ts\";\r\nimport { _HINT, _PREFIXES, _PREFIX_A, _PREFIX_A_VISIBLE, _PREFIX_B, _PREFIX_B_VISIBLE, _PREFIX_OBSOLETE, _PREFIX_OBSOLETE_VISIBLE, _SUFFIXES } from \"./FeatureInplaceConstants.ts\";\r\n\r\nexport class FeatureInplaceTextAnalysis{\r\n\tprocessedText:string;\r\n\tisEmpty: boolean;\r\n\t\r\n\tprefix: string;\r\n\tsuffix: string;\r\n\r\n\thasObsoleteEncryptedPrefix: boolean;\r\n\thasEncryptedPrefix: boolean;\r\n\thasEncryptedSuffix: boolean;\r\n\tcanDecrypt: boolean;\r\n\tcanEncrypt: boolean;\r\n\tcontainsEncryptedMarkers: boolean;\r\n\tdecryptable? : Decryptable;\r\n\r\n\tconstructor(text: string){\r\n\t\tthis.process(text);\r\n\t}\r\n\r\n\tprivate process( text: string ) : void{\r\n\t\t\r\n\t\tthis.processedText = text;\r\n\r\n\t\tthis.isEmpty = text.length === 0;\r\n\r\n\t\tthis.prefix = _PREFIXES.find( (prefix) => text.startsWith(prefix) ) ?? '';\r\n\t\tthis.suffix = _SUFFIXES.find( (suffix) => text.endsWith(suffix) ) ?? '';\r\n\t\t\r\n\t\tthis.hasEncryptedPrefix = this.prefix.length > 0;\r\n\t\tthis.hasEncryptedSuffix = this.suffix.length > 0;\r\n\r\n\t\tthis.hasObsoleteEncryptedPrefix = this.prefix === _PREFIX_OBSOLETE || this.prefix === _PREFIX_OBSOLETE_VISIBLE;\r\n\r\n\t\tthis.containsEncryptedMarkers = [..._PREFIXES, ..._SUFFIXES].some( (marker) => text.includes(marker ));\r\n\r\n\t\tthis.canDecrypt = this.hasEncryptedPrefix && this.hasEncryptedSuffix;\r\n\t\tthis.canEncrypt = !this.hasEncryptedPrefix && !this.containsEncryptedMarkers;\r\n\t\t\r\n\t\tif (this.canDecrypt){\r\n\t\t\tconst decryptable = this.parseDecryptableContent(text);\r\n\r\n\t\t\tif ( decryptable != null ){\r\n\t\t\t\tthis.decryptable = decryptable;\r\n\t\t\t}else{\r\n\t\t\t\tthis.canDecrypt = false;\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\tprivate parseDecryptableContent(text: string) : Decryptable | null {\r\n\t\tconst result = new Decryptable();\r\n\r\n\t\tif (\r\n\t\t\t!this.hasEncryptedPrefix\r\n\t\t\t|| !this.hasEncryptedSuffix\r\n\t\t){\r\n\t\t\treturn null; // invalid format\r\n\t\t}\r\n\t\t\r\n\t\tif ( this.hasObsoleteEncryptedPrefix ){\r\n\t\t\tresult.version = 0;\r\n\t\t}else if ( this.prefix == _PREFIX_B || this.prefix == _PREFIX_B_VISIBLE ){\r\n\t\t\tresult.version = 2;\r\n\t\t}else if ( this.prefix == _PREFIX_A || this.prefix == _PREFIX_A_VISIBLE ){\r\n\t\t\tresult.version = 1;\r\n\t\t}\r\n\r\n\t\t// remove markers from start and end\t\r\n\t\tconst content = text.substring(this.prefix.length, text.length - this.suffix.length);\r\n\r\n\t\tif ( [..._PREFIXES, ..._SUFFIXES].some( (marker) => content.includes( marker )) ){\r\n\t\t\t// content, itself has markers\r\n\t\t\treturn null;\r\n\t\t}\r\n\r\n\t\t// check if there is a hint\r\n\t\tif (content.substring(0,_HINT.length) == _HINT){\r\n\t\t\tconst endHintMarker = content.indexOf(_HINT,_HINT.length);\r\n\t\t\tif (endHintMarker<0){\r\n\t\t\t\treturn null; // invalid format\r\n\t\t\t}\r\n\t\t\tresult.hint = content.substring(_HINT.length,endHintMarker)\r\n\t\t\tresult.base64CipherText = content.substring(endHintMarker+_HINT.length);\r\n\t\t}else{\r\n\t\t\tresult.base64CipherText = content;\r\n\t\t}\r\n\t\tresult.showInReadingView = !this.prefix.includes(\"%%\");\r\n\t\treturn result;\r\n\r\n\t}\r\n}", "const vectorSize\t= 16;\r\nconst utf8Encoder\t= new TextEncoder();\r\nconst utf8Decoder\t= new TextDecoder();\r\nconst iterations\t= 1000;\r\nconst salt\t\t\t= utf8Encoder.encode('XHWnDAT6ehMVY2zD');\r\n\r\nexport class CryptoHelper {\r\n\r\n\t// constructor(){\r\n\t// \tconsole.debug('new CryptoHelper');\r\n\t// }\r\n\r\n\tprivate async deriveKey(password:string) :Promise<CryptoKey> {\r\n\t\tconst buffer     = utf8Encoder.encode(password);\r\n\t\tconst key        = await crypto.subtle.importKey('raw', buffer, {name: 'PBKDF2'}, false, ['deriveKey']);\r\n\t\tconst privateKey = crypto.subtle.deriveKey(\r\n\t\t\t{\r\n\t\t\t\tname: 'PBKDF2',\r\n\t\t\t\thash: {name: 'SHA-256'},\r\n\t\t\t\titerations,\r\n\t\t\t\tsalt\r\n\t\t\t},\r\n\t\t\tkey,\r\n\t\t\t{\r\n\t\t\t\tname: 'AES-GCM',\r\n\t\t\t\tlength: 256\r\n\t\t\t},\r\n\t\t\tfalse,\r\n\t\t\t['encrypt', 'decrypt']\r\n\t\t);\r\n\t\t\r\n\t\treturn privateKey;\r\n\t}\r\n\r\n\tpublic async encryptToBytes(text: string, password: string): Promise<Uint8Array> {\r\n\r\n\t\tconst key = await this.deriveKey(password);\r\n\t\t\r\n\t\tconst textBytesToEncrypt = utf8Encoder.encode(text);\r\n\t\tconst vector = crypto.getRandomValues(new Uint8Array(vectorSize));\r\n\t\t\r\n\t\t// encrypt into bytes\r\n\t\tconst encryptedBytes = new Uint8Array(\r\n\t\t\tawait crypto.subtle.encrypt(\r\n\t\t\t\t{name: 'AES-GCM', iv: vector},\r\n\t\t\t\tkey,\r\n\t\t\t\ttextBytesToEncrypt\r\n\t\t\t)\r\n\t\t);\r\n\t\t\r\n\t\tconst finalBytes = new Uint8Array( vector.byteLength + encryptedBytes.byteLength );\r\n\t\tfinalBytes.set( vector, 0 );\r\n\t\tfinalBytes.set( encryptedBytes, vector.byteLength );\r\n\r\n\t\treturn finalBytes;\r\n\t}\r\n\r\n\tprivate convertToString( bytes : Uint8Array ): string {\r\n\t\tlet result = '';\r\n\t\tfor (let idx = 0; idx < bytes.length; idx++) {\r\n\t\t\t// append to result\r\n\t\t\tresult += String.fromCharCode(bytes[idx]);\r\n\t\t}\r\n\t\treturn result;\r\n\t}\r\n\r\n\tpublic async encryptToBase64(text: string, password: string): Promise<string> {\r\n\r\n\t\tconst finalBytes = await this.encryptToBytes(text, password);\r\n\r\n\t\t//convert array to base64\r\n\t\tconst base64Text = btoa( this.convertToString(finalBytes) );\r\n\r\n\t\treturn base64Text;\r\n\t}\r\n\r\n\tprivate stringToArray(str: string): Uint8Array {\r\n\t\tconst result = [];\r\n\t\tfor (let i = 0; i < str.length; i++) {\r\n\t\t\tresult.push(str.charCodeAt(i));\r\n\t\t}\r\n\t\treturn new Uint8Array(result);\r\n\t}\r\n\r\n\tpublic async decryptFromBytes(encryptedBytes: Uint8Array, password: string): Promise<string|null> {\r\n\t\ttry {\r\n\r\n\t\t\t// extract iv\r\n\t\t\tconst vector = encryptedBytes.slice(0,vectorSize);\r\n\r\n\t\t\t// extract encrypted text\r\n\t\t\tconst encryptedTextBytes = encryptedBytes.slice(vectorSize);\r\n\r\n\t\t\tconst key = await this.deriveKey(password);\r\n\r\n\t\t\t// decrypt into bytes\r\n\t\t\tconst decryptedBytes = await crypto.subtle.decrypt(\r\n\t\t\t\t{name: 'AES-GCM', iv: vector},\r\n\t\t\t\tkey,\r\n\t\t\t\tencryptedTextBytes\r\n\t\t\t);\r\n\r\n\t\t\t// convert bytes to text\r\n\t\t\tconst decryptedText = utf8Decoder.decode(decryptedBytes);\r\n\t\t\treturn decryptedText;\r\n\t\t} catch (e) {\r\n\t\t\t//console.error(e);\r\n\t\t\treturn null;\r\n\t\t}\r\n\t}\r\n\r\n\tpublic async decryptFromBase64(base64Encoded: string, password: string): Promise<string|null> {\r\n\t\ttry {\r\n\r\n\t\t\tconst bytesToDecode = this.stringToArray(atob(base64Encoded));\r\n\t\t\t\r\n\t\t\treturn await this.decryptFromBytes(bytesToDecode, password);\r\n\r\n\t\t\t// // extract iv\r\n\t\t\t// const vector = bytesToDecode.slice(0,vectorSize);\r\n\r\n\t\t\t// // extract encrypted text\r\n\t\t\t// const encryptedTextBytes = bytesToDecode.slice(vectorSize);\r\n\r\n\t\t\t// const key = await this.deriveKey(password);\r\n\r\n\t\t\t// // decrypt into bytes\r\n\t\t\t// let decryptedBytes = await crypto.subtle.decrypt(\r\n\t\t\t// \t{name: 'AES-GCM', iv: vector},\r\n\t\t\t// \tkey,\r\n\t\t\t// \tencryptedTextBytes\r\n\t\t\t// );\r\n\r\n\t\t\t// // convert bytes to text\r\n\t\t\t// let decryptedText = utf8Decoder.decode(decryptedBytes);\r\n\t\t\t// return decryptedText;\r\n\t\t} catch (e) {\r\n\t\t\t//console.error(e);\r\n\t\t\treturn null;\r\n\t\t}\r\n\t}\r\n\r\n}\r\n\r\n\r\n\r\n", "import { ICryptoHelper } from \"./ICryptoHelper.ts\";\r\n\r\nexport class CryptoHelper2304 implements ICryptoHelper {\r\n\tpublic vectorSize: number;\r\n\tpublic saltSize: number;\r\n\tpublic iterations: number;\r\n\r\n\tconstructor( vectorSize: number, saltSize: number, iterations: number ){\r\n\t\t//console.debug('new CryptoHelper2304', {vectorSize, saltSize, iterations});\r\n\t\tthis.vectorSize = vectorSize;\r\n\t\tthis.saltSize = saltSize;\r\n\t\tthis.iterations = iterations;\r\n\t}\r\n\r\n\tprivate async deriveKey( password:string, salt:Uint8Array ) :Promise<CryptoKey> {\r\n\t\t// console.trace('CryptoHelper2304.deriveKey');\r\n\t\t//See: https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto\r\n\t\tconst utf8Encoder\t= new TextEncoder();\r\n\t\tconst buffer     = utf8Encoder.encode(password);\r\n\t\tconst key        = await crypto.subtle.importKey(\r\n\t\t\t/*format*/ 'raw',\r\n\t\t\t/*keyData*/ buffer,\r\n\t\t\t/*algorithm*/ 'PBKDF2',\r\n\t\t\t/*extractable*/ false,\r\n\t\t\t/*keyUsages*/ ['deriveKey']\r\n\t\t);\r\n\t\t\r\n\t\t//console.time('CryptoHelper2304.deriveKey');\r\n\t\ttry{\r\n\t\t\tconst privateKey = await crypto.subtle.deriveKey(\r\n\t\t\t\t/*algorithm*/ {\r\n\t\t\t\t\tname: 'PBKDF2',\r\n\t\t\t\t\thash: 'SHA-512',\r\n\t\t\t\t\tsalt,\r\n\t\t\t\t\titerations: this.iterations,\r\n\t\t\t\t},\r\n\t\t\t\t/*baseKey*/ key,\r\n\t\t\t\t/*derivedKeyAlgorithm*/ {\r\n\t\t\t\t\tname: 'AES-GCM',\r\n\t\t\t\t\tlength: 256\r\n\t\t\t\t},\r\n\t\t\t\t/*extractable*/ false,\r\n\t\t\t\t/*keyUsages*/ ['encrypt', 'decrypt']\r\n\t\t\t);\r\n\t\t\t\r\n\t\t\treturn privateKey;\r\n\t\t}finally{\r\n\t\t\t//console.timeEnd('CryptoHelper2304.deriveKey');\r\n\t\t}\r\n\t}\r\n\r\n\tprivate async encryptToBytes( text: string, password: string ): Promise<Uint8Array> {\r\n\r\n\t\tconst salt = crypto.getRandomValues( new Uint8Array(this.saltSize) );\r\n\r\n\t\tconst key = await this.deriveKey( password, salt );\r\n\t\t\r\n\t\tconst utf8Encoder\t= new TextEncoder();\r\n\t\tconst textBytesToEncrypt = utf8Encoder.encode(text);\r\n\t\tconst vector = crypto.getRandomValues(new Uint8Array(this.vectorSize));\r\n\t\t\r\n\t\t// encrypt into bytes\r\n\t\tconst encryptedBytes = new Uint8Array(\r\n\t\t\tawait crypto.subtle.encrypt(\r\n\t\t\t\t/*algorithm*/ {\r\n\t\t\t\t\tname: 'AES-GCM',\r\n\t\t\t\t\tiv: vector\r\n\t\t\t\t},\r\n\t\t\t\t/*key*/ key,\r\n\t\t\t\t/*data*/ textBytesToEncrypt\r\n\t\t\t)\r\n\t\t);\r\n\t\t\r\n\t\tconst finalBytes = new Uint8Array( vector.byteLength + salt.byteLength + encryptedBytes.byteLength );\r\n\t\tfinalBytes.set( vector, 0 );\r\n\t\tfinalBytes.set( salt, vector.byteLength );\r\n\t\tfinalBytes.set( encryptedBytes, vector.byteLength + salt.byteLength );\r\n\r\n\t\treturn finalBytes;\r\n\t}\r\n\r\n\tprivate convertToString( bytes : Uint8Array ): string {\r\n\t\tlet result = '';\r\n\t\tfor (let idx = 0; idx < bytes.length; idx++) {\r\n\t\t\t// append to result\r\n\t\t\tresult += String.fromCharCode(bytes[idx]);\r\n\t\t}\r\n\t\treturn result;\r\n\t}\r\n\r\n\tpublic async encryptToBase64(text: string, password: string): Promise<string> {\r\n\r\n\t\tconst finalBytes = await this.encryptToBytes(text, password);\r\n\r\n\t\t//convert array to base64\r\n\t\tconst base64Text = btoa( this.convertToString(finalBytes) );\r\n\r\n\t\treturn base64Text;\r\n\t}\r\n\r\n\tprivate stringToArray(str: string): Uint8Array {\r\n\t\tconst result = [];\r\n\t\tfor (let i = 0; i < str.length; i++) {\r\n\t\t\tresult.push(str.charCodeAt(i));\r\n\t\t}\r\n\t\treturn new Uint8Array(result);\r\n\t}\r\n\r\n\tprivate async decryptFromBytes(\r\n\t\tencryptedBytes: Uint8Array,\r\n\t\tpassword: string\r\n\t): Promise<string|null> {\r\n\t\ttry {\r\n\t\t\t\r\n\t\t\tlet offset: number;\r\n\t\t\tlet nextOffset : number|undefined;\r\n\t\t\t\r\n\t\t\t// extract iv\r\n\t\t\toffset = 0;\r\n\t\t\tnextOffset = offset + this.vectorSize;\r\n\t\t\tconst vector = encryptedBytes.slice(offset, nextOffset);\r\n\t\t\t\r\n\t\t\t// extract salt\r\n\t\t\toffset = nextOffset;\r\n\t\t\tnextOffset = offset + this.saltSize;\r\n\t\t\tconst salt = encryptedBytes.slice(offset, nextOffset);\r\n\t\t\t\r\n\t\t\t// extract encrypted text\r\n\t\t\toffset = nextOffset;\r\n\t\t\tnextOffset = undefined;\r\n\t\t\tconst encryptedTextBytes = encryptedBytes.slice(offset);\r\n\t\t\t\r\n\t\t\tconst key = await this.deriveKey(password, salt);\r\n\t\t\t\r\n\t\t\t// decrypt into bytes\r\n\t\t\tconst decryptedBytes = await crypto.subtle.decrypt(\r\n\t\t\t\t/*algorithm*/ {\r\n\t\t\t\t\tname: 'AES-GCM',\r\n\t\t\t\t\tiv: vector\r\n\t\t\t\t},\r\n\t\t\t\t/*key*/ key,\r\n\t\t\t\t/*data*/ encryptedTextBytes\r\n\t\t\t);\r\n\t\t\t\r\n\t\t\t// convert bytes to text\r\n\t\t\tconst utf8Decoder\t= new TextDecoder();\r\n\t\t\tconst decryptedText = utf8Decoder.decode(decryptedBytes);\r\n\t\t\treturn decryptedText;\r\n\t\t\t\r\n\t\t} catch (e) {\r\n\t\t\t//console.error(e);\r\n\t\t\treturn null;\r\n\t\t}\r\n\t}\r\n\r\n\tpublic async decryptFromBase64( base64Encoded: string, password: string ): Promise<string|null> {\r\n\t\ttry {\r\n\t\t\tconst bytesToDecode = this.stringToArray(atob(base64Encoded));\r\n\t\t\treturn await this.decryptFromBytes( bytesToDecode, password );\r\n\t\t} catch (e) {\r\n\t\t\treturn null;\r\n\t\t}\r\n\t}\r\n\r\n}", "export const algorithmObsolete = {\r\n\tname: 'AES-GCM',\r\n\tiv: new Uint8Array([196, 190, 240, 190, 188, 78, 41, 132, 15, 220, 84, 211]),\r\n\ttagLength: 128\r\n}\r\n\r\nexport class CryptoHelperObsolete {\r\n\r\n\tprivate async buildKey(password: string) {\r\n\t\tconst utf8Encode = new TextEncoder();\r\n\t\tconst passwordBytes = utf8Encode.encode(password);\r\n\r\n\t\tconst passwordDigest = await crypto.subtle.digest({ name: 'SHA-256' }, passwordBytes);\r\n\r\n\t\tconst key = await crypto.subtle.importKey(\r\n\t\t\t'raw',\r\n\t\t\tpasswordDigest,\r\n\t\t\talgorithmObsolete,\r\n\t\t\tfalse,\r\n\t\t\t['encrypt', 'decrypt']\r\n\t\t);\r\n\r\n\t\treturn key;\r\n\t}\r\n\t\r\n\t/**\r\n  \t* @deprecated\r\n \t*/\r\n\tpublic async encryptToBase64(text: string, password: string): Promise<string> {\r\n\t\tconst key = await this.buildKey(password);\r\n\r\n\t\tconst utf8Encode = new TextEncoder();\r\n\t\tconst bytesToEncrypt = utf8Encode.encode(text);\r\n\r\n\t\t// encrypt into bytes\r\n\t\tconst encryptedBytes = new Uint8Array(await crypto.subtle.encrypt(\r\n\t\t\talgorithmObsolete, key, bytesToEncrypt\r\n\t\t));\r\n\r\n\t\t//convert array to base64\r\n\t\tconst base64Text = btoa(String.fromCharCode(...encryptedBytes));\r\n\r\n\t\treturn base64Text;\r\n\t}\r\n\r\n\tprivate stringToArray(str: string): Uint8Array {\r\n\t\tconst result = [];\r\n\t\tfor (let i = 0; i < str.length; i++) {\r\n\t\t\tresult.push(str.charCodeAt(i));\r\n\t\t}\r\n\t\treturn new Uint8Array(result);\r\n\t}\r\n\r\n\tpublic async decryptFromBase64(base64Encoded: string, password: string): Promise<string|null> {\r\n\t\ttry {\r\n\t\t\t// convert base 64 to array\r\n\t\t\tconst bytesToDecrypt = this.stringToArray(atob(base64Encoded));\r\n\r\n\t\t\tconst key = await this.buildKey(password);\r\n\r\n\t\t\t// decrypt into bytes\r\n\t\t\tconst decryptedBytes = await crypto.subtle.decrypt(algorithmObsolete, key, bytesToDecrypt);\r\n\r\n\t\t\t// convert bytes to text\r\n\t\t\tconst utf8Decode = new TextDecoder();\r\n\t\t\tconst decryptedText = utf8Decode.decode(decryptedBytes);\r\n\t\t\treturn decryptedText;\r\n\t\t} catch (e) {\r\n\t\t\treturn null;\r\n\t\t}\r\n\t}\r\n\r\n}\r\n", "import { FileData } from \"./FileDataHelper.ts\";\r\nimport { Decryptable } from \"../features/feature-inplace-encrypt/Decryptable.ts\";\r\nimport { CryptoHelper } from \"./CryptoHelper.ts\";\r\nimport { ICryptoHelper } from \"./ICryptoHelper.ts\";\r\nimport { CryptoHelper2304 } from \"./CryptoHelper2304.ts\";\r\nimport { CryptoHelperObsolete } from \"./CryptoHelperObsolete.ts\";\r\n\r\nexport class CryptoHelperFactory{\r\n\r\n\tpublic static cryptoHelper2304_v2 = new CryptoHelper2304( 16, 16, 210000 );\r\n\r\n\tpublic static BuildDefault(): ICryptoHelper{\r\n\t\treturn this.cryptoHelper2304_v2;\r\n\t}\r\n\r\n\tpublic static BuildFromFileDataOrThrow( data: FileData ) : ICryptoHelper {\r\n\t\tconst result = CryptoHelperFactory.BuildFromFileDataOrNull(data);\r\n\t\tif ( result != null ){\r\n\t\t\treturn result;\r\n\t\t}\r\n\t\tthrow new Error( `Unable to determine ICryptoHelper for File ver ${data.version}`);\r\n\t}\r\n\r\n\tpublic static BuildFromFileDataOrNull( data: FileData ) : ICryptoHelper | null {\r\n\t\tif ( data.version == '1.0' ){\r\n\t\t\treturn new CryptoHelper();\r\n\t\t}\r\n\r\n\t\t// note\t\t\t\tv2.0\tCryptoHelper2304\r\n\t\tif ( data.version == '2.0' ){\r\n\t\t\treturn this.cryptoHelper2304_v2;\r\n\t\t}\r\n\r\n\t\treturn null;\r\n\t}\r\n\r\n\tpublic static BuildFromDecryptableOrThrow( decryptable: Decryptable ) : ICryptoHelper {\r\n\t\tconst result = CryptoHelperFactory.BuildFromDecryptableOrNull( decryptable );\r\n\r\n\t\tif (result != null){\r\n\t\t\treturn result;\r\n\t\t}\r\n\t\tthrow new Error( `Unable to determine ICryptoHelper for Decryptable ver ${decryptable.version}`);\r\n\t}\r\n\r\n\tpublic static BuildFromDecryptableOrNull( decryptable: Decryptable ) : ICryptoHelper | null {\r\n\t\t// Versions\r\n\t\t// inplace original\t_PREFIX_OBSOLETE = '%%\uD83D\uDD10 '  CryptoHelperObsolete\r\n\t\t\r\n\t\t// inplace alpha\t_PREFIX_A = '%%\uD83D\uDD10\u03B1 '\t\tCryptoHelper\r\n\t\t// \t\t\t\t\t_PREFIX_A_VISIBLE = '\uD83D\uDD10\u03B1 '\tCryptoHelper\r\n\r\n\t\t// inplace beta \t_PREFIX_B = '%%\uD83D\uDD10\u03B2 '\t\tCryptoHelper2304( 16, 16, 210000 )\r\n\t\t//\t\t\t\t\t_PREFIX_B_VISIBLE = '\uD83D\uDD10\u03B2 '\tCryptoHelper2304( 16, 16, 210000 )\r\n\t\t\r\n\t\tif ( decryptable.version == 0 ){\r\n\t\t\treturn new CryptoHelperObsolete();\r\n\t\t}\r\n\r\n\t\tif ( decryptable.version == 1 ){\r\n\t\t\treturn new CryptoHelper();\r\n\t\t}\r\n\r\n\t\tif ( decryptable.version == 2 ){\r\n\t\t\treturn this.cryptoHelper2304_v2;\r\n\t\t}\r\n\r\n\t\treturn null;\r\n\t}\r\n\r\n}", "import { CryptoHelperFactory } from \"./CryptoHelperFactory.ts\";\r\n\r\nexport class FileData {\r\n\t\r\n\tpublic version = '1.0';\r\n\tpublic hint: string;\r\n\tpublic encodedData:string;\r\n\r\n\tconstructor( version:string, hint:string, encodedData:string ){\r\n\t\tthis.version = version;\r\n\t\tthis.hint = hint;\r\n\t\tthis.encodedData = encodedData;\r\n\t}\r\n}\r\n\r\nexport class FileDataHelper{\r\n\r\n\tpublic static DEFAULT_VERSION = '2.0';\r\n\r\n\tpublic static async encrypt( pass: string, hint:string, text:string ) : Promise<FileData>{\r\n\t\tconst crypto = CryptoHelperFactory.BuildDefault();\r\n\t\tconst encryptedData = await crypto.encryptToBase64(text, pass);\r\n\t\treturn new FileData( FileDataHelper.DEFAULT_VERSION, hint, encryptedData);\r\n\t}\r\n\r\n\tpublic static async decrypt( data: FileData, pass:string ) : Promise<string|null>{\r\n\t\tif ( data.encodedData == '' ){\r\n\t\t\treturn '';\r\n\t\t}\r\n\t\tconst crypto = CryptoHelperFactory.BuildFromFileDataOrThrow( data );\r\n\t\treturn await crypto.decryptFromBase64( data.encodedData, pass );\r\n\t}\r\n}\r\n\r\nexport class JsonFileEncoding {\r\n\r\n\tpublic static encode( data: FileData ) : string{\r\n\t\t//console.debug( 'JsonFileEncoding.encode', {data} );\r\n\t\treturn JSON.stringify(data, null, 2);\r\n\t}\r\n\r\n\tpublic static isEncoded( text: string ) : boolean {\r\n\t\ttry {\r\n\t\t\tJSON.parse( text );\r\n\t\t\treturn true;\r\n\t\t} catch ( error ) {\r\n\t\t\treturn false;\r\n\t\t}\r\n\t}\r\n\r\n\tpublic static decode( encodedText:string ) : FileData {\r\n\t\t//console.debug('JsonFileEncoding.decode',{encodedText});\r\n\t\tif ( encodedText === '' ){\r\n\t\t\treturn new FileData( FileDataHelper.DEFAULT_VERSION, '', '' );\r\n\t\t}\r\n\t\treturn JSON.parse( encodedText ) as FileData;\r\n\t}\r\n}", "import { Decryptable } from \"../features/feature-inplace-encrypt/Decryptable.ts\";\r\nimport { FeatureInplaceTextAnalysis } from \"../features/feature-inplace-encrypt/featureInplaceTextAnalysis.ts\";\r\nimport { CryptoHelperFactory } from \"../services/CryptoHelperFactory.ts\";\r\nimport { JsonFileEncoding } from \"../services/FileDataHelper.ts\";\r\n\r\nexport class OfflineDecrypt {\r\n\r\n\tpublic async decrypt( content:string, password: string ) : Promise<string | null> {\r\n\r\n\t\t// Trying the default decryption\r\n\t\tconsole.info( 'Trying the default decryption' );\r\n\t\tconst chDef = CryptoHelperFactory.BuildDefault();\r\n\t\tconst result = await chDef.decryptFromBase64( content, password );\r\n\t\tif ( result != null ){\r\n\t\t\treturn result;\r\n\t\t}\r\n\r\n\t\t// Trying marked inplace feature decryption\r\n\t\tconsole.info( 'Trying marked inplace feature decryption' );\r\n\t\tconst ta = new FeatureInplaceTextAnalysis( content );\r\n\t\tif ( ta.decryptable != null ){\r\n\t\t\tconst ch = CryptoHelperFactory.BuildFromDecryptableOrNull(ta.decryptable);\r\n\t\t\tif (ch != null){\r\n\t\t\t\tconst result = await ch.decryptFromBase64( ta.decryptable.base64CipherText, password );\r\n\t\t\t\tif ( result != null ){\r\n\t\t\t\t\treturn result;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\t// Trying non-marked inplace feature decryption\r\n\t\tfor (let ver = 10; ver >= 0; ver--) {\r\n\t\t\tconsole.info( 'Trying non-marked inplace feature decryption', 'ver', ver );\r\n\t\t\tconst decryptable : Decryptable = { version: ver, base64CipherText: content, hint: '', showInReadingView: false };\r\n\t\t\tconst ch = CryptoHelperFactory.BuildFromDecryptableOrNull(decryptable)\r\n\t\t\tconst result = await ch?.decryptFromBase64( decryptable.base64CipherText, password );\r\n\t\t\tif ( result != null ){\r\n\t\t\t\treturn result;\r\n\t\t\t}\r\n\t\t}\r\n\r\n\r\n\t\t// Trying whole note feature decryption\r\n\t\tconsole.info( 'Trying whole note feature decryption' );\r\n\t\ttry{\r\n\t\t\tconst fileData = JsonFileEncoding.decode( content );\r\n\t\t\tconsole.debug(fileData);\r\n\t\t\tconst chFd = CryptoHelperFactory.BuildFromFileDataOrNull( fileData );\r\n\t\t\tconst resultFd = await chFd?.decryptFromBase64( fileData.encodedData, password );\r\n\t\t\tif ( resultFd != null ){\r\n\t\t\t\treturn resultFd;\r\n\t\t\t}\r\n\t\t} catch (e){\r\n\t\t\tconsole.info(e);\r\n\t\t}\r\n\r\n\t\treturn null;\r\n\t}\r\n}\r\ndeclare global {\r\n    interface Window { $: OfflineDecrypt; }\r\n}\r\n\r\nwindow.$ = new OfflineDecrypt();\r\n"],
  "mappings": "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",
  "names": ["vectorSize", "iterations", "salt", "utf8Encoder", "utf8Decoder", "FileData", "crypto", "result"]
}
