How to use lzutf8 - 10 common examples

async encrypt (pld, secrets) {
    try {
      let rawPld
      try {
        rawPld = LZUTF8.compress(JSON.stringify(pld))
      } catch (e) {
        throw this.err('Packing process failed', { e })
      }
      try {
        secrets = await this.loadSecrets(['encrypt'], secrets)
        const tagSize = 128 // 128 bits
        const iv = new Uint8Array(12) // 12 bytes
        crypto.getRandomValues(iv)
        let cypher = await crypto.subtle.encrypt(
          {
            name: 'AES-GCM',
            iv,
            tagLength: tagSize,
            additionalData: __.strToArrBuf(secrets.userId)
          },
          secrets.cryptKeyObj,

name: 'AES-GCM',
            tagLength: 128, // 128 bits
            iv: new Uint8Array(data.iv), // 12 bytes
            additionalData: __.strToArrBuf(secrets.userId)
          },
          secrets.cryptKeyObj,
          new Uint8Array(data.cypher)
        )
      } catch (e) {
        throw this.err('Decryption process failed. Most likely reason: ' +
                       'Wrong crypto-key. Other (very unlikely) reasons: ' +
                       'tagLength or iv or additionalData are not ' +
                       'congruent with related encryption values', { e })
      }
      try {
        return JSON.parse(LZUTF8.decompress(new Uint8Array(rawPld)))
      } catch (e) {
        throw this.err('Unpacking process failed', { e })
      }
    } catch (e) {
      if (isLogin) throw this.err('Decrypting data failed', { e })
      throw this.err('Decrypting data failed', { e, sts: 900 })
    }
  }

require.ensure('lzutf8', (require) => {
            const decompress = require('lzutf8').decompress
            if (!base64Data) rej(Error('No base64 data given'))

            const decompressedData = base64Data
                                  && base64Data.length % 4 === 0
                                  && decompress(base64Data, { inputEncoding: 'Base64' })

            const preset = /[A-Za-z0-9+/=]/.test(decompressedData) ? JSON.parse(decompressedData) : undefined
            res(preset)
        }, 'lzutf8')
    })

getShareableURL = (preset) => {
        const compressedPreset = compress(JSON.stringify(preset), { outputEncoding: 'Base64' })
        const shareableURL = `djen.co/#share=${compressedPreset}`
        if (shareableURL.length > 2048) logError('URL exceeds 2048 chars. May not succeed')
        return shareableURL
    }

serialize (value) {
    return LZUTF8.compress(JSON.stringify(value), {
      outputEncoding: 'BinaryString'
    })
  }

private async encrypt(): Promise {
    const compressed = LZUTF8.compress(JSON.stringify([...this.passwords]));

    const initializationVector = new Uint8Array(this.ivLen);
    crypto.getRandomValues(initializationVector);

    const encrypted = await crypto.subtle.encrypt({
        name: 'AES-GCM',
        iv: initializationVector
      },
      this.masterKey,
      compressed
    );

    return this.concatUint8Array(initializationVector, new Uint8Array(encrypted));
  }

private updatePattern(pattern : Pattern, patternSettings: PatternSettings) {
		
		var patternSettingsQueryString = encodeURIComponent(lzutf8.compress(JSON.stringify(patternSettings),{outputEncoding: "Base64"}));
		window.history.pushState('pattern', 'pattern', window.location.origin + window.location.pathname + '?patternSettings=' + patternSettingsQueryString);
		this.setState({pattern: pattern, patternSettings: patternSettings});		
	}

require.ensure(['lzutf8'], (require) => {
            const compress = require('lzutf8').compress
            const compressedPreset = compress(JSON.stringify(preset), { outputEncoding: 'Base64' })
            const shareableURL = `djen.co/#share=${compressedPreset}`
            if (shareableURL.length > 2048) logError('URL exceeds 2048 chars. May not succeed')
            res(shareableURL)
        }, 'lzutf8')
    })

private async decrypt(buffer: ArrayBuffer): Promise {
    const iv = buffer.slice(0, this.ivLen);
    const data = buffer.slice(this.ivLen);

    const decrypted = await window.crypto.subtle.decrypt({
        name: 'AES-GCM',
        iv: iv
      },
      this.masterKey,
      data
    );

    const uncompressed = LZUTF8.decompress(new Uint8Array(decrypted));
    this.passwords = new Map(JSON.parse(uncompressed));
  }

deserialize (value) {
    return JSON.parse(LZUTF8.decompress(value, {
      inputEncoding: 'BinaryString'
    }))
  }