var LZStringUnsafe = (
  function () {

    // private property
    var f = String.fromCharCode,
      Base64CharArray = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".split(''),
      UriSafeCharArray = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-$".split(''),
      Base64ReverseDic = {},
      UriSafeReverseDic = {},
      i = 65;
    while (i--) {
      Base64ReverseDic[Base64CharArray[i].charCodeAt(0)] = i;
      UriSafeReverseDic[UriSafeCharArray[i].charCodeAt(0)] = i;
    }
    var getChar16Bits = function (a) { return f(a); },
      getCharFromBase64 = function (a) { return Base64CharArray[a]; },
      getCharFromURISafe = function (a) { return UriSafeCharArray[a]; },
      getCharFromUTF16 = function (a) { return f(a + 32); };

    var LZString = {
      compressToBase64: function (input) {
        if (input == null) return "";
        var res = LZString._compressToArray(input, 6, getCharFromBase64);
        // To produce valid Base64
        var i = res.length % 4;
        while (i--) {
          res.push("=");
        }

        return res.join('');
      },

      decompressFromBase64: function (input) {
        if (input == null) return "";
        if (input == "") return null;
        return LZString._decompress(input.length, 6, function (index) { return Base64ReverseDic[input.charCodeAt(index)]; });
      },

      compressToUTF16: function (input) {
        if (input == null) return "";
        var compressed = LZString._compressToArray(input, 15, getCharFromUTF16);
        compressed.push(" ");
        return compressed.join('');
      },

      decompressFromUTF16: function (compressed) {
        if (compressed == null) return "";
        if (compressed == "") return null;
        return LZString._decompress(compressed.length, 15, function (index) { return compressed.charCodeAt(index) - 32; });
      },

      //compress into uint8array (UCS-2 big endian format)
      compressToUint8Array: function (uncompressed) {
        var compressed = LZString.compressToArray(uncompressed);
        var buf = new Uint8Array(compressed.length * 2); // 2 bytes per character

        for (var i = 0, TotalLen = compressed.length; i < TotalLen; i++) {
          var current_value = compressed[i].charCodeAt(0);
          buf[i * 2] = current_value >>> 8;
          buf[i * 2 + 1] = current_value & 0xFF;
        }
        return buf;
      },

      //decompress from uint8array (UCS-2 big endian format)
      decompressFromUint8Array: function (compressed) {
        if (compressed === null || compressed === undefined) {
          return LZString.decompressFromArray(compressed);
        } else if (compressed.length == 0) {
          return null;
        }
        return LZString._decompress(compressed.length, 8, function (index) { return compressed[index]; });
      },


      //compress into a string that is already URI encoded
      compressToEncodedURIComponent: function (input) {
        if (input == null) return "";
        return LZString._compressToArray(input, 6, getCharFromURISafe).join('');
      },

      //decompress from an output of compressToEncodedURIComponent
      decompressFromEncodedURIComponent: function (input) {
        if (input == null) return "";
        if (input == "") return null;
        input = input.replace(/ /g, "+");
        return LZString._decompress(input.length, 6, function (index) { return UriSafeReverseDic[input.charCodeAt(index)]; });
      },

      compress: function (uncompressed) {
        return LZString.compressToArray(uncompressed).join('');
      },
      compressToArray: function (uncompressed) {
        return LZString._compressToArray(uncompressed, 16, getChar16Bits);
      },
      _compressToArray: function (uncompressed, bitsPerChar, getCharFromInt) {
        if (uncompressed == null) return [];
        var i = 0, j = 0, k = 0, value = 0,
          node = [3], // first node will always be initialised like this.
          // we should never output the root anyway,
          // so we initiate with terminating token
          // Also, dictionary[1] will be overwritten
          // by the firs charCode
          dictionary = [2, 2, node],
          freshNode = true,
          c = 0,
          nextNode,
          enlargeIn = 1,
          dictSize = 4,
          numBits = 2,
          data = [],
          data_val = 0,
          data_position = 0;

        if (uncompressed.length) {
          // If there is a string, the first charCode is guaranteed to
          // be new, so we write it to output stream, and add it to the
          // dictionary. For the same reason we can initialize freshNode
          // as true, and new_node, node and dictSize as if
          // it was already added to the dictionary (see above).

          c = uncompressed.charCodeAt(0);

          // == Write first charCode token to output ==

          // 8 or 16 bit?
          value = c < 256 ? 0 : 1

          // insert "new 8/16 bit charCode" token
          // into bitstream (value 1)
          for (i = 0; i < numBits; i++) {
            // Value is 0 (8 bit) or 1 (16 bit).
            // We shift it into the bitstream in reverse
            // (shifting has precedence over bitmasking)
            data_val = value >> i | data_val << 1;
            if (++data_position == bitsPerChar) {
              data_position = 0;
              data.push(getCharFromInt(data_val));
              data_val = 0;
            }
          }
          // insert charCode bits into bitstream
          // Nasty but effective hack:
          // loop 8 or 16 times based on token value
          value = 8 + 8 * value;
          for (i = 0; i < value; i++) {
            // shifting has precedence over bitmasking
            data_val = c >> i & 1 | data_val << 1;
            if (++data_position == bitsPerChar) {
              data_position = 0;
              data.push(getCharFromInt(data_val));
              data_val = 0;
            }
          }

          // Add charCode to the dictionary.
          dictionary[1] = c;

          nextchar:
          for (j = 1; j < uncompressed.length; j++) {
            c = uncompressed.charCodeAt(j);
            // does the new charCode match an existing prefix?
            for (k = 1; k < node.length; k += 2) {
              if (node[k] == c) {
                node = node[k + 1];
                continue nextchar;
              }
            }
            // we only end up here if there is no matching char

            // Prefix+charCode does not exist in trie yet.
            // We write the prefix to the bitstream, and add
            // the new charCode to the dictionary if it's new
            // Then we set `node` to the root node matching
            // the charCode.

            if (freshNode) {
              // Prefix is a freshly added character token,
              // which was already written to the bitstream
              freshNode = false;
            } else {
              // write out the current prefix token
              value = node[0];
              for (i = 0; i < numBits; i++) {
                // shifting has precedence over bitmasking
                data_val = value >> i & 1 | data_val << 1;
                if (++data_position == bitsPerChar) {
                  data_position = 0;
                  data.push(getCharFromInt(data_val));
                  data_val = 0;
                }
              }
            }

            // Is the new charCode a new character
            // that needs to be stored at the root?
            k = 1;
            while (dictionary[k] != c && k < dictionary.length) {
              k += 2;
            }
            if (k == dictionary.length) {
              // increase token bitlength if necessary
              if (--enlargeIn == 0) {
                enlargeIn = 1 << numBits++;
              }

              // insert "new 8/16 bit charCode" token,
              // see comments above for explanation
              value = c < 256 ? 0 : 1
              for (i = 0; i < numBits; i++) {
                data_val = value >> i | data_val << 1;
                if (++data_position == bitsPerChar) {
                  data_position = 0;
                  data.push(getCharFromInt(data_val));
                  data_val = 0;
                }
              }
              value = 8 + 8 * value;
              for (i = 0; i < value; i++) {
                data_val = c >> i & 1 | data_val << 1;
                if (++data_position == bitsPerChar) {
                  data_position = 0;
                  data.push(getCharFromInt(data_val));
                  data_val = 0;
                }
              }
              dictionary.push(c);
              dictionary.push([dictSize++]);
              // Note of that we already wrote
              // the charCode token to the bitstream
              freshNode = true;
            }
            // add node representing prefix + new charCode to trie
            node.push(c);
            node.push([dictSize++]);
            // increase token bitlength if necessary
            if (--enlargeIn == 0) {
              enlargeIn = 1 << numBits++;
            }
            // set node to first charCode of new prefix
            // k is guaranteed to be at the current charCode,
            // since we either broke out of the while loop
            // when it matched, or just added the new charCode
            node = dictionary[k + 1];

          }

          // === Write last prefix to output ===
          if (freshNode) {
            // character token already written to output
            freshNode = false;
          } else {
            // write out the prefix token
            value = node[0];
            for (i = 0; i < numBits; i++) {
              // shifting has precedence over bitmasking
              data_val = value >> i & 1 | data_val << 1;
              if (++data_position == bitsPerChar) {
                data_position = 0;
                data.push(getCharFromInt(data_val));
                data_val = 0;
              }
            }
          }

          // Is c a new character?
          k = 1;
          while (dictionary[k] != c && k < dictionary.length) {
            k += 2;
          }
          if (k == dictionary.length) {
            // increase token bitlength if necessary
            if (--enlargeIn == 0) {
              enlargeIn = 1 << numBits++;
            }
            // insert "new 8/16 bit charCode" token,
            // see comments above for explanation
            value = c < 256 ? 0 : 1
            for (i = 0; i < numBits; i++) {
              data_val = value >> i | data_val << 1;
              if (++data_position == bitsPerChar) {
                data_position = 0;
                data.push(getCharFromInt(data_val));
                data_val = 0;
              }
            }
            value = 8 + 8 * value;
            for (i = 0; i < value; i++) {
              data_val = c >> i & 1 | data_val << 1;
              if (++data_position == bitsPerChar) {
                data_position = 0;
                data.push(getCharFromInt(data_val));
                data_val = 0;
              }
            }
          }
          // increase token bitlength if necessary
          if (--enlargeIn == 0) {
            enlargeIn = 1 << numBits++;
          }
        }

        // Mark the end of the stream
        for (i = 0; i < numBits; i++) {
          // shifting has precedence over bitmasking
          data_val = 2 >> i & 1 | data_val << 1;
          if (++data_position == bitsPerChar) {
            data_position = 0;
            data.push(getCharFromInt(data_val));
            data_val = 0;
          }
        }

        // Flush the last char
        data_val <<= bitsPerChar - data_position;
        data.push(getCharFromInt(data_val));
        return data;
      },

      decompress: function (compressed) {
        if (compressed == null) return "";
        if (compressed == "") return null;
        return LZString._decompress(compressed.length, 16, function (index) { return compressed.charCodeAt(index); });
      },

      decompressFromArray: function (compressed) {
        if (compressed == null) return "";
        if (compressed.length == 0) return null;
        return LZString._decompress(compressed.length, 16, function (index) { return compressed[index].charCodeAt(0); });
      },

      _decompress: function (length, resetBits, getNextValue) {
        var dictionary = [0, 1, 2],
          enlargeIn = 4,
          dictSize = 4,
          numBits = 3,
          entry = "",
          result = [],
          w = "",
          bits = 0,
          maxpower = 2,
          power = 0,
          c = "",
          data_val = getNextValue(0),
          data_position = resetBits,
          data_index = 1;

        // Get first token, guaranteed to be either
        // a new character token (8 or 16 bits)
        // or end of stream token.
        while (power != maxpower) {
          // shifting has precedence over bitmasking
          bits += (data_val >> --data_position & 1) << power++;
          if (data_position == 0) {
            data_position = resetBits;
            data_val = getNextValue(data_index++);
          }
        }

        // if end of stream token, return empty string
        if (bits == 2) {
          return "";
        }

        // else, get character
        maxpower = bits * 8 + 8;
        bits = power = 0;
        while (power != maxpower) {
          // shifting has precedence over bitmasking
          bits += (data_val >> --data_position & 1) << power++;
          if (data_position == 0) {
            data_position = resetBits;
            data_val = getNextValue(data_index++);
          }
        }
        c = f(bits);
        dictionary[3] = c;
        w = c;
        result.push(c);

        // read rest of string
        while (data_index <= length) {
          // read out next token
          maxpower = numBits;
          bits = power = 0;
          while (power != maxpower) {
            // shifting has precedence over bitmasking
            bits += (data_val >> --data_position & 1) << power++;
            if (data_position == 0) {
              data_position = resetBits;
              data_val = getNextValue(data_index++);
            }
          }

          // 0 or 1 implies new character token
          if (bits < 2) {
            maxpower = (8 + 8 * bits);
            bits = power = 0;
            while (power != maxpower) {
              // shifting has precedence over bitmasking
              bits += (data_val >> --data_position & 1) << power++;
              if (data_position == 0) {
                data_position = resetBits;
                data_val = getNextValue(data_index++);
              }
            }
            dictionary[dictSize] = f(bits);
            bits = dictSize++;
            if (--enlargeIn == 0) {
              enlargeIn = 1 << numBits++;
            }
          } else if (bits == 2) {
            // end of stream token
            return result.join('');
          }

          if (bits > dictionary.length) {
            return null;
          }
          entry = bits < dictionary.length ? dictionary[bits] : w + w.charAt(0);
          result.push(entry);
          // Add w+entry[0] to the dictionary.
          dictionary[dictSize++] = w + entry.charAt(0);

          w = entry;

          if (--enlargeIn == 0) {
            enlargeIn = 1 << numBits++;
          }

        }
        return "";
      }
    };
    return LZString;
  }
)();

if (typeof define === 'function' && define.amd) {
  define(function () { return LZStringUnsafe; });
} else if (typeof module !== 'undefined' && module != null) {
  module.exports = LZStringUnsafe
} else if (typeof angular !== 'undefined' && angular != null) {
  angular.module('LZStringUnsafe', [])
    .factory('LZStringUnsafe', function () {
      return LZStringUnsafe;
    });
}