text: cordova.define("cordova-sqlite-storage.SQLitePlugin", function(require, exports, module) { (function() {
    var DB_STATE_INIT, DB_STATE_OPEN, READ_ONLY_REGEX, SQLiteFactory, SQLitePlugin, SQLitePluginTransaction, argsArray, dblocations, newSQLError, nextTick, root, txLocks;
  
    root = this;
  
    READ_ONLY_REGEX = /^\s*(?:drop|delete|insert|update|create)\s/i;
  
    DB_STATE_INIT = "INIT";
  
    DB_STATE_OPEN = "OPEN";
  
    txLocks = {};
  
    newSQLError = function(error, code) {
      var sqlError;
      sqlError = error;
      if (!code) {
        code = 0;
      }
      if (!sqlError) {
        sqlError = new Error("a plugin had an error but provided no response");
        sqlError.code = code;
      }
      if (typeof sqlError === "string") {
        sqlError = new Error(error);
        sqlError.code = code;
      }
      if (!sqlError.code && sqlError.message) {
        sqlError.code = code;
      }
      if (!sqlError.code && !sqlError.message) {
        sqlError = new Error("an unknown error was returned: " + JSON.stringify(sqlError));
        sqlError.code = code;
      }
      return sqlError;
    };
  
    nextTick = window.setImmediate || function(fun) {
      window.setTimeout(fun, 0);
    };
  
  
    /*
      Utility that avoids leaking the arguments object. See
      https://www.npmjs.org/package/argsarray
     */
  
    argsArray = function(fun) {
      return function() {
        var args, i, len;
        len = arguments.length;
        if (len) {
          args = [];
          i = -1;
          while (++i < len) {
            args[i] = arguments[i];
          }
          return fun.call(this, args);
        } else {
          return fun.call(this, []);
        }
      };
    };
  
    SQLitePlugin = function(openargs, openSuccess, openError) {
      var dbname;
      if (!(openargs && openargs['name'])) {
        throw newSQLError("Cannot create a SQLitePlugin db instance without a db name");
      }
      dbname = openargs.name;
      if (typeof dbname !== 'string') {
        throw newSQLError('sqlite plugin database name must be a string');
      }
      this.openargs = openargs;
      this.dbname = dbname;
      this.openSuccess = openSuccess;
      this.openError = openError;
      this.openSuccess || (this.openSuccess = function() {
        console.log("DB opened: " + dbname);
      });
      this.openError || (this.openError = function(e) {
        console.log(e.message);
      });
      this.open(this.openSuccess, this.openError);
    };
  
    SQLitePlugin.prototype.databaseFeatures = {
      isSQLitePluginDatabase: true
    };
  
    SQLitePlugin.prototype.openDBs = {};
  
    SQLitePlugin.prototype.addTransaction = function(t) {
      if (!txLocks[this.dbname]) {
        txLocks[this.dbname] = {
          queue: [],
          inProgress: false
        };
      }
      txLocks[this.dbname].queue.push(t);
      if (this.dbname in this.openDBs && this.openDBs[this.dbname] !== DB_STATE_INIT) {
        this.startNextTransaction();
      } else {
        if (this.dbname in this.openDBs) {
          console.log('new transaction is waiting for open operation');
        } else {
          console.log('database is closed, new transaction is [stuck] waiting until db is opened again!');
        }
      }
    };
  
    SQLitePlugin.prototype.transaction = function(fn, error, success) {
      if (!this.openDBs[this.dbname]) {
        error(newSQLError('database not open'));
        return;
      }
      this.addTransaction(new SQLitePluginTransaction(this, fn, error, success, true, false));
    };
  
    SQLitePlugin.prototype.readTransaction = function(fn, error, success) {
      if (!this.openDBs[this.dbname]) {
        error(newSQLError('database not open'));
        return;
      }
      this.addTransaction(new SQLitePluginTransaction(this, fn, error, success, true, true));
    };
  
    SQLitePlugin.prototype.startNextTransaction = function() {
      var self;
      self = this;
      nextTick((function(_this) {
        return function() {
          var txLock;
          if (!(_this.dbname in _this.openDBs) || _this.openDBs[_this.dbname] !== DB_STATE_OPEN) {
            console.log('cannot start next transaction: database not open');
            return;
          }
          txLock = txLocks[self.dbname];
          if (!txLock) {
            console.log('cannot start next transaction: database connection is lost');
            return;
          } else if (txLock.queue.length > 0 && !txLock.inProgress) {
            txLock.inProgress = true;
            txLock.queue.shift().start();
          }
        };
      })(this));
    };
  
    SQLitePlugin.prototype.abortAllPendingTransactions = function() {
      var tx, txLock, _i, _len, _ref;
      txLock = txLocks[this.dbname];
      if (!!txLock && txLock.queue.length > 0) {
        _ref = txLock.queue;
        for (_i = 0, _len = _ref.length; _i < _len; _i++) {
          tx = _ref[_i];
          tx.abortFromQ(newSQLError('Invalid database handle'));
        }
        txLock.queue = [];
        txLock.inProgress = false;
      }
    };
  
    SQLitePlugin.prototype.open = function(success, error) {
      var openerrorcb, opensuccesscb;
      if (this.dbname in this.openDBs) {
        console.log('database already open: ' + this.dbname);
        nextTick((function(_this) {
          return function() {
            success(_this);
          };
        })(this));
      } else {
        console.log('OPEN database: ' + this.dbname);
        opensuccesscb = (function(_this) {
          return function() {
            var txLock;
            if (!_this.openDBs[_this.dbname]) {
              console.log('database was closed during open operation');
            }
            if (_this.dbname in _this.openDBs) {
              _this.openDBs[_this.dbname] = DB_STATE_OPEN;
            }
            if (!!success) {
              success(_this);
            }
            txLock = txLocks[_this.dbname];
            if (!!txLock && txLock.queue.length > 0 && !txLock.inProgress) {
              _this.startNextTransaction();
            }
          };
        })(this);
        openerrorcb = (function(_this) {
          return function() {
            console.log('OPEN database: ' + _this.dbname + ' failed, aborting any pending transactions');
            if (!!error) {
              error(newSQLError('Could not open database'));
            }
            delete _this.openDBs[_this.dbname];
            _this.abortAllPendingTransactions();
          };
        })(this);
        this.openDBs[this.dbname] = DB_STATE_INIT;
        cordova.exec(opensuccesscb, openerrorcb, "SQLitePlugin", "open", [this.openargs]);
      }
    };
  
    SQLitePlugin.prototype.close = function(success, error) {
      if (this.dbname in this.openDBs) {
        if (txLocks[this.dbname] && txLocks[this.dbname].inProgress) {
          console.log('cannot close: transaction is in progress');
          error(newSQLError('database cannot be closed while a transaction is in progress'));
          return;
        }
        console.log('CLOSE database: ' + this.dbname);
        delete this.openDBs[this.dbname];
        if (txLocks[this.dbname]) {
          console.log('closing db with transaction queue length: ' + txLocks[this.dbname].queue.length);
        } else {
          console.log('closing db with no transaction lock state');
        }
        cordova.exec(success, error, "SQLitePlugin", "close", [
          {
            path: this.dbname
          }
        ]);
      } else {
        console.log('cannot close: database is not open');
        if (error) {
          nextTick(function() {
            return error();
          });
        }
      }
    };
  
    SQLitePlugin.prototype.executeSql = function(statement, params, success, error) {
      var myerror, myfn, mysuccess;
      mysuccess = function(t, r) {
        if (!!success) {
          return success(r);
        }
      };
      myerror = function(t, e) {
        if (!!error) {
          return error(e);
        }
      };
      myfn = function(tx) {
        tx.addStatement(statement, params, mysuccess, myerror);
      };
      this.addTransaction(new SQLitePluginTransaction(this, myfn, null, null, false, false));
    };
  
    SQLitePluginTransaction = function(db, fn, error, success, txlock, readOnly) {
      if (typeof fn !== "function") {
  
        /*
        This is consistent with the implementation in Chrome -- it
        throws if you pass anything other than a function. This also
        prevents us from stalling our txQueue if somebody passes a
        false value for fn.
         */
        throw newSQLError("transaction expected a function");
      }
      this.db = db;
      this.fn = fn;
      this.error = error;
      this.success = success;
      this.txlock = txlock;
      this.readOnly = readOnly;
      this.executes = [];
      if (txlock) {
        this.addStatement("BEGIN", [], null, function(tx, err) {
          throw newSQLError("unable to begin transaction: " + err.message, err.code);
        });
      }
    };
  
    SQLitePluginTransaction.prototype.start = function() {
      var err;
      try {
        this.fn(this);
        this.run();
      } catch (_error) {
        err = _error;
        txLocks[this.db.dbname].inProgress = false;
        this.db.startNextTransaction();
        if (this.error) {
          this.error(newSQLError(err));
        }
      }
    };
  
    SQLitePluginTransaction.prototype.executeSql = function(sql, values, success, error) {
      if (this.finalized) {
        throw {
          message: 'InvalidStateError: DOM Exception 11: This transaction is already finalized. Transactions are committed after its success or failure handlers are called. If you are using a Promise to handle callbacks, be aware that implementations following the A+ standard adhere to run-to-completion semantics and so Promise resolution occurs on a subsequent tick and therefore after the transaction commits.',
          code: 11
        };
        return;
      }
      if (this.readOnly && READ_ONLY_REGEX.test(sql)) {
        this.handleStatementFailure(error, {
          message: 'invalid sql for a read-only transaction'
        });
        return;
      }
      this.addStatement(sql, values, success, error);
    };
  
    SQLitePluginTransaction.prototype.addStatement = function(sql, values, success, error) {
      var params, t, v, _i, _len;
      params = [];
      if (!!values && values.constructor === Array) {
        for (_i = 0, _len = values.length; _i < _len; _i++) {
          v = values[_i];
          t = typeof v;
          params.push((v === null || v === void 0 || t === 'number' || t === 'string' ? v : v instanceof Blob ? v.valueOf() : v.toString()));
        }
      }
      this.executes.push({
        success: success,
        error: error,
        sql: sql,
        params: params
      });
    };
  
    SQLitePluginTransaction.prototype.handleStatementSuccess = function(handler, response) {
      var payload, rows;
      if (!handler) {
        return;
      }
      rows = response.rows || [];
      payload = {
        rows: {
          item: function(i) {
            return rows[i];
          },
          length: rows.length
        },
        rowsAffected: response.rowsAffected || 0,
        insertId: response.insertId || void 0
      };
      handler(this, payload);
    };
  
    SQLitePluginTransaction.prototype.handleStatementFailure = function(handler, response) {
      if (!handler) {
        throw newSQLError("a statement with no error handler failed: " + response.message, response.code);
      }
      if (handler(this, response) !== false) {
        throw newSQLError("a statement error callback did not return false: " + response.message, response.code);
      }
    };
  
    SQLitePluginTransaction.prototype.run = function() {
      var batchExecutes, handlerFor, i, mycb, mycbmap, request, tropts, tx, txFailure, waiting;
      txFailure = null;
      tropts = [];
      batchExecutes = this.executes;
      waiting = batchExecutes.length;
      this.executes = [];
      tx = this;
      handlerFor = function(index, didSucceed) {
        return function(response) {
          var err;
          try {
            if (didSucceed) {
              tx.handleStatementSuccess(batchExecutes[index].success, response);
            } else {
              tx.handleStatementFailure(batchExecutes[index].error, newSQLError(response));
            }
          } catch (_error) {
            err = _error;
            if (!txFailure) {
              txFailure = newSQLError(err);
            }
          }
          if (--waiting === 0) {
            if (txFailure) {
              tx.abort(txFailure);
            } else if (tx.executes.length > 0) {
              tx.run();
            } else {
              tx.finish();
            }
          }
        };
      };
      i = 0;
      mycbmap = {};
      while (i < batchExecutes.length) {
        request = batchExecutes[i];
        mycbmap[i] = {
          success: handlerFor(i, true),
          error: handlerFor(i, false)
        };
        tropts.push({
          qid: 1111,
          sql: request.sql,
          params: request.params
        });
        i++;
      }
      mycb = function(result) {
        var last, q, r, res, type, _i;
        last = result.length - 1;
        for (i = _i = 0; 0 <= last ? _i <= last : _i >= last; i = 0 <= last ? ++_i : --_i) {
          r = result[i];
          type = r.type;
          res = r.result;
          q = mycbmap[i];
          if (q) {
            if (q[type]) {
              q[type](res);
            }
          }
        }
      };
      cordova.exec(mycb, null, "SQLitePlugin", "backgroundExecuteSqlBatch", [
        {
          dbargs: {
            dbname: this.db.dbname
          },
          executes: tropts
        }
      ]);
    };
  
    SQLitePluginTransaction.prototype.abort = function(txFailure) {
      var failed, succeeded, tx;
      if (this.finalized) {
        return;
      }
      tx = this;
      succeeded = function(tx) {
        txLocks[tx.db.dbname].inProgress = false;
        tx.db.startNextTransaction();
        if (tx.error) {
          tx.error(txFailure);
        }
      };
      failed = function(tx, err) {
        txLocks[tx.db.dbname].inProgress = false;
        tx.db.startNextTransaction();
        if (tx.error) {
          tx.error(newSQLError("error while trying to roll back: " + err.message, err.code));
        }
      };
      this.finalized = true;
      if (this.txlock) {
        this.addStatement("ROLLBACK", [], succeeded, failed);
        this.run();
      } else {
        succeeded(tx);
      }
    };
  
    SQLitePluginTransaction.prototype.finish = function() {
      var failed, succeeded, tx;
      if (this.finalized) {
        return;
      }
      tx = this;
      succeeded = function(tx) {
        txLocks[tx.db.dbname].inProgress = false;
        tx.db.startNextTransaction();
        if (tx.success) {
          tx.success();
        }
      };
      failed = function(tx, err) {
        txLocks[tx.db.dbname].inProgress = false;
        tx.db.startNextTransaction();
        if (tx.error) {
          tx.error(newSQLError("error while trying to commit: " + err.message, err.code));
        }
      };
      this.finalized = true;
      if (this.txlock) {
        this.addStatement("COMMIT", [], succeeded, failed);
        this.run();
      } else {
        succeeded(tx);
      }
    };
  
    SQLitePluginTransaction.prototype.abortFromQ = function(sqlerror) {
      if (this.error) {
        this.error(sqlerror);
      }
    };
  
    dblocations = ["docs", "libs", "nosync"];
  
    SQLiteFactory = {
  
      /*
      NOTE: this function should NOT be translated from Javascript
      back to CoffeeScript by js2coffee.
      If this function is edited in Javascript then someone will
      have to translate it back to CoffeeScript by hand.
       */
      opendb: argsArray(function(args) {
        var dblocation, errorcb, first, okcb, openargs;
        if (args.length < 1) {
          return null;
        }
        first = args[0];
        openargs = null;
        okcb = null;
        errorcb = null;
        if (first.constructor === String) {
          openargs = {
            name: first
          };
          if (args.length >= 5) {
            okcb = args[4];
            if (args.length > 5) {
              errorcb = args[5];
            }
          }
        } else {
          openargs = first;
          if (args.length >= 2) {
            okcb = args[1];
            if (args.length > 2) {
              errorcb = args[2];
            }
          }
        }
        dblocation = !!openargs.location ? dblocations[openargs.location] : null;
        openargs.dblocation = dblocation || dblocations[0];
        if (!!openargs.createFromLocation && openargs.createFromLocation === 1) {
          openargs.createFromResource = "1";
        }
        if (!!openargs.androidDatabaseImplementation && openargs.androidDatabaseImplementation === 2) {
          openargs.androidOldDatabaseImplementation = 1;
        }
        if (!!openargs.androidLockWorkaround && openargs.androidLockWorkaround === 1) {
          openargs.androidBugWorkaround = 1;
        }
        return new SQLitePlugin(openargs, okcb, errorcb);
      }),
      deleteDb: function(first, success, error) {
        var args, dblocation;
        args = {};
        if (first.constructor === String) {
          args.path = first;
          args.dblocation = dblocations[0];
        } else {
          if (!(first && first['name'])) {
            throw new Error("Please specify db name");
          }
          args.path = first.name;
          dblocation = !!first.location ? dblocations[first.location] : null;
          args.dblocation = dblocation || dblocations[0];
        }
        delete SQLitePlugin.prototype.openDBs[args.path];
        return cordova.exec(success, error, "SQLitePlugin", "delete", [args]);
      }
    };
  
    root.sqlitePlugin = {
      sqliteFeatures: {
        isSQLitePlugin: true
      },
      openDatabase: SQLiteFactory.opendb,
      deleteDatabase: SQLiteFactory.deleteDb
    };
  
  }).call(this);
  
  });
  