Limechat Quake Notifier 去年の震災直後に作った 、P2P地震情報をLimechatと連携させるソフト。お蔵入りにしてたけれどもったいないので保存

ini.js

//
// Simple Ini file controller
//
// [ ] で囲まれたものはセクションとして扱われ、それ以降のデータはセクションに所属する
// セクションが登場するまでのデータは global というセクションに割り当てられる
//
// var ini = new Ini("setting.ini");
// value1 = ini.data.global.key;
// value2 = ini.data.section.key;
//
var Ini = Class.create({
  delimiter: "=",
  global_section: "global",

  initialize: function(filename) {
    this.filename = filename;
  },

  clear: function() {
    this.data = { global: {} };
  },

  load: function() {
    this.clear();
    var file = openFile(this.filename);
    if (file) {
      var section = this.global_section;
      var line;
      while ((line = file.readLine()) != null) {
        if (line.trim() == 0) continue;
        if (/^\[(.+?)\]/.test(line)) {
          section = RegExp.$1.trim();
          if (!this.data[section]) {
            this.data[section] = {};
          }
          continue;
        }
        var res = line.split(this.delimiter);
        if (res.length != 2) continue;
        var key = res[0].trim(), value = res[1].trim();
        this.data[section][key] = value;
      }
      file.close();
      return true;
    }
    return false;
  },

  save: function() {
    var file = openFile(this.filename, false);
    if (file) {
      for (var section in this.data) {
        if (section != this.global_section) {
          file.writeLine("[" + section + "]");
        }
        for (var key in this.data[section]) {
          file.writeLine(key + this.delimiter + this.data[section][key]);
        }
      }
      file.truncate();
      file.close();
      return true;
    }
    return false;
  }
});

String.prototype.trim = function() {
  return this.replace(/(^\s+)|(\s+$)/g, "");
};

prototype4lime.js

/*  Prototype JavaScript framework, version 1.7
 *  (c) 2005-2010 Sam Stephenson
 *
 *  Prototype is freely distributable under the terms of an MIT-style license.
 *  For details, see the Prototype web site: http://www.prototypejs.org/
 *
 *--------------------------------------------------------------------------*/

var document={getElementsByTagName:function(){return[{src:''}];},
createElement:function(){return{appendChild:function(){}};},
createTextNode:function(){},createEvent:function(){return{__proto__:{}};},
getElementById:function(){return{};},write:function(){},domain:'localhost'};
var window={document:document,attachEvent:function(){},setTimeout:function(a,b){setTimeout(a,b);}};
var navigator={userAgent:'LimeChat'};var location={protocol:'http:',port:''};

var Prototype = {

  Version: '1.7',

  Browser: (function(){
    var ua = navigator.userAgent;
    var isOpera = Object.prototype.toString.call(window.opera) == '[object Opera]';
    return {
      IE:             !!window.attachEvent && !isOpera,
      Opera:          isOpera,
      WebKit:         ua.indexOf('AppleWebKit/') > -1,
      Gecko:          ua.indexOf('Gecko') > -1 && ua.indexOf('KHTML') === -1,
      MobileSafari:   /Apple.*Mobile/.test(ua)
    }
  })(),

  BrowserFeatures: {
    XPath: !!document.evaluate,

    SelectorsAPI: !!document.querySelector,

    ElementExtensions: (function() {
      var constructor = window.Element || window.HTMLElement;
      return !!(constructor && constructor.prototype);
    })(),
    SpecificElementExtensions: (function() {
      if (typeof window.HTMLDivElement !== 'undefined')
        return true;

      var div = document.createElement('div'),
          form = document.createElement('form'),
          isSupported = false;

      if (div['__proto__'] && (div['__proto__'] !== form['__proto__'])) {
        isSupported = true;
      }

      div = form = null;

      return isSupported;
    })()
  },

  ScriptFragment: '<script[^>]*>([\\S\\s]*?)<\/script>',
  JSONFilter: /^\/\*-secure-([\s\S]*)\*\/\s*$/,

  emptyFunction: function() { },

  K: function(x) { return x }
};

if (Prototype.Browser.MobileSafari)
  Prototype.BrowserFeatures.SpecificElementExtensions = false;


var Abstract = { };


var Try = {
  these: function() {
    var returnValue;

    for (var i = 0, length = arguments.length; i < length; i++) {
      var lambda = arguments[i];
      try {
        returnValue = lambda();
        break;
      } catch (e) { }
    }

    return returnValue;
  }
};

/* Based on Alex Arnell's inheritance implementation. */

