From 8034ba15e4325c326720ff16e7a602e2c995e7a0 Mon Sep 17 00:00:00 2001
From: teramako
Date: Fri, 2 Jul 2010 14:55:17 +0000
Subject: first release

git-svn-id: http://svn.coderepos.org/share/lang/javascript/vimperator-plugins/trunk@37887 d0d07461-0603-4401-acd4-de1884942a52
---
 twittperator.js | 1277 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 1277 insertions(+)
 create mode 100755 twittperator.js

(limited to 'twittperator.js')

diff --git a/twittperator.js b/twittperator.js
new file mode 100755
index 0000000..1ab1d4e
--- /dev/null
+++ b/twittperator.js
@@ -0,0 +1,1277 @@
+var GM_OAuth = <><![CDATA[
+// ==UserScript==
+// @name oauth for Greasemonkey
+// @namespace http://efcl.info/
+// @include http://*
+// ==/UserScript==
+]]></>;
+
+// TwitterOauth for Greasemonkey
+function TwitterOauth(){
+    this.initialize.apply(this, arguments);
+}
+
+TwitterOauth.prototype = (function(){
+
+  // {{{2 oauth.js
+  /*
+    OAuth.js
+    SHA-1.js
+    TwitterOauth for Greasemonkey
+  */
+
+  /*
+   * Copyright 2008 Netflix, Inc.
+   *
+   * Licensed under the Apache License, Version 2.0 (the "License");
+   * you may not use this file except in compliance with the License.
+   * You may obtain a copy of the License at
+   *
+   *     http://www.apache.org/licenses/LICENSE-2.0
+   *
+   * Unless required by applicable law or agreed to in writing, software
+   * distributed under the License is distributed on an "AS IS" BASIS,
+   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   * See the License for the specific language governing permissions and
+   * limitations under the License.
+   */
+
+  /* Here's some JavaScript software for implementing OAuth.
+
+     This isn't as useful as you might hope.  OAuth is based around
+     allowing tools and websites to talk to each other.  However,
+     JavaScript running in web browsers is hampered by security
+     restrictions that prevent code running on one website from
+     accessing data stored or served on another.
+
+     Before you start hacking, make sure you understand the limitations
+     posed by cross-domain XMLHttpRequest.
+
+     On the bright side, some platforms use JavaScript as their
+     language, but enable the programmer to access other web sites.
+     Examples include Google Gadgets, and Microsoft Vista Sidebar.
+     For those platforms, this library should come in handy.
+  */
+
+  // The HMAC-SHA1 signature method calls b64_hmac_sha1, defined by
+  // http://pajhome.org.uk/crypt/md5/sha1.js
+
+  /* An OAuth message is represented as an object like this:
+     {method: "GET", action: "http://server.com/path", parameters: ...}
+
+     The parameters may be either a map {name: value, name2: value2}
+     or an Array of name-value pairs [[name, value], [name2, value2]].
+     The latter representation is more powerful: it supports parameters
+     in a specific sequence, or several parameters with the same name;
+     for example [["a", 1], ["b", 2], ["a", 3]].
+
+     Parameter names and values are NOT percent-encoded in an object.
+     They must be encoded before transmission and decoded after reception.
+     For example, this message object:
+     {method: "GET", action: "http://server/path", parameters: {p: "x y"}}
+     ... can be transmitted as an HTTP request that begins:
+     GET /path?p=x%20y HTTP/1.0
+     (This isn't a valid OAuth request, since it lacks a signature etc.)
+     Note that the object "x y" is transmitted as x%20y.  To encode
+     parameters, you can call OAuth.addToURL, OAuth.formEncode or
+     OAuth.getAuthorization.
+
+     This message object model harmonizes with the browser object model for
+     input elements of an form, whose value property isn't percent encoded.
+     The browser encodes each value before transmitting it. For example,
+     see consumer.setInputs in example/consumer.js.
+   */
+
+  /* This script needs to know what time it is. By default, it uses the local
+     clock (new Date), which is apt to be inaccurate in browsers. To do
+     better, you can load this script from a URL whose query string contains
+     an oauth_timestamp parameter, whose value is a current Unix timestamp.
+     For example, when generating the enclosing document using PHP:
+
+     <script src="oauth.js?oauth_timestamp=<?=time()?>" ...
+
+     Another option is to call OAuth.correctTimestamp with a Unix timestamp.
+   */
+
+
+  var OAuth; if (OAuth == null) OAuth = {};
+  OAuth.setProperties = function setProperties(into, from) {
+      if (into != null && from != null) {
+          for (var key in from) {
+              into[key] = from[key];
+          }
+      }
+      return into;
+  }
+
+  OAuth.setProperties(OAuth, // utility functions
+  {
+      percentEncode: function percentEncode(s) {
+          if (s == null) {
+              return "";
+          }
+          if (s instanceof Array) {
+              var e = "";
+              for (var i = 0; i < s.length; ++s) {
+                  if (e != "") e += '&';
+                  e += OAuth.percentEncode(s[i]);
+              }
+              return e;
+          }
+          s = encodeURIComponent(s);
+          // Now replace the values which encodeURIComponent doesn't do
+          // encodeURIComponent ignores: - _ . ! ~ * ' ( )
+          // OAuth dictates the only ones you can ignore are: - _ . ~
+          // Source: http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Functions:encodeURIComponent
+          s = s.replace(/\!/g, "%21");
+          s = s.replace(/\*/g, "%2A");
+          s = s.replace(/\'/g, "%27");
+          s = s.replace(/\(/g, "%28");
+          s = s.replace(/\)/g, "%29");
+          return s;
+      }
+  ,
+      decodePercent: function decodePercent(s) {
+          if (s != null) {
+              // Handle application/x-www-form-urlencoded, which is defined by
+              // http://www.w3.org/TR/html4/interact/forms.html#h-17.13.4.1
+              s = s.replace(/\+/g, " ");
+          }
+          return decodeURIComponent(s);
+      }
+  ,
+      /** Convert the given parameters to an Array of name-value pairs. */
+      getParameterList: function getParameterList(parameters) {
+          if (parameters == null) {
+              return [];
+          }
+          if (typeof parameters != "object") {
+              return OAuth.decodeForm(parameters + "");
+          }
+          if (parameters instanceof Array) {
+              return parameters;
+          }
+          var list = [];
+          for (var p in parameters) {
+              list.push([p, parameters[p]]);
+          }
+          return list;
+      }
+  ,
+      /** Convert the given parameters to a map from name to value. */
+      getParameterMap: function getParameterMap(parameters) {
+          if (parameters == null) {
+              return {};
+          }
+          if (typeof parameters != "object") {
+              return OAuth.getParameterMap(OAuth.decodeForm(parameters + ""));
+          }
+          if (parameters instanceof Array) {
+              var map = {};
+              for (var p = 0; p < parameters.length; ++p) {
+                  var key = parameters[p][0];
+                  if (map[key] === undefined) { // first value wins
+                      map[key] = parameters[p][1];
+                  }
+              }
+              return map;
+          }
+          return parameters;
+      }
+  ,
+      getParameter: function getParameter(parameters, name) {
+          if (parameters instanceof Array) {
+              for (var p = 0; p < parameters.length; ++p) {
+                  if (parameters[p][0] == name) {
+                      return parameters[p][1]; // first value wins
+                  }
+              }
+          } else {
+              return OAuth.getParameterMap(parameters)[name];
+          }
+          return null;
+      }
+  ,
+      formEncode: function formEncode(parameters) {
+          var form = "";
+          var list = OAuth.getParameterList(parameters);
+          for (var p = 0; p < list.length; ++p) {
+              var value = list[p][1];
+              if (value == null) value = "";
+              if (form != "") form += '&';
+              form += OAuth.percentEncode(list[p][0])
+                +'='+ OAuth.percentEncode(value);
+          }
+          return form;
+      }
+  ,
+      decodeForm: function decodeForm(form) {
+          var list = [];
+          var nvps = form.split('&');
+          for (var n = 0; n < nvps.length; ++n) {
+              var nvp = nvps[n];
+              if (nvp == "") {
+                  continue;
+              }
+              var equals = nvp.indexOf('=');
+              var name;
+              var value;
+              if (equals < 0) {
+                  name = OAuth.decodePercent(nvp);
+                  value = null;
+              } else {
+                  name = OAuth.decodePercent(nvp.substring(0, equals));
+                  value = OAuth.decodePercent(nvp.substring(equals + 1));
+              }
+              list.push([name, value]);
+          }
+          return list;
+      }
+  ,
+      setParameter: function setParameter(message, name, value) {
+          var parameters = message.parameters;
+          if (parameters instanceof Array) {
+              for (var p = 0; p < parameters.length; ++p) {
+                  if (parameters[p][0] == name) {
+                      if (value === undefined) {
+                          parameters.splice(p, 1);
+                      } else {
+                          parameters[p][1] = value;
+                          value = undefined;
+                      }
+                  }
+              }
+              if (value !== undefined) {
+                  parameters.push([name, value]);
+              }
+          } else {
+              parameters = OAuth.getParameterMap(parameters);
+              parameters[name] = value;
+              message.parameters = parameters;
+          }
+      }
+  ,
+      setParameters: function setParameters(message, parameters) {
+          var list = OAuth.getParameterList(parameters);
+          for (var i = 0; i < list.length; ++i) {
+              OAuth.setParameter(message, list[i][0], list[i][1]);
+          }
+      }
+  ,
+      /** Fill in parameters to help construct a request message.
+          This function doesn't fill in every parameter.
+          The accessor object should be like:
+          {consumerKey:'foo', consumerSecret:'bar', accessorSecret:'nurn', token:'krelm', tokenSecret:'blah'}
+          The accessorSecret property is optional.
+       */
+      completeRequest: function completeRequest(message, accessor) {
+          if (message.method == null) {
+              message.method = "GET";
+          }
+          var map = OAuth.getParameterMap(message.parameters);
+          if (map.oauth_consumer_key == null) {
+              OAuth.setParameter(message, "oauth_consumer_key", accessor.consumerKey || "");
+          }
+          if (map.oauth_token == null && accessor.token != null) {
+              OAuth.setParameter(message, "oauth_token", accessor.token);
+          }
+          if (map.oauth_version == null) {
+              OAuth.setParameter(message, "oauth_version", "1.0");
+          }
+          if (map.oauth_timestamp == null) {
+              OAuth.setParameter(message, "oauth_timestamp", OAuth.timestamp());
+          }
+          if (map.oauth_nonce == null) {
+              OAuth.setParameter(message, "oauth_nonce", OAuth.nonce(6));
+          }
+          OAuth.SignatureMethod.sign(message, accessor);
+      }
+  ,
+      setTimestampAndNonce: function setTimestampAndNonce(message) {
+          OAuth.setParameter(message, "oauth_timestamp", OAuth.timestamp());
+          OAuth.setParameter(message, "oauth_nonce", OAuth.nonce(6));
+      }
+  ,
+      addToURL: function addToURL(url, parameters) {
+          newURL = url;
+          if (parameters != null) {
+              var toAdd = OAuth.formEncode(parameters);
+              if (toAdd.length > 0) {
+                  var q = url.indexOf('?');
+                  if (q < 0) newURL += '?';
+                  else       newURL += '&';
+                  newURL += toAdd;
+              }
+          }
+          return newURL;
+      }
+  ,
+      /** Construct the value of the Authorization header for an HTTP request. */
+      getAuthorizationHeader: function getAuthorizationHeader(realm, parameters) {
+          var header = 'OAuth realm="' + OAuth.percentEncode(realm) + '"';
+          var list = OAuth.getParameterList(parameters);
+          for (var p = 0; p < list.length; ++p) {
+              var parameter = list[p];
+              var name = parameter[0];
+              if (name.indexOf("oauth_") == 0) {
+                  header += ',' + OAuth.percentEncode(name) + '="' + OAuth.percentEncode(parameter[1]) + '"';
+              }
+          }
+          return header;
+      }
+  ,
+      /** Correct the time using a parameter from the URL from which the last script was loaded. */
+      correctTimestampFromSrc: function correctTimestampFromSrc(parameterName) {
+          parameterName = parameterName || "oauth_timestamp";
+          var scripts = document.getElementsByTagName('script');
+          if (scripts == null || !scripts.length) return;
+          var src = scripts[scripts.length-1].src;
+          if (!src) return;
+          var q = src.indexOf("?");
+          if (q < 0) return;
+          parameters = OAuth.getParameterMap(OAuth.decodeForm(src.substring(q+1)));
+          var t = parameters[parameterName];
+          if (t == null) return;
+          OAuth.correctTimestamp(t);
+      }
+  ,
+      /** Generate timestamps starting with the given value. */
+      correctTimestamp: function correctTimestamp(timestamp) {
+          OAuth.timeCorrectionMsec = (timestamp * 1000) - (new Date()).getTime();
+      }
+  ,
+      /** The difference between the correct time and my clock. */
+      timeCorrectionMsec: 0
+  ,
+      timestamp: function timestamp() {
+          var t = (new Date()).getTime() + OAuth.timeCorrectionMsec;
+          return Math.floor(t / 1000);
+      }
+  ,
+      nonce: function nonce(length) {
+          var chars = OAuth.nonce.CHARS;
+          var result = "";
+          for (var i = 0; i < length; ++i) {
+              var rnum = Math.floor(Math.random() * chars.length);
+              result += chars.substring(rnum, rnum+1);
+          }
+          return result;
+      }
+  });
+
+  OAuth.nonce.CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXTZabcdefghiklmnopqrstuvwxyz";
+
+  /** Define a constructor function,
+      without causing trouble to anyone who was using it as a namespace.
+      That is, if parent[name] already existed and had properties,
+      copy those properties into the new constructor.
+   */
+  OAuth.declareClass = function declareClass(parent, name, newConstructor) {
+      var previous = parent[name];
+      parent[name] = newConstructor;
+      if (newConstructor != null && previous != null) {
+          for (var key in previous) {
+              if (key != "prototype") {
+                  newConstructor[key] = previous[key];
+              }
+          }
+      }
+      return newConstructor;
+  }
+
+  /** An abstract algorithm for signing messages. */
+  OAuth.declareClass(OAuth, "SignatureMethod", function OAuthSignatureMethod(){});
+
+  OAuth.setProperties(OAuth.SignatureMethod.prototype, // instance members
+  {
+      /** Add a signature to the message. */
+      sign: function sign(message) {
+          var baseString = OAuth.SignatureMethod.getBaseString(message);
+          var signature = this.getSignature(baseString);
+          OAuth.setParameter(message, "oauth_signature", signature);
+          return signature; // just in case someone's interested
+      }
+  ,
+      /** Set the key string for signing. */
+      initialize: function initialize(name, accessor) {
+          var consumerSecret;
+          if (accessor.accessorSecret != null
+              && name.length > 9
+              && name.substring(name.length-9) == "-Accessor")
+          {
+              consumerSecret = accessor.accessorSecret;
+          } else {
+              consumerSecret = accessor.consumerSecret;
+          }
+          this.key = OAuth.percentEncode(consumerSecret)
+               +"&"+ OAuth.percentEncode(accessor.tokenSecret);
+      }
+  });
+
+  /* SignatureMethod expects an accessor object to be like this:
+     {tokenSecret: "lakjsdflkj...", consumerSecret: "QOUEWRI..", accessorSecret: "xcmvzc..."}
+     The accessorSecret property is optional.
+   */
+  // Class members:
+  OAuth.setProperties(OAuth.SignatureMethod, // class members
+  {
+      sign: function sign(message, accessor) {
+          var name = OAuth.getParameterMap(message.parameters).oauth_signature_method;
+          if (name == null || name == "") {
+              name = "HMAC-SHA1";
+              OAuth.setParameter(message, "oauth_signature_method", name);
+          }
+          OAuth.SignatureMethod.newMethod(name, accessor).sign(message);
+      }
+  ,
+      /** Instantiate a SignatureMethod for the given method name. */
+      newMethod: function newMethod(name, accessor) {
+          var impl = OAuth.SignatureMethod.REGISTERED[name];
+          if (impl != null) {
+              var method = new impl();
+              method.initialize(name, accessor);
+              return method;
+          }
+          var err = new Error("signature_method_rejected");
+          var acceptable = "";
+          for (var r in OAuth.SignatureMethod.REGISTERED) {
+              if (acceptable != "") acceptable += '&';
+              acceptable += OAuth.percentEncode(r);
+          }
+          err.oauth_acceptable_signature_methods = acceptable;
+          throw err;
+      }
+  ,
+      /** A map from signature method name to constructor. */
+      REGISTERED : {}
+  ,
+      /** Subsequently, the given constructor will be used for the named methods.
+          The constructor will be called with no parameters.
+          The resulting object should usually implement getSignature(baseString).
+          You can easily define such a constructor by calling makeSubclass, below.
+       */
+      registerMethodClass: function registerMethodClass(names, classConstructor) {
+          for (var n = 0; n < names.length; ++n) {
+              OAuth.SignatureMethod.REGISTERED[names[n]] = classConstructor;
+          }
+      }
+  ,
+      /** Create a subclass of OAuth.SignatureMethod, with the given getSignature function. */
+      makeSubclass: function makeSubclass(getSignatureFunction) {
+          var superClass = OAuth.SignatureMethod;
+          var subClass = function() {
+              superClass.call(this);
+          };
+          subClass.prototype = new superClass();
+          // Delete instance variables from prototype:
+          // delete subclass.prototype... There aren't any.
+          subClass.prototype.getSignature = getSignatureFunction;
+          subClass.prototype.constructor = subClass;
+          return subClass;
+      }
+  ,
+      getBaseString: function getBaseString(message) {
+          var URL = message.action;
+          var q = URL.indexOf('?');
+          var parameters;
+          if (q < 0) {
+              parameters = message.parameters;
+          } else {
+              // Combine the URL query string with the other parameters:
+              parameters = OAuth.decodeForm(URL.substring(q + 1));
+              var toAdd = OAuth.getParameterList(message.parameters);
+              for (var a = 0; a < toAdd.length; ++a) {
+                  parameters.push(toAdd[a]);
+              }
+          }
+          return OAuth.percentEncode(message.method.toUpperCase())
+           +'&'+ OAuth.percentEncode(OAuth.SignatureMethod.normalizeUrl(URL))
+           +'&'+ OAuth.percentEncode(OAuth.SignatureMethod.normalizeParameters(parameters));
+      }
+  ,
+      normalizeUrl: function normalizeUrl(url) {
+          var uri = OAuth.SignatureMethod.parseUri(url);
+          var scheme = uri.protocol.toLowerCase();
+          var authority = uri.authority.toLowerCase();
+          var dropPort = (scheme == "http" && uri.port == 80)
+                      || (scheme == "https" && uri.port == 443);
+          if (dropPort) {
+              // find the last : in the authority
+              var index = authority.lastIndexOf(":");
+              if (index >= 0) {
+                  authority = authority.substring(0, index);
+              }
+          }
+          var path = uri.path;
+          if (!path) {
+              path = "/"; // conforms to RFC 2616 section 3.2.2
+          }
+          // we know that there is no query and no fragment here.
+          return scheme + "://" + authority + path;
+      }
+  ,
+      parseUri: function parseUri (str) {
+          /* This function was adapted from parseUri 1.2.1
+             http://stevenlevithan.com/demo/parseuri/js/assets/parseuri.js
+           */
+          var o = {key: ["source","protocol","authority","userInfo","user","password","host","port","relative","path","directory","file","query","anchor"],
+                   parser: {strict: /^(?:([^:\/?#]+):)?(?:\/\/((?:(([^:@\/]*):?([^:@\/]*))?@)?([^:\/?#]*)(?::(\d*))?))?((((?:[^?#\/]*\/)*)([^?#]*))(?:\?([^#]*))?(?:#(.*))?)/ }};
+          var m = o.parser.strict.exec(str);
+          var uri = {};
+          var i = 14;
+          while (i--) uri[o.key[i]] = m[i] || "";
+          return uri;
+      }
+  ,
+      normalizeParameters: function normalizeParameters(parameters) {
+          if (parameters == null) {
+              return "";
+          }
+          var list = OAuth.getParameterList(parameters);
+          var sortable = [];
+          for (var p = 0; p < list.length; ++p) {
+              var nvp = list[p];
+              if (nvp[0] != "oauth_signature") {
+                  sortable.push([ OAuth.percentEncode(nvp[0])
+                                + " " // because it comes before any character that can appear in a percentEncoded string.
+                                + OAuth.percentEncode(nvp[1])
+                                , nvp]);
+              }
+          }
+          sortable.sort(function(a,b) {
+                            if (a[0] < b[0]) return  -1;
+                            if (a[0] > b[0]) return 1;
+                            return 0;
+                        });
+          var sorted = [];
+          for (var s = 0; s < sortable.length; ++s) {
+              sorted.push(sortable[s][1]);
+          }
+          return OAuth.formEncode(sorted);
+      }
+  });
+
+  OAuth.SignatureMethod.registerMethodClass(["PLAINTEXT", "PLAINTEXT-Accessor"],
+      OAuth.SignatureMethod.makeSubclass(
+          function getSignature(baseString) {
+              return this.key;
+          }
+      ));
+
+  OAuth.SignatureMethod.registerMethodClass(["HMAC-SHA1", "HMAC-SHA1-Accessor"],
+      OAuth.SignatureMethod.makeSubclass(
+          function getSignature(baseString) {
+              b64pad = '=';
+              var signature = b64_hmac_sha1(this.key, baseString);
+              return signature;
+          }
+      ));
+
+  OAuth.correctTimestamp(new Date());
+  // oauth.js 2}}}
+  // {{{2 sha1.js
+  /*
+   * A JavaScript implementation of the Secure Hash Algorithm, SHA-1, as defined
+   * in FIPS PUB 180-1
+   * Version 2.1a Copyright Paul Johnston 2000 - 2002.
+   * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
+   * Distributed under the BSD License
+   * See http://pajhome.org.uk/crypt/md5 for details.
+   */
+
+  /*
+   * Configurable variables. You may need to tweak these to be compatible with
+   * the server-side, but the defaults work in most cases.
+   */
+  var hexcase = 0;  /* hex output format. 0 - lowercase; 1 - uppercase        */
+  var b64pad  = ""; /* base-64 pad character. "=" for strict RFC compliance   */
+  var chrsz   = 8;  /* bits per input character. 8 - ASCII; 16 - Unicode      */
+
+  /*
+   * These are the functions you'll usually want to call
+   * They take string arguments and return either hex or base-64 encoded strings
+   */
+  function hex_sha1(s){return binb2hex(core_sha1(str2binb(s),s.length * chrsz));}
+  function b64_sha1(s){return binb2b64(core_sha1(str2binb(s),s.length * chrsz));}
+  function str_sha1(s){return binb2str(core_sha1(str2binb(s),s.length * chrsz));}
+  function hex_hmac_sha1(key, data){ return binb2hex(core_hmac_sha1(key, data));}
+  function b64_hmac_sha1(key, data){ return binb2b64(core_hmac_sha1(key, data));}
+  function str_hmac_sha1(key, data){ return binb2str(core_hmac_sha1(key, data));}
+
+  /*
+   * Perform a simple self-test to see if the VM is working
+   */
+  function sha1_vm_test()
+  {
+    return hex_sha1("abc") == "a9993e364706816aba3e25717850c26c9cd0d89d";
+  }
+
+  /*
+   * Calculate the SHA-1 of an array of big-endian words, and a bit length
+   */
+  function core_sha1(x, len)
+  {
+    /* append padding */
+    x[len >> 5] |= 0x80 << (24 - len % 32);
+    x[((len + 64 >> 9) << 4) + 15] = len;
+
+    var w = Array(80);
+    var a =  1732584193;
+    var b = -271733879;
+    var c = -1732584194;
+    var d =  271733878;
+    var e = -1009589776;
+
+    for(var i = 0; i < x.length; i += 16)
+    {
+      var olda = a;
+      var oldb = b;
+      var oldc = c;
+      var oldd = d;
+      var olde = e;
+
+      for(var j = 0; j < 80; j++)
+      {
+        if(j < 16) w[j] = x[i + j];
+        else w[j] = rol(w[j-3] ^ w[j-8] ^ w[j-14] ^ w[j-16], 1);
+        var t = safe_add(safe_add(rol(a, 5), sha1_ft(j, b, c, d)),
+                         safe_add(safe_add(e, w[j]), sha1_kt(j)));
+        e = d;
+        d = c;
+        c = rol(b, 30);
+        b = a;
+        a = t;
+      }
+
+      a = safe_add(a, olda);
+      b = safe_add(b, oldb);
+      c = safe_add(c, oldc);
+      d = safe_add(d, oldd);
+      e = safe_add(e, olde);
+    }
+    return Array(a, b, c, d, e);
+
+  }
+
+  /*
+   * Perform the appropriate triplet combination function for the current
+   * iteration
+   */
+  function sha1_ft(t, b, c, d)
+  {
+    if(t < 20) return (b & c) | ((~b) & d);
+    if(t < 40) return b ^ c ^ d;
+    if(t < 60) return (b & c) | (b & d) | (c & d);
+    return b ^ c ^ d;
+  }
+
+  /*
+   * Determine the appropriate additive constant for the current iteration
+   */
+  function sha1_kt(t)
+  {
+    return (t < 20) ?  1518500249 : (t < 40) ?  1859775393 :
+           (t < 60) ? -1894007588 : -899497514;
+  }
+
+  /*
+   * Calculate the HMAC-SHA1 of a key and some data
+   */
+  function core_hmac_sha1(key, data)
+  {
+    var bkey = str2binb(key);
+    if(bkey.length > 16) bkey = core_sha1(bkey, key.length * chrsz);
+
+    var ipad = Array(16), opad = Array(16);
+    for(var i = 0; i < 16; i++)
+    {
+      ipad[i] = bkey[i] ^ 0x36363636;
+      opad[i] = bkey[i] ^ 0x5C5C5C5C;
+    }
+
+    var hash = core_sha1(ipad.concat(str2binb(data)), 512 + data.length * chrsz);
+    return core_sha1(opad.concat(hash), 512 + 160);
+  }
+
+  /*
+   * Add integers, wrapping at 2^32. This uses 16-bit operations internally
+   * to work around bugs in some JS interpreters.
+   */
+  function safe_add(x, y)
+  {
+    var lsw = (x & 0xFFFF) + (y & 0xFFFF);
+    var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
+    return (msw << 16) | (lsw & 0xFFFF);
+  }
+
+  /*
+   * Bitwise rotate a 32-bit number to the left.
+   */
+  function rol(num, cnt)
+  {
+    return (num << cnt) | (num >>> (32 - cnt));
+  }
+
+  /*
+   * Convert an 8-bit or 16-bit string to an array of big-endian words
+   * In 8-bit function, characters >255 have their hi-byte silently ignored.
+   */
+  function str2binb(str)
+  {
+    var bin = Array();
+    var mask = (1 << chrsz) - 1;
+    for(var i = 0; i < str.length * chrsz; i += chrsz)
+      bin[i>>5] |= (str.charCodeAt(i / chrsz) & mask) << (32 - chrsz - i%32);
+    return bin;
+  }
+
+  /*
+   * Convert an array of big-endian words to a string
+   */
+  function binb2str(bin)
+  {
+    var str = "";
+    var mask = (1 << chrsz) - 1;
+    for(var i = 0; i < bin.length * 32; i += chrsz)
+      str += String.fromCharCode((bin[i>>5] >>> (32 - chrsz - i%32)) & mask);
+    return str;
+  }
+
+  /*
+   * Convert an array of big-endian words to a hex string.
+   */
+  function binb2hex(binarray)
+  {
+    var hex_tab = hexcase ? "0123456789ABCDEF" : "0123456789abcdef";
+    var str = "";
+    for(var i = 0; i < binarray.length * 4; i++)
+    {
+      str += hex_tab.charAt((binarray[i>>2] >> ((3 - i%4)*8+4)) & 0xF) +
+             hex_tab.charAt((binarray[i>>2] >> ((3 - i%4)*8  )) & 0xF);
+    }
+    return str;
+  }
+
+  /*
+   * Convert an array of big-endian words to a base-64 string
+   */
+  function binb2b64(binarray)
+  {
+    var tab = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    var str = "";
+    for(var i = 0; i < binarray.length * 4; i += 3)
+    {
+      var triplet = (((binarray[i   >> 2] >> 8 * (3 -  i   %4)) & 0xFF) << 16)
+                  | (((binarray[i+1 >> 2] >> 8 * (3 - (i+1)%4)) & 0xFF) << 8 )
+                  |  ((binarray[i+2 >> 2] >> 8 * (3 - (i+2)%4)) & 0xFF);
+      for(var j = 0; j < 4; j++)
+      {
+        if(i * 8 + j * 6 > binarray.length * 32) str += b64pad;
+        else str += tab.charAt((triplet >> 6*(3-j)) & 0x3F);
+      }
+    }
+    return str;
+  }
+  // sha1.js 2}}}
+
+  let p = {
+    initialize: function(accessor) {
+      if (accessor)
+        this.accessor = accessor;
+      if (this.isAuthorize()){
+        setup();
+      } else {
+        preSetup();
+      }
+    },
+    // temp for request
+    request : {
+      token :"",// response oauth_token
+      tokenSecret: ""// response oauth_token_secret
+    },
+    // トークンが取得済みかの真偽値を返す
+    isAuthorize : function(){
+      let accessor = this.getAccessor();
+      if (accessor.consumerKey && accessor.consumerSecret &&
+          accessor.token && accessor.tokenSecret) {
+        return true;
+      }else{
+        return false;
+      }
+    },
+    getAccessor: function(){
+      return {
+        consumerKey: this.accessor.get("consumerKey",""),
+        consumerSecret: this.accessor.get("consumerSecret",""),
+        token: this.accessor.get("token",""),
+        tokenSecret: this.accessor.get("tokenSecret","")
+      };
+    },
+    deleteAccessor : function(){
+      var clientInfo = {
+        clientName: this.accessor.get("clientName", ""),
+        consumerKey: this.accessor.get("consumerKey",""),
+        consumerSecret: this.accessor.get("consumerSecret",""),
+      };
+      this.accessor.clear();
+      this.accessor.set("clientName", clientInfo.clientName);
+      this.accessor.set("consumerKey", clientInfo.consumerKey);
+      this.accessor.set("consumerSecret", clientInfo.consumerSecret);
+    },
+    // 認証ページのURLを取得
+    getRequestToken : function(callback){
+      let message = {
+        method: "GET",
+        action: "https://twitter.com/oauth/request_token",
+        parameters: {
+          oauth_signature_method: "HMAC-SHA1",
+          oauth_consumer_key: this.accessor.get("consumerKey","")
+        }
+      };
+      OAuth.setTimestampAndNonce(message);
+      OAuth.SignatureMethod.sign(message, this.getAccessor());
+      var target = OAuth.addToURL(message.action, message.parameters);
+      var self = this;
+      var options = {
+        method: message.method,
+        url: target,
+        onload: function(d) {
+          if(d.status == 200){
+            var res = d.responseText;
+            var parameter = self.getParameter(res);
+            self.request.token = parameter["oauth_token"];
+            self.request.tokenSecret = parameter["oauth_token_secret"];
+            // requestURLを引数にcallback
+            if(callback){
+              callback("https://twitter.com/oauth/authorize?oauth_token="+self.request.token);
+            }
+          }else{
+            alert(d.statusText);
+          }
+        },
+      };
+      xmlhttpRequest(options);
+
+    },
+    setPin: function (pin) {
+      let self = this;
+      this.getAccessToken(pin, function(){
+        liberator.echo("Twittperator: getting access token is success.", true);
+        self.initialize();
+      });
+    },
+    // pinを元にAccess Tokenを取得して保存、callbackにはaccessorオブジェクトを渡す
+    getAccessToken: function(pin ,callback) {
+      var message = {
+        method: "GET",
+        action: "https://twitter.com/oauth/access_token",
+        parameters: {
+          oauth_signature_method: "HMAC-SHA1",
+          oauth_consumer_key: this.accessor.get("consumerKey",""),
+          oauth_token: this.request.token, // Request Token
+          oauth_verifier: pin
+        }
+      };
+      OAuth.setTimestampAndNonce(message);
+      OAuth.SignatureMethod.sign(message, this.request);
+      var target = OAuth.addToURL(message.action, message.parameters);
+      var self = this;
+      var options = {
+        method: message.method,
+        url: target,
+        onload: function(d) {
+          if(d.status == 200){
+            /* 返り値からAccess Token/Access Token Secretを取り出す */
+            var res = d.responseText;
+            var parameter = self.getParameter(res);
+            self.accessor.set("token", parameter["oauth_token"]);
+            self.accessor.set("tokenSecret", parameter["oauth_token_secret"]);
+            // Accessorの保存
+            //self.saveAccessor();
+            if(callback){
+              callback(self.accessor);
+            }
+          }else{
+            alert(d.statusText);
+          }
+        },
+      };
+
+      xmlhttpRequest(options); // 送信
+    },
+    // api+?+query にアクセスした結果をcallbackに渡す
+    get: function(api, query, callback) {
+      var btquery = (query)? "?"+this.buildQuery(query) : "";
+      var message = {
+        method: "GET",
+        action: api + btquery,
+        parameters: {
+          oauth_signature_method: "HMAC-SHA1",
+          oauth_consumer_key: this.accessor.get("consumerKey",""),// queryの構築
+          oauth_token: this.accessor.get("token","") // Access Token
+        }
+      };
+      OAuth.setTimestampAndNonce(message);
+      OAuth.SignatureMethod.sign(message, this.getAccessor());
+      var target = OAuth.addToURL(message.action, message.parameters);
+      var options = {
+        method: message.method,
+        url: target,
+        onload: function(d) {
+          if(d.status == 200){
+            if(callback){
+                callback(d.responseText);
+            }
+          }else{
+            callback(d.statusText);
+          }
+        },
+      };
+      xmlhttpRequest(options); // 送信
+    },
+    post: function(api, content, callback) {
+      var message = {
+        method: "POST",
+        action: api,
+        parameters: {
+          oauth_signature_method: "HMAC-SHA1",
+          oauth_consumer_key: this.accessor.get("consumerKey",""),
+          oauth_token: this.accessor.get("token","") // Access Token
+        }
+      };
+      // 送信するデータをパラメータに追加する
+      for ( var key in content ) {
+        message.parameters[key] = content[key];
+      }
+      OAuth.setTimestampAndNonce(message);
+      OAuth.SignatureMethod.sign(message, this.getAccessor());
+      var target = OAuth.addToURL(message.action, message.parameters);
+      var options = {
+        method: message.method,
+        url: target,
+        onload: function(d) {
+          if (d.status == 200) {
+            if (callback) {
+                callback(d.responseText);
+            }
+          } else {
+            // typeof d == object
+            callback(d);
+          }
+        }
+      };
+      xmlhttpRequest(options); // 送信
+    },
+    // utility関数
+    // http://kevin.vanzonneveld.net
+    urlencode : function (str) {
+      str = (str+'').toString();
+      return encodeURIComponent(str).replace(/!/g, '%21').replace(/'/g, '%27').replace(/\(/g, '%28')
+                                    .replace(/\)/g, '%29').replace(/\*/g, '%2A').replace(/%20/g, '+');
+    },
+    // オブジェクトからクエリを生成
+    buildQuery : function(formdata, numeric_prefix, arg_separator) {
+      // * example 1: http_build_query({foo: 'bar', php: 'hypertext processor', baz: 'boom', cow: 'milk'}, '', '&amp;');
+      // * returns 1: 'foo=bar&amp;php=hypertext+processor&amp;baz=boom&amp;cow=milk'
+      // * example 2: http_build_query({'php': 'hypertext processor', 0: 'foo', 1: 'bar', 2: 'baz', 3: 'boom', 'cow': 'milk'}, 'myvar_');
+      // * returns 2: 'php=hypertext+processor&myvar_0=foo&myvar_1=bar&myvar_2=baz&myvar_3=boom&cow=milk'
+      var value, key, tmp = [];
+      var self = this;
+      var _http_build_query_helper = function (key, val, arg_separator) {
+        var k, tmp = [];
+        if (val === true) {
+          val = "1";
+        } else if (val === false) {
+          val = "0";
+        }
+        if (val !== null && typeof(val) === "object") {
+          for (k in val) {
+            if (val[k] !== null) {
+              tmp.push(_http_build_query_helper(key + "[" + k + "]", val[k], arg_separator));
+            }
+          }
+          return tmp.join(arg_separator);
+        } else if (typeof(val) !== "function") {
+          return self.urlencode(key) + "=" + self.urlencode(val);
+        } else {
+          throw new Error('There was an error processing for http_build_query().');
+        }
+      };
+
+      if (!arg_separator) {
+        arg_separator = "&";
+      }
+      for (key in formdata) {
+        value = formdata[key];
+        if (numeric_prefix && !isNaN(key)) {
+          key = String(numeric_prefix) + key;
+        }
+        tmp.push(_http_build_query_helper(key, value, arg_separator));
+      }
+
+      return tmp.join(arg_separator);
+    },
+    // Query String から 連想配列を返す
+    getParameter: function(str){
+      var dec = decodeURIComponent;
+      var par = {}, itm;
+      if(typeof(str) == 'undefined') return par;
+      if(str.indexOf('?', 0) > -1) str = str.split('?')[1];
+      str = str.split('&');
+      for(var i = 0; str.length > i; i++){
+        itm = str[i].split("=");
+        if(itm[0] != ''){
+          par[itm[0]] = typeof(itm[1]) == 'undefined' ? true : dec(itm[1]);
+        }
+      }
+      return par;
+   }
+ };
+ return p;
+})();
+
+
+// Twittperator
+function xmlhttpRequest(options){
+  let xhr = new XMLHttpRequest();
+  xhr.open(options.method, options.url, true);
+  if (typeof options.onload == "function"){
+	  xhr.onload = function(){
+		  options.onload(xhr);
+	  }
+  }
+  xhr.send(null);
+}
+
+let accessor = storage.newMap("twittperator", { store: true });
+accessor.set("clientName", "Twittperator");
+accessor.set("consumerKey", "GQWob4E5tCHVQnEVPvmorQ");
+accessor.set("consumerSecret","gVwj45GaW6Sp7gdua6UFyiF910ffIety0sD1dv36Cz8");
+let tw = new TwitterOauth(accessor);
+plugins.twittperator = tw;
+
+let statuses = [];
+let expiredStatus = false;
+let autoStatusUpdate = !!parseInt(liberator.globalVariables.twittperator_auto_status_update || 0);
+let statusValidDuration = parseInt(liberator.globalVariables.twitperator_status_valid_duration || 90);
+let statusRefreshTimer;
+
+function showTL (s) {
+  let html = <style type="text/css"><![CDATA[
+      span.twitter.entry-content a { text-decoration: none; }
+      span.twitter.entry-content.rt:before { content: "RT "; color: silver; }
+      img.twitter.photo { border; 0px; width: 16px; height: 16px; vertical-align: baseline; margin: 1px; }
+  ]]></style>.toSource()
+             .replace(/(?:\r\n|[\r\n])[ \t]*/g, " ") +
+      s.map(function(status){
+        let xml;
+        if ("retweeted_status" in status) {
+          let rt = status.retweeted_status;
+          xml = <>
+            <img src={rt.user.profile_image_url} alt={rt.user.screen_name} class="twitter photo"/>
+            <strong>{rt.user.screen_name}&#x202C;</strong>
+            <img src={status.user.profile_image_url} alt={status.user.screen_name} class="twitter photo"/>
+            : <span class="twitter entry-content rt">{detectLink(rt.text)}</span>
+          </>
+        } else {
+         xml = <>
+            <img src={status.user.profile_image_url} alt={status.user.screen_name} class="twitter photo"/>
+            <strong title={status.user.name}>{status.user.screen_name}&#x202C;</strong>
+            : <span class="twitter entry-content">{detectLink(status.text)}</span>
+          </>;
+        }
+        return xml.toSource().replace(/(?:\r\n|[\r\n])[ \t]*/g, " ");
+      }).join("<br/>");
+
+  //liberator.log(html);
+  liberator.echo(html, true);
+}
+function detectLink (str) {
+  let m = str.match(/https?:\/\/\S+/);
+  if (m) {
+    let left = str.substr(0, m.index);
+    let url = m[0];
+    let right = str.substring(m.index + m[0].length);
+    return <>{detectLink(left)}<a highlight="URL" href={url}> {url} </a>{detectLink(right)}</>;
+  }
+  return str;
+}
+function showTwitterSearchResult(word){ // {{{
+  tw.get("http://search.twitter.com/search.json", { q: word }, function(text){
+    let results = JSON.parse(text);
+    showTL(results);
+  });
+} // }}}
+function getFollowersStatus(target, force, onload){
+  function setRefresher(){
+    expiredStatus = false;
+    if (statusRefreshTimer)
+      clearTimeout(statusRefreshTimer);
+    statusRefreshTimer = setTimeout(function () expiredStatus = true, statusValidDuration * 1000);
+  }
+  if (!force && !expiredStatus && statuses.length > 0){
+    onload();
+  } else {
+    let api = "http://api.twitter.com/1/statuses/home_timeline.json",
+        query = {};
+    if (target) {
+      api = "http://api.twitter.com/1/statuses/user_timeline.json";
+      query.screen_name = target;
+    } else {
+      query = null;
+    }
+    tw.get(api, query, function(text){
+      setRefresher();
+      statuses = JSON.parse(text);
+      onload();
+    });
+  }
+}
+function showFollowersStatus(arg, force){ // {{{
+  getFollowersStatus(arg, force, function(text){
+    showTL(statuses);
+  });
+} // }}}
+
+function showTwitterMentions(arg){ // {{{
+  if (/^@/.test(arg))
+    arg = arg.substr(1);
+  tw.get("http://api.twitter.com/1/statuses/mentions.json", null, function(text) {
+    statuses = JSON.parse(text);
+    showTL(statuses);
+  });
+} // }}}
+function favTwitter(id){ // {{{
+  tw.post("http://api.twitter.com/1/favorites/create/" + id + ".json", null, function(text){
+    let res = JSON.parse(text);
+    liberator.echo("[Twittperator] fav: " + res.user.name + " " + res.text, true);
+  });
+} // }}}
+function unfavTwitter(id){ // {{{
+  tw.post("http://api.twitter.com/1/favorites/destroy/" + id + ".json", null, function(text){
+    let res = JSON.parse(text);
+    liberator.echo("[Twittperator] unfav: " + res.user.name + " " + res.text, true);
+  });
+} // }}}
+function sayTwitter(stat){ // {{{
+  let sendData = {};
+  if (stat.match(/^(.*)@([^\s#]+)(?:#(\d+))(.*)$/)){
+    let [prefix, replyUser, replyID, postfix] = [RegExp.$1, RegExp.$2, RegExp.$3, RegExp.$4];
+    if (stat.indexOf("RT @" + replyUser + "#" + replyID) == 0){
+      ReTweet(replyID);
+      return;
+    }
+    stat = prefix + "@" + replyUser + postfix;
+    if (replyID && !prefix)
+      sendData.in_reply_to_status_id = replyID;
+  }
+  sendData.status = stat;
+  sendData.source = "Twittperator";
+  tw.post("http://api.twitter.com/1/statuses/update.json", sendData, function(text){
+    let result = JSON.parse(text || "{}");
+    let t = result.text;
+    liberator.echo("[Twittperator] Your post " + '"' + t + '" (' + t.length + " characters) was sent.", true);
+  });
+} // }}}
+function ReTweet(id){ // {{{
+  let url = "http://api.twitter.com/1/statuses/retweet/" + id + ".json";
+  tw.post(url, null, function(text) {
+    let res = JSON.parse(text);
+    liberator.log(res.toSource(), 0);
+    liberator.echo("[Twittperator] ReTweet: " + res.retweeted_status.text, true);
+  });
+} // }}}
+function setup() {
+  commands.addUserCommand(["tw[ittperator]"], "Twittperator command",
+    function (arg) {
+      var special = arg.bang;
+      arg = arg.string.replace(/%URL%/g, liberator.modules.buffer.URL)
+          .replace(/%TITLE%/g, liberator.modules.buffer.title);
+
+      if (special && arg.match(/^\?\s*(.*)/))
+          showTwitterSearchResult(RegExp.$1);
+      else
+      if (special && arg.match(/^\+\s*.*#(\d+)/))
+          favTwitter(RegExp.$1);
+      else
+      if (special && arg.match(/^-\s*.*#(\d+)/))
+          unfavTwitter(RegExp.$1);
+      else
+      if (special && arg.match(/^@/))
+          showTwitterMentions();
+      else
+      if (special || arg.length == 0)
+          showFollowersStatus(arg, special);
+      else
+          sayTwitter(arg);
+    }, {
+      bang: true,
+      literal: 0,
+      completer: let (getting, targetContext) function(context, args){
+        function compl(){
+          if (args.bang && !/^[-+]/.test(args[0])){
+            targetContext.title = ["Name","Entry"];
+            list = statuses.map(function(s) ("retweeted_status" in s) ?
+              ["@" + s.retweeted_status.user.screen_name, s.retweeted_status.text ] :
+              ["@" + s.user.screen_name, s.text]);
+          } else if (/RT\s+@\w*$/.test(args[0])){
+            targetContext.title = ["Name + Text"];
+            list = statuses.map(function(s) ("retweeted_status" in s) ?
+              ["@"+s.retweeted_status.user.screen_name+"#"+s.retweeted_status.id+": "+s.retweeted_status.text, "-" ] :
+              ["@"+s.user.screen_name+"#"+s.id+": "+s.text, "-"]);
+          } else {
+            targetContext.title = ["Name#ID","Entry"];
+            list = statuses.map(function(s) ("retweeted_status" in s) ?
+              ["@"+s.retweeted_status.user.screen_name+"#"+s.retweeted_status.id+" ", s.retweeted_status.text] :
+              ["@"+s.user.screen_name+"#"+s.id+" ", s.text]);
+          }
+
+          if (target){
+            list = list.filter(function($_) $_[0].indexOf(target) >= 0);
+          }
+          targetContext.completions = list;
+          targetContext.incomplete = false;
+          targetContext = getting = null;
+        }
+
+        var matches= context.filter.match(/@(\w*)$/);
+        if (!matches) return;
+        var list = [];
+        var target = matches[1];
+        var doGet = (expiredStatus || !(statuses && statuses.length)) && autoStatusUpdate;
+        context.offset += matches.index;
+        context.incomplete = doGet;
+        context.hasitems = !doGet;
+        targetContext = context;
+        if (doGet) {
+          if (!getting) {
+            getting = true;
+            getFollowersStatus(null, compl);
+          }
+        } else {
+          compl();
+        }
+      }
+    }, true);
+}
+// PIN code を取得して AccessToken を得る前
+function preSetup() {
+  commands.addUserCommand(["tw[ittperator]"], "Twittperator setup command",
+    function (args) {
+      if (args["-getPIN"]){
+        tw.getRequestToken(function(url){
+          liberator.open(url, { where: liberator.NEW_TAB });
+        });
+        liberator.echo("Twittperator","Please get PIN code and execute\n :tw -setPIN {PINcode}");
+      } else if (args["-setPIN"]) {
+        tw.setPin(args["-setPIN"]);
+      }
+    }, {
+      options: [
+        [["-getPIN"], commands.OPTION_NOARG],
+        [["-setPIN"], commands.OPTION_STRING, null, null]
+      ],
+    }, true);
+}
+
+// vim: sw=2 ts=2 et fdm=marker:
-- 
cgit v1.2.3