var Class = (function() {

  var IS_DONTENUM_BUGGY = (function(){
    for (var p in { toString: 1 }) {
      if (p === 'toString') return false;
    }
    return true;
  })();

  function subclass() {};
  function create() {
    var parent = null, properties = $A(arguments);
    if (Object.isFunction(properties[0]))
      parent = properties.shift();

    function klass() {
      this.initialize.apply(this, arguments);
    }

    Object.extend(klass, Class.Methods);
    klass.superclass = parent;
    klass.subclasses = [];

    if (parent) {
      subclass.prototype = parent.prototype;
      klass.prototype = new subclass;
      parent.subclasses.push(klass);
    }

    for (var i = 0, length = properties.length; i < length; i++)
      klass.addMethods(properties[i]);

    if (!klass.prototype.initialize)
      klass.prototype.initialize = Prototype.emptyFunction;

    klass.prototype.constructor = klass;
    return klass;
  }

  function addMethods(source) {
    var ancestor   = this.superclass && this.superclass.prototype,
        properties = Object.keys(source);

    if (IS_DONTENUM_BUGGY) {
      if (source.toString != Object.prototype.toString)
        properties.push("toString");
      if (source.valueOf != Object.prototype.valueOf)
        properties.push("valueOf");
    }

    for (var i = 0, length = properties.length; i < length; i++) {
      var property = properties[i], value = source[property];
      if (ancestor && Object.isFunction(value) &&
          value.argumentNames()[0] == "$super") {
        var method = value;
        value = (function(m) {
          return function() { return ancestor[m].apply(this, arguments); };
        })(property).wrap(method);

        value.valueOf = method.valueOf.bind(method);
        value.toString = method.toString.bind(method);
      }
      this.prototype[property] = value;
    }

    return this;
  }

  return {
    create: create,
    Methods: {
      addMethods: addMethods
    }
  };
})();
(function() {

  var _toString = Object.prototype.toString,
      NULL_TYPE = 'Null',
      UNDEFINED_TYPE = 'Undefined',
      BOOLEAN_TYPE = 'Boolean',
      NUMBER_TYPE = 'Number',
      STRING_TYPE = 'String',
      OBJECT_TYPE = 'Object',
      FUNCTION_CLASS = '[object Function]',
      BOOLEAN_CLASS = '[object Boolean]',
      NUMBER_CLASS = '[object Number]',
      STRING_CLASS = '[object String]',
      ARRAY_CLASS = '[object Array]',
      DATE_CLASS = '[object Date]',
      NATIVE_JSON_STRINGIFY_SUPPORT = window.JSON &&
        typeof JSON.stringify === 'function' &&
        JSON.stringify(0) === '0' &&
        typeof JSON.stringify(Prototype.K) === 'undefined';

  function Type(o) {
    switch(o) {
      case null: return NULL_TYPE;
      case (void 0): return UNDEFINED_TYPE;
    }
    var type = typeof o;
    switch(type) {
      case 'boolean': return BOOLEAN_TYPE;
      case 'number':  return NUMBER_TYPE;
      case 'string':  return STRING_TYPE;
    }
    return OBJECT_TYPE;
  }

  function extend(destination, source) {
    for (var property in source)
      destination[property] = source[property];
    return destination;
  }

  function inspect(object) {
    try {
      if (isUndefined(object)) return 'undefined';
      if (object === null) return 'null';
      return object.inspect ? object.inspect() : String(object);
    } catch (e) {
      if (e instanceof RangeError) return '...';
      throw e;
    }
  }

  function toJSON(value) {
    return Str('', { '': value }, []);
  }

  function Str(key, holder, stack) {
    var value = holder[key],
        type = typeof value;

    if (Type(value) === OBJECT_TYPE && typeof value.toJSON === 'function') {
      value = value.toJSON(key);
    }

    var _class = _toString.call(value);

    switch (_class) {
      case NUMBER_CLASS:
      case BOOLEAN_CLASS:
      case STRING_CLASS:
        value = value.valueOf();
    }

    switch (value) {
      case null: return 'null';
      case true: return 'true';
      case false: return 'false';
    }

    type = typeof value;
    switch (type) {
      case 'string':
        return value.inspect(true);
      case 'number':
        return isFinite(value) ? String(value) : 'null';
      case 'object':

        for (var i = 0, length = stack.length; i < length; i++) {
          if (stack[i] === value) { throw new TypeError(); }
        }
        stack.push(value);

        var partial = [];
        if (_class === ARRAY_CLASS) {
          for (var i = 0, length = value.length; i < length; i++) {
            var str = Str(i, value, stack);
            partial.push(typeof str === 'undefined' ? 'null' : str);
          }
          partial = '[' + partial.join(',') + ']';
        } else {
          var keys = Object.keys(value);
          for (var i = 0, length = keys.length; i < length; i++) {
            var key = keys[i], str = Str(key, value, stack);
            if (typeof str !== "undefined") {
               partial.push(key.inspect(true)+ ':' + str);
             }
          }
          partial = '{' + partial.join(',') + '}';
        }
        stack.pop();
        return partial;
    }
  }

  function stringify(object) {
    return JSON.stringify(object);
  }

  function toQueryString(object) {
    return $H(object).toQueryString();
  }

  function toHTML(object) {
    return object && object.toHTML ? object.toHTML() : String.interpret(object);
  }

  function keys(object) {
    if (Type(object) !== OBJECT_TYPE) { throw new TypeError(); }
    var results = [];
    for (var property in object) {
      if (object.hasOwnProperty(property)) {
        results.push(property);
      }
    }
    return results;
  }

  function values(object) {
    var results = [];
    for (var property in object)
      results.push(object[property]);
    return results;
  }

  function clone(object) {
    return extend({ }, object);
  }

  function isElement(object) {
    return !!(object && object.nodeType == 1);
  }

  function isArray(object) {
    return _toString.call(object) === ARRAY_CLASS;
  }

  var hasNativeIsArray = (typeof Array.isArray == 'function')
    && Array.isArray([]) && !Array.isArray({});

  if (hasNativeIsArray) {
    isArray = Array.isArray;
  }

  function isHash(object) {
    return object instanceof Hash;
  }

  function isFunction(object) {
    return _toString.call(object) === FUNCTION_CLASS;
  }

  function isString(object) {
    return _toString.call(object) === STRING_CLASS;
  }

  function isNumber(object) {
    return _toString.call(object) === NUMBER_CLASS;
  }

  function isDate(object) {
    return _toString.call(object) === DATE_CLASS;
  }

  function isUndefined(object) {
    return typeof object === "undefined";
  }

  extend(Object, {
    extend:        extend,
    inspect:       inspect,
    toJSON:        NATIVE_JSON_STRINGIFY_SUPPORT ? stringify : toJSON,
    toQueryString: toQueryString,
    toHTML:        toHTML,
    keys:          Object.keys || keys,
    values:        values,
    clone:         clone,
    isElement:     isElement,
    isArray:       isArray,
    isHash:        isHash,
    isFunction:    isFunction,
    isString:      isString,
    isNumber:      isNumber,
    isDate:        isDate,
    isUndefined:   isUndefined
  });
})();
Object.extend(Function.prototype, (function() {
  var slice = Array.prototype.slice;

  function update(array, args) {
    var arrayLength = array.length, length = args.length;
    while (length--) array[arrayLength + length] = args[length];
    return array;
  }

  function merge(array, args) {
    array = slice.call(array, 0);
    return update(array, args);
  }

  function argumentNames() {
    var names = this.toString().match(/^[\s\(]*function[^(]*\(([^)]*)\)/)[1]
      .replace(/\/\/.*?[\r\n]|\/\*(?:.|[\r\n])*?\*\//g, '')
      .replace(/\s+/g, '').split(',');
    return names.length == 1 && !names[0] ? [] : names;
  }

  function bind(context) {
    if (arguments.length < 2 && Object.isUndefined(arguments[0])) return this;
    var __method = this, args = slice.call(arguments, 1);
    return function() {
      var a = merge(args, arguments);
      return __method.apply(context, a);
    }
  }

  function bindAsEventListener(context) {
    var __method = this, args = slice.call(arguments, 1);
    return function(event) {
      var a = update([event || window.event], args);
      return __method.apply(context, a);
    }
  }

  function curry() {
    if (!arguments.length) return this;
    var __method = this, args = slice.call(arguments, 0);
    return function() {
      var a = merge(args, arguments);
      return __method.apply(this, a);
    }
  }

  function delay(timeout) {
    var __method = this, args = slice.call(arguments, 1);
    timeout = timeout * 1000;
    return window.setTimeout(function() {
      return __method.apply(__method, args);
    }, timeout);
  }

  function defer() {
    var args = update([0.01], arguments);
    return this.delay.apply(this, args);
  }

  function wrap(wrapper) {
    var __method = this;
    return function() {
      var a = update([__method.bind(this)], arguments);
      return wrapper.apply(this, a);
    }
  }

  function methodize() {
    if (this._methodized) return this._methodized;
    var __method = this;
    return this._methodized = function() {
      var a = update([this], arguments);
      return __method.apply(null, a);
    };
  }

  return {
    argumentNames:       argumentNames,
    bind:                bind,
    bindAsEventListener: bindAsEventListener,
    curry:               curry,
    delay:               delay,
    defer:               defer,
    wrap:                wrap,
    methodize:           methodize
  }
})());



(function(proto) {


  function toISOString() {
    return this.getUTCFullYear() + '-' +
      (this.getUTCMonth() + 1).toPaddedString(2) + '-' +
      this.getUTCDate().toPaddedString(2) + 'T' +
      this.getUTCHours().toPaddedString(2) + ':' +
      this.getUTCMinutes().toPaddedString(2) + ':' +
      this.getUTCSeconds().toPaddedString(2) + 'Z';
  }


  function toJSON() {
    return this.toISOString();
  }

  if (!proto.toISOString) proto.toISOString = toISOString;
  if (!proto.toJSON) proto.toJSON = toJSON;

})(Date.prototype);


RegExp.prototype.match = RegExp.prototype.test;

RegExp.escape = function(str) {
  return String(str).replace(/([.*+?^=!:${}()|[\]\/\\])/g, '\\$1');
};
var PeriodicalExecuter = Class.create({
  initialize: function(callback, frequency) {
    this.callback = callback;
    this.frequency = frequency;
    this.currentlyExecuting = false;

    this.registerCallback();
  },

  registerCallback: function() {
    this.timer = setInterval(this.onTimerEvent.bind(this), this.frequency * 1000);
  },

  execute: function() {
    this.callback(this);
  },

  stop: function() {
    if (!this.timer) return;
    clearInterval(this.timer);
    this.timer = null;
  },

  onTimerEvent: function() {
    if (!this.currentlyExecuting) {
      try {
        this.currentlyExecuting = true;
        this.execute();
        this.currentlyExecuting = false;
      } catch(e) {
        this.currentlyExecuting = false;
        throw e;
      }
    }
  }
});
Object.extend(String, {
  interpret: function(value) {
    return value == null ? '' : String(value);
  },
  specialChar: {
    '\b': '\\b',
    '\t': '\\t',
    '\n': '\\n',
    '\f': '\\f',
    '\r': '\\r',
    '\\': '\\\\'
  }
});

Object.extend(String.prototype, (function() {
  var NATIVE_JSON_PARSE_SUPPORT = window.JSON &&
    typeof JSON.parse === 'function' &&
    JSON.parse('{"test": true}').test;

  function prepareReplacement(replacement) {
    if (Object.isFunction(replacement)) return replacement;
    var template = new Template(replacement);
    return function(match) { return template.evaluate(match) };
  }

  function gsub(pattern, replacement) {
    var result = '', source = this, match;
    replacement = prepareReplacement(replacement);

    if (Object.isString(pattern))
      pattern = RegExp.escape(pattern);

    if (!(pattern.length || pattern.source)) {
      replacement = replacement('');
      return replacement + source.split('').join(replacement) + replacement;
    }

    while (source.length > 0) {
      if (match = source.match(pattern)) {
        result += source.slice(0, match.index);
        result += String.interpret(replacement(match));
        source  = source.slice(match.index + match[0].length);
      } else {
        result += source, source = '';
      }
    }
    return result;
  }

  function sub(pattern, replacement, count) {
    replacement = prepareReplacement(replacement);
    count = Object.isUndefined(count) ? 1 : count;

    return this.gsub(pattern, function(match) {
      if (--count < 0) return match[0];
      return replacement(match);
    });
  }

  function scan(pattern, iterator) {
    this.gsub(pattern, iterator);
    return String(this);
  }

  function truncate(length, truncation) {
    length = length || 30;
    truncation = Object.isUndefined(truncation) ? '...' : truncation;
    return this.length > length ?
      this.slice(0, length - truncation.length) + truncation : String(this);
  }

  function strip() {
    return this.replace(/^\s+/, '').replace(/\s+$/, '');
  }

  function stripTags() {
    return this.replace(/<\w+(\s+("[^"]*"|'[^']*'|[^>])+)?>|<\/\w+>/gi, '');
  }

  function stripScripts() {
    return this.replace(new RegExp(Prototype.ScriptFragment, 'img'), '');
  }

  function extractScripts() {
    var matchAll = new RegExp(Prototype.ScriptFragment, 'img'),
        matchOne = new RegExp(Prototype.ScriptFragment, 'im');
    return (this.match(matchAll) || []).map(function(scriptTag) {
      return (scriptTag.match(matchOne) || ['', ''])[1];
    });
  }

  function evalScripts() {
    return this.extractScripts().map(function(script) { return eval(script) });
  }

  function escapeHTML() {
    return this.replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;');
  }

  function unescapeHTML() {
    return this.stripTags().replace(/&lt;/g,'<').replace(/&gt;/g,'>').replace(/&amp;/g,'&');
  }


  function toQueryParams(separator) {
    var match = this.strip().match(/([^?#]*)(#.*)?$/);
    if (!match) return { };

    return match[1].split(separator || '&').inject({ }, function(hash, pair) {
      if ((pair = pair.split('='))[0]) {
        var key = decodeURIComponent(pair.shift()),
            value = pair.length > 1 ? pair.join('=') : pair[0];

        if (value != undefined) value = decodeURIComponent(value);

        if (key in hash) {
          if (!Object.isArray(hash[key])) hash[key] = [hash[key]];
          hash[key].push(value);
        }
        else hash[key] = value;
      }
      return hash;
    });
  }

  function toArray() {
    return this.split('');
  }

  function succ() {
    return this.slice(0, this.length - 1) +
      String.fromCharCode(this.charCodeAt(this.length - 1) + 1);
  }

  function times(count) {
    return count < 1 ? '' : new Array(count + 1).join(this);
  }

  function camelize() {
    return this.replace(/-+(.)?/g, function(match, chr) {
      return chr ? chr.toUpperCase() : '';
    });
  }

  function capitalize() {
    return this.charAt(0).toUpperCase() + this.substring(1).toLowerCase();
  }

  function underscore() {
    return this.replace(/::/g, '/')
               .replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2')
               .replace(/([a-z\d])([A-Z])/g, '$1_$2')
               .replace(/-/g, '_')
               .toLowerCase();
  }

  function dasherize() {
    return this.replace(/_/g, '-');
  }

  function inspect(useDoubleQuotes) {
    var escapedString = this.replace(/[\x00-\x1f\\]/g, function(character) {
      if (character in String.specialChar) {
        return String.specialChar[character];
      }
      return '\\u00' + character.charCodeAt().toPaddedString(2, 16);
    });
    if (useDoubleQuotes) return '"' + escapedString.replace(/"/g, '\\"') + '"';
    return "'" + escapedString.replace(/'/g, '\\\'') + "'";
  }

  function unfilterJSON(filter) {
    return this.replace(filter || Prototype.JSONFilter, '$1');
  }

  function isJSON() {
    var str = this;
    if (str.blank()) return false;
    str = str.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, '@');
    str = str.replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']');
    str = str.replace(/(?:^|:|,)(?:\s*\[)+/g, '');
    return (/^[\],:{}\s]*$/).test(str);
  }

  function evalJSON(sanitize) {
    var json = this.unfilterJSON(),
        cx = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g;
    if (cx.test(json)) {
      json = json.replace(cx, function (a) {
        return '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
      });
    }
    try {
      if (!sanitize || json.isJSON()) return eval('(' + json + ')');
    } catch (e) { }
    throw new SyntaxError('Badly formed JSON string: ' + this.inspect());
  }

  function parseJSON() {
    var json = this.unfilterJSON();
    return JSON.parse(json);
  }

  function include(pattern) {
    return this.indexOf(pattern) > -1;
  }

  function startsWith(pattern) {
    return this.lastIndexOf(pattern, 0) === 0;
  }

  function endsWith(pattern) {
    var d = this.length - pattern.length;
    return d >= 0 && this.indexOf(pattern, d) === d;
  }

  function empty() {
    return this == '';
  }

  function blank() {
    return /^\s*$/.test(this);
  }

  function interpolate(object, pattern) {
    return new Template(this, pattern).evaluate(object);
  }

  return {
    gsub:           gsub,
    sub:            sub,
    scan:           scan,
    truncate:       truncate,
    strip:          String.prototype.trim || strip,
    stripTags:      stripTags,
    stripScripts:   stripScripts,
    extractScripts: extractScripts,
    evalScripts:    evalScripts,
    escapeHTML:     escapeHTML,
    unescapeHTML:   unescapeHTML,
    toQueryParams:  toQueryParams,
    parseQuery:     toQueryParams,
    toArray:        toArray,
    succ:           succ,
    times:          times,
    camelize:       camelize,
    capitalize:     capitalize,
    underscore:     underscore,
    dasherize:      dasherize,
    inspect:        inspect,
    unfilterJSON:   unfilterJSON,
    isJSON:         isJSON,
    evalJSON:       NATIVE_JSON_PARSE_SUPPORT ? parseJSON : evalJSON,
    include:        include,
    startsWith:     startsWith,
    endsWith:       endsWith,
    empty:          empty,
    blank:          blank,
    interpolate:    interpolate
  };
})());

var Template = Class.create({
  initialize: function(template, pattern) {
    this.template = template.toString();
    this.pattern = pattern || Template.Pattern;
  },

  evaluate: function(object) {
    if (object && Object.isFunction(object.toTemplateReplacements))
      object = object.toTemplateReplacements();

    return this.template.gsub(this.pattern, function(match) {
      if (object == null) return (match[1] + '');

      var before = match[1] || '';
      if (before == '\\') return match[2];

      var ctx = object, expr = match[3],
          pattern = /^([^.[]+|\[((?:.*?[^\\])?)\])(\.|\[|$)/;

      match = pattern.exec(expr);
      if (match == null) return before;

      while (match != null) {
        var comp = match[1].startsWith('[') ? match[2].replace(/\\\\]/g, ']') : match[1];
        ctx = ctx[comp];
        if (null == ctx || '' == match[3]) break;
        expr = expr.substring('[' == match[3] ? match[1].length : match[0].length);
        match = pattern.exec(expr);
      }

      return before + String.interpret(ctx);
    });
  }
});
Template.Pattern = /(^|.|\r|\n)(#\{(.*?)\})/;

var $break = { };

var Enumerable = (function() {
  function each(iterator, context) {
    var index = 0;
    try {
      this._each(function(value) {
        iterator.call(context, value, index++);
      });
    } catch (e) {
      if (e != $break) throw e;
    }
    return this;
  }

  function eachSlice(number, iterator, context) {
    var index = -number, slices = [], array = this.toArray();
    if (number < 1) return array;
    while ((index += number) < array.length)
      slices.push(array.slice(index, index+number));
    return slices.collect(iterator, context);
  }

  function all(iterator, context) {
    iterator = iterator || Prototype.K;
    var result = true;
    this.each(function(value, index) {
      result = result && !!iterator.call(context, value, index);
      if (!result) throw $break;
    });
    return result;
  }

  function any(iterator, context) {
    iterator = iterator || Prototype.K;
    var result = false;
    this.each(function(value, index) {
      if (result = !!iterator.call(context, value, index))
        throw $break;
    });
    return result;
  }

  function collect(iterator, context) {
    iterator = iterator || Prototype.K;
    var results = [];
    this.each(function(value, index) {
      results.push(iterator.call(context, value, index));
    });
    return results;
  }

  function detect(iterator, context) {
    var result;
    this.each(function(value, index) {
      if (iterator.call(context, value, index)) {
        result = value;
        throw $break;
      }
    });
    return result;
  }

  function findAll(iterator, context) {
    var results = [];
    this.each(function(value, index) {
      if (iterator.call(context, value, index))
        results.push(value);
    });
    return results;
  }

  function grep(filter, iterator, context) {
    iterator = iterator || Prototype.K;
    var results = [];

    if (Object.isString(filter))
      filter = new RegExp(RegExp.escape(filter));

    this.each(function(value, index) {
      if (filter.match(value))
        results.push(iterator.call(context, value, index));
    });
    return results;
  }

  function include(object) {
    if (Object.isFunction(this.indexOf))
      if (this.indexOf(object) != -1) return true;

    var found = false;
    this.each(function(value) {
      if (value == object) {
        found = true;
        throw $break;
      }
    });
    return found;
  }

  function inGroupsOf(number, fillWith) {
    fillWith = Object.isUndefined(fillWith) ? null : fillWith;
    return this.eachSlice(number, function(slice) {
      while(slice.length < number) slice.push(fillWith);
      return slice;
    });
  }

  function inject(memo, iterator, context) {
    this.each(function(value, index) {
      memo = iterator.call(context, memo, value, index);
    });
    return memo;
  }

  function invoke(method) {
    var args = $A(arguments).slice(1);
    return this.map(function(value) {
      return value[method].apply(value, args);
    });
  }

  function max(iterator, context) {
    iterator = iterator || Prototype.K;
    var result;
    this.each(function(value, index) {
      value = iterator.call(context, value, index);
      if (result == null || value >= result)
        result = value;
    });
    return result;
  }

  function min(iterator, context) {
    iterator = iterator || Prototype.K;
    var result;
    this.each(function(value, index) {
      value = iterator.call(context, value, index);
      if (result == null || value < result)
        result = value;
    });
    return result;
  }

  function partition(iterator, context) {
    iterator = iterator || Prototype.K;
    var trues = [], falses = [];
    this.each(function(value, index) {
      (iterator.call(context, value, index) ?
        trues : falses).push(value);
    });
    return [trues, falses];
  }

  function pluck(property) {
    var results = [];
    this.each(function(value) {
      results.push(value[property]);
    });
    return results;
  }

  function reject(iterator, context) {
    var results = [];
    this.each(function(value, index) {
      if (!iterator.call(context, value, index))
        results.push(value);
    });
    return results;
  }

  function sortBy(iterator, context) {
    return this.map(function(value, index) {
      return {
        value: value,
        criteria: iterator.call(context, value, index)
      };
    }).sort(function(left, right) {
      var a = left.criteria, b = right.criteria;
      return a < b ? -1 : a > b ? 1 : 0;
    }).pluck('value');
  }

  function toArray() {
    return this.map();
  }

  function zip() {
    var iterator = Prototype.K, args = $A(arguments);
    if (Object.isFunction(args.last()))
      iterator = args.pop();

    var collections = [this].concat(args).map($A);
    return this.map(function(value, index) {
      return iterator(collections.pluck(index));
    });
  }

  function size() {
    return this.toArray().length;
  }

  function inspect() {
    return '#<Enumerable:' + this.toArray().inspect() + '>';
  }









  return {
    each:       each,
    eachSlice:  eachSlice,
    all:        all,
    every:      all,
    any:        any,
    some:       any,
    collect:    collect,
    map:        collect,
    detect:     detect,
    findAll:    findAll,
    select:     findAll,
    filter:     findAll,
    grep:       grep,
    include:    include,
    member:     include,
    inGroupsOf: inGroupsOf,
    inject:     inject,
    invoke:     invoke,
    max:        max,
    min:        min,
    partition:  partition,
    pluck:      pluck,
    reject:     reject,
    sortBy:     sortBy,
    toArray:    toArray,
    entries:    toArray,
    zip:        zip,
    size:       size,
    inspect:    inspect,
    find:       detect
  };
})();

function $A(iterable) {
  if (!iterable) return [];
  if ('toArray' in Object(iterable)) return iterable.toArray();
  var length = iterable.length || 0, results = new Array(length);
  while (length--) results[length] = iterable[length];
  return results;
}


function $w(string) {
  if (!Object.isString(string)) return [];
  string = string.strip();
  return string ? string.split(/\s+/) : [];
}

Array.from = $A;


(function() {
  var arrayProto = Array.prototype,
      slice = arrayProto.slice,
      _each = arrayProto.forEach; // use native browser JS 1.6 implementation if available

  function each(iterator, context) {
    for (var i = 0, length = this.length >>> 0; i < length; i++) {
      if (i in this) iterator.call(context, this[i], i, this);
    }
  }
  if (!_each) _each = each;

  function clear() {
    this.length = 0;
    return this;
  }

  function first() {
    return this[0];
  }

  function last() {
    return this[this.length - 1];
  }

  function compact() {
    return this.select(function(value) {
      return value != null;
    });
  }

  function flatten() {
    return this.inject([], function(array, value) {
      if (Object.isArray(value))
        return array.concat(value.flatten());
      array.push(value);
      return array;
    });
  }

  function without() {
    var values = slice.call(arguments, 0);
    return this.select(function(value) {
      return !values.include(value);
    });
  }

  function reverse(inline) {
    return (inline === false ? this.toArray() : this)._reverse();
  }

  function uniq(sorted) {
    return this.inject([], function(array, value, index) {
      if (0 == index || (sorted ? array.last() != value : !array.include(value)))
        array.push(value);
      return array;
    });
  }

  function intersect(array) {
    return this.uniq().findAll(function(item) {
      return array.detect(function(value) { return item === value });
    });
  }


  function clone() {
    return slice.call(this, 0);
  }

  function size() {
    return this.length;
  }

  function inspect() {
    return '[' + this.map(Object.inspect).join(', ') + ']';
  }

  function indexOf(item, i) {
    i || (i = 0);
    var length = this.length;
    if (i < 0) i = length + i;
    for (; i < length; i++)
      if (this[i] === item) return i;
    return -1;
  }

  function lastIndexOf(item, i) {
    i = isNaN(i) ? this.length : (i < 0 ? this.length + i : i) + 1;
    var n = this.slice(0, i).reverse().indexOf(item);
    return (n < 0) ? n : i - n - 1;
  }

  function concat() {
    var array = slice.call(this, 0), item;
    for (var i = 0, length = arguments.length; i < length; i++) {
      item = arguments[i];
      if (Object.isArray(item) && !('callee' in item)) {
        for (var j = 0, arrayLength = item.length; j < arrayLength; j++)
          array.push(item[j]);
      } else {
        array.push(item);
      }
    }
    return array;
  }

  Object.extend(arrayProto, Enumerable);

  if (!arrayProto._reverse)
    arrayProto._reverse = arrayProto.reverse;

  Object.extend(arrayProto, {
    _each:     _each,
    clear:     clear,
    first:     first,
    last:      last,
    compact:   compact,
    flatten:   flatten,
    without:   without,
    reverse:   reverse,
    uniq:      uniq,
    intersect: intersect,
    clone:     clone,
    toArray:   clone,
    size:      size,
    inspect:   inspect
  });

  var CONCAT_ARGUMENTS_BUGGY = (function() {
    return [].concat(arguments)[0][0] !== 1;
  })(1,2)

  if (CONCAT_ARGUMENTS_BUGGY) arrayProto.concat = concat;

  if (!arrayProto.indexOf) arrayProto.indexOf = indexOf;
  if (!arrayProto.lastIndexOf) arrayProto.lastIndexOf = lastIndexOf;
})();
function $H(object) {
  return new Hash(object);
};

var Hash = Class.create(Enumerable, (function() {
  function initialize(object) {
    this._object = Object.isHash(object) ? object.toObject() : Object.clone(object);
  }


  function _each(iterator) {
    for (var key in this._object) {
      var value = this._object[key], pair = [key, value];
      pair.key = key;
      pair.value = value;
      iterator(pair);
    }
  }

  function set(key, value) {
    return this._object[key] = value;
  }

  function get(key) {
    if (this._object[key] !== Object.prototype[key])
      return this._object[key];
  }

  function unset(key) {
    var value = this._object[key];
    delete this._object[key];
    return value;
  }

  function toObject() {
    return Object.clone(this._object);
  }



  function keys() {
    return this.pluck('key');
  }

  function values() {
    return this.pluck('value');
  }

  function index(value) {
    var match = this.detect(function(pair) {
      return pair.value === value;
    });
    return match && match.key;
  }

  function merge(object) {
    return this.clone().update(object);
  }

  function update(object) {
    return new Hash(object).inject(this, function(result, pair) {
      result.set(pair.key, pair.value);
      return result;
    });
  }

  function toQueryPair(key, value) {
    if (Object.isUndefined(value)) return key;
    return key + '=' + encodeURIComponent(String.interpret(value));
  }

  function toQueryString() {
    return this.inject([], function(results, pair) {
      var key = encodeURIComponent(pair.key), values = pair.value;

      if (values && typeof values == 'object') {
        if (Object.isArray(values)) {
          var queryValues = [];
          for (var i = 0, len = values.length, value; i < len; i++) {
            value = values[i];
            queryValues.push(toQueryPair(key, value));
          }
          return results.concat(queryValues);
        }
      } else results.push(toQueryPair(key, values));
      return results;
    }).join('&');
  }

  function inspect() {
    return '#<Hash:{' + this.map(function(pair) {
      return pair.map(Object.inspect).join(': ');
    }).join(', ') + '}>';
  }

  function clone() {
    return new Hash(this);
  }

  return {
    initialize:             initialize,
    _each:                  _each,
    set:                    set,
    get:                    get,
    unset:                  unset,
    toObject:               toObject,
    toTemplateReplacements: toObject,
    keys:                   keys,
    values:                 values,
    index:                  index,
    merge:                  merge,
    update:                 update,
    toQueryString:          toQueryString,
    inspect:                inspect,
    toJSON:                 toObject,
    clone:                  clone
  };
})());

Hash.from = $H;
Object.extend(Number.prototype, (function() {
  function toColorPart() {
    return this.toPaddedString(2, 16);
  }

  function succ() {
    return this + 1;
  }

  function times(iterator, context) {
    $R(0, this, true).each(iterator, context);
    return this;
  }

  function toPaddedString(length, radix) {
    var string = this.toString(radix || 10);
    return '0'.times(length - string.length) + string;
  }

  function abs() {
    return Math.abs(this);
  }

  function round() {
    return Math.round(this);
  }

  function ceil() {
    return Math.ceil(this);
  }

  function floor() {
    return Math.floor(this);
  }

  return {
    toColorPart:    toColorPart,
    succ:           succ,
    times:          times,
    toPaddedString: toPaddedString,
    abs:            abs,
    round:          round,
    ceil:           ceil,
    floor:          floor
  };
})());

function $R(start, end, exclusive) {
  return new ObjectRange(start, end, exclusive);
}

var ObjectRange = Class.create(Enumerable, (function() {
  function initialize(start, end, exclusive) {
    this.start = start;
    this.end = end;
    this.exclusive = exclusive;
  }

  function _each(iterator) {
    var value = this.start;
    while (this.include(value)) {
      iterator(value);
      value = value.succ();
    }
  }

  function include(value) {
    if (value < this.start)
      return false;
    if (this.exclusive)
      return value < this.end;
    return value <= this.end;
  }

  return {
    initialize: initialize,
    _each:      _each,
    include:    include
  };
})());



var Ajax = {
  getTransport: function() {
    return Try.these(
      function() {return new XMLHttpRequest()},
      function() {return new ActiveXObject('Msxml2.XMLHTTP')},
      function() {return new ActiveXObject('Microsoft.XMLHTTP')}
    ) || false;
  },

  activeRequestCount: 0
};

Ajax.Responders = {
  responders: [],

  _each: function(iterator) {
    this.responders._each(iterator);
  },

  register: function(responder) {
    if (!this.include(responder))
      this.responders.push(responder);
  },

  unregister: function(responder) {
    this.responders = this.responders.without(responder);
  },

  dispatch: function(callback, request, transport, json) {
    this.each(function(responder) {
      if (Object.isFunction(responder[callback])) {
        try {
          responder[callback].apply(responder, [request, transport, json]);
        } catch (e) { }
      }
    });
  }
};

Object.extend(Ajax.Responders, Enumerable);

Ajax.Responders.register({
  onCreate:   function() { Ajax.activeRequestCount++ },
  onComplete: function() { Ajax.activeRequestCount-- }
});
Ajax.Base = Class.create({
  initialize: function(options) {
    this.options = {
      method:       'post',
      asynchronous: true,
      contentType:  'application/x-www-form-urlencoded',
      encoding:     'UTF-8',
      parameters:   '',
      evalJSON:     true,
      evalJS:       true
    };
    Object.extend(this.options, options || { });

    this.options.method = this.options.method.toLowerCase();

    if (Object.isHash(this.options.parameters))
      this.options.parameters = this.options.parameters.toObject();
  }
});
Ajax.Request = Class.create(Ajax.Base, {
  _complete: false,

  initialize: function($super, url, options) {
    $super(options);
    this.transport = Ajax.getTransport();
    this.request(url);
  },

  request: function(url) {
    this.url = url;
    this.method = this.options.method;
    var params = Object.isString(this.options.parameters) ?
          this.options.parameters :
          Object.toQueryString(this.options.parameters);

    if (!['get', 'post'].include(this.method)) {
      params += (params ? '&' : '') + "_method=" + this.method;
      this.method = 'post';
    }

    if (params && this.method === 'get') {
      this.url += (this.url.include('?') ? '&' : '?') + params;
    }

    this.parameters = params.toQueryParams();

//    try {
      var response = new Ajax.Response(this);
      if (this.options.onCreate) this.options.onCreate(response);
      Ajax.Responders.dispatch('onCreate', this, response);

      this.transport.open(this.method.toUpperCase(), this.url,
        this.options.asynchronous);

      if (this.options.asynchronous) this.respondToReadyState.bind(this).defer(1);

      this.transport.onreadystatechange = this.onStateChange.bind(this);
      this.setRequestHeaders();

      this.body = this.method == 'post' ? (this.options.postBody || params) : null;
      this.transport.send(this.body);

      /* Force Firefox to handle ready state 4 for synchronous requests */
      if (!this.options.asynchronous && this.transport.overrideMimeType)
        this.onStateChange();

/*    }
    catch (e) {
      this.dispatchException(e);
    }*/
  },

  onStateChange: function() {
    var readyState = this.transport.readyState;
    if (readyState > 1 && !((readyState == 4) && this._complete))
      this.respondToReadyState(this.transport.readyState);
  },

  setRequestHeaders: function() {
    var headers = {
      'X-Requested-With': 'XMLHttpRequest',
      'X-Prototype-Version': Prototype.Version,
      'Accept': 'text/javascript, text/html, application/xml, text/xml, */*'
    };

    if (this.method == 'post') {
      headers['Content-type'] = this.options.contentType +
        (this.options.encoding ? '; charset=' + this.options.encoding : '');

      /* Force "Connection: close" for older Mozilla browsers to work
       * around a bug where XMLHttpRequest sends an incorrect
       * Content-length header. See Mozilla Bugzilla #246651.
       */
      if (this.transport.overrideMimeType &&
          (navigator.userAgent.match(/Gecko\/(\d{4})/) || [0,2005])[1] < 2005)
            headers['Connection'] = 'close';
    }

    if (typeof this.options.requestHeaders == 'object') {
      var extras = this.options.requestHeaders;

      if (Object.isFunction(extras.push))
        for (var i = 0, length = extras.length; i < length; i += 2)
          headers[extras[i]] = extras[i+1];
      else
        $H(extras).each(function(pair) { headers[pair.key] = pair.value });
    }

    for (var name in headers)
      this.transport.setRequestHeader(name, headers[name]);
  },

  success: function() {
    var status = this.getStatus();
    return !status || (status >= 200 && status < 300) || status == 304;
  },

  getStatus: function() {
    //try {
      if (this.transport.status === 1223) return 204;
      return this.transport.status || 0;
    //} catch (e) { return 0 }
  },

  respondToReadyState: function(readyState) {
    var state = Ajax.Request.Events[readyState], response = new Ajax.Response(this);

    if (state == 'Complete') {
      //try {
        this._complete = true;
        (this.options['on' + response.status]
         || this.options['on' + (this.success() ? 'Success' : 'Failure')]
         || Prototype.emptyFunction)(response, response.headerJSON);
      /*} catch (e) {
        this.dispatchException(e);
      }*/

      var contentType = response.getHeader('Content-type');
      if (this.options.evalJS == 'force'
          || (this.options.evalJS && this.isSameOrigin() && contentType
          && contentType.match(/^\s*(text|application)\/(x-)?(java|ecma)script(;.*)?\s*$/i)))
        this.evalResponse();
    }

    //try {
      (this.options['on' + state] || Prototype.emptyFunction)(response, response.headerJSON);
      Ajax.Responders.dispatch('on' + state, this, response, response.headerJSON);
    /*} catch (e) {
      this.dispatchException(e);
    }*/

    if (state == 'Complete') {
      this.transport.onreadystatechange = Prototype.emptyFunction;
    }
  },

  isSameOrigin: function() {
    var m = this.url.match(/^\s*https?:\/\/[^\/]*/);
    return !m || (m[0] == '#{protocol}//#{domain}#{port}'.interpolate({
      protocol: location.protocol,
      domain: document.domain,
      port: location.port ? ':' + location.port : ''
    }));
  },

  getHeader: function(name) {
    try {
      return this.transport.getResponseHeader(name) || null;
    } catch (e) { return null; }
  },

  evalResponse: function() {
    try {
      return eval((this.transport.responseText || '').unfilterJSON());
    } catch (e) {
      this.dispatchException(e);
    }
  },

  dispatchException: function(exception) {
    (this.options.onException || Prototype.emptyFunction)(this, exception);
    Ajax.Responders.dispatch('onException', this, exception);
  }
});

Ajax.Request.Events =
  ['Uninitialized', 'Loading', 'Loaded', 'Interactive', 'Complete'];








Ajax.Response = Class.create({
  initialize: function(request){
    this.request = request;
    var transport  = this.transport  = request.transport,
        readyState = this.readyState = transport.readyState;

    if ((readyState > 2 && !Prototype.Browser.IE) || readyState == 4) {
      this.status       = this.getStatus();
      this.statusText   = this.getStatusText();
      this.responseText = String.interpret(transport.responseText);
      this.headerJSON   = this._getHeaderJSON();
    }

    if (readyState == 4) {
      var xml = transport.responseXML;
      this.responseXML  = Object.isUndefined(xml) ? null : xml;
      this.responseJSON = this._getResponseJSON();
    }
  },

  status:      0,

  statusText: '',

  getStatus: Ajax.Request.prototype.getStatus,

  getStatusText: function() {
    try {
      return this.transport.statusText || '';
    } catch (e) { return '' }
  },

  getHeader: Ajax.Request.prototype.getHeader,

  getAllHeaders: function() {
    try {
      return this.getAllResponseHeaders();
    } catch (e) { return null }
  },

  getResponseHeader: function(name) {
    return this.transport.getResponseHeader(name);
  },

  getAllResponseHeaders: function() {
    return this.transport.getAllResponseHeaders();
  },

  _getHeaderJSON: function() {
    var json = this.getHeader('X-JSON');
    if (!json) return null;
    json = decodeURIComponent(escape(json));
    try {
      return json.evalJSON(this.request.options.sanitizeJSON ||
        !this.request.isSameOrigin());
    } catch (e) {
      this.request.dispatchException(e);
    }
  },

  _getResponseJSON: function() {
    var options = this.request.options;
    if (!options.evalJSON || (options.evalJSON != 'force' &&
      !(this.getHeader('Content-type') || '').include('application/json')) ||
        this.responseText.blank())
          return null;
    try {
      return this.responseText.evalJSON(options.sanitizeJSON ||
        !this.request.isSameOrigin());
    } catch (e) {
      this.request.dispatchException(e);
    }
  }
});

Ajax.Updater = Class.create(Ajax.Request, {
  initialize: function($super, container, url, options) {
    this.container = {
      success: (container.success || container),
      failure: (container.failure || (container.success ? null : container))
    };

    options = Object.clone(options);
    var onComplete = options.onComplete;
    options.onComplete = (function(response, json) {
      this.updateContent(response.responseText);
      if (Object.isFunction(onComplete)) onComplete(response, json);
    }).bind(this);

    $super(url, options);
  },

  updateContent: function(responseText) {
    var receiver = this.container[this.success() ? 'success' : 'failure'],
        options = this.options;

    if (!options.evalScripts) responseText = responseText.stripScripts();

    if (receiver = $(receiver)) {
      if (options.insertion) {
        if (Object.isString(options.insertion)) {
          var insertion = { }; insertion[options.insertion] = responseText;
          receiver.insert(insertion);
        }
        else options.insertion(receiver, responseText);
      }
      else receiver.update(responseText);
    }
  }
});

Ajax.PeriodicalUpdater = Class.create(Ajax.Base, {
  initialize: function($super, container, url, options) {
    $super(options);
    this.onComplete = this.options.onComplete;

    this.frequency = (this.options.frequency || 2);
    this.decay = (this.options.decay || 1);

    this.updater = { };
    this.container = container;
    this.url = url;

    this.start();
  },

  start: function() {
    this.options.onComplete = this.updateComplete.bind(this);
    this.onTimerEvent();
  },

  stop: function() {
    this.updater.options.onComplete = undefined;
    clearTimeout(this.timer);
    (this.onComplete || Prototype.emptyFunction).apply(this, arguments);
  },

  updateComplete: function(response) {
    if (this.options.decay) {
      this.decay = (response.responseText == this.lastText ?
        this.decay * this.options.decay : 1);

      this.lastText = response.responseText;
    }
    this.timer = this.onTimerEvent.bind(this).delay(this.decay * this.frequency);
  },

  onTimerEvent: function() {
    this.updater = new Ajax.Updater(this.container, this.url, this.options);
  }
});

quake.js

//
// Limechat Quake Notifier by whiteleaf
//
// 2011/03/28 Ver.1.0
//

LimeExt.Require("library/prototype4lime.js");
LimeExt.Require("library/socket.js");
LimeExt.Require("library/ini.js");

var debug = false;

var Quake = {
  default_min_shindo: 3,                  // これ以上の震度だけ表示する(デフォ値、チャンネルごとに設定可能)
  arguments_order_prefix: "quake",        // コマンド名
  arguments_spliter: ">",                 // コマンドの区切り文字
  setting_filename: "quake_setting_" + escape_filename(name) + ".ini"    // 設定ファイル名(プロファイル別管理)
};

Quake.version = "1.1";

var P2PQuakePlugin = Class.create(Socket, {
  port: (debug ? 7777 : 6918),
  retry_limit: 10,
  retry_interval: 2000,

  initialize: function($super, options) {
    $super();
    this.connected = false;
    this.retry_count = 0;
    this.quited = false;
    this.data_buffer = "";
    this.options = {
      name: "P2PQuake Plugin for Limechat",
      onReceive: function() {}
    };
    Object.extend(this.options, options || {});
    this.reconnect(30 * 1000 + Math.floor(Math.random() * 10 * 1000));
  },

  connectToP2PQuakeCliant: function() {
    if (!this.connected) {
      this.connect("localhost", this.port);
      if (this.retry_count-- > 0) {
        setTimeout(this.connectToP2PQuakeCliant.bind(this), this.retry_interval);
      }
      else {
        log("[LQH] Error: P2P地震情報クライアントに接続出来ませんでした。" +
            "再接続には quake>reconnect を使用してください");
      }
    }
  },

  reconnect: function(interval) {
    if (!interval) {
      interval = this.retry_interval
    }
    if (this.connected || this.retry_count > 0) return;
    this.retry_count = this.retry_limit;
    setTimeout(this.connectToP2PQuakeCliant.bind(this), interval);
  },

  onConnect: function() {
    this.connected = true;
    this.retry_count = 0;
    this.send("JOIN", this.options.name);
  },

  onClose: function() {
    this.connected = false;
    log("[LQN] Error: P2P地震情報クライアントとの接続が切れました");
  },

  onError: function($super) {
    $super();
    this.connected = false;
  },

  onDataArrival: function(total) {
    this.data_buffer = this.getData();
    var operation = this.data_buffer.substring(0, 4);
    var data = (this.data_buffer.length > 5 ? this.data_buffer.substring(5).replace(/[\r\n]/g, "") : "");
    this.options.onReceive.apply(this, [operation, data]);
    this.data_buffer = "";
  },

  quit: function() {
    if (!this.quited) {
      this.close();
      this.quited = true;
    }
  },

  send: function(operation, data) {
    this.sendData(operation.toUpperCase() + " " + data + "\r\n");
  }
});

Quake.Notifier = Class.create(P2PQuakePlugin, {
  initialize: function($super) {
    $super({
      name: "Limechat Quake Notifier (Version " + Quake.version+ ")",
      onReceive: this.receive
    });
    this.load_setting();
    log(this.options.name);
  },

  test: function() {
    this.receive("SVER", "P2P地震情報 for Peer(Beta 3/Revision 1012)");
    //this.receive("QUAK", "28日14時38分,3,0,4,秋田県内陸南部,20km,4.1,0,N39.6,E140.5,気象庁:-秋田県,+3,*大仙市,*仙北市,+1,*秋田市,*由利本荘市,*大館市,*北秋田市,*秋田美郷町,-岩手県,+1,*矢巾町");
    this.receive("QUAK", "28日20時08分,3,0,4,茨城県北部,20km,4.1,0,N36.7,E140.6,気象庁:-茨城県,+3,*常陸太田市,+2,*日立市,*高萩市,*大子町,*常陸大宮市,+1,*水戸市,*北茨城市,*笠間市,*ひたちなか市,*那珂市,*城里町,*小美玉市,*土浦市,*石岡市,*つくば市,*茨城鹿嶋市,*坂東市,*筑西市,*かすみがうら市,*桜川市,*鉾田市,*常総市,-福島県,+2,*矢祭町,*平田村,*楢葉町,+1,*白河市,*二本松市,*鏡石町,*天栄村,*棚倉町,*玉川村,*浅川町,*古殿町,*小野町,*田村,*福島伊達市,*いわき市,*飯舘村,-宮城県,+1,*岩沼市,-栃木県,+1,*宇都宮市,*栃木市,*鹿沼市,*芳賀町,*那須烏山市,*栃木那珂川町,-埼玉県,+1,*宮代町");
    //this.receive("QUAK", "28日23時32分,2,0,4,新潟県中越地方,10km,1.9,0,N37.0,E138.6,気象庁:-長野県,+2,*栄村");
    this.receive("OPTI");
    this.receive("EEW1", "1");
    this.receive("EEW1", "0");
  },

  commandline: function(prefix, channel, text) {
    new Quake.Command(prefix, channel, text, this);
  },

  receive: function(operation, data) {
    switch (operation) {
    case "SVER":
      log("[LQN] connected to " + data);
      break;
    case "QUAK":
      this.notify_quak(data);
      break;
    case "EEW1":
      if (data == "0") {
        this.channels.each(function(ch) {
          send(ch, "<bold><color red>!!!緊急地震速報!!!<stop>");
        });
      }
      break;
    case "OPTI":
      log(this.options.name);
      log("操作方法に関しては " + Quake.arguments_order_prefix +
          Quake.arguments_spliter + "help を参照して下さい");
      break;
    default:
      break;
    }
  },

  cache_summary: {},
  cache_detail: "",
  latest_summary: "",
  latest_detail: "",

  notify_quak: function(data) {
    var split_data = data.split(":");
    var summary = split_data[0], detail = split_data[1];
    if (detail.length == 0) {
      return;
    }
    var result = this.get_quak_summary(summary);
    if (result.elements.seismic_intensity == 0 || this.cache_summary[result.elements.date]) {
      return;
    }
    if (result.elements.eq_position == "--") {
      // 「地震速報」では震源・規模情報が配信されずに、速報震度と各地震度情報しか配信されない。
      // 第二報以降の「地震情報」「震源情報」で詳細が発表されるため、第一報の各地震度のみ保存して
      // 第二報以降の震度概要と統合する
      this.cache_detail = detail;
      return;
    }
    if (this.cache_detail != "") {
      detail = this.cache_detail;
      this.latest_detail = detail;
      this.cache_detail = "";
    }
    this.cache_summary[result.elements.date] = true;
    var summary_message = result.message;
    this.latest_summary = summary_message;
    this.channels.each(function(ch) {
      var min = (this.min_shindo[ch] ? this.min_shindo[ch] : Quake.default_min_shindo);
      var detail_messages = this.get_quak_detail(detail, min);
      if (detail_messages.length > 0) {
        send(ch, summary_message);
        detail_messages.each(function(msg) {
          send(ch, msg);
        });
      }
    }, this);
  },

  get_quak_summary: function(summary) {
    var split_data = summary.split(",");
    var elements = {
      date: split_data[0],
      seismic_intensity: split_data[1],
      eq_position: split_data[4],
      eq_deep: split_data[5],
      magnitude: split_data[6],
      eq_pos_n: split_data[8],
      eq_pos_e: split_data[9],
      vender: split_data[10]
    };
    if (elements.eq_position == "") {
      elements.eq_position = "--";
    }
    if (elements.magnitude == "-1.0") {
      elements.magnitude = "--";
    }
    var template = new Template(
      "<bold>地震情報<stop> #{date} (最大震度#{seismic_intensity}) [震源]#{eq_position} [規模]M#{magnitude}");
    return {
      elements: elements,
      message: template.evaluate(elements)
    };
  },

  get_quak_detail: function(detail, min_shindo) {
    var result = {};
    var prefecture = "", seismic_intensity = 0;
    detail.split(",").each(function(value) {
      var op = value.substring(0, 1);
      var info = value.substring(1);
      switch (op) {
      case "-":
        prefecture = info;
        if (!result[prefecture]) {
          result[prefecture] = {};
        }
        break;
      case "+":
        seismic_intensity = info;
        result[prefecture][seismic_intensity] = [];
        break;
      case "*":
        result[prefecture][seismic_intensity].push(info);
        break;
      default:
        break;
      }
    }, this);
    var messages = [];
    for (prefecture in result) {
      if (prefecture.length > 0) {
        var cities = [];
        for (seismic_intensity in result[prefecture]) {
          if (seismic_intensity >= min_shindo) {
            cities.push("震度" + seismic_intensity + ":" +
                        result[prefecture][seismic_intensity].join(" "));
          }
        }
        if (cities.length > 0) {
          messages.push("[" + prefecture + "]" + cities.join("  "));
        }
      }
    }
    return messages;
  },

  load_setting: function() {
    this.channels = [];
    this.min_shindo = {};
    this.setting = new Ini(Quake.setting_filename);
    if (!this.setting.load()) {
      return;
    }
    if (this.setting.data.global.channels != "") {
      this.channels = this.setting.data.global.channels.split(",");
    }
    for (var ch in this.setting.data.min_shindo) {
      if (/^[1-7]$/.test(this.setting.data.min_shindo[ch])) {
        this.min_shindo[ch] = this.setting.data.min_shindo[ch];
      }
      else {
        this.min_shindo[ch] = Quake.default_min_shindo;
      }
    }
  },

  save_setting: function() {
    this.setting.data.global.channels = this.channels.join(",");
    this.setting.data.min_shindo = this.min_shindo;
    this.setting.save();
  }
});

Quake.Console = Class.create({
  initialize: function(channel) {
    this.channel = channel;
  },

  send: function(message) {
    send(this.channel, message);
  },

  action: function(message) {
    action(this.channel, message);
  },

  privmsg: function(message) {
    sendRaw("privmsg " + this.channel + " " + message);
  },

  information: function(message) {
    this.send("[LQN] " + message);
  }
});

Quake.Command = Class.create({
  commands: {
    min: ["[1-7](表示震度の閾値)"], latest: [], boot: [], kill: [], reconnect: []/*, test: []*/
  },

  initialize: function(prefix, channel, text, notifier) {
    var args = text.toLowerCase().split(Quake.arguments_spliter);
    if (args.shift() != Quake.arguments_order_prefix) {
      return;
    }
    this.notifier = notifier;
    this.channel = channel;
    this.owner = (prefix.nick == myNick);
    this.is_boot = this.is_valid_channel(channel);
    this.console = new Quake.Console(channel);
    var order = args.shift();
    if (!order) {
      this.help();
      return;
    }
    if (order == "help") {
      this.help();
      return;
    }
    if (this.commands[order]) {
      if (args.length < this.commands[order].length) {
        this.console.information("コマンドの引数が足りません。 " + Quake.arguments_order_prefix +
                                 Quake.arguments_spliter + "help を参照して下さい");
        return;
      }
      this[order](args);
      return;
    }
    if (!this.is_boot && !this.owner) return;
    this.console.information("コマンドが間違っています。 " + Quake.arguments_order_prefix +
                             Quake.arguments_spliter + "help を参照して下さい");
  },

  is_valid_channel: function(channel) {
    return this.notifier.channels.include(channel);
  },

  test: function() {
    this.notifier.test();
  },

  // quake>boot
  // for owner
  boot: function() {
    if (!this.owner) return;
    if (!this.is_boot) {
      this.notifier.channels.push(this.channel);
      this.console.information("このチャンネルで QuakeNotifier を有効にしました");
      this.notifier.save_setting();
    }
    else {
      this.console.information("すでに有効済みです");
    }
  },

  // quake>kill
  // for owner
  kill: function() {
    if (!this.owner) return;
    if (!this.is_boot) {
      this.help();
      return;
    }
    var index = this.notifier.channels.indexOf(this.channel);
    if (index >= 0) {
      this.notifier.channels.splice(index, 1);
      this.console.information("このチャンネルで QuakeNotifier を無効にしました");
      this.notifier.save_setting();
    }
  },

  // quake>min>[1-7]
  // for owner
  min: function(args) {
    if (!this.owner) return;
    if (!this.is_boot) {
      this.help();
      return;
    }
    if (/^[1-7]$/.test(args[0])) {
      this.notifier.min_shindo[this.channel] = args[0];
      this.console.information("このチャンネルでの閾値を " + args[0] + " 以上にしました");
      this.notifier.save_setting();
    }
    else {
      this.console.information("震度の閾値は 1～7 の間で入力して下さい");
    }
  },

  // quake>latest>&option shindo
  latest: function(args) {
    var min;
    if (args.length == 1 && /^[1-7]$/.test(args[0])) {
      min = args[0];
    }
    else {
      min = (this.notifier.min_shindo[this.channel] ? this.notifier.min_shindo[this.channel] : Quake.default_min_shindo);
    }
    if (this.notifier.latest_summary != "" && this.notifier.latest_detail != "") {
      var detail_messages = this.notifier.get_quak_detail(this.notifier.latest_detail, min);
      if (detail_messages.length > 0) {
        this.console.information(this.notifier.latest_summary)
        detail_messages.each(function(msg) {
          this.console.information(msg);
        }, this);
      }
    }
  },

  // quake>reconnect
  // for owner
  reconnect: function() {
    if (!this.owner) return;
    if (!this.is_boot) {
      this.help();
      return;
    }
    if (!this.notifier.connected) {
      this.console.information("P2P地震情報クライアントに再接続を試みます");
      this.notifier.reconnect();
    }
    else {
      this.console.information("接続済みです");
    }
  },

  // quake>help
  help: function() {
    if (!this.owner) return;
    if (!this.is_boot) {
      this.console.information("このチャンネルで有効にするには " + Quake.arguments_order_prefix +
                               Quake.arguments_spliter + "boot を実行して下さい");
      return;
    }
    var messages = [];
    for (var order in this.commands) {
      msg = Quake.arguments_order_prefix + Quake.arguments_spliter + order;
      if (this.commands[order].length > 0) {
        msg += Quake.arguments_spliter + this.commands[order].join(Quake.arguments_spliter);
      }
      messages.push(msg);
    }
    this.console.send(messages.join(" | ") + " " + (this.notifier.connected ? "接続中" : "未接続"));
  }
});

var quake = null;

function event::onLoad() {
  quake = new Quake.Notifier;
  //quake = new Quake.NotifierTest;
}

function event::onUnload() {
  if (quake) {
    quake.quit();
  }
}

function event::onChannelText(prefix, channel, text) {
  quake.commandline(prefix, channel, text);
}

//
// ファイル名に使えない文字等をエスケープ
//
function escape_filename(filename) {
  var pattern = [[":", "colon"], ["?", "question"], ["/", "slash"]];
  for (var i in pattern) {
    filename = filename.replace(pattern[i][0], pattern[i][1]);
  }
  return encodeURI(filename);
}

socket.js

//
// Socket library
// require: OSWINSOCK.dll
//          http://www.ostrosoft.com/oswinsck.asp
//
var Socket = Class.create({
  STATE: {
    CLOSED: 0, OPEN: 1, LISTENING: 2, CONNECTION_PENDING: 3, RESOLVING_HOST: 4,
    HOST_RESOLVED: 5, CONNECTING: 6, CONNECTED: 7, CLOSING: 8, ERROR: 9
  },

  initialize: function() {
    this.regist_event();
    this.winsock = new ActiveXObject("OSWINSCK.Winsock");
    LimeExt.ConnectObject(this.winsock, this);
  },

  connect: function(host, port) {
    return this.winsock.Connect(host, port);
  },

  close: function() {
    this.winsock.CloseWinsock();
  },

  accept: function(request_id) {
    return this.winsock.Accept(request_id);
  },

  bind: function(local_port, local_ip) {
    if (!local_port) local_port = LimeExt.Empty;
    if (!local_ip) local_ip = LimeExt.Empty;
    return this.winsock.Bind(local_port, local_ip);
  },

  getData: function() {
    return this.winsock.GetDataBuffer();
  },

  getDataBuffer: function() {    // alias getData
    return this.getData();
  },

  listen: function() {
    return this.winsock.Listen();
  },

  sendData: function(data) {
    this.winsock.SendData(data);
  },

  // event handlers
  onClose: function() {},
  onConnect: function() {},
  onConnectionRequest: function(request_id) {},
  onDataArrival: function(bytes_total) {},
  onError: function(number, description, scode, source, help_file, help_context, cancel_display) {
    log("SocketError(" + number + ") : " + description);
  },
  onSendComplete: function() {},
  onSendProgress: function(bytes_sent, bytes_remaining) {},
  onStatusChanged: function(status) {},

  events: ["Close", "Connect", "ConnectionRequest", "DataArrival", "Error", "SendComplete",
           "SendProgress", "StatusChanged"],

  regist_event: function() {
    this.events.each(function(event_name) {
      this["On" + event_name] = function() {
        this["on" + event_name].apply(this, arguments);
      }.bind(this);
    }.bind(this));
  }
});