/ *プロトタイプのJavaScriptフレームワーク、バージョン1.7
 *（C）2005-2010サムスティーブンソン
 *
 *プロトタイプはMITスタイルのライセンスの条件の下で自由に配布です。
 ※詳細については、プロトタイプのWebサイトを参照してください。http://www.prototypejs.org/~~V
 *
 *------------------------------------------------- -------------------------*/

VARプロトタイプ= {

  バージョン：'1 0.7"、

  ブラウザ：（関数（）{
    VAR UA = navigator.userAgent;
    VAR isOpera = Object.prototype.toString.call（window.opera）=='[オブジェクトオペラ]';
    返す{
      IE：！window.attachEvent＆isOpera、！
      オペラ：isOpera、
      WebKitは：ua.indexOf（'AppleWebKit /'）> -1、
      ヤモリ：ua.indexOf（'のGecko"）> -1＆＆ua.indexOf（'KHTML'）=== -1、
      MobileSafari：/アップル.*モバイル/ .test（UA）
    }
  })(),

  BrowserFeatures：{
    XPathは：！、document.evaluate

    SelectorsAPI：！document.querySelector、

    ElementExtensions：（関数（）{
      VARコンストラクタ= window.Element | | window.HTMLElement。
      戻る（コンストラクタ＆＆constructor.prototype）！;
    })(),
    SpecificElementExtensions：（関数（）{
      場合（typeof演算window.HTMLDivElement！=='未定義'）
        trueを返します。

      VAR DIV = document.createElement（'DIV'）、
          フォームは= document.createElement（'form'の）、
          で、IsSupported =偽;

      場合（DIV ['__proto__']＆＆（DIV ['__proto__']！==フォーム['__proto__']））{
        で、IsSupported = TRUE;
      }

      DIV =フォーム= NULL;

      で、IsSupported返します。
    }）（）
  }、

  ScriptFragment："<script[^> ]*>([ \ \ S \ \ sの]*?)< \ /スクリプト>'、
  JSONFilter：/ ^ \ / \ *-セキュア（[\ S \ S] *）\ * \ / \ S * $ /、

  emptyFunction：関数（）{}、

  K：関数（x）は{返すX}
};

場合（Prototype.Browser.MobileSafari）
  Prototype.BrowserFeatures.SpecificElementExtensions =偽;


VARの概要= {};


VARトライ= {
  これらの：関数（）{
    VARは、returnValue;

    （; I <長さは、i + +します。var i = 0、長さ=のarguments.length）{用
      VARラムダ=引数[私];
      してみてください{
        のreturnValue =λ（）;
        破る;
      します} catch（e）{}
    }

    returnValueを返す。
  }
};

/ *アレックスアーネルの継承の実装に基づいて。* /

VARクラス=（関数（）{

  VAR IS_DONTENUM_BUGGY =（関数（）{
    {：（VAR pの{1 ToStringメソッド}）のための
      （P ==='のtoString'）falseを返す場合。
    }
    trueを返します。
  })();

  関数のサブクラス（）{};
  作成する関数（）{
    VAR親= nullの場合、プロパティ= $（引数）;
    場合（Object.isFunction（プロパティ[0]））
      親= properties.shift（）;

    機能klassの（）{
      this.initialize.apply（この、引数）;
    }

    Object.extend（klassの、Class.Methods）;
    klass.superclass =親;
    klass.subclasses = [];

    場合（親）{
      subclass.prototype = parent.prototype;
      klass.prototype =新しいサブクラス。
      parent.subclasses.push（klassの）;
    }

    のための（します。var i = 0、長さ= properties.lengthは、i <長さは、i + +）
      klass.addMethods（特性[I]）;

    するif（！klass.prototype.initialize）
      = Prototype.emptyFunctionをklass.prototype.initialize。

    klass.prototype.constructor = klassの;
    klassを返す。
  }

  関数addMethods（ソース）{
    VAR祖先= this.superclass＆this.superclass.prototype、
        プロパティ= Object.keys（ソース）;

    場合（IS_DONTENUM_BUGGY）{
      場合（source.toString！= Object.prototype.toString）
        properties.push（"ToStringメソッド"）;
      場合（source.valueOf！= Object.prototype.valueOf）
        properties.push（"valueOfの"）;
    }

    （; I <長さは、i + +します。var i = 0、長さ= properties.length）{用
      VARプロパティ=プロパティの[i]は、値=ソース[プロパティ];
      場合（祖先＆Object.isFunction（値）＆＆
          value.argumentNames（）[0] =="$スーパー"）{
        VAR法=値;
        値=（関数（M）{
          return関数（）{戻り祖先[m]の適用（これ、引数）;};
        }）（プロパティ）ラップ（方法）。。

        value.valueOf = method.valueOf.bind（法）;
        value.toString = method.toString.bind（法）;
      }
      this.prototype [プロパティ] =値;
    }

    これを返す;
  }

  返す{
    作成：作成、
    方法：{
      addMethods：addMethods
    }
  };
})();
（関数（）{

  VAR _toString = Object.prototype.toString、
      NULL_TYPE ='NULL'、
      UNDEFINED_TYPE ="未定義"、
      BOOLEAN_TYPE ="ブール"、
      NUMBER_TYPE ='数'、
      STRING_TYPE ='文字列'、
      OBJECT_TYPE ='オブジェクト'、
      FUNCTION_CLASS ='[オブジェクト機能]'、
      BOOLEAN_CLASS ='[オブジェクトブール]'、
      NUMBER_CLASS ='[オブジェクト番号]"、
      STRING_CLASS ='[オブジェクトの文字列]"、
      ARRAY_CLASS ='[オブジェクトの配列]'、
      DATE_CLASS ='[オブジェクトの日付]"、
      NATIVE_JSON_STRINGIFY_SUPPORT = window.JSON＆＆
        typeof演算JSON.stringify ==='関数'＆＆
        JSON.stringify（0）=== '0'＆＆
        typeof演算JSON.stringify（Prototype.K）==='未定義';

  関数のタイプ（O）{
    スイッチ（O）{
      場合は、null：リターンNULL_TYPE;
      ケース（ボイド0）：戻りUNDEFINED_TYPE;
    }
    VARタイプ= typeof演算O;
    スイッチ（タイプ）{
      ケース'ブール'：リターンBOOLEAN_TYPE;
      場合は'number'：リターンNUMBER_TYPE;
      ケース'文字列'：リターンSTRING_TYPE;
    }
    OBJECT_TYPEを返します。
  }

  機能拡張（デスティネーション、ソース）{
    （ソースのvarプロパティ）のための
      デスティネーション[プロパティ] =ソース[プロパティ];
    宛先を返します。
  }

  この関数は、検査（オブジェクト）{
    してみてください{
      リターン'未定義'（（オブジェクト）isUndefined）場合はtrue。
      場合（オブジェクト=== null）を戻り値'NULL';
      object.inspectを返す？object.inspect（）：文字列（オブジェクト）;
    します} catch（e）{
      リターン（電子のinstanceof RangeErrorが）場合'...';
      eを投げる。
    }
  }

  機能toJSON（値）{
    筋力を戻す（''、{''：値}、[]）;
  }

  関数str（キー、ホルダー、スタック）{
    var値=ホルダー[キー]、
        タイプ= typeof演算値;

    場合（タイプ（値）=== OBJECT_TYPE＆＆typeof演算value.toJSON ==='関数'）{
      値= value.toJSON（キー）;
    }

    VAR _class = _toString.call（値）;

    スイッチ（_class）{
      ケースNUMBER_CLASS：
      ケースBOOLEAN_CLASS：
      ケースSTRING_CLASS：
        値= value.valueOf（）;
    }

    スイッチ（値）{
      場合は、null：リターン'NULL';
      真の場合：戻り値は'true';
      偽の場合：戻り値は'false';
    }

    タイプ= typeof演算値;
    スイッチ（タイプ）{
      ケース'文字列'：
        value.inspect（true）を返します。
      場合は'number'：
        かどうかの検査isfinite（値）を返す？文字列（値）：'NULL';
      ケース'オブジェクト'：

        （; I <長さは、i + +します。var i = 0、長さ= stack.length）{用
          （[I] ===値をスタック）で{新しいTypeErrorを（投げる）;}
        }
        stack.push（値）;

        VAR部分= [];
        場合（_class === ARRAY_CLASS）{
          （; I <長さは、i + +します。var i = 0、長さ= value.length）{用
            VAR STR = STR（I、値、スタック）;
            partial.push（typeof演算STR ==='未定義'NULL'：？文字列）;
          }
          部分的='['+ partial.join (',') +']';
        }他{
          VARキー= Object.keys（値）;
          （; I <長さは、i + +します。var i = 0、長さ= keys.length）{用
            VARキー=キー[i]は、STR = STR（キー、値、スタック）;
            場合（typeof演算strに！=="未定義"）{
               partial.push（key.inspect（真）+'：'+ STR）;
             }
          }
          部分的='{'+ partial.join (',') +'}';
        }
        stack.pop（）;
        部分的に返す。
    }
  }

  ファンクション文字列化（オブジェクト）{
    JSON.stringify（オブジェクト）を返します。
  }

  関数toQueryString（オブジェクト）{
    Hは、（オブジェクト）$を??返すtoQueryString（）;
  }

  機能toHTML（オブジェクト）{
    オブジェクト＆object.toHTML返す？object.toHTML（）：String.interpret（オブジェクト）;
  }

  ファンクションキー（オブジェクト）{
    場合（タイプ（オブジェクト）== OBJECT_TYPE！）{新しいTypeError（）を投げる;}
    VARの結果= [];
    {（オブジェクトのvarプロパティ）のための
      場合（object.hasOwnProperty（プロパティ））{
        results.push（プロパティ）;
      }
    }
    結果を返す。
  }

  関数値（オブジェクト）{
    VARの結果= [];
    （オブジェクトのvarプロパティ）のための
      results.push（オブジェクト[プロパティ]）;
    結果を返す。
  }

  関数のクローン（オブジェクト）{
    （{}、オブジェクト）を拡張して返します。
  }

  関数isElement（オブジェクト）{
    リターン（オブジェクト＆＆object.nodeType == 1）！;
  }

  機能IsArray関数（オブジェクト）{
    _toString.call（オブジェクト）=== ARRAY_CLASSを返します。
  }

  VAR hasNativeIsArray =（typeof演算Array.isArray =='関数'）
    ＆＆Array.isArray（[]）＆＆！Array.isArray ({});

  場合（hasNativeIsArray）{
    IsArray関数は= Array.isArray。
  }

  機能isHash（オブジェクト）{
    オブジェクトのinstanceofのハッシュを返します。
  }

  関数isFunction（オブジェクト）{
    _toString.call（オブジェクト）=== FUNCTION_CLASSを返します。
  }

  機能isString（オブジェクト）{
    _toString.call（オブジェクト）=== STRING_CLASSを返します。
  }

  関数ISNUMBER（オブジェクト）{
    _toString.call（オブジェクト）=== NUM??BER_CLASSを返します。
  }

  機能ISDATE（オブジェクト）{
    _toString.call（オブジェクト）=== DATE_CLASSを返します。
  }

  isUndefined機能（オブジェクト）{
    ==="未定義"typeof演算のオブジェクトを返します。
  }

  拡張（オブジェクト、{
    拡張：拡張する、
    検査：検査、
    toJSON：NATIVE_JSON_STRINGIFY_SUPPORT？文字列化取得：toJson、
    toQueryString：toQueryString、
    toHTML：toHTML、
    キー：Object.keys | |キー、
    値：値は、
    クローン：クローン、
    isElement：isElement、
    IsArray関数：IsArray関数、
    isHash：isH??ash、
    isFunction：isFunction、
    isString：isString、
    ISNUMBER：ISNUMBER、
    ISDATE：ISDATE、
    isUndefined：isUndefined
  }）;
})();
Object.extend（Function.prototype、（関数（）{
  VARスライス= Array.prototype.slice;

  機能アップデート（配列、引数）{
    VAR arrayLength = array.length以下、長さ= args.length;
    一方、（長さ - ）配列[arrayLength +長さ] =引数[長さ];
    配列を返す。
  }

  機能マージ（配列、引数）{
    配列= slice.call（配列、0）;
    アップデート（配列、引数）を返します。
  }

  関数argumentNamesが（）{
    VAR名= this.toString（）。一致（/ ^ [\ S \（] *機能[^(]* \ (([^)]*) \）/）[1]
      された。replace（/ \ / \ /.*?[ \ r \ nを] | \ / \ *(?:.|[ \ r \ nを]）？* \ * \ / / gで、''）
      された。replace（/ \ S + / G、''）。分割(',');
    戻りnames.length == 1＆＆！名[0]？[]：名;
  }

  関数のバインド（コンテキスト）{
    （のarguments.length <2＆＆Object.isUndefined（引数[0]））は、これを返す場合。
    VAR __method =この場合は、args = slice.call（引数、1）;
    return関数（）{
      VAR =マージ（引数、引数）;
      __method.applyを（コンテキスト）を返す。
    }
  }

  関数bindAsEventListener（コンテキスト）{
    VAR __method =この場合は、args = slice.call（引数、1）;
    return関数（イベント）{
      VAR =更新（[イベント| | window.event]、args）を;
      __method.applyを（コンテキスト）を返す。
    }
  }

  機能のカレー（）{
    （！のarguments.length）、これを返す場合。
    VAR __method =この場合は、args = slice.call（引数、0）;
    return関数（）{
      VAR =マージ（引数、引数）;
      （これ、）__method.apply返します。
    }
  }

  関数遅延（タイムアウト）{
    VAR __method =この場合は、args = slice.call（引数、1）;
    タイムアウト=タイムアウト* 1000;
    window.setTimeoutを（関数（）{返す
      __method.applyを（__method、args）を返します。
    }、タイムアウト）;
  }

  機能延期（）{
    可変引数=更新（[0.01]、引数）;
    （これは、args）this.delay.apply返します。
  }

  関数のラップ（ラッパー）{
    VAR __method =この;
    return関数（）{
      VAR =更新（[__method.bind（この）]、引数）;
      （これ、）wrapper.apply返します。
    }
  }

  関数方式化する（）{
    （this._methodized）this._methodized返す場合。
    VAR __method =この;
    this._methodized =関数（）{返す
      VAR =更新（[この]、引数）;
      __method.applyを（null、）を返す。
    };
  }

  返す{
    argumentNamesが：argumentNamesが、
    バインド：バインド、
    bindAsEventListener：bindAsEventListener、
    カレー：カレー、
    遅延：遅延、
    延期：延期、
    ラップ：ラップ、
    順序だてる：秩序だてる
  }
})());



（関数（プロト）{


  関数toISOString（）{
    （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';
  }


  機能toJSON（）{
    this.toISOString（）を返す。
  }

  場合proto.toISOString = toISOString（proto.toISOString！）;
  （！proto.toJSON）proto.toJSON = toJSON場合はtrue。

}）（Date.prototype）;


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

RegExp.escape =関数（文字列）{
  返される文字列（文字列）(/([.*+?^=!:${}()|[を置き換える\] \ / \ \]）/ G、'\ \ $ 1'）;
};
VAR PeriodicalExecuter = Class.create（{
  初期化：関数（コールバック、周波数）{
    this.callback =コールバック;
    this.frequency =周波数;
    this.currentlyExecuting =偽;

    this.registerCallback（）;
  }、

  registerCallback：関数（）{
    this.timer =をsetInterval（this.onTimerEvent.bind（この）、this.frequency * 1000）;
  }、

  実行機能（）{
    this.callback（この）;
  }、

  ストップ：関数（）{
    （！this.timer）復帰場合はtrue。
    てclearInterval（this.timer）;
    this.timer = NULL;
  }、

  onTimerEvent：関数（）{
    するif（！this.currentlyExecuting）{
      してみてください{
        =真this.currentlyExecuting;
        this.execute（）;
        this.currentlyExecuting =偽;
      します} catch（e）{
        this.currentlyExecuting =偽;
        eを投げる。
      }
    }
  }
}）;
Object.extend（文字列、{
  解釈：関数（値）{
    戻り値== nullの？''：文字列（値）;
  }、
  SPECIALCHAR：{
    '\ B'：'\ \ b'は、
    '\ t'を'\ \ t'を、
    の'\ n'：'\ \ n'は、
    "\ f'は'\ \ f'は、
    の'\ r'：'\ \ r'が、
    '\ \'：'\ \ \ \'
  }
}）;

Object.extend（String.prototype、（関数（）{
  VAR NATIVE_JSON_PARSE_SUPPORT = window.JSON＆＆
    typeof演算JSON.parse ==='関数'＆＆
    JSON.parse（'{"テスト"：真}'）テスト;。

  関数prepareReplacement（交換）{
    （Object.isFunction（交換））戻り交換する場合はtrue。
    VARテンプレート=新しいテンプレート（置換）;
    リターン機能（一致）{戻りtemplate.evaluate（一致）};
  }

  機能なくすgsub（パターン、置換）{
    VAR結果= ''、ソース=この、一致する。
    交換= prepareReplacement（交換）;

    場合（Object.isString（パターン））
      パターン= RegExp.escape（パターン）;

    場合（（pattern.length |！| pattern.source））{
      交換=交換('');
      戻り交換+ source.split ('').結合（交換）+交換。
    }

    一方、（source.length> 0）{
      {（= source.match（パターン）と一致している）場合
        結果+ = source.slice（0、match.index）;
        結果+ = String.interpret（置換（マッチ））;
        ソース= source.slice（match.index +マッチ[0]の長さ。）;
      }他{
        結果+ =ソース、ソース= '';
      }
    }
    結果を返す。
  }

  関数sub（パターン、置換、回数）{
    交換= prepareReplacement（交換）;
    （カウント）= Object.isUndefinedを数える？1：カウント;

    this.gsubを（パターン、機能（マッチ）{返す
      場合（ - カウント<0）のリターンマッチ[0];
      リターンの交換（一致）;
    }）;
  }

  機能スキャン（パターン、イテレータ）{
    this.gsub（パターン、イテレータ）;
    返される文字列（この）;
  }

  関数truncate（長さ、切り捨て）{
    長さ=長さ| | 30;
    切り捨て= Object.isUndefined（切り捨て）？'...' ：切り捨て;
    this.length>長さを返す？
      this.slice（0、長さ - truncation.length）+切り捨て：文字列（この）;
  }

  関数のストリップ（）{
    this.replaceを返す（/ ^ \ S + /、''）に置き換える（/ \ S + $ /、''）;
  }

  関数stripTags（）{
    （/ <\ w +は（\ S +("[^"]*"|'[^']*'|[^>])+)?>|< \ / \ w +は> / GI、'' this.replaceを返す）;
  }

  関数stripScripts（）{
    this.replaceを（新しい正規表現（Prototype.ScriptFragment、'IMG'）、''）を返します。
  }

  関数extractScripts（）{
    VAR matchAll =新しい正規表現（Prototype.ScriptFragment、'IMG'）、
        matchOne =新しい正規表現（Prototype.ScriptFragment、'IM'）;
    リターン（this.match（matchAll）| | []）。マップ（関数（scriptTag）{
      リターン（scriptTag.match（matchOne）| | [''、''])[ 1];
    }）;
  }

  関数evalScripts（）{
    戻りthis.extractScripts（）マップ（関数（スクリプト）{evalの戻り値（スクリプト）}）;
  }

  機能のescapeHTML（）{
    （/＆/ gの,'&').置き換える（/ </ gの,'<').が置き換える（/> / gの,'>'); this.replaceを返す
  }

  関数unescapeHTML（）{
    戻りthis.stripTagsは（）。（/ </ gの,'<').置き換える（/> / gの,'>').が（/＆/ gの,'&');置き換えを交換してください
  }


  関数toQueryParams（セパレータ）{
    VAR一致= this.strip（）。一致(/([^?#]*)(#.*)?$/);
    場合、戻り{}（マッチ！）;

    。| '&').注入（{}は、関数（ハッシュ、ペア）{| [1]スプリット（区切り文字と一致返す
      場合（（ペア= pair.split ('='))[ 0]）{
        VARキー=は、decodeURIComponent（pair.shift（））、
            値= pair.length> 1？pair.join ('=')：ペア[0];

        場合（値=不定と！）値=は、decodeURIComponent（値）;

        {（ハッシュのキー）場合
          ならハッシュ[キー] = [ハッシュ[キー]]（Object.isArray（ハッシュ[キー]）！）;
          ハッシュ[キー]プッシュ（値）;
        }
        他のハッシュ[キー] =値;
      }
      ハッシュを返す。
    }）;
  }

  関数れたToArray（）{
    this.splitを返す('');
  }

  機能SUCC（）{
    this.sliceを（0、this.length - 1）を返す+
      String.fromCharCode（this.charCodeAt（this.length - 1）+ 1）;
  }

  関数の時間（回数）{
    <1をカウント返す？''：新しい配列（+ 1カウント）に参加（この）;。
  }

  機能camelize（）{
    this.replace (/-+(.)?/ G、機能を（マッチ、CHR）{返す
      CHRを返す？chr.toUpperCase（）：'';
    }）;
  }

  この関数は、{）（大文字
    this.charAt（0）を返しますtoUpperCaseのを（）+これはthis.substring（1）toLowerCase（）。。。
  }

  この関数は、{）（アンダースコア
    this.replace (/::/ G、'/'）を返す
               された。replace（/（[AZ ]+)([ AZ] [AZ]）/ gの'$ 1_ $ 2'）
               された。replace（/（[AZ \ D]）（[AZ]）/ gの'$ 1_ $ 2'）
               された。replace（/ - / G、'_'）
               。toLowerCase（）;
  }

  機能dasherize（）{
    戻りthis.replace（/ _ / gの'-');
  }

  この関数は、{（useDoubleQuotes）検査
    VAR escapedString = this.replace（/ [\ x00を、\ X1F \ \] / gで、機能（文字）{
      {（String.specialCharの文字）であれば
        String.specialChar [文字]を返す。
      }
      。リターン'\ \ U00"+ character.charCodeAt（）toPaddedString（2、16）;
    }）;
    （useDoubleQuotes）リターン'"'+ escapedString.replace（/"IF / G、'\ \"'）+'"';
    "'"を返す+ escapedString.replace（/'/ G、'\ \ \ ''）+"'";
  }

  function unfilterJSON（フィルター）{
    this.replaceを返す（フィルタ| | Prototype.JSONFilter、'$ 1'）;
  }

  関数の前の処理（）{
    VAR strは=この;
    （str.blank（））falseを返す場合。
    STR = str.replace（/ \ \ (?:[" \ \ \ / bfnrt] | U [0 - 9A - Fa - f]と{4}）/ G、'@');
    strは= str.replace (/"[^" \ \ \ nを\ r]を*"|真|偽|ヌル| - \ D +（：？？。\ \ dは*)?(?:[ EE] [+ \ - ？] \ D +）/ gの']');
    strは= str.replace (/(?:^|:|,)(?: \ S * \ [）+ / G、''）;
    リターン（/ ^ [\ ],:{} \ S ]*$/).テスト（STR）;
  }

  機能evalJSON（サニタイズ）{
    VAR JSON = this.unfilterJSON（）、
        CX =
    場合（cx.test（JSON））{
      JSON = json.replace（CX、関数（）{
        リターン'\ \ U'+（'0000'+ a.charCodeAt（0）のtoString（16）。）スライス（-4）;
      }）;
    }
    してみてください{
      場合（サニタイズ|！| json.isJSON（））を返すでeval（'（'+ JSON + ')');
    します} catch（e）{}
    ;：新しいSyntaxErrorを（+ this.inspect（）'不正な形式のJSON文字列'）投げる
  }

  機能parseJSON（）{
    VAR JSON = this.unfilterJSON（）;
    JSON.parse（JSON）を返します。
  }

  機能としては、（パターン）{
    this.indexOf（パターン）> -1を返します。
  }

  機能STARTSWITH（パターン）{
    リターンthis.lastIndexOf（パターン、0）=== 0;
  }

  機能endsWith（パターン）{
    VAR D = this.length - pattern.length。
    リターンD> = 0＆＆this.indexOf（パターン、D）=== D;
  }

  空の関数（）{
    このを返す== '';
  }

  関数空白（）{
    。リターン/ ^ \ S * $ /テスト（この）;
  }

  関数補間（オブジェクト、パターン）{
    新しいテンプレートを返す（これ、パターン）を評価する（オブジェクト）;
  }

  返す{
    GSUB：GSUB、
    サブ：サブ、
    スキャン：スキャン、
    TRUNCATE：TRUNCATE、
    ストリップ：String.prototype.trim | |ストリップ、
    stripTags：stripTags、
    stripScripts：stripScripts、
    extractScripts：extractScripts、
    evalScripts：evalScripts、
    escapeHTML：escapeHTML、
    unescapeHTML：unescapeHTML、
    toQueryParams：toQueryParams、
    parseQuery：toQueryParams、
    れたToArray取得：toArray、
    SUCC：SUCC、
    時間：時間、
    camelize：camelize、
    大文字：大文字、
    アンダー：アンダースコア、
    dasherize：dasherize、
    検査：検査、
    unfilterJSON：unfilterJSON、
    前の処理：前の処理、
    evalJSON：NATIVE_JSON_PARSE_SUPPORT？parseJSON：evalJSON、
    次のとおり含まれ、
    STARTSWITH：STARTSWITH、
    endsWith：endsWith、
    空：空、
    空白：空白、
    補間：補間
  };
})());

VARテンプレート= Class.create（{
  初期化：機能（テンプレート、パターン）{
    this.template = template.toString（）;
    this.pattern =パターン| | Template.Pattern。
  }、

  評価：関数（オブジェクト）{
    場合（オブジェクト＆Object.isFunction（object.toTemplateReplacements））
      オブジェクト= object.toTemplateReplacements（）;

    this.template.gsub（this.pattern、ファンクション（試合を）{返す
      （オブジェクト== null）を返す場合（[1]と一致+ ''）;

      VARの前に=マッチ[1] | | '';
      場合（==の前に'\ \'）のリターンマッチ[2];

      VAR CTX =オブジェクト、exprは=マッチ[3]、
          パターン= /^([^.[]+| \ [((?:.*?[^ \ \]））\]）（\ |？\ [|$)/;

      一致= pattern.exec（式）;
      リターンの前に（== nullを一致させる）場合はtrue。

      一方（マッチ！= NULL）{
        VARカンプ= [1]と一致する。STARTSWITH ('[')？。置き換える（/ \ \ \ \] / gで、']'）[2]と一致する：[1を一致させる];
        CTX = CTX [COMP];
        場合（ヌル== CTX | | '' == [3]と一致）破る。
        式expr = expr.substring（？。。'['==マッチ[3] [1を一致させる]長さ：一致する[0]の長さ）;
        一致= pattern.exec（式）;
      }

      返す前に+ String.interpret（CTX）;
    }）;
  }
}）;
Template.Pattern = /(^|.|に\ r | \ n）を（＃\ {(.*?) \}）/;

$ varにブレーク= {};

VAR Enumerableの=（関数（）{
  それぞれを（イテレータ、コンテキスト）{関数
    VARインデックス= 0;
    してみてください{
      this._each（関数（値）{
        iterator.call（コンテキスト、値、インデックス+ +）;
      }）;
    します} catch（e）{
      場合（E = $ブレイク！）のeを投げる。
    }
    これを返す;
  }

  関数eachSlice（数、反復子、文脈）{
    VARインデックス=番号、スライス= []、配列= this.toArray（）;
    （数<1）の戻り配列の場合;
    一方、（（インデックス+ =番号）<array.length以下）
      slices.push（array.slice（インデックス、インデックス+番号））;
    slices.collect（イテレータ、コンテキスト）を返します。
  }

  すべて（イテレータ、コンテキストを）{関数
    イテレータ=イテレータ| | Prototype.K。
    VAR結果=真;
    this.each（関数（値、指数）{
      ！結果=結果＆＆iterator.call（コンテキスト、値、インデックス）;
      （！結果）ブレーク$をスローする場合;
    }）;
    結果を返す。
  }

  いずれかを（イテレータ、コンテキスト）{関数
    イテレータ=イテレータ| | Prototype.K。
    VAR結果=偽;
    this.each（関数（値、指数）{
      場合（結果=！iterator.call（コンテキスト、値、指数））
        ブレーク$を投げる。
    }）;
    結果を返す。
  }

  この関数は、{（イテレータ、コンテキスト）の収集
    イテレータ=イテレータ| | Prototype.K。
    VARの結果= [];
    this.each（関数（値、指数）{
      results.push（iterator.call（コンテキスト、値、インデックス））;
    }）;
    結果を返す。
  }

  機能検出（イテレータ、コンテキスト）{
    VARの結果;
    this.each（関数（値、指数）{
      場合（iterator.call（コンテキスト、値、指数））{
        =値を生じる。
        ブレーク$を投げる。
      }
    }）;
    結果を返す。
  }

  関数findAllの（反復子、文脈）{
    VARの結果= [];
    this.each（関数（値、指数）{
      場合（iterator.call（コンテキスト、値、指数））
        results.push（値）;
    }）;
    結果を返す。
  }

  機能はgrep（フィルタ、イテレータ、コンテキスト）{
    イテレータ=イテレータ| | Prototype.K。
    VARの結果= [];

    場合（Object.isString（フィルタ））
      フィルタ=新しい正規表現（RegExp.escape（フィルタ））;

    this.each（関数（値、指数）{
      場合（filter.match（値））
        results.push（iterator.call（コンテキスト、値、インデックス））;
    }）;
    結果を返す。
  }

  機能としては、（オブジェクト）{
    場合（Object.isFunction（this.indexOf））
      （！this.indexOf（オブジェクト）= -1）はtrueを返す場合。

    varは= falseを発見した。
    this.each（関数（値）{
      場合（値==オブジェクト）{
        = trueを発見した。
        ブレーク$を投げる。
      }
    }）;
    見つかった返します。
  }

  機能inGroupsOf（数値、fillWith）{
    fillWith = Object.isUndefined（fillWith）？ヌル：fillWith;
    戻りthis.eachSlice（番号、機能（スライス）{
      一方、（slice.length <番号）slice.push（fillWith）;
      スライスを返します。
    }）;
  }

  注入の機能（メモ、反復子、文脈）{
    this.each（関数（値、指数）{
      メモ= iterator.call（コンテキスト、メモ、値、インデックス）;
    }）;
    メモを返します。
  }

  この関数は、{（メソッド）を呼び出す
    。可変引数は= $ A（引数）スライス（1）;
    戻りthis.map（関数（値）{
      値を返す[方法]適用（値は、args）;
    }）;
  }

  関数max（イテレータ、コンテキスト）{
    イテレータ=イテレータ| | Prototype.K。
    VARの結果;
    this.each（関数（値、指数）{
      値= iterator.call（コンテキスト、値、インデックス）;
      場合（== NULLの結果| |値> =結果を）
        =値を生じる。
    }）;
    結果を返す。
  }

  関数min（イテレータ、コンテキスト）{
    イテレータ=イテレータ| | Prototype.K。
    VARの結果;
    this.each（関数（値、指数）{
      値= iterator.call（コンテキスト、値、インデックス）;
      場合（== NULLの結果| |値<結果）
        =値を生じる。
    }）;
    結果を返す。
  }

  機能のパーティション（イテレータ、コンテキスト）{
    イテレータ=イテレータ| | Prototype.K。
    VAR trues = []、falses = [];
    this.each（関数（値、指数）{
      （iterator.call（コンテキスト、値、インデックス）？
        trues：falses）プッシュ（値）;。
    }）;
    リターン[trues、falses];
  }

  この関数は、{（プロパティ）を取り出さなけれ
    VARの結果= [];
    this.each（関数（値）{
      results.push（値[プロパティ]）;
    }）;
    結果を返す。
  }

  この関数は、{（イテレータ、コンテキスト）拒絶する
    VARの結果= [];
    this.each（関数（値、指数）{
      するif（！iterator.call（コンテキスト、値、指数））
        results.push（値）;
    }）;
    結果を返す。
  }

  機能動画数（反復子、文脈）{
    戻りthis.map（関数（値、指数）{
      返す{
        値：値、
        基準：iterator.call（コンテキスト、値、指数）
      };
    }）。ソート（関数（左、右）{
      VAR = left.criteria、B = right.criteria;
      <bを返す？-1：A> B？1：0;
    }）摘む（'値'）;
  }

  関数れたToArray（）{
    this.map（）を返す。
  }

  関数のzip（）{
    VARイテレータ= Prototype.Kは、args = $ A（引数）;
    場合（Object.isFunction（args.last（）））
      イテレータ= args.pop（）;

    。。VARコレクションには、= [この]のconcat（args）を地図（$）;
    戻りthis.map（関数（値、指数）{
      戻りイテレータ（collections.pluck（インデックス））;
    }）;
  }

  関数size（）{
    this.toArrayを（）を返す長さ。
  }

  機能検査（）{
    戻る'＃<Enumerable:' + this.toArray().inspect() + '>';
  }









  返す{
    各：各、
    eachSlice：eachSlice、
    すべて：すべての、
    毎：すべて、
    any：任意の、
    いくつか：任意、
    収集：収集、
    マップ：収集、
    検出：検出、
    findAllの：findAllの、
    選択：findAllの、
    フィルタ：findAllの、
    grepは：grepは、
    次のとおり含まれ、
    メンバー：インクルード、
    inGroupsOf：inGroupsOf、
    注入：注入、
    起動する：起動する、
    最大：最大、
    分：分、
    パーティション：パーティション、
    摘み取る：摘み取る、
    拒否：拒否、
    動画数：動画数、
    れたToArray取得：toArray、
    エントリの取得：toArray、
    郵便番号：郵便番号、
    サイズ：サイズ、
    検査：検査、
    見つける：検出
  };
})();

A $を（イテレート）{関数
  場合、戻り[]（イテレーション可能！）;
  場合（オブジェクトの"されたToArray"（イテレーション可能オブジェクト））リターンiterable.toArray（）;
  VARの長さ= iterable.length | | 0、結果=新しい配列（長さ）;
  一方、（長さ - ）結果[長さ] =イテラブル[長さ];
  結果を返す。
}


関数$ W（文字列）{
  場合、戻り[]（Object.isString（文字列）！）;
  文字列= string.strip（）;
  文字列を返す？string.split（/ \ S + /）：[];
}

Array.from = $;


（関数（）{
  VAR arrayProto = Array.prototypeを、
      スライス= arrayProto.slice、
      _each = arrayProto.forEach; / /使用するネイティブブラウザJS 1.6実装可能な場合

  それぞれを（イテレータ、コンテキスト）{関数
    のための（します。var i = 0、長さ= this.length>>> 0は、i <長さは、i + +）{
      場合、（私はこれで）iterator.call（コンテキスト、この[i]は、私、この）;
    }
  }
  _each =各（！_each）場合はtrue。

  クリア機能（）{
    this.length = 0;
    これを返す;
  }

  関数は最初（）{
    この[0]を返します。
  }

  最後の関数（）{
    この[が、this.length - 1]を返します。
  }

  機能コンパクト（）{
    戻りthis.select（関数（値）{
      値を返す= nullを！;
    }）;
  }

  機能平坦化（）{
    （[]、関数（配列、値）{this.injectを返す
      場合（Object.isArray（値））
        array.concatを（（をvalue.flatten））を返す。
      array.push（値）;
      配列を返す。
    }）;
  }

  ない関数（）{
    VARの値= slice.call（引数、0）;
    戻りthis.select（関数（値）{
      ！返りvalues??.include（値）;
    }）;
  }

  関数の逆（インライン）{
    リターン（インライン===偽this.toArray（）：この？）_reverse（）;。
  }

  機能uniqは（ソート）{
    （[]、関数（配列、値、インデックス）{this.injectを返す
      場合（0 ==インデックス| |（ソートarray.last（）=値：？！array.include（値）））
        array.push（値）;
      配列を返す。
    }）;
  }

  この関数は、交差する（配列）{
    this.uniqを（）を返す。findAllの（関数（アイテム）{
      array.detect（関数（値）{戻りアイテム===値}）を返す。
    }）;
  }


  関数のクローン（）{
    slice.call（この、0）を返す。
  }

  関数size（）{
    this.lengthを返します。
  }

  機能検査（）{
    戻る'['+ this.map（Object.inspect）に参加（'、'）+']';
  }

  機能indexOfを（項目は、i）{
    私は| |（I = 0）;
    VARの長さ= this.length;
    場合（I <0）はi =長さ+ I;
    のための（; I <長さは、i + +）
      （この[I] ===アイテム）iを返す場合。
    戻り値-1;
  }

  機能lastIndexOfでも、（項目は、i）{
    私は= isNaNは（i）は？this.length：（？I <0 this.length + I：）+ 1;
    。。VAR N = this.slice（0、i）は逆（）indexOfを（項目）;
    リターン（n <0の場合）？N：I - N - 1;
  }

  関数concat（）{
    VAR配列= slice.call（この、0）、項目;
    （; I <長さは、i + +します。var i = 0、長さ=のarguments.length）{用
      項目=引数[私];
      場合（Object.isArray（アイテム）＆＆！（アイテムの"呼び出し先"））{
        （; J <arrayLength、J + + VAR J = 0、arrayLength = item.length）用
          array.push（アイテム[J]）;
      }他{
        array.push（項目）;
      }
    }
    配列を返す。
  }

  Object.extend（arrayProto、Enumerableの）;

  するif（！arrayProto._reverse）
    arrayProto._reverse = arrayProto.reverse;

  Object.extend（arrayProto、{
    _each：_each、
    クリア：透明な、
    First：最初、
    最後：最後に、
    コンパクト：コンパクト、
    フラット：平ら、
    なし：なし、
    リバース：逆、
    uniqは：uniqを、
    交差：交差する、
    クローン：クローン、
    れたToArray：クローン、
    サイズ：サイズ、
    検査：検査
  }）;

  VAR CONCAT_ARGUMENTS_BUGGY =（関数（）{
    リターン[]のconcat（引数）[0] [0] == 1。！;
  }）（1,2）

  arrayProto.concat = CONCAT（CONCAT_ARGUMENTS_BUGGY）場合はtrue。

  場合arrayProto.indexOf = indexOfを（arrayProto.indexOf！）;
  （！arrayProto.lastIndexOf）arrayProto.lastIndexOf = lastIndexOfでも場合はtrue。
})();
関数$ H（オブジェクト）{
  新しいハッシュ（オブジェクト）を返します。
};

VARハッシュ= Class.create（Enumerableの、（関数（）{
  機能の初期化（オブジェクト）{
    this._object = Object.isHash（オブジェクト）？object.toObject（）：Object.clone（オブジェクト）;
  }


  機能_each（イテレータ）{
    {（this._objectのvarキー）のための
      var値= this._object [キー]、ペア= [キー、値];
      pair.key =キー。
      pair.value =値;
      イテレータ（ペア）;
    }
  }

  ファンクションセット（キー、値）{
    this._object [キー] =値を返します。
  }

  この関数は、{（キー）を取得
    場合（this._object [キー]！== Object.prototype [キー]）
      this._objectを返す[キー];
  }

  ファンクション設定解除（キー）{
    var値= this._object [キー];
    削除this._object [キー];
    値を返す。
  }

  機能toObject（）{
    Object.clone（this._object）を返します。
  }



  ファンクションキー（）{
    this.pluckを（'key'）を返します。
  }

  関数値（）{
    this.pluckを（'value'）を返します。
  }

  関数インデックス（値）{
    varはマッチ= this.detect（機能（ペア）{
      pair.value ===値を返します。
    }）;
    返し＆＆match.key一致。
  }

  機能マージ（オブジェクト）{
    this.clone（）を返すアップデート（オブジェクトは）。
  }

  機能アップデート（オブジェクト）{
    新しいハッシュ（オブジェクト）を返します。（これは、関数を（結果、ペア）{注入
      result.set（pair.key、pair.value）;
      結果を返す。
    }）;
  }

  ファンクションtoQueryPair（キー、値）{
    場合（Object.isUndefined（値））リターンキー。
    鍵を返す+'='+ encodeURIComponent（String.interpret（値））;
  }

  関数toQueryString（）{
    （[]、関数（結果、ペア）{this.injectを返す
      VARキー= encodeURIComponent（pair.key）、値は= pair.value;

      場合（値＆＆typeof演算値=='オブジェクト'）{
        場合（Object.isArray（値））{
          VAR queryValues?? = [];
          のための（します。var i = 0、lenは= values??.length、値は、i <lenのは、i + +）{
            値=値[i]の;
            queryValues??.push（toQueryPair（キー、値））;
          }
          リターンresults.concat（queryValues??）;
        }
      }他results.push（toQueryPair（キー、値））;
      結果を返す。
    }）。加入('&');
  }

  機能検査（）{
    戻る'＃<ハッシュ：{'+ this.map（関数（ペア）{
      pair.map（Object.inspect）を返すに参加（'：'）;
    }）。（'、'）+ '}>';に参加
  }

  関数のクローン（）{
    新しいハッシュを（これ）を返す。
  }

  返す{
    初期化：初期化、
    _each：_each、
    セット：セット、
    取得：取得、
    未設定??：設定されていない、
    toObject：toObject、
    toTemplateReplacements：toObject、
    キー：キー、
    値：値は、
    インデックス：インデックス、
    マージ：マージ、
    アップデート：アップデート、
    toQueryString：toQueryString、
    検査：検査、
    toJSON：toObject、
    クローン：クローン
  };
})());

Hash.from = $ H;
Object.extend（Number.prototype、（関数（）{
  関数toColorPart（）{
    リターンthis.toPaddedString（2、16）;
  }

  機能SUCC（）{
    この+ 1を返す。
  }

  関数時間（反復子、文脈）{
    $ R（0、この、真）各（イテレータ、コンテキスト）;
    これを返す;
  }

  関数toPaddedString（長さ、基数）{
    VAR文字列= this.toString（基数| | 10）;
    。'0'倍（長さ - string.length以下）を返す+文字列を;
  }

  関数abs（）{
    Math.abs（this）を返す。
  }

  関数round（）{
    Math.round（this）を返す。
  }

  関数CEIL（）{
    Math.ceil（this）を返す。
  }

  関数floor（）{
    数学。床（this）を返す。
  }

  返す{
    toColorPart：toColorPart、
    SUCC：SUCC、
    時間：時間、
    toPaddedString：toPaddedString、
    ABS：ABS、
    ラウンド：ラウンド、
    CEIL：CEIL、
    床：床
  };
})());

関数$ R（開始、終了、排他的）{
  新しいは、ObjectRangeを（開始、終了、排他的な）を返す。
}

VARは、ObjectRange = Class.create（Enumerableの、（関数（）{
  機能の初期化（開始、終了、排他的）{
    this.start =開始。
    this.end =終了;
    this.exclusive =排他的;
  }

  機能_each（イテレータ）{
    var値= this.start;
    一方、（this.include（値））{
      イテレータ（値）;
      値= value.succ（）;
    }
  }

  機能としては、（値）{
    場合（<this.start値）
      falseを返します。
    場合（this.exclusive）
      値<this.endを返します。
    値を返す<= this.end;
  }

  返す{
    初期化：初期化、
    _each：_each、
    次のとおり含まれ
  };
})());



VARアヤックス= {
  getTransport：関数（）{
    （Try.theseを返す
      この関数は、（）、{新しいXMLHttpRequest（）を返す}
      関数（）{新しいActiveXObjectを（'MSXML2.XMLHTTP'）を返す}、
      関数（）{新しいActiveXObjectを（"Microsoft.XMLHTTP"）を返す}
    ）| |偽;
  }、

  activeRequestCount：0
};

Ajax.Responders = {
  回答者：[]、

  _each：機能（イテレータ）{
    this.responders._each（イテレータ）;
  }、

  レジスタ：関数（応答者）{
    するif（！this.include（応答者））
      this.responders.push（応答者）;
  }、

  解除：機能（応答者）{
    this.responders = this.responders.without（応答者）;
  }、

  ディスパッチ：関数（コールバック、リクエスト、輸送、JSON）{
    this.each（関数（応答者）{
      場合（Object.isFunction（レスポンダー[コールバック]））{
        してみてください{
          応答者[コールバック]（レスポンダー、[要求、輸送、JSON]）を適用する。
        します} catch（e）{}
      }
    }）;
  }
};

Object.extend（Ajax.Responders、Enumerableの）;

Ajax.Responders.register（{
  OnCreate関数：関数（）{Ajax.activeRequestCount + +}、
  onCompleteの：関数（）{Ajax.activeRequestCount -  - }
}）;
Ajax.Base = Class.create（{
  初期化：機能（オプション）{
    this.options = {
      方法：'POST'、
      非同期：真、
      のcontentType："アプリケーション/ x - www - form - urlencodedで"、
      エンコーディング："UTF - 8'、
      パラメータ：''、
      evalJSON：真、
      evalJS：真
    };
    Object.extend（this.options、オプション| | {}）;

    this.options.method = this.options.method.toLowerCase（）;

    場合（Object.isHash（this.options.parameters））
      this.options.parameters = this.options.parameters.toObject（）;
  }
}）;
担うAjax.Request = Class.create（Ajax.Base、{
  _complete：偽、

  初期化：関数（$超、URL、オプション）{
    スーパー$（オプション）;
    this.transport = Ajax.getTransport（）;
    this.request（URL）;
  }、

  リクエスト：機能（URL）{
    this.url = URL;
    this.method = this.options.method;
    VAR paramsは= Object.isString（this.options.parameters）？
          this.options.parameters：
          Object.toQueryString（this.options.parameters）;

    {（！[の'get'、'POST']。（this.method）を含む）場合
      paramsは+ =（paramsを'＆'：''？）+"_method ="+ this.method。
      this.method ='POST';
    }

    場合（paramsは＆＆this.method ==='get'）を{
      this.url + =（this.url.include ("?")'＆'：'？'）+ paramsは。
    }

    this.parameters = params.toQueryParams（）;

    してみてください{
      VAR応答=新しいAjax.Response（この）;
      this.options.onCreate（レスポンス）（this.options.onCreate）場合はtrue。
      Ajax.Responders.dispatch（'OnCreateイベント"、この、応答）;

      this.transport.open（this.method.toUpperCase（）、this.url、
        this.options.asynchronous）;

      （this.options.asynchronous）this.respondToReadyState.bind（この）場合延期（1）;

      this.transport.onreadystatechange = this.onStateChange.bind（この）;
      this.setRequestHeaders（）;

      this.body = this.method =='POST'？（this.options.postBody | | paramsは）：NULL;
      this.transport.send（this.body）;

      / *強制的にFirefoxが同期要求に対する準備状態4を処理する* /
      するif（！this.options.asynchronous＆this.transport.overrideMimeType）
        this.onStateChange（）;

    }
    キャッチ（電子）{
      this.dispatchException（E）;
    }
  }、

  OnStateChangeの：関数（）{
    VAR readyStateが= this.transport.readyState;
    なら（readyStateが> 1＆＆！（（readyStateが== 4）＆＆this._complete））
      this.respondToReadyState（this.transport.readyState）;
  }、

  setRequestHeaders：関数（）{
    VARヘッダ= {
      "X -要求された - と'：'XMLHttpRequestを"、
      "X -プロトタイプバージョン"：Prototype.Version、
      [受け入れる]："テキスト/ javascriptの、テキスト/ html、application / xmlに、text / xmlに、* / *'
    };

    場合（this.method =='POST'）{
      ヘッダ['Content - typeを'] = this.options.contentType +
        （this.options.encoding';文字コード='+ this.options.encoding：？''）;

      / *強制的に"接続：クローズ"古いMozillaブラウザが動作する
       * XMLHttpRequestが正しくないを送信するバグを回避
       * Content - lengthヘッダ。MozillaのBugzillaの＃246651を参照してください。
       * /
      場合（this.transport.overrideMimeType＆＆
          （navigator.userAgent.match（/ Geckoの\ /（\ d {4}という）/）| | [0,2005]）[1] <2005年）
            ヘッダ['接続'] ='近い';
    }

    場合（typeof演算this.options.requestHeaders =='オブジェクト'）{
      VARエクストラ= this.options.requestHeaders;

      場合（Object.isFunction（extras.push））
        （; I <長さは、i + = 2します。var i = 0、長さ= extras.length）用
          ヘッダ[エクストラ[I]] =エクストラ[I +1];
      他
        $ H（エクストラ）各（関数（ペア）{ヘッダ[pair.key] = pair.value}）;
    }

    （ヘッダ内でvar名）のための
      this.transport.setRequestHeader（名前、ヘッダ[名前]）;
  }、

  成功：関数（）{
    VAR状態= this.getStatus（）;
    ！リターンステータス| |（ステータス> = 200＆＆ステータス<300）| |ステータス== 304;
  }、

  getStatusを：関数（）{
    してみてください{
      リターン204（this.transport.status === 1223）場合はtrue。
      this.transport.statusを返す| | 0;
    します} catch（e）{戻り値0}
  }、

  respondToReadyState：関数（readyStateの）{
    VAR状態= Ajax.Request.Events [readyStateの]、応答=新しいAjax.Response（この）;

    場合（状態==??'完全'）{
      してみてください{
        this._complete = TRUE;
        （this.options [+ response.statusを'on']
         | | this.options ['on'に+（？this.success（）'成功'：'失敗'）]
         | | Prototype.emptyFunction）（応答、response.headerJSON）;
      します} catch（e）{
        this.dispatchException（E）;
      }

      VARのcontentType = response.getHeader（'Content - typeを'）;
      場合（this.options.evalJS =='力'
          | |（this.options.evalJS＆＆this.isSameOrigin（）＆＆のcontentType
          ＆＆contentType.match（/ ^ \ S *（テキスト|アプリケーション）\ /（X -）（javaの|？ECMA）スクリプト(;.*)? \ S * $ / i）を））
        this.evalResponse（）;
    }

    してみてください{
      （this.options [+状態を'on'] | | Prototype.emptyFunction）（応答、response.headerJSON）;
      Ajax.Responders.dispatch（+状態を'on'、この、レスポンス、response.headerJSON）;
    します} catch（e）{
      this.dispatchException（E）;
    }

    場合（状態==??'完全'）{
      this.transport.onreadystatechange = Prototype.emptyFunction;
    }
  }、

  isSameOrigin：関数（）{
    VAR M = this.url.match（/ ^ \ S * H??TTPS：？\ / \ / [^ \ /]*/);
    リターンM |！|（M [0] =='＃＃{プロトコル}//#{ドメイン} {ポート}'を補間（{。
      プロトコル：location.protocol、
      ドメイン：document.domainを、
      ポート：location.port？'：'+ location.port：''
    }））;
  }、

  GetHeaderは：関数（名）{
    してみてください{
      this.transport.getResponseHeader（名前）を返す| | NULL;
    します} catch（e）{nullを返します。}
  }、

  evalResponse：関数（）{
    してみてください{
      evalを返す（（this.transport.responseText | | ''）unfilterJSON（））;
    します} catch（e）{
      this.dispatchException（E）;
    }
  }、

  dispatchException：関数（例外）{
    （this.options.onException | | Prototype.emptyFunction）（この、例外）;
    Ajax.Responders.dispatch（'onExceptionの"、この、例外）;
  }
}）;

Ajax.Request.Events =
  [、"初期化されていない'完全な'、'対話'、'ロード'、'ロード'];








Ajax.Response = Class.create（{
  初期化：機能（リクエスト）{
    this.request =要求;
    VAR輸送= this.transport = request.transport、
        readyStateが= this.readyState = transport.readyState;

    {|（readyStateが== 4！|（readyStateが> 2＆＆Prototype.Browser.IE））場合
      this.status = this.getStatus（）;
      this.statusText = this.getStatusText（）;
      this.responseText =は（transport.responseText）String.interpret。
      this.headerJSON = this._getHeaderJSON（）;
    }

    なら（readyStateが== 4）{
      VARのxml = transport.responseXML;
      this.responseXML = Object.isUndefined（XML）？ヌル：XML;
      this.responseJSON = this._getResponseJSON（）;
    }
  }、

  状態：0、

  statusText：''、

  getStatusを：Ajax.Request.prototype.getStatus、

  getStatusText：関数（）{
    してみてください{
      this.transport.statusTextを返す| | '';
    します} catch（e）{''を返す}
  }、

  GetHeaderは：Ajax.Request.prototype.getHeader、

  全てのヘッダを取得：関数（）{
    してみてください{
      戻りthis.getAllResponseHeaders（）;
    します} catch（e）{nullを返します}
  }、

  getResponseHeader：関数（名）{
    this.transport.getResponseHeader（名前）を返します。
  }、

  getAllResponseHeaders：関数（）{
    戻りthis.transport.getAllResponseHeaders（）;
  }、

  _getHeaderJSON：関数（）{
    VAR JSON = this.getHeader（'X - JSON'）;
    場合（JSON！）はnullを返します。
    JSON =は、decodeURIComponent（エスケープ（JSON））;
    してみてください{
      | | json.evalJSON（this.request.options.sanitizeJSONを返す
        ！this.request.isSameOrigin（））;
    します} catch（e）{
      this.request.dispatchException（E）;
    }
  }、

  _getResponseJSON：関数（）{
    VARオプション= this.request.options;
    場合（options.evalJSON |！|！（options.evalJSON ='力'＆＆
      ！（this.getHeader（'Content - typeを'）| | ''）（は'application / json'）を含む）。| |
        this.responseText.blank（））
          nullを返します。
    してみてください{
      | | this.responseText.evalJSON（options.sanitizeJSONを返す
        ！this.request.isSameOrigin（））;
    します} catch（e）{
      this.request.dispatchException（E）;
    }
  }
}）;

Ajax.Updaterから= Class.create（担うAjax.Request、{
  初期化：関数（$超、コンテナ、URL、オプション）{
    this.container = {
      成功：（container.success | |コンテナ）、
      失敗：（container.failure | |（container.successヌル：コンテナ）？）
    };

    オプション= Object.clone（オプション）;
    VAR onCompleteの= options.onComplete;
    options.onComplete =（関数（応答、JSON）{
      this.updateContent（response.responseText）;
      （Object.isFunction（onCompleteの））onCompleteの（応答、JSON）場合はtrue。
    。}）バインド（この）;

    スーパー$（URL、オプション）;
  }、

  updateContent：関数（のresponseText）{
    VAR受信機= this.container [this.success（）？"成功"：'失敗']、
        オプション= this.options;

    （！options.evalScripts）のresponseText = responseText.stripScripts（）場合はtrue。

    場合（受信機= $（受信機））{
      場合（options.insertion）{
        場合（Object.isString（options.insertion））{
          VAR挿入= {};挿入[options.insertion] =のresponseText;
          receiver.insert（挿入）;
        }
        他options.insertion（受信機、のresponseText）;
      }
      他receiver.update（のresponseText）;
    }
  }
}）;

Ajax.PeriodicalUpdater = Class.create（Ajax.Base、{
  初期化：関数（$超、コンテナ、URL、オプション）{
    スーパー$（オプション）;
    this.onComplete = this.options.onComplete;

    this.frequency =（this.options.frequency | | 2）;
    this.decay =（this.options.decay | | 1）;

    this.updater = {};
    this.container =コンテナ;
    this.url = URL;

    this.start（）;
  }、

  スタート：関数（）{
    this.options.onComplete = this.updateComplete.bind（この）;
    this.onTimerEvent（）;
  }、

  ストップ：関数（）{
    this.updater.options.onComplete =未定義;
    てclearTimeout（this.timer）;
    （this.onComplete | | Prototype.emptyFunction）適用される（これ、引数）;
  }、

  updateComplete：関数（応答）{
    場合（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.decay * this.frequency）。
  }、

  onTimerEvent：関数（）{
    this.updater =新しいAjax.Updaterから（this.container、this.url、this.options）;
  }
}）;


関数$（要素）{
  場合（のarguments.length> 1）{
    のための（します。var i = 0、要素= []、長さ=のarguments.lengthは、i <長さは、i + +）
      elements.push（$（引数[i]の））;
    の要素を返します。
  }
  場合（Object.isString（要素））
    要素= document.getElementByIdを（要素）;
  Element.extend（要素）を返します。
}

場合（Prototype.BrowserFeatures.XPath）{
  document._getElementsByXPath =関数（表現、parentElement）{
    VARの結果= [];
    VARクエリ=（式の、$（parentElement）document.evaluate | |文書を、
      ヌル、XPathResult.ORDERED_NODE_SNAPSHOT_TYPE、NULL）;
    のための（します。var i = 0、長さ= query.snapshotLengthは、i <長さは、i + +）
      results.push（Element.extend（query.snapshotItem（I）））;
    結果を返す。
  };
}

/*------------------------------------------------ --------------------------*/

場合VARノード= {}（ノード？）;

するif（！Node.ELEMENT_NODE）{
  Object.extend（ノード、{
    ELEMENT_NODE：1、
    ATTRIBUTE_NODE：2、
    TEXT_NODE：3、
    CDATA_SECTION_NODE：4、
    ENTITY_REFERENCE_NODE：5、
    ENTITY_NODE：6、
    PROCESSING_INSTRUCTION_NODE：7、
    COMMENT_NODE：8、
    DOCUMENT_NODE：9、
    DOCUMENT_TYPE_NODE：10、
    DOCUMENT_FRAGMENT_NODE：11、
    NOTATION_NODE：12
  }）;
}



（関数（グローバル）{
  機能shouldUseCache（tagNameを、属性）{
    場合（tagNameを==='選択'）はfalseを返します。
    falseを返す（属性の'型'）場合はtrue。
    trueを返します。
  }

  varのHAS_EXTENDED_CREATE_ELEMENT_SYNTAX =（関数（）{
    してみてください{
      VARエル= document.createElement（'<input name="x">'）;
      el.tagName.toLowerCaseを（返却）==='入力'＆＆el.name ==='X';
    }
    キャッチ（ERR）{
      falseを返します。
    }
  })();

  var要素= global.Element;

  global.Element =関数（tagNameを、属性）{
    属性=属性| | {};
    tagNameに= tagName.toLowerCase（）;
    VARキャッシュ= Element.cache;

    場合（HAS_EXTENDED_CREATE_ELEMENT_SYNTAX＆＆attributes.name）{
      tagNameに='<'+ tagNameを+'名前="'+ attributes.name + '">';
      attributes.nameを削除する。
      Element.writeAttribute（document.createElement（tagNameを）、属性）を返します。
    }

    場合キャッシュ[tagNameを] = Element.extend（document.createElement（tagNameを））（キャッシュ[tagNameを]！）;

    VARノード= shouldUseCache（tagNameを、属性）？
     。キャッシュ[tagNameを] cloneNodeとして作成（偽）：document.createElement（tagNameを）;

    Element.writeAttribute（ノード、属性）を返します。
  };

  Object.extend（global.Element、要素| | {}）;
  場合（要素）global.Element.prototype = element.prototype;

}）（この）;

Element.idCounter = 1;
Element.cache = {};

Element._purgeElement =関数（要素）{
  VARはuid = element._prototypeUID;
  場合（UID）{
    Element.stopObserving（要素）;
    element._prototypeUID =無効0;
    削除Element.Storage [UID];
  }
}

Element.Methods = {
  目に見える：関数（要素）{
    $を（要素）を返すstyle.display ='none'に！;
  }、

  トグル：関数（要素）{
    要素= $（要素）;
    要素[Element.visible（要素）？"非表示"：'ショー']（要素）;
    要素を返します。
  }、

  非表示：関数（要素）{
    要素= $（要素）;
    element.style.display ='なし';
    要素を返します。
  }、

  ショー：関数（要素）{
    要素= $（要素）;
    element.style.display = '';
    要素を返します。
  }、

  削除：関数（要素）{
    要素= $（要素）;
    element.parentNode.removeChild（要素）;
    要素を返します。
  }、

  更新：（関数（）{

    VAR SELECT_ELEMENT_INNERHTML_BUGGY =（関数（）{
      VARエル= document.createElement（"選択"）、
          isBuggy = TRUE;
      el.innerHTML ="<option value=\"test\">テスト</オプション>";
      場合（el.options＆＆el.options [0]）{
        isBuggy = el.options [0] nodeName.toUpperCase（）=="OPTION"。！;
      }
      エル= NULL;
      isBuggyを返します。
    })();

    VAR TABLE_ELEMENT_INNERHTML_BUGGY =（関数（）{
      してみてください{
        VARエル= document.createElement（"テーブル"）;
        場合（エル＆＆el.tBodies）{
          el.innerHTML ="<TBODY> <TR> <TD>テスト</ TD> </ TR> </ TBODY>";
          VAR isBuggy = typeof演算el.tBodies [0] =="未定義";
          エル= NULL;
          isBuggyを返します。
        }
      します} catch（e）{
        trueを返します。
      }
    })();

    VAR LINK_ELEMENT_INNERHTML_BUGGY =（関数（）{
      してみてください{
        VARエル= document.createElement（'DIV'）;
        el.innerHTML ="<link>の";
        VAR isBuggy =（el.childNodes.length === 0）;
        エル= NULL;
        isBuggyを返します。
      します} catch（e）{
        trueを返します。
      }
    })();

    VAR ANY_INNERHTML_BUGGY = SELECT_ELEMENT_INNERHTML_BUGGY | |
     TABLE_ELEMENT_INNERHTML_BUGGY | | LINK_ELEMENT_INNERHTML_BUGGY。

    varのSCRIPT_ELEMENT_REJECTS_TEXTNODE_APPENDING =（関数（）{
      varの= document.createElement（"スクリプト"）、
          isBuggy =偽;
      してみてください{
        s.appendChild（document.createTextNode (""));
        isBuggy = s.firstChild！| |
          s.firstChild＆s.firstChild.nodeType == 3！;
      します} catch（e）{
        isBuggy = TRUE;
      }
      S = NULL;
      isBuggyを返します。
    })();


    機能アップデート（要素、コンテンツ）{
      要素= $（要素）;
      VAR purgeElement = Element._purgeElement;

      VARの子孫= element.getElementsByTagName ('*'),
       I = descendants.length;
      一方、（I - ）purgeElement（子孫[I]）;

      場合（コンテンツ＆content.toElement）
        コンテンツ= content.toElement（）;

      場合（Object.isElement（コンテンツ））
        戻りelement.update（）インサート（コンテンツ）;

      コンテンツ= Object.toHTML（コンテンツ）;

      VAR tagNameを= element.tagName.toUpperCase（）;

      場合（tagNameを==='SCRIPT'＆＆SCRIPT_ELEMENT_REJECTS_TEXTNODE_APPENDING）{
        element.text =コンテンツ;
        要素を返します。
      }

      場合（ANY_INNERHTML_BUGGY）{
        {（Element._insertionTranslations.tagsのtagNameを）場合
          一方、（element.firstChild）{
            element.removeChild（element.firstChild）;
          }
          Element._getContentFromAnonymousElement（tagNameを、content.stripScripts（））
            各（関数（ノード）{
              element.appendChild（ノード）
            }）;
        }他の場合（LINK_ELEMENT_INNERHTML_BUGGY＆Object.isString（コンテンツ）＆＆content.indexOf（'<link')> -1）{
          一方、（element.firstChild）{
            element.removeChild（element.firstChild）;
          }
          VARノード= Element._getContentFromAnonymousElement（tagNameを、content.stripScripts（）、TRUE）;
          nodes.each（関数（ノード）{element.appendChild（ノード）}）;
        }
        他に{
          element.innerHTML = content.stripScripts（）;
        }
      }
      他に{
        element.innerHTML = content.stripScripts（）;
      }

      。content.evalScripts.bindは（コンテンツ）（延期）;
      要素を返します。
    }

    更新を返します。
  })(),

  交換してください：関数（要素、コンテンツ）{
    要素= $（要素）;
    （コンテンツ＆＆content.toElement）コンテンツなら= content.toElement（）;
    他の場合（！Object.isElement（コンテンツ））{
      コンテンツ= Object.toHTML（コンテンツ）;
      VARの範囲= element.ownerDocument.createRange（）;
      range.selectNode（要素）;
      。content.evalScripts.bindは（コンテンツ）（延期）;
      内容は= range.createContextualFragment（co??ntent.stripScripts（））;
    }
    element.parentNode.replaceChild（コンテンツ、要素）;
    要素を返します。
  }、

  挿入：関数（要素、挿入）{
    要素= $（要素）;

    場合（Object.isString（挿入）| | Object.isNumber（挿入）| |
        Object.isElement（挿入）| |（挿入＆＆（insertions.toElement | | insertions.toHTML）））
          挿入= {底部：挿入};

    VARコンテンツ、挿入、tagNameを、childNodes;

    {（挿入のvar位置）のための
      コンテンツ=挿入[位置];
      位置= position.toLowerCase（）;
      挿入= Element._insertionTranslations [位置];

      （コンテンツ＆＆content.toElement）コンテンツなら= content.toElement（）;
      場合（Object.isElement（コンテンツ））{
        インサート（要素、コンテンツ）;
        継続する;
      }

      コンテンツ= Object.toHTML（コンテンツ）;

      tagNameに=（（ポジション=='の前に'| |位置=='後'）
        ？element.parentNode：要素）tagName.toUpperCase（）;。

      childNodes = Element._getContentFromAnonymousElement（tagNameを、content.stripScripts（））;

      場合（位置=='トップ'| |位置=='後'）childNodes.reverse（）;
      childNodes.each（insert.curry（エレメント））;

      。content.evalScripts.bindは（コンテンツ）（延期）;
    }

    要素を返します。
  }、

  ラップ：関数（要素、ラッパー、属性）{
    要素= $（要素）;
    場合（Object.isElement（ラッパー））
      $（ラッパー）writeAttribute（属性| | {}）;
    他の場合（Object.isString（ラッパー））ラッパー=新しい要素（ラッパー、属性）;
    他のラッパー=新しい要素（は'div'、ラッパーを）;
    場合（element.parentNode）
      element.parentNode.replaceChild（ラッパー、要素）;
    wrapper.appendChild（要素）;
    ラッパーを返します。
  }、

  点検：機能（要素）{
    要素= $（要素）;
    VARの結果='<'+ element.tagName.toLowerCase（）;
    $ H（{'id'の'id'を、が"className'：'クラス'}）。各（関数（ペア）{
      VARプロパティ= pair.first（）、
          属性= pair.last（）、
          値=（要素[プロパティ] | | ''）のtoString（）;
      場合（値）の結果+ =''+属性+'='+ value.inspect（真の）;
    }）;
    +'>'結果を返す。
  }、

  recursivelyC??ollect：関数（要素、プロパティ、maximumLength）{
    要素= $（要素）;
    maximumLength = maximumLength | | -1;
    VAR要素= [];

    一方、（要素=要素[プロパティ]）{
      場合（element.nodeType == 1）
        elements.push（Element.extend（エレメント））;
      場合（elements.length == maximumLength）
        破る;
    }

    の要素を返します。
  }、

  祖先：関数（要素）{
    戻りElement.recursivelyC??ollect（要素、"のparentNode'）;
  }、

  子孫：関数（要素）{
    戻りElement.select（要素、"*");
  }、

  firstDescendant：関数（要素）{
    要素= $（要素）firstChild。
    一方、（要素＆＆element.nodeType = 1！）要素= element.nextSibling;
    $（要素）を返します。
  }、

  immediateDescendants：関数（要素）{
    VARの結果= []、子= $（要素）firstChild。
    一方、（子）{
      場合（child.nodeType === 1）{
        results.push（Element.extend（子））;
      }
      子= child.nextSibling;
    }
    結果を返す。
  }、

  previousSiblings：関数（要素、maximumLength）{
    戻りElement.recursivelyC??ollect（要素、"previousSiblingは'）;
  }、

  nextSiblings：関数（要素）{
    Element.recursivelyC??ollect（要素、"nextSiblingを"）を返します。
  }、

  兄弟：関数（要素）{
    要素= $（要素）;
    Element.previousSiblingsを（要素）を返す。逆（）
      。連結（Element.nextSiblings（エレメント））;
  }、

  マッチ：関数（要素、セレクタ）{
    要素= $（要素）;
    場合（Object.isString（セレクタ））
      Prototype.Selector.match（要素、セレクタ）を返します。
    selector.match（要素）を返します。
  }、

  上：関数（要素、表現、インデックス）{
    要素= $（要素）;
    （のarguments.length == 1）$を（element.parentNode）を返す場合。
    VARの祖先= Element.ancestors（要素）;
    Object.isNumber（表現）を返す？先祖[式]：
      Prototype.Selector.find（祖先、表現、インデックス）;
  }、

  ダウン：関数（要素、表現、インデックス）{
    要素= $（要素）;
    （のarguments.length == 1）リターンElement.firstDescendant（要素）場合はtrue。
    Object.isNumber（表現）を返す？Element.descendants（要素）[式]：
      Element.select（要素、表現）[インデックス| | 0];
  }、

  前：関数（要素、表現、インデックス）{
    要素= $（要素）;
    場合（Object.isNumber（表現））指数=発現、発現=偽;
    （！Object.isNumber（インデックス））であればインデックス= 0;

    場合（式）{
      Prototype.Selector.find（element.previousSiblings（）、表現、インデックス）を返します。
    }他{
      戻りelement.recursivelyC??ollect（"previousSiblingは"、インデックス+ 1）[インデックス];
    }
  }、

  次：関数（要素、表現、インデックス）{
    要素= $（要素）;
    場合（Object.isNumber（表現））指数=発現、発現=偽;
    （！Object.isNumber（インデックス））であればインデックス= 0;

    場合（式）{
      Prototype.Selector.find（element.nextSiblings（）、表現、インデックス）を返します。
    }他{
      VAR maximumLength = Object.isNumber（インデックス）？インデックス+ 1：1;
      戻りelement.recursivelyC??ollect（"nextSibling"、インデックス+ 1）[インデックス];
    }
  }、


  選択：関数??（要素）{
    要素= $（要素）;
    VAR表現= Array.prototype.slice.call（引数、1）参加する（'、'）;
    Prototype.Selector.select（表現、要素）を返します。
  }、

  隣接：関数（要素）{
    要素= $（要素）;
    VAR表現= Array.prototype.slice.call（引数、1）参加する（'、'）;
    Prototype.Selector.select（表現、element.parentNode）を返す（要素）なし。
  }、

  識別：関数（要素）{
    要素= $（要素）;
    VAR ID = Element.readAttribute（要素、の'id'）;
    （ID）IDを返す場合はtrue。
    {idは='anonymous_element_'+ Element.idCounter + +}（$（ID））しながらの操作を行います。
    Element.writeAttribute（要素、'id'を、ID）;
    idを返す。
  }、

  readAttribute：関数（要素、名）{
    要素= $（要素）;
    場合（Prototype.Browser.IE）{
      VAR T = Element._attributeTranslations.read;
      場合（t.values?? [名]）戻りt.values?? [名]（要素、名）;
      場合（t.names [名前]）名前= t.names [名];
      （name.include (':')) {場合
        リターン（element.attributes |！|！element.attributes [名前]）？ヌル：
         element.attributes [名前]の値。
      }
    }
    戻りelement.getAttribute（名）;
  }、

  writeAttribute：関数（要素、名前、値）{
    要素= $（要素）;
    のvar属性= {}、T = Element._attributeTranslations.write;

    場合（typeof演算名=='object'）を属性=名前;
    他の属性は[名前]（値）= Object.isUndefined？真：値;

    {（属性にvar attrが）のための
      名前= t.names [attrは] | | attrの。
      値=属性[attrの];
      場合（t.values?? [attrの]）名前= t.values?? [attrは]（要素、値）;
      （| |値=== null値=== false）をした場合
        element.removeAttribute（名）;
      他の場合（値=== true）を
        element.setAttribute（名前、名前）;
      他element.setAttribute（名前、値）;
    }
    要素を返します。
  }、

  のgetHeight：関数（要素）{
    戻りElement.getDimensions（要素）の高さ。
  }、

  getWidth：関数（要素）{
    戻りElement.getDimensions（要素）の幅。
  }、

  クラス名：関数（要素）{
    新しいElement.ClassNames（要素）を返します。
  }、

  hasClassName：関数（要素は、className）{
    リターン（！（要素= $（要素）））場合はtrue。
    VAR elementClassName = element.className;
    リターン（elementClassName.length> 0＆＆（elementClassName == classNameの| |
      新しい正規表現("(^| \ \ S）"+ classNameの+"（\ \ sの|$)").試験（elementClassName）））;
  }、

  addClassName：関数（要素は、className）{
    リターン（！（要素= $（要素）））場合はtrue。
    するif（！Element.hasClassName（要素は、className））
      element.className + =（element.className'：？''）+ classNameの。
    要素を返します。
  }、

  removeClassName：関数（要素は、className）{
    リターン（！（要素= $（要素）））場合はtrue。
    element.className = element.className.replace（
      新しい正規表現("(^| \ \ S +）"+ classNameの+"（\ \ sの+|$)"),'）ストリップ（）;
    要素を返します。
  }、

  toggleClassName：関数（要素は、className）{
    リターン（！（要素= $（要素）））場合はtrue。
    エレメント[Element.hasClassNameを（エレメント、className）を返す？
      "removeClassName'：'addClassName']（要素は、className）;
  }、

  cleanWhitespace：関数（要素）{
    要素= $（要素）;
    VARノード= element.firstChild;
    {（ノード）間
      VAR NEXTNODE = node.nextSibling;
      場合（node.nodeType == 3＆＆！/ \ S / .test（node.nodeValue））
        element.removeChild（ノード）;
      ノード= NEXTNODE;
    }
    要素を返します。
  }、

  空の：関数（要素）{
    $を（要素）を返すinnerHTML.blank（）;
  }、

  descendantOf：関数（要素、祖先）{
    要素= $（要素）、祖先= $（祖先）;

    場合（element.compareDocumentPosition）
      リターン（element.compareDocumentPosition（祖先）＆8）=== 8;

    場合（ancestor.contains）
      ancestor.contains（要素）＆＆祖先を返す==要素！;

    一方、（要素= element.parentNode）
      trueを返す（要素==祖先）場合はtrue。

    falseを返します。
  }、

  scrollTo：関数（要素）{
    要素= $（要素）;
    VARのpos = Element.cumulativeOffset（要素）;
    window.scrollTo（POS [0]、posの[1]）;
    要素を返します。
  }、

  getStyle：関数（要素、スタイル）{
    要素= $（要素）;
    スタイル=スタイル=='フロート'？"cssFloat'：style.camelize（）;
    var値= element.style [スタイル];
    場合（値|！|値=='auto'）は、{
      VAR CSS = document.defaultView.getComputedStyle（要素、NULL）;
      値= CSS？CSS [スタイル]：NULL;
    }
    場合（スタイル=='不透明'）戻り値？parseFloatは（値）：1.0;
    戻り値=='auto'を？ヌル：値;
  }、

  getOpacity：関数（要素）{
    $（要素）を返しますgetStyle（'不透明'）;
  }、

  をsetStyle：関数（要素、スタイル）{
    要素= $（要素）;
    VAR elementStyle = element.style、マッチ;
    場合（Object.isString（様式））{
      element.style.cssText + =';'+スタイル;
      styles.include（'不透明'）を返す？
        element.setOpacity（styles.match（/不透明度：\ S *（\ dは\ \ dは*)/)[ 1]）：？？要素;
    }
    （スタイルのvarプロパティ）のための
      （プロパティ=='不透明'）element.setOpacity（スタイル[プロパティ]）場合はtrue。
      他
        elementStyle [（プロパティ=='フロート'| |プロパティ=='cssFloat'）？
          （（elementStyle.styleFloat）Object.isUndefined"cssFloat"：？"styleFloat'）：
            プロパティ] =スタイルが[プロパティ];

    要素を返します。
  }、

  setOpacity：関数（要素、値）{
    要素= $（要素）;
    element.style.opacity =（値== 1 | |値=== ''）？''：
      （値<0.00001）？0：値;
    要素を返します。
  }、

  makePositioned：関数（要素）{
    要素= $（要素）;
    VAR posは= Element.getStyle（要素、'位置'）;
    場合（POS =='静的な'| |！POS）{
      =真element._madePositioned;
      element.style.position ='相対';
      場合（Prototype.Browser.Opera）{
        element.style.top = 0;
        element.style.left = 0;
      }
    }
    要素を返します。
  }、

  undoPositioned：関数（要素）{
    要素= $（要素）;
    場合（element._madePositioned）{
      =未定義element._madePositioned;
      element.style.position =
        element.style.top =
        element.style.left =
        element.style.bottom =
        element.style.right = '';
    }
    要素を返します。
  }、

  makeClipping：関数（要素）{
    要素= $（要素）;
    （element._overflow）return要素場合はtrue。
    element._overflow = Element.getStyle（要素、"オーバーフロー"）| |'オート';
    場合（element._overflow！=='隠された'）
      エルement.style.overflow ='隠された';
    要素を返します。
  }、

  undoClipping：関数（要素）{
    要素= $（要素）;
    （！element._overflow）return要素場合はtrue。
    element.style.overflow = element._overflow =='auto'を？''：element._overflow;
    element._overflow = NULL;
    要素を返します。
  }、

  clonePosition：関数（要素、ソース）{
    VARオプション= Object.extend（{
      setLeft：真、
      セットトップ：真、
      setWidth：真、
      setHeight：真、
      offsetTop：0、
      offsetLeft：0
    }、引数[2] | | {}）;

    ソース= $（ソース）;
    します。var p = Element.viewportOffset（ソース）、デルタ= [0、0]、親= NULL;

    要素= $（要素）;

    場合（Element.getStyle（要素、'位置'）=='絶対'）{
      親= Element.getOffsetParent（要素）;
      デルタ= Element.viewportOffset（親）;
    }

    {（親== document.body）場合
      デルタ[0] -= document.body.offsetLeft。
      デルタ[1] -= document.body.offsetTop。
    }

    場合（options.setLeft）element.style.left =（P [0] - デルタ[0] + options.offsetLeft）+'ピクセル';
    場合（options.setTop）element.style.top =（P [1] - デルタ[1] + options.offsetTop）+'ピクセル';
    場合（options.setWidth）element.style.width = source.offsetWidth +'ピクセル';
    場合（options.setHeight）element.style.height = source.offsetHeight +'ピクセル';
    要素を返します。
  }
};

Object.extend（Element.Methods、{
  getElementsBySelector：Element.Methods.select、

  childElements：Element.Methods.immediateDescendants
}）;

Element._attributeTranslations = {
  書き込み：{
    名前：{
      classNameの：'クラス'、
      htmlFor：'の"
    }、
    値：{}
  }
};

場合（Prototype.Browser.Opera）{
  Element.Methods.getStyle = Element.Methods.getStyle.wrap（
    関数（、要素、スタイルを続行）{
      スイッチ（スタイル）{
        ケース"高さ"：大文字の'width'：
          （！Element.visible（要素））はnullを返します場合はtrue。

          VAR DIM = parseInt（進むに（要素、スタイル）、10）;

          場合（薄暗い！==要素['オフセット'+）（style.capitalize]）
            薄暗い返す+'ピクセル';

          VARの特性;
          場合（スタイル==='高さ'）{
            プロパティ= ['国境トップ幅'、'パディングトップ"、
             "パディング底'、'国境 - ボトム幅'];
          }
          他に{
            プロパティ= ['国境左幅'、'パディング左"、
             "パディング右'、'国境右幅'];
          }
          薄暗い、機能（メモ、プロパティ）{（properties.injectを返す
            VARヴァル=進むに（要素、プロパティ）;
            ヴァル=== nullを返す？メモ：メモ - parseInt（VAL、10）;
          }）+'ピクセル';
        デフォルト：リターン（要素、スタイル）進みます。
      }
    }
  ）;

  Element.Methods.readAttribute = Element.Methods.readAttribute.wrap（
    関数（、要素、属性を続行）{
      （属性==='タイトル'）戻りelement.title場合はtrue。
      （要素、属性）355-2052返します。
    }
  ）;
}

他{（Prototype.Browser.IE）場合
  Element.Methods.getStyle =関数（要素、スタイル）{
    要素= $（要素）;
    スタイル=（スタイル=='フロート'| |スタイル=='cssFloat'）？"styleFloat'：style.camelize（）;
    var値= element.style [スタイル];
    場合値= element.currentStyle [スタイル]（値＆＆element.currentStyle！）;

    場合（スタイル=='不透明'）{
      場合（値=（element.getStyle（'フィルタ'）| | ''）（/α\（不透明度=(.*)は\）/）と一致している。）
        場合（値[1]）返りparseFloatは（値は[1]）/ 100;
      1.0を返します。
    }

    場合（値=='auto'）は、{
      場合（（スタイル=='幅'| |スタイル=='高さ'）＆＆（element.getStyle（'display'の）='なし'）！）
        戻り要素['オフセット'+ style.capitalize（）] +'ピクセル';
      nullを返します。
    }
    値を返す。
  };

  Element.Methods.setOpacity =関数（要素、値）{
    機能stripAlpha（フィルター）{
      戻りfilter.replace（/α\（[^ \）] * \）/ GI ,'');
    }
    要素= $（要素）;
    VAR currentStyle = element.currentStyle;
    場合（（currentStyle＆＆currentStyle.hasLayout）！| |
      （！currentStyle＆element.style.zoom =='通常'））
        element.style.zoom = 1;

    VARフィルタ= element.getStyle（'フィルタ'）、スタイル= element.style;
    場合（値== 1 | |値=== ''）{
      （フィルタ= stripAlpha（フィルタ））？
        style.filter =フィルター：style.removeAttribute（'フィルタ'）;
      要素を返します。
    }他の場合（値<0.00001）値= 0;
    style.filter = stripAlpha（フィルタ）+
      "アルファ（不透明度='+（値* 100）+'）';
    要素を返します。
  };

  Element._attributeTranslations =（関数（）{

    VAR classProp =が"className"、
        forProp ='は'、
        エル= document.createElement（'DIV'）;

    el.setAttribute（classProp、'X'）;

    場合（el.className！=='X'）{
      el.setAttribute（'クラス'、'X'）;
      場合（el.className ==='X'）{
        classProp ='クラス';
      }
    }
    エル= NULL;

    エル= document.createElement（'ラベル'）;
    el.setAttribute（forProp、'X'）;
    場合（el.htmlFor！=='X'）{
      el.setAttribute（'htmlFor'、'X'）;
      場合（el.htmlFor ==='X'）{
        forProp ='htmlFor';
      }
    }
    エル= NULL;

    返す{
      読み取り：{
        名前：{
          'クラス'：classProp、
          が"className"：classProp、
          'の'：forProp、
          "htmlFor'：forProp
        }、
        値：{
          _getAttr：関数（要素、属性）{
            戻りelement.getAttribute（属性）;
          }、
          _getAttr2：関数（要素、属性）{
            element.getAttribute（属性、2）を返す。
          }、
          _getAttrNode：関数（要素、属性）{
            VARノード= element.getAttributeNode（属性）;
            ノードを返す？node.value："";
          }、
          _getEv：（関数（）{

            VARエル= document.createElement（'DIV'）、F;
            el.onclick = Prototype.emptyFunction;
            var値= el.getAttribute（'onclickの'）;

            場合（文字列（値）。indexOfを('{')> -1）{
              F =関数（要素、属性）{
                = element.getAttribute（属性）属性。
                場合はnullを返します（属性？）;
                属性は= attribute.toString（）;
                属性= attribute.split ('{')[ 1];
                属性= attribute.split ('}')[ 0];
                attribute.strip（）を返す。
              };
            }
            他の場合（値=== ''）{
              F =関数（要素、属性）{
                = element.getAttribute（属性）属性。
                場合はnullを返します（属性？）;
                attribute.strip（）を返す。
              };
            }
            エル= NULL;
            fを返す。
          })(),
          _flag：関数（要素、属性）{
            $（要素）。hasAttribute（属性）を返します？属性：NULL;
          }、
          スタイル：関数（要素）{
            element.style.cssText.toLowerCase（）を返す。
          }、
          タイトル：関数（要素）{
            element.title返します。
          }
        }
      }
    }
  })();

  Element._attributeTranslations.write = {
    名前：Object.extend（{
      CELLPADDING："CELLPADDING"、
      CELLSPACING："CELLSPACING"
    }、Element._attributeTranslations.read.names）、
    値：{
      チェック：機能（要素、値）{
        element.checked =値！;
      }、

      スタイル：関数（要素、値）{
        element.style.cssText =値？値：'';
      }
    }
  };

  Element._attributeTranslations.has = {};

  $ W（'COLSPAN ROWSPAN VALIGN dateTimeのアクセスキーtabIndexの'+
      "enctypeがmaxLengthがreadOnlyのLONGDESC FRAMEBORDER'）。各（関数（attrが）{
    Element._attributeTranslations.write.names [attr.toLowerCase（）] = attrは;
    Element._attributeTranslations.has [attr.toLowerCase（）] = attrは;
  }）;

  （関数（V）{
    Object.extend（V、{
      HREF：v._getAttr2、
      SRC：v._getAttr2、
      タイプ：v._getAttr、
      アクション：v._getAttrNode、
      無効：v._flag、
      チェック：v._flag、
      読み取り専用：v._flag、
      複数：v._flag、
      onloadイベント：v._getEv、
      onunloadを：v._getEv、
      onclickの：v._getEv、
      ondblclick：v._getEv、
      にOnMouseDown：v._getEv、
      onMouseUpの：v._getEv、
      onmouseoverイベント：v._getEv、
      onmousemove：v._getEv、
      onmouseout：v._getEv、
      onfocusイベント：v._getEv、
      onblurイベント：v._getEv、
      onkeypress：v._getEv、
      onkeydownイベント：v._getEv、
      onkeyupの：v._getEv、
      onSubmitメソッド：v._getEv、
      onreset：v._getEv、
      ONSELECT：v._getEv、
      備考OnChange：v._getEv
    }）;
  }）（Element._attributeTranslations.read.values??）;

  場合（Prototype.BrowserFeatures.ElementExtensions）{
    （関数（）{
      関数_descendants（要素）{
        VARノード= element.getElementsByTagName ('*'),結果= [];
        のための（します。var i = 0、ノード、ノード=ノード[i]はは、i + +）
          （node.tagName！=="！"）/ /は、コメントノードをフィルタする場合。
            results.push（ノード）;
        結果を返す。
      }

      Element.Methods.down =関数（要素、表現、インデックス）{
        要素= $（要素）;
        場合（のarguments.length == 1）リターンelement.firstDescendant（）;
        Object.isNumber（表現）を返す？_descendants（要素）[式]：
          Element.select（要素、表現）[インデックス| | 0];
      }
    })();
  }

}

他の場合（Prototype.Browser.Geck??o＆＆/ RV：1 \ 0.8は\ .0/.test（navigator.userAgent））{
  Element.Methods.setOpacity =関数（要素、値）{
    要素= $（要素）;
    element.style.opacity =（値== 1）？0.999999：
      （値=== ''）？''：（値<0.00001）？0：値;
    要素を返します。
  };
}

他{（Prototype.Browser.WebKit）場合
  Element.Methods.setOpacity =関数（要素、値）{
    要素= $（要素）;
    element.style.opacity =（値== 1 | |値=== ''）？''：
      （値<0.00001）？0：値;

    場合（値== 1）
      場合（element.tagName.toUpperCase（）=='IMG'＆＆element.width）{
        element.width + +; element.width - - ;
      }他{してみてください
        VAR N = document.createTextNode（''）;
        element.appendChild（N）;
        element.removeChild（N）;
      します} catch（e）{}

    要素を返します。
  };
}

{（にdocument.documentElementで"outerHTML"）場合
  Element.Methods.replace =関数（要素、コンテンツ）{
    要素= $（要素）;

    （コンテンツ＆＆content.toElement）コンテンツなら= content.toElement（）;
    場合（Object.isElement（コンテンツ））{
      element.parentNode.replaceChild（コンテンツ、要素）;
      要素を返します。
    }

    コンテンツ= Object.toHTML（コンテンツ）;
    VAR親= element.parentNode、tagNameを= parent.tagName.toUpperCase（）;

    場合（Element._insertionTranslations.tags [tagNameを]）{
      VAR nextSibling = element.next（）、
          フラグメントは= Element._getContentFromAnonymousElement（tagNameを、content.stripScripts（））;
      parent.removeChild（要素）;
      場合（nextSibling）
        fragments.each（関数（ノード）{parent.insertBefore（ノード、nextSibling）}）;
      他
        fragments.each（関数（ノード）{parent.appendChild（ノード）}）;
    }
    他element.outerHTML = content.stripScripts（）;

    。content.evalScripts.bindは（コンテンツ）（延期）;
    要素を返します。
  };
}

Element._returnOffset =機能（L、T）{
  VAR結果= [L、T];
  result.left = L;
  result.top = T;
  結果を返す。
};

Element._getContentFromAnonymousElement =関数（tagNameを、HTML、力）{
  VAR DIV =新しい要素（は'div'）、
      T = Element._insertionTranslations.tags [tagNameを];

  VAR回避策=偽;
  この問題を回避する=真（t）の場合はtrue。
  他{（力）場合
    この問題を回避する=真;
    T = [''、''、0];
  }

  場合（回避策）{
    div.innerHTML =''+ T [0] + HTML + T [1];
    div.removeChild（div.firstChild）;
    {、 - 、（ⅰします。var i = T [2]）のための
      DIV = div.firstChild;
    }
  }
  他に{
    div.innerHTML = htmlの;
  }
  戻る$ A（div.childNodes）;
};

Element._insertionTranslations = {
  前：関数（要素、ノード）{
    element.parentNode.insertBefore（ノード、要素）;
  }、
  トップ：関数（要素、ノード）{
    element.insertBefore（ノード、element.firstChild）;
  }、
  底部：関数（要素、ノード）{
    element.appendChild（ノード）;
  }、
  後：関数（要素、ノード）{
    element.parentNode.insertBefore（ノード、element.nextSibling）;
  }、
  タグ：{
    表：['<TABLE>'、'</テーブル>'、1]、
    TBODY：['<TABLE> <TBODY>'、'</ TBODY> </テーブル>'、2]、
    TR：['<TABLE> <TBODY> <TR>'、'</ TR> </ TBODY> </テーブル>'、3]、
    TD：['<TABLE> <TBODY> <tr> <td>送信'、'</ TD> </ TR> </ TBODY> </テーブル>'、4]、
    SELECT：['<select>の'、'</ SELECT>'、1]
  }
};

（関数（）{
  VARタグ= Element._insertionTranslations.tags;
  Object.extend（タグ、{
    THEAD：tags.TBODY、
    TFOOT：tags.TBODY、
    TH：tags.TD
  }）;
})();

Element.Methods.Simulated = {
  hasAttribute：関数（要素、属性）{
    属性= Element._attributeTranslations.has [属性] | |属性;
    。VARノード= $（要素）getAttributeNode（属性）;
    リターン（ノード＆＆node.specified）！;
  }
};

Element.Methods.ByTag = {};

Object.extend（要素、Element.Methods）;

（機能（DIV）{

  するif（！Prototype.BrowserFeatures.ElementExtensions＆DIV ['__proto__']）{
    window.HTMLElement = {};
    window.HTMLElement.prototype = DIV ['__proto__'];
    Prototype.BrowserFeatures.ElementExtensions = TRUE;
  }

  DIV = NULL;

}）（document.createElement（'DIV'））;

Element.extend =（関数（）{

  機能checkDeficiency（tagNameを）{
    場合（typeof演算window.Element！='未定義'）{
      VARプロト= window.Element.prototype;
      場合（プロト）{
        VAR ID ='_'+（Mat??h.random ()+'').スライス（2）、
            エル= document.createElement（tagNameを）;
        プロト[ID] ='X';
        VAR isBuggy =（！エル[ID] =='X'）;
        削除プロト[ID];
        エル= NULL;
        isBuggyを返します。
      }
    }
    falseを返します。
  }

  機能extendElementWith（要素、メソッド）{
    {（メソッドのvarプロパティ）のための
      var値=メソッドは[プロパティ];
      場合（Object.isFunction（値）＆＆！（要素内のプロパティ））
        要素[プロパティ] = value.methodize（）;
    }
  }

  VAR HTMLOBJECTELEMENT_PROTOTYPE_BUGGY = checkDeficiency（'オブジェクト'）;

  場合（Prototype.BrowserFeatures.SpecificElementExtensions）{
    場合（HTMLOBJECTELEMENT_PROTOTYPE_BUGGY）{
      return関数（要素）{
        場合（要素＆＆typeof演算element._extendedByPrototype =='未定義'）{
          VAR T = element.tagName;
          場合（T＆＆(/^(?:オブジェクト|アプレット|埋め込む）$ / i.test（T）））{
            extendElementWith（要素、Element.Methods）;
            extendElementWith（要素、Element.Methods.Simulated）;
            extendElementWith（要素、Element.Methods.ByTag [t.toUpperCase ()]);
          }
        }
        要素を返します。
      }
    }
    Prototype.Kを返します。
  }

  VAR法= {}、ByTag = Element.Methods.ByTag;

  VARを拡張= Object.extend（関数（要素）{
    （if要素|！|！typeof演算element._extendedByPrototype ='未定義'| |
        element.nodeType = 1 | |要素==ウィンドウ）return要素！;

    VARの手法は= Object.clone（方法）、
        tagNameに= element.tagName.toUpperCase（）;

    場合（ByTag [tagNameを]）Object.extend（メソッド、ByTag [tagNameを]）;

    extendElementWith（要素、メソッド）;

    element._extendedByPrototype = Prototype.emptyFunction;
    要素を返します。

  }、{
    リフレッシュ：関数（）{
      するif（！Prototype.BrowserFeatures.ElementExtensions）{
        Object.extend（方法、Element.Methods）;
        Object.extend（方法、Element.Methods.Simulated）;
      }
    }
  }）;

  extend.refresh（）;
  拡張を返します。
})();

場合（document.documentElement.hasAttribute）{
  Element.hasAttribute =関数（要素、属性）{
    戻りelement.hasAttribute（属性）;
  };
}
他に{
  Element.hasAttribute = Element.Methods.Simulated.hasAttribute;
}

Element.addMethodsは=関数（メソッド）{
  VAR F = Prototype.BrowserFeatures、T = Element.Methods.ByTag;

  するif（！の方法）{
    Object.extend（フォーム、Form.Methods）;
    Object.extend（Form.Element、Form.Element.Methods）;
    Object.extend（Element.Methods.ByTag、{
      "FORM"：Object.clone（Form.Methods）、
      "INPUT"：Object.clone（Form.Element.Methods）、
      "SELECT"：Object.clone（Form.Element.Methods）、
      "TEXTAREA"：Object.clone（Form.Element.Methods）、
      "BUTTON"：Object.clone（Form.Element.Methods）
    }）;
  }

  場合（のarguments.length == 2）{
    VAR tagNameを=方法;
    方法=引数[1];
  }

  場合Object.extend（Element.Methods、方法| | {}）（tagNameを！）;
  他に{
    （Object.isArray（tagNameを））tagName.each（拡張）場合はtrue。
    他の（tagNameを）延長する。
  }

  機能拡張（tagNameを）{
    tagNameに= tagName.toUpperCase（）;
    するif（！Element.Methods.ByTag [tagNameを]）
      Element.Methods.ByTag [tagNameに] = {};
    Object.extend（Element.Methods.ByTag [tagNameを]、メソッド）;
  }

  関数copy（方法、目的地、onlyIfAbsent）{
    onlyIfAbsent = onlyIfAbsent | |偽;
    {（メソッドのvarプロパティ）のための
      var値=メソッドは[プロパティ];
      （！Object.isFunction（値））継続した場合。
      場合（onlyIfAbsent |！|！先の（プロパティ））
        デスティネーション[プロパティ] = value.methodize（）;
    }
  }

  関数findDOMClass（tagNameを）{
    VAR klassの;
    VARトランス= {
      "OPTGROUP"："OPTGROUP"、"TEXTAREA"："TextAreaの"、"P"："段落"、
      "FIELDSET"："フィールドセット"、"UL"："UList"、"OL"："OLIST"、"DL"："DList"、
      "DIR"："ディレクトリ"、"H1"："H2"は、"見出し"："見出し"、"H3"："見出し"は、
      "H4"："H5"、"見出し"："見出し"、"H6"："見出し"、"Q"："引用"、
      "INS"："モッズ"、"DEL"："モッズ"、""："アンカー"、"IMG"："イメージ"、"CAPTION"：
      "TableCaption"、"COL"："TableCol"、"COLGROUP"："TableCol"、"THEAD"：
      "TableSection"、"TFOOT"："TableSection"、"TBODY"："TableSection"、"TR"：
      "のTableRow"、"TH"："TableCellの"、"TD"："TableCellの"、"FRAMESET"：
      "フレームセット"、"IFRAME"："IFRAME"
    };
    場合（トランス[tagNameを]）klassの='HTML'+トランス[tagNameを] +'エレメント';
    場合（ウィンドウ[klassの]）戻りウィンドウ[klassの];
    klassの="HTML"+ tagNameを+'要素';
    場合（ウィンドウ[klassの]）戻りウィンドウ[klassの];
    klassの="HTML"+ tagName.capitalize（）+'要素';
    場合（ウィンドウ[klassの]）戻りウィンドウ[klassの];

    var要素= document.createElement（tagNameを）、
        プロト=要素['__proto__'] | | element.constructor.prototype。

    要素= NULL;
    protoを返します。
  }

  VAR elementPrototype = window.HTMLElement？HTMLElement.prototype：
   Element.prototype;

  場合（F.のElementExtensions）{
    コピー（Element.Methods、elementPrototype）;
    コピー（Element.Methods.Simulated、elementPrototype、真の）;
  }

  場合（F.のSpecificElementExtensions）{
    {（Element.Methods.ByTagでvarタグ）用
      VAR klassが= findDOMClass（タグ）;
      （（klassの）Object.isUndefined）継続する場合;
      コピー（T [タグ]、klass.prototype）;
    }
  }

  Object.extend（要素、Element.Methods）;
  Element.ByTagを削除する。

  （Element.extend.refresh）Element.extend.refresh（）場合はtrue。
  Element.cache = {};
};


document.viewport = {

  getDimensions：関数（）{
    リターン{幅：this.getWidth（）、高さ：this.getHeight（）};
  }、

  getScrollOffsets：関数（）{
    （Element._returnOffsetを返す
      window.pageXOffset | | document.documentElement.scrollLeft | | document.body.scrollLeft、
      window.pageYOffset | | document.documentElement.scrollTop | | document.body.scrollTop）;
  }
};

（関数（ビューポート）{
  VAR B = Prototype.Browser、DOC =文書、要素、プロパティ= {};

  関数getRootElement（）{
    場合（B. WebKitの＆＆が！doc.evaluate）
      ドキュメントを返します。

    場合（B.オペラは、＆＆window.parseFloat（window.opera.version（））<9.5）
      document.bodyを返します。

    document.documentElementを返します。
  }

  この関数は、定義（D）{
    （！要素）要素= getRootElement（）場合はtrue。

    プロパティ[D] ='クライアント'+ D;

    ビューポート['get'の+ D] =関数（）{return要素[プロパティ[D]]};
    ビューポートを返す['get'の+ D]（）;
  }

  viewport.getWidth = define.curry（'幅'）;

  viewport.getHeight = define.curry（'高さ'）;
}）（document.viewport）;


Element.Storage = {
  UID：1
};

Element.addMethods（{
  getStorage：関数（要素）{
    リターン（！（要素= $（要素）））場合はtrue。

    VARのuid;
    場合（要素===ウィンドウ）{
      UID = 0;
    }他{
      場合（typeof演算element._prototypeUID ==="未定義"）
        element._prototypeUID = Element.Storage.UID + +;
      UID = element._prototypeUID;
    }

    するif（！Element.Storage [UID]）
      Element.Storage [UID] = $ H（）;

    Element.Storage戻る[UID];
  }、

  ストア：関数（要素、キー、値）{
    リターン（！（要素= $（要素）））場合はtrue。

    場合（のarguments.length === 2）{
      Element.getStorage（要素）の更新（キー）;
    }他{
      。Element.getStorage（要素）のセット（キー、値）;
    }

    要素を返します。
  }、

  取得：関数（要素、キー、はdefaultValue）{
    リターン（！（要素= $（要素）））場合はtrue。
    VARハッシュ= Element.getStorage（要素）、値= hash.get（キー）;

    場合（Object.isUndefined（値））{
      hash.set（キー、はdefaultValue）;
      値= defaultValueに。
    }

    値を返す。
  }、

  クローン：関数（要素、深い）{
    リターン（！（要素= $（要素）））場合はtrue。
    VARクローン= element.cloneNode（深さ）;
    clone._prototypeUID =無効0;
    {（深い）場合
      VARの子孫= Element.select（クローン、'*'),
          I = descendants.length;
      { - （i）の中
        子孫[i]は_prototypeUID =無効0;
      }
    }
    Element.extend（クローン）を返します。
  }、

  パージ：関数（要素）{
    リターン（！（要素= $（要素）））場合はtrue。
    VAR purgeElement = Element._purgeElement;

    purgeElement（要素）;

    VARの子孫= element.getElementsByTagName ('*'),
     I = descendants.length;

    一方、（I - ）purgeElement（子孫[I]）;

    nullを返します。
  }
}）;

（関数（）{

  関数ToDecimalの（pctString）{
    VAR一致= pctString.match（/ ^（\ dは+)%?$/ⅰ）;
    場合はnullを返します（一致するもの！）;
    リターン（番号（[1]）/ 100と一致）。
  }

  機能getPixelValue（値、プロパティ、コンテキスト）{
    var要素= NULL;
    場合（Object.isElement（値））{
      要素は、=値;
      値= element.getStyle（プロパティ）;
    }

    場合（値=== NULL）{
      nullを返します。
    }

    場合((/^(?:-)? \ D +（\。\ d +）は？（ピクセル）？$ / i）を。テスト（値））??{
      window.parseFloat（値）を返す。
    }

    VAR isPercentage = value.include ('%'), isViewport =（コンテキスト=== document.viewport）;

    場合（/ \ D / .test（値）＆＆要素＆＆element.runtimeStyle＆＆！（isPercentage＆isViewport））{
      VARスタイル= element.style.left、rStyle = element.runtimeStyle.left;
      element.runtimeStyle.left = element.currentStyle.left;
      element.style.left =値| | 0;
      値= element.style.pixelLeft;
      element.style.left =スタイル。
      element.runtimeStyle.left = rStyle;

      値を返す。
    }

    場合（要素＆＆isPercentage）{
      コンテキスト=コンテキスト| | element.parentNode。
      VAR進= ToDecimalの（値）;
      VAR全体= NULL;
      VAR位置= element.getStyle（'位置'）;

      VAR isHorizo??ntal = property.include（'左'）| | property.include（'右'）| |
       property.include（'幅'）;

      VAR isVertical = property.include（'上部'）| | property.include（'底'）| |
        property.include（'高さ'）;

      場合（コンテキスト=== document.viewport）{
        場合（isHorizo??ntal）{
          全体= document.viewport.getWidth（）;
        }他の場合（isVertical）{
          全体= document.viewport.getHeight（）;
        }
      }他{
        場合（isHorizo??ntal）{
          。全体= $（コンテキスト）を測定（の'width'）;
        }他の場合（isVertical）{
          。全体= $（コンテキスト）を測定（'高さ'）;
        }
      }

      リターン（全体=== NULL）？0：全体*の10進数。
    }

    0を返します。
  }

  関数toCSSPixels（番号）{
    場合（Object.isString（番号）＆＆number.endsWith（'ピクセル'））{
      数を返します。
    }
    戻り番号+'ピクセル';
  }

  この関数は、{（要素）isDisplayed
    VAR originalElement =要素;
    一方、（要素＆＆element.parentNode）{
      VARディスプレイ= element.getStyle（の'display'）;
      {（==='none'を表示していない）場合
        falseを返します。
      }
      要素= $（element.parentNode）;
    }
    trueを返します。
  }

  VAR hasLayout = Prototype.K;
  {（にdocument.documentElementで"currentStyle"）場合
    hasLayout =関数（要素）{
      するif（！element.currentStyle.hasLayout）{
        element.style.zoom = 1;
      }
      要素を返します。
    };
  }

  ファンクションcssNameFor（キー）{
    （key.include（'国境'））キー=キー+"- width'の場合はtrue。
    key.camelize（）を返す。
  }

  Element.Layout = Class.create（ハッシュ、{
    初期化：関数（$超、要素、事前に計算）{
      スーパー$（）;
      this.element = $（要素）;

      Element.Layout.PROPERTIES.each（関数（プロパティ）{
        this._set（プロパティは、null）;
      }、この）;

      場合（事前に計算）{
        this._preComputing = TRUE;
        this._begin（）;
        Element.Layout.PROPERTIES.each（この、this._compute）;
        this._end（）;
        this._preComputing =偽;
      }
    }、

    _set：機能（プロパティ、値）{
      Hash.prototype.set.call（この、プロパティ、値）を返します。
    }、

    セット：機能（プロパティ、値）{
      "Element.Layoutのプロパティは読み取り専用です。"投げる;
    }、

    取得：関数（$超、プロパティ）{
      var値= $スーパー（プロパティ）;
      値=== nullを返す？this._compute（プロパティ）：値;
    }、

    _begin：関数（）{
      リターン（this._prepared）場合はtrue。

      var要素= this.element;
      {（（要素）isDisplayed）場合
        this._prepared = TRUE;
        リターン;
      }

      VAR originalStyles = {
        位置：element.style.position | | ''、
        幅：element.style.width | | ''、
        可視性：element.style.visibility | | ''、
        ディスプレイ：element.style.display | | ''
      };

      element.store（'prototype_original_styles"、originalStyles）;

      VAR位置= element.getStyle（'position'）を、
       幅= element.getStyle（'幅'）;

      場合（幅==="0px"| |幅=== NULL）{
        element.style.display ='ブロック';
        幅= element.getStyle（'幅'）;
      }

      VARコンテキスト=（位置==='固定'）？document.viewport：
       element.parentNode;

      element.setStyle（{
        位置："絶対的"、
        可視性：'hidden'は、
        ディスプレイ："ブロック"
      }）;

      VAR positionedWidth = element.getStyle（'幅'）;

      VAR newWidth;
      場合（幅＆＆（positionedWidth ===幅））{
        newWidth = getPixelValue（要素、'width'の、コンテキスト）;
      }他の場合| {（位置==='絶対的な"位置==='固定'|）
        newWidth = getPixelValue（要素、'width'の、コンテキスト）;
      }他{
        VAR親= element.parentNode、再生= $（親）getLayout（）;

        newWidth = pLayout.get（'幅'） - 
         this.get（'margin - leftの"） - 
         this.get（'国境左'） - 
         this.get（'パディング左'） - 
         this.get（'パディング右'） - 
         this.get（"ボーダー右"） - 
         this.get（'マージン右'）;
      }

      element.setStyle（{幅：newWidth +'ピクセル'}）;

      this._prepared = TRUE;
    }、

    _end：関数（）{
      var要素= this.element;
      VAR originalStyles = element.retrieve（'prototype_original_styles'）;
      element.store（'prototype_original_styles'、NULL）;
      element.setStyle（originalStyles）;
      this._prepared =偽;
    }、

    _compute：関数（プロパティ）{
      VARの計算= Element.Layout.COMPUTATIONS;
      するif（！（計算でプロパティ））{
        "プロパティが見つかりません。"投げる;
      }

      this._setを（。財産、計算[プロパティ]の呼び出し（これ、this.element））を返す。
    }、

    toObject：関数（）{
      可変引数= $ A（引数）;
      VARキー=（args.length == 0）？Element.Layout.PROPERTIES：
       args.join（''）。スプリット（''）;
      れます。var obj = {};
      keys.each（ファンクション（キー）{
        リターン（！Element.Layout.PROPERTIES.include（キー））場合はtrue。
        var値= this.get（キー）;
        場合（値= NULL！）は、obj [キー] =値;
      }、この）;
      objを返します。
    }、

    toHash：関数（）{
      れます。var obj = this.toObject.apply（これ、引数）;
      新しいハッシュ（obj）を返します。
    }、

    toCSS：関数（）{
      可変引数= $ A（引数）;
      VARキー=（args.length == 0）？Element.Layout.PROPERTIES：
       args.join（''）。スプリット（''）;
      VAR CSS = {};

      keys.each（ファンクション（キー）{
        リターン（！Element.Layout.PROPERTIES.include（キー））場合はtrue。
        リターン（Element.Layout.COMPOSITE_PROPERTIES.include（キー））場合はtrue。

        var値= this.get（キー）;
        場合（値= NULL！）CSS [cssNameFor（キー）] =値+'ピクセル';
      }、この）;
      CSSを返します。
    }、

    検査：関数（）{
      "＃<Element.Layout>"を返します。
    }
  }）;

  Object.extend（Element.Layout、{
    PROPERTIES：$ W（"高さの幅の上では右下の枠線 - 左ボーダー - 右ボーダー - 上ボーダーから下のパディング - 左パディング - 右パディングトップパディング下マージントップマージン、下部マージン、左マージン、右パディングを左ボックス幅のパディングボックスの高さの境界ボックスの幅の境界ボックスの高さマージンボックスの幅マージンボックスの高さ'）、

    COMPOSITE_PROPERTIES：$ W（'パディングボックスの幅のパディングボックスの高さのマージンボックスの幅マージンボックスの高さの境界線ボックスの幅の境界線ボックスの高さ'）、

    計算：{
      "高さ"：関数（要素）{
        （！this._preComputing）this._begin（）場合はtrue。

        VAR bHeight = this.get（'ボーダーボックスの高さ'）;
        場合（bHeight <= 0）{
          （！this._preComputing）this._end（）場合はtrue。
          0を返します。
        }

        VAR bTop = this.get（'国境トップ"）、
         bBottom = this.get（'国境底'）;

        VAR PTOP = this.get（'パディングトップ"）、
         pBottom = this.get（'パディング底'）;

        （！this._preComputing）this._end（）場合はtrue。

        bTop -  - bBottom - PTOP - bHeight返すpBottomを。
      }、

      '幅'：関数（要素）{
        （！this._preComputing）this._begin（）場合はtrue。

        VAR bWidth = this.get（'ボーダーボックス幅'）;
        場合（bWidth <= 0）{
          （！this._preComputing）this._end（）場合はtrue。
          0を返します。
        }

        VAR bLeft = this.get（'国境左"）、
         明るい= this.get（'国境右'）;

        VAR pLeft = this.get（'パディング左"）、
         pRight = this.get（'パディング右'）;

        （！this._preComputing）this._end（）場合はtrue。

        bWidth返す - bLeft - 明るい - pLeft - pRight。
      }、

      "パディングボックスの高さ'：関数（要素）{
        VAR高さ= this.get（'高さ'）、
         PTOP = this.get（'パディングトップ"）、
         pBottom = this.get（'パディング底'）;

        高さを返す+ PTOP + pBottom。
      }、

      "パディングボックスの幅'：関数（要素）{
        VAR幅= this.get（'幅'）、
         pLeft = this.get（'パディング左"）、
         pRight = this.get（'パディング右'）;

        幅を返す+ pLeft + pRight。
      }、

      "境界ボックスの高さ'：関数（要素）{
        （！this._preComputing）this._begin（）場合はtrue。
        VAR高さ= element.offsetHeight;
        （！this._preComputing）this._end（）場合はtrue。
        高さを返します。
      }、

      "境界ボックスの幅'：関数（要素）{
        （！this._preComputing）this._begin（）場合はtrue。
        VAR幅= element.offsetWidth;
        （！this._preComputing）this._end（）場合はtrue。
        幅を返します。
      }、

      "マージンボックスの高さ'：関数（要素）{
        VAR bHeight = this.get（'ボーダーボックスの高さ'）、
         MTOP = this.get（"マージントップ"）、
         mBottom = this.get（'マージン底'）;

        0を返す（bHeight <= 0）場合はtrue。

        bHeight + MTOP + mBottomを返します。
      }、

      "マージンボックスの幅'：関数（要素）{
        VAR bWidth = this.get（'ボーダーボックス幅"）、
         mLeft = this.get（'margin - leftの'）、
         mRight = this.get（'マージン右'）;

        0を返す（bWidth <= 0）場合はtrue。

        bWidth + mLeft + mRightを返します。
      }、

      "最'：関数（要素）{
        varは= element.positionedOffsetを（）オフセット;
        offset.topを返します。
      }、

      "底'：関数（要素）{
        varは= element.positionedOffsetを（）、オフセット
         親= element.getOffsetParent（）、
         pHeight = parent.measure（'高さ'）;

        VAR mHeight = this.get（'ボーダーボックスの高さ'）;

        pHeight返す - mHeight - offset.top。
      }、

      '左'：関数（要素）{
        varは= element.positionedOffsetを（）オフセット;
        offset.leftを返します。
      }、

      "正しい"：関数（要素）{
        varは= element.positionedOffsetを（）、オフセット
         親= element.getOffsetParent（）、
         PWIDTH = parent.measure（'幅'）;

        VAR mWidth = this.get（'ボーダーボックス幅'）;

        PWIDTH返す - mWidth - offset.left。
      }、

      "パディングトップ'：関数（要素）{
        getPixelValueを（要素、"paddingTop"）を返す。
      }、

      "パディング底'：関数（要素）{
        getPixelValueを（要素、"paddingBottom'）を返す。
      }、

      "パディング左'：関数（要素）{
        getPixelValueを（要素、"は、paddingLeft'）を返す。
      }、

      "パディング右'：関数（要素）{
        getPixelValueを（要素、"paddingRightの'）を返す。
      }、

      "国境トップ'：関数（要素）{
        getPixelValueを（要素、"borderTopWidth'）を返す。
      }、

      "国境底'：関数（要素）{
        getPixelValueを（要素、"borderBottomWidth'）を返す。
      }、

      "国境左'：関数（要素）{
        getPixelValueを（要素、"borderLeftWidth'）を返す。
      }、

      "国境右'：関数（要素）{
        getPixelValueを（要素、"borderRightWidth'）を返す。
      }、

      "マージントップ'：関数（要素）{
        getPixelValueを返す（要素、"marginTop'）;
      }、

      "マージン底'：関数（要素）{
        getPixelValueを（要素、"marginBottom'）を返す。
      }、

      "margin - leftの'：関数（要素）{
        getPixelValueを（要素、"marginLeft'）を返す。
      }、

      "マージン右'：関数（要素）{
        getPixelValueを（要素、"marginRight'）を返す。
      }
    }
  }）;

  {（にdocument.documentElementで"getBoundingClientRect"）場合
    Object.extend（Element.Layout.COMPUTATIONS、{
      "正しい"：関数（要素）{
        VAR親= hasLayout（element.getOffsetParent（））;
        VAR RECT = element.getBoundingClientRect（）、
         pRect = parent.getBoundingClientRect（）;

        リターン（pRect.right - rect.right）ラウンド（）;
      }、

      "底'：関数（要素）{
        VAR親= hasLayout（element.getOffsetParent（））;
        VAR RECT = element.getBoundingClientRect（）、
         pRect = parent.getBoundingClientRect（）;

        リターン（pRect.bottom - rect.bottom）ラウンド（）;
      }
    }）;
  }

  Element.Offset = Class.create（{
    初期化：関数（上、左）{
      this.left = left.round（）;
      this.top = top.round（）;

      この[0] = this.left;
      この[1] = this.top;
    }、

    relativeToで：機能（オフセット）{
      新しいElement.Offsetを（返す
        this.left - offset.left、
        this.top - offset.top
      ）;
    }、

    検査：関数（）{
      "＃<Element.Offset left: #{left} top: #{top}>"補間（this）を返す。
    }、

    toString戻り値：関数（）{
      。。"[＃{左}、＃{トップ}]"を補間して（これ）を返す
    }、

    れたToArray：関数（）{
      リターン[this.left、this.top];
    }
  }）;

  関数getLayout（要素、事前に計算）{
    新しいElement.Layout（要素、事前に計算して）返す。
  }

  機能の指標（要素、プロパティ）{
    $を（要素）を返すgetLayout（）取得（プロパティ）。。。
  }

  関数getDimensions（要素）{
    要素= $（要素）;
    VARディスプレイ= Element.getStyle（要素、の'display'）;

    {（ディスプレイ＆ディスプレイ！=='none'は）場合
      リターン{幅：element.offsetWidth、高さ：element.offsetHeight};
    }

    VARスタイル= element.style;
    VAR originalStyles = {
      可視性：style.visibility、
      位置：style.position、
      ディスプレイ：style.display
    };

    VAR newStyles = {
      可視性：'hidden'は、
      ディスプレイ："ブロック"
    };

    （originalStyles.position！=='固定'）場合
      newStyles.position ='絶対';

    Element.setStyle（要素、newStyles）;

    VARの寸法= {
      幅：element.offsetWidth、
      高さ：element.offsetHeight
    };

    Element.setStyle（要素、originalStyles）;

    寸法を返します。
  }

  関数getOffsetParent（要素）{
    要素= $（要素）;

    場合（isDocument（エレメント）| |（要素）isDetached | | isBody（エレメント）| | isHtml（要素））
      $を（document.body）を返す。

    VAR isInline =（Element.getStyle（要素、'display'の）==='インライン'）;
    場合のリターン$（element.offsetParent）（isInline＆＆element.offsetParent！）;

    一方、（（要素は= element.parentNode）＆＆要素！== document.body）{
      場合（Element.getStyle（要素、'位置'）！=='静的'）{
        isHtmlを（要素）を返す？$（document.body）：$（要素）;
      }
    }

    $を（document.body）を返す。
  }


  機能cumulativeOffset（要素）{
    要素= $（要素）;
    VAR valueT = 0、valueL = 0;
    場合（element.parentNode）{
      か{
        valueT + = element.offsetTop | | 0;
        valueL + = element.offsetLeft | | 0;
        要素= element.offsetParent;
      }中（要素）;
    }
    新しいElement.Offset（valueL、valueT）を返します。
  }

  機能positionedOffset（要素）{
    要素= $（要素）;

    VARレイアウト= element.getLayout（）;

    VAR valueT = 0、valueL = 0;
    か{
      valueT + = element.offsetTop | | 0;
      valueL + = element.offsetLeft | | 0;
      要素= element.offsetParent;
      場合（要素）{
        休憩（isBody（エレメント））場合はtrue。
        します。var p = Element.getStyle（要素、'位置'）;
        休憩（！P =='静的'）場合はtrue。
      }
    }中（要素）;

    valueL -= layout.get（"マージントップ'）;
    valueT -= layout.get（'margin - leftの'）;

    新しいElement.Offset（valueL、valueT）を返します。
  }

  機能cumulativeScrollOffset（要素）{
    VAR valueT = 0、valueL = 0;
    か{
      valueT + = element.scrollTop | | 0;
      valueL + = element.scrollLeft | | 0;
      要素= element.parentNode;
    }中（要素）;
    新しいElement.Offset（valueL、valueT）を返します。
  }

  機能viewportOffset（forElement）{
    要素= $（要素）;
    VAR valueT = 0、valueL = 0、docBody = document.body;

    var要素= forElement;
    か{
      valueT + = element.offsetTop | | 0;
      valueL + = element.offsetLeft | | 0;
      場合（element.offsetParent == docBody＆＆
        Element.getStyle（要素、'位置'）=='絶対'）休憩;
    }一方、（要素= element.offsetParent）;

    要素= forElement;
    か{
      場合（要素！= docBody）{
        valueT -= element.scrollTop | | 0;
        valueL -= element.scrollLeft | | 0;
      }
    }一方、（要素= element.parentNode）;
    新しいElement.Offset（valueL、valueT）を返します。
  }

  機能絶対化する（要素）{
    要素= $（要素）;

    場合（Element.getStyle（要素、'位置'）==='絶対'）{
      要素を返します。
    }

    VAR offsetParentの= getOffsetParent（要素）;
    VAR eOffset = element.viewportOffset（）、
     pOffset = offsetParent.viewportOffset（）;

    VARオフセット= eOffset.relativeTo（pOffset）;
    VARレイアウト= element.getLayout（）;

    element.store（'prototype_absolutize_original_styles'、{
      左：element.getStyle（'左'）、
      トップ：element.getStyle（'上部'）、
      幅：element.getStyle（'幅'）、
      高さ：element.getStyle（"高さ"）
    }）;

    element.setStyle（{
      位置："絶対的"、
      トップ：offset.top +'ピクセル'、
      左：offset.left +'ピクセル'、
      幅：layout.get（'幅'）+'ピクセル'、
      高さ：layout.get（'高さ'）+'ピクセル'
    }）;

    要素を返します。
  }

  機能相対化（要素）{
    要素= $（要素）;
    場合（Element.getStyle（要素、'位置'）==='相対'）{
      要素を返します。
    }

    VAR originalStyles =
     element.retrieve（'prototype_absolutize_original_styles'）;

    （originalStyles）element.setStyle（originalStyles）場合はtrue。
    要素を返します。
  }

  場合（Prototype.Browser.IE）{
    getOffsetParent = getOffsetParent.wrap（
      関数（、要素を進む）{
        要素= $（要素）;

        場合（isDocument（エレメント）| |（要素）isDetached | | isBody（エレメント）| | isHtml（要素））
          $を（document.body）を返す。

        VAR位置= element.getStyle（'位置'）;
        場合（位置=='静的な'！）（要素）355-2052返します。

        element.setStyle（{位置：'相対'}）;
        var値=進む（要素）;
        element.setStyle（{位置：位置}）;
        値を返す。
      }
    ）;

    positionedOffset = positionedOffset.wrap（機能（進む、要素）{
      要素= $（要素）;
      場合、戻り新しいElement.Offset（0、0）（element.parentNode！）;
      VAR位置= element.getStyle（'位置'）;
      場合（位置=='静的な'！）（要素）355-2052返します。

      VAR offsetParentの= element.getOffsetParent（）;
      （offsetParentの＆＆offsetParent.getStyle（'位置'）==='固定'）場合
        hasLayout（offsetParentの）;

      element.setStyle（{位置：'相対'}）;
      var値=進む（要素）;
      element.setStyle（{位置：位置}）;
      値を返す。
    }）;
  }他の場合（Prototype.Browser.Webkit）{
    cumulativeOffset =関数（要素）{
      要素= $（要素）;
      VAR valueT = 0、valueL = 0;
      か{
        valueT + = element.offsetTop | | 0;
        valueL + = element.offsetLeft | | 0;
        場合（element.offsetParent == document.body）
          休憩（Element.getStyle（要素、'位置'）=='絶対'）場合はtrue。

        要素= element.offsetParent;
      }中（要素）;

      新しいElement.Offset（valueL、valueT）を返します。
    };
  }


  Element.addMethods（{
    getLayout：getLayout、
    測定：測定、
    getDimensions：getDimensions、
    getOffsetParent：getOffsetParent、
    cumulativeOffset：cumulativeOffset、
    positionedOffset：positionedOffset、
    cumulativeScrollOffset：cumulativeScrollOffset、
    viewportOffset：viewportOffset、
    絶対化する：絶対化する、
    相対化：相対化
  }）;

  機能isBody（要素）{
    element.nodeName.toUpperCaseを（返す）==='BODY';
  }

  機能isHtml（要素）{
    element.nodeName.toUpperCase（）==='HTML'を返します。
  }

  isDocument機能（要素）{
    element.nodeType === Node.DOCUMENT_NODEを返します。
  }

  isDetached機能（要素）{
    戻り要素！== document.body＆＆
     ！Element.descendantOf（要素、document.body）;
  }

  {（にdocument.documentElementで"getBoundingClientRect"）場合
    Element.addMethods（{
      viewportOffset：関数（要素）{
        要素= $（要素）;
        リターン新しいElement.Offset（0、0）（（要素）isDetached）場合はtrue。

        VAR RECT = element.getBoundingClientRect（）、
         docEl =にdocument.documentElement;
        docEl.clientLeft、 - 新しいElement.Offset（rect.leftを返す
         rect.top - docEl.clientTop）;
      }
    }）;
  }
})();
ウィンドウ。$ $ =関数（）{
  VAR表現= $ A（引数）に参加（'、'）;
  Prototype.Selector.select（表現、文書）を返します。
};

Prototype.Selector =（関数（）{

  機能選択（）{
    新しいエラーを（'。方式"Prototype.Selector.select"定義されている必要があります"）をスローします。
  }

  関数マッチ（）{
    新しいエラーを（'。方式"Prototype.Selector.match"定義されている必要があります"）をスローします。
  }

  findを関数（要素、表現、インデックス）{
    インデックス=インデックス| | 0;
    VARマッチ= Prototype.Selector.match、長さ= elements.length、matchIndex = 0、I;

    （; I <長さは、i + + I = 0）{のための
      場合（（要素[i]は、式に一致する）＆＆インデックス== matchIndex + +）{
        Element.extendを返す（要素が[I]）;
      }
    }
  }

  関数extendElements（要素）{
    （; I <長さは、i + +します。var i = 0、長さ= elements.length）{用
      Element.extend（要素[I]）;
    }
    の要素を返します。
  }


  VAR K = Prototype.K;

  返す{
    選択：選択して、
    マッチ：マッチ、
    見つける：見つける、
    extendElements：（Element.extend === K）？K：extendElements、
    extendElement：Element.extend
  };
})();
Prototype._original_property = window.Sizzle;
/ *！
 v1.0の - * CSSセレクタエンジンをシズル
 *著作権2009、Dojo Foundationの
 * MIT、BSD、およびGPLライセンス下でリリースされて。
 *詳しい情報：http://sizzlejs.com/
 * /
（関数（）{

VAR chunker = /((?: \（（：\ ([^()]+ \ )|[^()]+)+ \）| \ [（：？？\ [[^ [\]] * \ ]|['"][^'"]*['"]|[^[ \ ]'"]+)+ \] | \ \ | [^ >+~,( \ [\ \] +）+ |[>+~])( \ S *、\ sの*)?((?:.| \ rを| \ n）の*）/ G、
	終了= 0、
	ToStringメソッド= Object.prototype.toString、
	hasDuplicate = falseの場合、
	= trueをbaseHasDuplicate。

[0、0]。ソート（関数（）{
	= falseをbaseHasDuplicate。
	0を返します。
}）;

varは=関数（セレクタ、コンテキスト、その結果、種子）{をシズル
	結果=結果| | [];
	VAR origContext =コンテキスト=コンテキスト| |文書;

	場合（context.nodeType！== 1＆＆context.nodeType！== 9）{
		リターン[];
	}

	場合（セレクタ|！|！typeof演算セレクタ=="文字列"）{
		結果を返す。
	}

	VARの部品= []、M、セット、checkSet、チェック、モード、余分な、=真、contextXML = isXML（コンテキスト）を整理、
		SOFAR =セレクタ;

	{（（chunker.exec (""), M = chunker.exec（SOFAR））！== null）の間
		SOFAR = M [3];

		parts.push（M [1]）;

		場合（M [2]）{
			余分な= M [3];
			破る;
		}
	}

	場合（parts.length> 1＆＆origPOS.exec（セレクタ））{
		場合（parts.length === 2＆＆Expr.relative [パーツ[0]]）{
			セット= posProcess（部品[0] +パーツ[1]、コンテキスト）;
		}他{
			セットは= Expr.relative [パーツ[0]]？
				[コンテキスト]：
				シズル（parts.shift（）、コンテキスト）;

			一方、（parts.length）{
				セレクタ= parts.shift（）;

				場合（Expr.relative [セレクタ]）
					セレクタ+ = parts.shift（）;

				セット= posProcess（セレクタ、セット）;
			}
		}
	}他{
		するif（！シード＆parts.length> 1＆＆context.nodeType === 9＆＆！contextXML＆
				！Expr.match.ID.test（部品[0]）＆＆Expr.match.ID.test（部品[parts.length - 1]））{
			VAR RET = Sizzle.find（parts.shift（）、コンテキスト、contextXML）;
			コンテキスト= ret.expr？Sizzle.filter（ret.expr、ret.set）[0]：ret.set [0];
		}

		{（コンテキスト）場合
			VAR RET =シード？
				{exprは：parts.pop（）、集合：makeArray（シード）}：
				Sizzle.find（parts.pop（）、parts.length === 1＆＆（部品[0] ==="?"| |パーツ[0] ==="+"）＆＆context.parentNode context.parentNode？ ：コンテキスト、contextXML）;
			= ret.exprを設定する？Sizzle.filter（ret.expr、ret.set）：ret.set;

			場合（parts.length> 0）{
				checkSet = makeArray（セット）;
			}他{
				= falseを刈る。
			}

			一方、（parts.length）{
				VAR電流= parts.pop（）、ポップ=電流;

				するif（！Expr.relative [最新版]）{
					最新版="";
				}他{
					ポップ= parts.pop（）;
				}

				場合（ポップアップ== NULL）{
					ポップ=コンテキスト;
				}

				Expr.relative [火]（checkSet、ポップ、contextXML）;
			}
		}他{
			checkSet =部品= [];
		}
	}

	するif（！checkSet）{
		checkSet =設定。
	}

	するif（！checkSet）{
		"構文エラー、認識されない表現："スロー+（|電流|セレクタを）;
	}

	場合（toString.call（checkSet）==="[オブジェクトの配列]"）{
		するif（！プルーン）{
			results.push.apply（結果、checkSet）;
		}他の場合（コンテキスト＆context.nodeType === 1）{
			{（I + +; checkSet [i]は= nullを！します。var i = 0）のための
				{|（checkSet [i]のnodeTypeに=== 1＆＆が含まれている（コンテキスト、checkSet [i]）と）|。checkSet [I]＆＆（checkSet [i]は=== true）をした場合
					results.push（セット[I]）;
				}
			}
		}他{
			{（I + +; checkSet [i]は= nullを！します。var i = 0）のための
				場合（checkSet [i]が＆＆checkSet [i]は。nodeTypeは=== 1）{
					results.push（セット[I]）;
				}
			}
		}
	}他{
		makeArray（checkSet、結果）;
	}

	{（余分な）場合
		シズル（余分、origContext、その結果、種子）;
		Sizzle.uniqueSort（結果）;
	}

	結果を返す。
};

Sizzle.uniqueSort =関数（結果）{
	{（ソート順）場合
		= baseHasDuplicateをhasDuplicate。
		results.sort（ソート順）。

		場合（hasDuplicate）{
			（; I <results.lengthのは、i + +します。var i = 1）{用
				場合（結果が[I] ===結果[I - 1]）{
					results.splice（I - 1）;
				}
			}
		}
	}

	結果を返す。
};

Sizzle.matchesは=関数（exprは、集合）{
	（式、NULL、NULL、セット）シズルを返します。
};

Sizzle.find =関数（exprは、コンテキスト、isXML）{
	変数のセット、マッチ;

	するif（！式expr）{
		リターン[];
	}

	のための（します。var i = 0、L = Expr.order.lengthは、i <Lは、i + +）{
		VARタイプ= Expr.order [i]は、マッチ;

		（（一致= Expr.leftMatch [タイプ]。EXEC（式）））場合{
			VAR左= [1]と一致する。
			match.splice（1,1）;

			場合（left.substr（left.length - ！1）=="\ \"）{
				= [1]と一致する（| [1]と一致|""）。置き換える（/ \ \ / gで、""）;
				セット= Expr.find [タイプ]（一致、コンテキスト、isXML）;
				{（！= nullを設定）した場合
					式expr = expr.replace（Expr.match [タイプ]、""）;
					破る;
				}
			}
		}
	}

	するif（！セット）{
		設定= context.getElementsByTagName ("*");
	}

	戻り値{セット：セット、式expr：expr}を;
};

Sizzle.filter =関数（式、セット、インプレース、ない）{
	VAR古い= exprに、結果= []、curLoop =セット、マッチ、anyFound、
		isXMLFilter =セット＆＆設定[0]＆＆isXML（設定[0]）;

	一方、（式expr＆＆set.length）{
		{（Expr.filterのvarタイプ）用
			{（（= Expr.match [タイプ]。EXEC（式））！= nullを一致させる）場合
				VARフィルタ= Expr.filter [タイプ]、見つかった、アイテム;
				anyFound =偽;

				{（curLoop ==結果）に応じ
					結果= [];
				}

				場合（Expr.preFilter [タイプ]）{
					一致= Expr.preFilter [タイプ]（マッチ、curLoop、インプレース、結果ではなく、isXMLFilter）;

					するif（！一致）{
						anyFound =見つかる= TRUE;
					}他の場合（一致=== TRUE）{
						継続する;
					}
				}

				{（一致す??る）場合
					のための（します。var i = 0;！（項目= curLoop [i]）と= NULL;私+ +）{
						場合（項目）{
							=フィルタ（アイテム、マッチ、私、curLoop）が見つかりました。
							！VARパス=は^が見つかりました。

							場合（インプレース＆＆発見！= NULL）{
								{（合格）した場合
									anyFound = TRUE;
								}他{
									curLoop [I] = FALSE;
								}
							}他の場合（通過）{
								result.push（項目）;
								anyFound = TRUE;
							}
						}
					}
				}

				場合（見つけた！==未定義）{
					するif（！インプレース）{
						curLoop =結果;
					}

					式expr = expr.replace（Expr.match [タイプ]、""）;

					するif（！anyFound）{
						リターン[];
					}

					破る;
				}
			}
		}

		{（exprに==古い）場合
			場合（anyFound == NULL）{
				; + exprは："構文エラー、認識されていない表現を"投げる
			}他{
				破る;
			}
		}

		古い=式;
	}

	curLoopを返します。
};

VAR規則Expr = Sizzle.selectors = {
	順序：["ID"、"NAME"、"TAG"]、
	マッチ：{
		ID：/#((?:[ \ W \ u00c0 - \ uFFFFの-] | \ \ .)+)/,
		CLASS：/ \ .((?:[ \ W \ u00c0 - \ uFFFFの-] | \ \ .)+)/,
		NAME：/ \ [名前=['"]*((?:[ \ W \ u00c0 - \ uFFFFの-] | \ \ .)+)['"]* \] /、
		ATTR：？/ \ [\ sの*((?:[ \ W \ u00c0 - \ uFFFFの-] | \ \）+）\ sは*(?:( \ S =）\ S *(['"]* )(.*?) \ 3 |）\ S * \] /、
		TAG：/^((?:[ \ W \ u00c0 - \ uFFFFの\ *-] | \ \ .)+)/,
		子供：/：（のみ| n番目の|最後|最初）の子（？：\（（偶数|奇数| [\ DN +-]*) \ ))?/,
		POS：/：（n番目の| EQ | GT | LT |最初|最後|偶数|奇数）（：？\（（\ D *）\ ))?(?=[^-]|$)/,
		PSEUDO：/:((?:[ \ W \ u00c0 - \ uFFFFの-] | \ \ .)+)(?: \ ((['"]*)((?: \（[^ \）] + \ ）|？[^ \ 2 \（\ )]*)+) \ 2 \））/
	}、
	leftMatch：{}、
	attrMap：{
		"クラス"："classNameの"、
		"の"："htmlFor"
	}、
	attrHandle：{
		HREF：関数（elemは）{
			戻りelem.getAttribute（"HREF"）;
		}
	}、
	相対：{
		"+"：関数（checkSet、一部、isXML）{
			VAR isPartStr = typeof演算部==="文字列"、
				isTag = isPartStr＆＆！/ \ W / .test（一部）、
				isPartStrNotTag = isPartStr＆＆isTag！;

			場合（isTag＆＆！isXML）{
				パート= part.toUpperCase（）;
			}

			のための（します。var i = 0、L = checkSet.length、elemは、I <L;私+ +）{
				場合（（elemは= checkSet [I]））{
					{}（（elemは= elem.previousSibling）＆＆??elem.nodeType！== 1）一方、

					checkSet [i]は= isPartStrNotTag | | elemは＆＆elem.nodeName ===パート？
						elemは| |偽：
						elemは===一部;
				}
			}

			場合（isPartStrNotTag）{
				Sizzle.filter（一部、checkSet、真の）;
			}
		}、
		">"：機能（checkSet、一部、isXML）{
			VAR isPartStr = typeof演算部==="文字列";

			場合（isPartStr＆＆！/ \ W / .test（一部））{
				一部= isXML？パート：part.toUpperCase（）;

				のための（します。var i = 0、L = checkSet.lengthは、i <Lは、i + +）{
					VAR elemは= checkSet [i]の;
					場合（elemは）{
						VAR親= elem.parentNode;
						checkSet [i]は= parent.nodeName ===パート？親：偽;
					}
				}
			}他{
				のための（します。var i = 0、L = checkSet.lengthは、i <Lは、i + +）{
					VAR elemは= checkSet [i]の;
					場合（elemは）{
						checkSet [i]は= isPartStr？
							elem.parentNode：
							elem.parentNode ===一部;
					}
				}

				場合（isPartStr）{
					Sizzle.filter（一部、checkSet、真の）;
				}
			}
		}、
		""：機能（checkSet、一部、isXML）{
			VAR doneName =終了+ +、checkFn = dirCheck;

			するif（！/ \ W / .test（一部））{
				VAR nodeCheck =パート= isXML？パート：part.toUpperCase（）;
				checkFn = dirNodeCheck;
			}

			checkFn（"parentNodeは"、一部、doneName、checkSet、nodeCheck、isXML）;
		}、
		"?"：機能（checkSet、一部、isXML）{
			VAR doneName =終了+ +、checkFn = dirCheck;

			場合（typeof演算部==="文字列"＆＆！/ \ W / .test（一部））{
				VAR nodeCheck =パート= isXML？パート：part.toUpperCase（）;
				checkFn = dirNodeCheck;
			}

			checkFn（"previousSiblingは"、一部、doneName、checkSet、nodeCheck、isXML）;
		}
	}、
	見つける：{
		ID：関数（一致、コンテキスト、isXML）{
			場合（typeof演算context.getElementById！=="未定義"＆＆！isXML）{
				VAR M = context.getElementById（[1]と一致）。
				mを返す？[M]：[];
			}
		}、
		NAME：関数（一致、コンテキスト、isXML）{
			場合（typeof演算context.getElementsByName！=="未定義"）{
				VAR RET = []、結果= context.getElementsByName（[1]と一致）。

				のための（します。var i = 0、L = results.lengthは、i <Lは、i + +）{
					場合（その結果[i]が。getAttributeメソッド（"名前"）===マッチ[1]）{
						ret.push（結果[I]）;
					}
				}

				ret.length === 0を返す？ヌル：RET;
			}
		}、
		TAG：関数（、コンテキストにマッチする）{
			context.getElementsByTagNameを返す（[1]と一致）。
		}
	}、
	プレフィルター：{
		CLASS：関数（マッチ、curLoop、インプレース、結果ではなく、isXML）{
			=""。+ [1]と一致置き換える（/ \ \ / gを、""）+""一致している。

			場合（isXML）{
				一致を返します。
			}

			{（I + +;（elemは= curLoop [i]）と= nullを！します。var i = 0、elemは）のための
				場合（elemは）{
					場合（ではない^（elem.className＆＆（""+ elem.className +""）。indexOfを（マッチ）> = 0））{
						するif（！インプレース）
							result.push（elemは）;
					}他の場合（インプレース）{
						curLoop [I] = FALSE;
					}
				}
			}

			falseを返します。
		}、
		ID：機能（マッチ）{
			[1]に置き換える（/ \ \ / gを、""）と一致返します。
		}、
		TAG：関数（マッチ、curLoop）{
			のための（します。var i = 0; curLoop [i]は=== falseは、私+ +）{}
			curLoop [I]＆＆isXML（curLoop [I]）を返す？[1]に一致する：[1]と一致するtoUpperCaseの（）;
		}、
		CHILD：機能（マッチ）{
			{（[1] =="n番目"に一致する）場合
				VARテスト= /(-?)( \ D *）N（（：？\ ??+|-)? \ D *）。/ execの（
					[2]と一致=="であっても"＆＆"2N"| |マッチ[2] =="奇数"＆＆"2N +1"| |
					！/ \ D / .test（[2]と一致する）＆＆"0N +"+マッチ[2] | |マッチ[2]）;

				[2]と一致する=（試験[1] +（試験[2] | | 1）） - 0;
				[3] =テスト[3]と一致して - 0;
			}

			一致する[0] =終了+ +;

			一致を返します。
		}、
		ATTR：関数（マッチ、curLoop、インプレース、結果ではなく、isXML）{
			。VAR名=マッチ[1]に置き換える（/ \ \ / gで、""）;

			するif（！isXML＆Expr.attrMap [名前]）{
				[1]と一致= Expr.attrMap [名];
			}

			場合（[2]と一致==="?="）{
				一致する[4] =""+マッチ[4] +"";
			}

			一致を返します。
		}、
		PSEUDO：関数（マッチ、curLoop、インプレース、結果、ではない）{
			場合（[1]と一致==="ではない"）{
				場合（（chunker.exec（[3]と一致する）| |。""）の長さ> 1 | | / ^ \ W / .test（[3]と一致））{
					[3]と一致=シズル（マッチ[3]、NULL、NULL、curLoop）;
				}他{
					VAR RET = Sizzle.filter（[3]と一致する、curLoop、インプレース、真^ではない）。
					するif（！インプレース）{
						result.push.apply（結果、RET）;
					}
					falseを返します。
				}
			}他の場合（Expr.match.POS.test（一致する[0]）| | Expr.match.CHILD.test（）[0]と一致する）{
				trueを返します。
			}

			一致を返します。
		}、
		POS：機能（マッチ）{
			match.unshift（真の）;
			一致を返します。
		}
	}、
	フィルタ：{
		有効：関数（elemは）{
			elem.disabled戻る===偽＆＆elem.type =="隠された";
		}、
		無効：関数（elemは）{
			elem.disabled === trueを返します。
		}、
		チェック：機能（elemは）{
			elem.checked === trueを返します。
		}、
		選択：関数??（elemは）{
			elem.parentNode.selectedIndex;
			===真elem.selected返します。
		}、
		親：関数（elemは）{
			リターンelem.firstChild！;
		}、
		空の：関数（elemは）{
			返すelem.firstChildを！;
		}、
		れています：関数（elemは、私、マッチ）{
			戻るシズル（、elemは[3]と一致する）の長さ！。
		}、
		ヘッダ：機能（elemは）{
			戻る/ H \ D / i.test（elem.nodeName）;
		}、
		テキスト：関数（elemは）{
			"テキスト"=== elem.typeを返します。
		}、
		ラジオ：関数（elemは）{
			"ラジオ"=== elem.typeを返します。
		}、
		チェックボックス：機能（elemは）{
			=== elem.typeを"チェックボックス"を返します。
		}、
		ファイル：関数（elemは）{
			"ファイル"を返す=== elem.type。
		}、
		パスワード：機能（elemは）{
			"パスワード"=== elem.typeを返します。
		}、
		提出：関数（elemは）{
			=== elem.typeを"提出"を返します。
		}、
		画像：機能（elemは）{
			"画像"=== elem.typeを返します。
		}、
		リセット：関数（elemは）{
			"リセット"=== elem.typeを返します。
		}、
		ボタン：機能（elemは）{
			"ボタン"を返す=== elem.type | | elem.nodeName.toUpperCase（）==="BUTTON";
		}、
		入力：関数（elemは）{
			リターン/入力|セレクト|テキストエリア|ボタン/ i.test（elem.nodeName）;
		}
	}、
	setFilters：{
		最初の：関数（elemは、i）を{
			私=== 0を返します。
		}、
		最後に：関数（elemは、私、マッチ、配列）{
			私は返す=== array.length以下 - 1;
		}、
		さえ：関数（elemは、i）を{
			私％2を返す=== 0;
		}、
		奇数：関数（elemは、i）を{
			私％2 === 1を返します。
		}、
		LT：関数（elemは、私が、一致する）{
			私は<[3]と一致して返す - 0;
		}、
		GT：関数（elemは、私が、一致する）{
			戻るi>にマッチ[3] - 0;
		}、
		n番目の：関数（elemは、私が、一致する）{
			[3]と一致戻す - 0 == I;
		}、
		EQ：関数（elemは、私が、一致する）{
			[3]と一致戻す - 0 == I;
		}
	}、
	フィルタ：{
		PSEUDO：関数（elemは、マッチ、私、配列）{
			VAR名= [1]と一致する、フィルタ= Expr.filters [名];

			場合（フィルタ）{
				フィルタを（elemは、私、マッチ、配列）を返す。
			}他の場合（名前は==="含む"）{
				リターン（elem.textContent | | elem.innerText | |""）indexOfを（[3]と一致する）> = 0;
			}他{（名==="ではない"）場合
				varが[3]と一致していない=;

				のための（します。var i = 0、L = not.lengthは、i <Lは、i + +）{
					場合（ではない[i]は=== elemは）{
						falseを返します。
					}
				}

				trueを返します。
			}
		}、
		CHILD：関数（elemは、一致する）{
			VARタイプ= [1]と一致する、ノード= elemは;
			スイッチ（タイプ）{
				場合"のみ"：
				ケース"最初の"：
					一方、（（ノード= node.previousSibling））{
						（node.nodeType === 1）はfalseを返す場合。
					}
					trueを返す（タイプ=='最初の'）場合はtrue。
					ノード= elemは;
				小文字の'最後の'：
					一方、（（ノード= node.nextSibling））{
						（node.nodeType === 1）はfalseを返す場合。
					}
					trueを返します。
				小文字の'n番目の'：
					VAR最初の=マッチ[2]、最後の=マッチ[3];

					場合（最初== 1＆＆最後の== 0）{
						trueを返します。
					}

					VAR doneName = [0]と一致する、
						親= elem.parentNode;

					場合（親＆＆（parent.sizcache == doneName |！|！elem.nodeIndex））{
						VARのカウント= 0;
						{（ノード= node.nextSibling;ノードnode = parent.firstChild）用
							場合（node.nodeType === 1）{
								node.nodeIndex = + +カウント;
							}
						}
						parent.sizcache = doneName;
					}

					VAR差分= elem.nodeIndex - 最後の;
					場合（最初== 0）{
						差分の== 0を返す。
					}他{
						リターン（== 0＆＆diffの最初/> = 0最初のdiff％）;
					}
			}
		}、
		ID：関数（elemは、一致する）{
			=== 1＆＆elem.getAttribute（"ID"）===一致elem.nodeType返します。
		}、
		TAG：関数（elemは、一致する）{
			return (match === "*" && elem.nodeType === 1) || elem.nodeName === match;
		},
		CLASS: function(elem, match){
			return (" " + (elem.className || elem.getAttribute("class")) + " ")
				.indexOf( match ) > -1;
		},
		ATTR: function(elem, match){
			var name = match[1],
				result = Expr.attrHandle[ name ] ?
					Expr.attrHandle[ name ]( elem ) :
					elem[ name ] != null ?
						elem[ name ] :
						elem.getAttribute( name ),
				value = result + "",
				type = match[2],
				check = match[4];

			return result == null ?
				type === "!=" :
				type === "=" ?
				value === check :
				type === "*=" ?
				value.indexOf(check) >= 0 :
				type === "~=" ?
				(" " + value + " ").indexOf(check) >= 0 :
				!check ?
				value && result !== false :
				type === "!=" ?
				value != check :
				type === "^=" ?
				value.indexOf(check) === 0 :
				type === "$=" ?
				value.substr(value.length - check.length) === check :
				type === "|=" ?
				value === check || value.substr(0, check.length + 1) === check + "-" :
				false;
		},
		POS: function(elem, match, i, array){
			var name = match[2], filter = Expr.setFilters[ name ];

			if ( filter ) {
				return filter( elem, i, match, array );
			}
		}
	}
};

var origPOS = Expr.match.POS;

for ( var type in Expr.match ) {
	Expr.match[ type ] = new RegExp( Expr.match[ type ].source + /(?![^\[]*\])(?![^\(]*\))/.source );
	Expr.leftMatch[ type ] = new RegExp( /(^(?:.|\r|\n)*?)/.source + Expr.match[ type ].source );
}

var makeArray = function(array, results) {
	array = Array.prototype.slice.call( array, 0 );

	if ( results ) {
		results.push.apply( results, array );
		return results;
	}

	return array;
};

try {
	Array.prototype.slice.call( document.documentElement.childNodes, 0 );

} catch(e){
	makeArray = function(array, results) {
		var ret = results || [];

		if ( toString.call(array) === "[object Array]" ) {
			Array.prototype.push.apply( ret, array );
		} else {
			if ( typeof array.length === "number" ) {
				for ( var i = 0, l = array.length; i < l; i++ ) {
					ret.push( array[i] );
				}
			} else {
				for ( var i = 0; array[i]; i++ ) {
					ret.push( array[i] );
				}
			}
		}

		return ret;
	};
}

var sortOrder;

if ( document.documentElement.compareDocumentPosition ) {
	sortOrder = function( a, b ) {
		if ( !a.compareDocumentPosition || !b.compareDocumentPosition ) {
			if ( a == b ) {
				hasDuplicate = true;
			}
			return 0;
		}

		var ret = a.compareDocumentPosition(b) & 4 ? -1 : a === b ? 0 : 1;
		if ( ret === 0 ) {
			hasDuplicate = true;
		}
		return ret;
	};
} else if ( "sourceIndex" in document.documentElement ) {
	sortOrder = function( a, b ) {
		if ( !a.sourceIndex || !b.sourceIndex ) {
			if ( a == b ) {
				hasDuplicate = true;
			}
			return 0;
		}

		var ret = a.sourceIndex - b.sourceIndex;
		if ( ret === 0 ) {
			hasDuplicate = true;
		}
		return ret;
	};
} else if ( document.createRange ) {
	sortOrder = function( a, b ) {
		if ( !a.ownerDocument || !b.ownerDocument ) {
			if ( a == b ) {
				hasDuplicate = true;
			}
			return 0;
		}

		var aRange = a.ownerDocument.createRange(), bRange = b.ownerDocument.createRange();
		aRange.setStart(a, 0);
		aRange.setEnd(a, 0);
		bRange.setStart(b, 0);
		bRange.setEnd(b, 0);
		var ret = aRange.compareBoundaryPoints(Range.START_TO_END, bRange);
		if ( ret === 0 ) {
			hasDuplicate = true;
		}
		return ret;
	};
}

(function(){
	var form = document.createElement("div"),
		id = "script" + (new Date).getTime();
	form.innerHTML = "<a name='" + id + "'/>";

	var root = document.documentElement;
	root.insertBefore( form, root.firstChild );

	if ( !!document.getElementById( id ) ) {
		Expr.find.ID = function(match, context, isXML){
			if ( typeof context.getElementById !== "undefined" && !isXML ) {
				var m = context.getElementById(match[1]);
				return m ? m.id === match[1] || typeof m.getAttributeNode !== "undefined" && m.getAttributeNode("id").nodeValue === match[1] ? [m] : undefined : [];
			}
		};

		Expr.filter.ID = function(elem, match){
			var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
			return elem.nodeType === 1 && node && node.nodeValue === match;
		};
	}

	root.removeChild( form );
	root = form = null; // release memory in IE
})();

(function(){

	var div = document.createElement("div");
	div.appendChild( document.createComment("") );

	if ( div.getElementsByTagName("*").length > 0 ) {
		Expr.find.TAG = function(match, context){
			var results = context.getElementsByTagName(match[1]);

			if ( match[1] === "*" ) {
				var tmp = [];

				for ( var i = 0; results[i]; i++ ) {
					if ( results[i].nodeType === 1 ) {
						tmp.push( results[i] );
					}
				}

				results = tmp;
			}

			return results;
		};
	}

	div.innerHTML = "<a href='#'></a>";
	if ( div.firstChild && typeof div.firstChild.getAttribute !== "undefined" &&
			div.firstChild.getAttribute("href") !== "#" ) {
		Expr.attrHandle.href = function(elem){
			return elem.getAttribute("href", 2);
		};
	}

	div = null; // release memory in IE
})();

if ( document.querySelectorAll ) (function(){
	var oldSizzle = Sizzle, div = document.createElement("div");
	div.innerHTML = "<p class='TEST'></p>";

	if ( div.querySelectorAll && div.querySelectorAll(".TEST").length === 0 ) {
		return;
	}

	Sizzle = function(query, context, extra, seed){
		context = context || document;

		if ( !seed && context.nodeType === 9 && !isXML(context) ) {
			try {
				return makeArray( context.querySelectorAll(query), extra );
			} catch(e){}
		}

		return oldSizzle(query, context, extra, seed);
	};

	for ( var prop in oldSizzle ) {
		Sizzle[ prop ] = oldSizzle[ prop ];
	}

	div = null; // release memory in IE
})();

if ( document.getElementsByClassName && document.documentElement.getElementsByClassName ) (function(){
	var div = document.createElement("div");
	div.innerHTML = "<div class='test e'></div><div class='test'></div>";

	if ( div.getElementsByClassName("e").length === 0 )
		return;

	div.lastChild.className = "e";

	if ( div.getElementsByClassName("e").length === 1 )
		return;

	Expr.order.splice(1, 0, "CLASS");
	Expr.find.CLASS = function(match, context, isXML) {
		if ( typeof context.getElementsByClassName !== "undefined" && !isXML ) {
			return context.getElementsByClassName(match[1]);
		}
	};

	div = null; // release memory in IE
})();

function dirNodeCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
	var sibDir = dir == "previousSibling" && !isXML;
	for ( var i = 0, l = checkSet.length; i < l; i++ ) {
		var elem = checkSet[i];
		if ( elem ) {
			if ( sibDir && elem.nodeType === 1 ){
				elem.sizcache = doneName;
				elem.sizset = i;
			}
			elem = elem[dir];
			var match = false;

			while ( elem ) {
				if ( elem.sizcache === doneName ) {
					match = checkSet[elem.sizset];
					break;
				}

				if ( elem.nodeType === 1 && !isXML ){
					elem.sizcache = doneName;
					elem.sizset = i;
				}

				if ( elem.nodeName === cur ) {
					match = elem;
					break;
				}

				elem = elem[dir];
			}

			checkSet[i] = match;
		}
	}
}

function dirCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
	var sibDir = dir == "previousSibling" && !isXML;
	for ( var i = 0, l = checkSet.length; i < l; i++ ) {
		var elem = checkSet[i];
		if ( elem ) {
			if ( sibDir && elem.nodeType === 1 ) {
				elem.sizcache = doneName;
				elem.sizset = i;
			}
			elem = elem[dir];
			var match = false;

			while ( elem ) {
				if ( elem.sizcache === doneName ) {
					match = checkSet[elem.sizset];
					break;
				}

				if ( elem.nodeType === 1 ) {
					if ( !isXML ) {
						elem.sizcache = doneName;
						elem.sizset = i;
					}
					if ( typeof cur !== "string" ) {
						if ( elem === cur ) {
							match = true;
							break;
						}

					} else if ( Sizzle.filter( cur, [elem] ).length > 0 ) {
						match = elem;
						break;
					}
				}

				elem = elem[dir];
			}

			checkSet[i] = match;
		}
	}
}

var contains = document.compareDocumentPosition ?  function(a, b){
	return a.compareDocumentPosition(b) & 16;
} : function(a, b){
	return a !== b && (a.contains ? a.contains(b) : true);
};

var isXML = function(elem){
	return elem.nodeType === 9 && elem.documentElement.nodeName !== "HTML" ||
		!!elem.ownerDocument && elem.ownerDocument.documentElement.nodeName !== "HTML";
};

var posProcess = function(selector, context){
	var tmpSet = [], later = "", match,
		root = context.nodeType ? [context] : context;

	while ( (match = Expr.match.PSEUDO.exec( selector )) ) {
		later += match[0];
		selector = selector.replace( Expr.match.PSEUDO, "" );
	}

	selector = Expr.relative[selector] ? selector + "*" : selector;

	for ( var i = 0, l = root.length; i < l; i++ ) {
		Sizzle( selector, root[i], tmpSet );
	}

	return Sizzle.filter( later, tmpSet );
};


window.Sizzle = Sizzle;

})();

;(function(engine) {
  var extendElements = Prototype.Selector.extendElements;

  function select(selector, scope) {
    return extendElements(engine(selector, scope || document));
  }

  function match(element, selector) {
    return engine.matches(selector, [element]).length == 1;
  }

  Prototype.Selector.engine = engine;
  Prototype.Selector.select = select;
  Prototype.Selector.match = match;
})(Sizzle);

window.Sizzle = Prototype._original_property;
delete Prototype._original_property;

var Form = {
  reset: function(form) {
    form = $(form);
    form.reset();
    return form;
  },

  serializeElements: function(elements, options) {
    if (typeof options != 'object') options = { hash: !!options };
    else if (Object.isUndefined(options.hash)) options.hash = true;
    var key, value, submitted = false, submit = options.submit, accumulator, initial;

    if (options.hash) {
      initial = {};
      accumulator = function(result, key, value) {
        if (key in result) {
          if (!Object.isArray(result[key])) result[key] = [result[key]];
          result[key].push(value);
        } else result[key] = value;
        return result;
      };
    } else {
      initial = '';
      accumulator = function(result, key, value) {
        return result + (result ? '&' : '') + encodeURIComponent(key) + '=' + encodeURIComponent(value);
      }
    }

    return elements.inject(initial, function(result, element) {
      if (!element.disabled && element.name) {
        key = element.name; value = $(element).getValue();
        if (value != null && element.type != 'file' && (element.type != 'submit' || (!submitted &&
            submit !== false && (!submit || key == submit) && (submitted = true)))) {
          result = accumulator(result, key, value);
        }
      }
      return result;
    });
  }
};

Form.Methods = {
  serialize: function(form, options) {
    return Form.serializeElements(Form.getElements(form), options);
  },

  getElements: function(form) {
    var elements = $(form).getElementsByTagName('*'),
        element,
        arr = [ ],
        serializers = Form.Element.Serializers;
    for (var i = 0; element = elements[i]; i++) {
      arr.push(element);
    }
    return arr.inject([], function(elements, child) {
      if (serializers[child.tagName.toLowerCase()])
        elements.push(Element.extend(child));
      return elements;
    })
  },

  getInputs: function(form, typeName, name) {
    form = $(form);
    var inputs = form.getElementsByTagName('input');

    if (!typeName && !name) return $A(inputs).map(Element.extend);

    for (var i = 0, matchingInputs = [], length = inputs.length; i < length; i++) {
      var input = inputs[i];
      if ((typeName && input.type != typeName) || (name && input.name != name))
        continue;
      matchingInputs.push(Element.extend(input));
    }

    return matchingInputs;
  },

  disable: function(form) {
    form = $(form);
    Form.getElements(form).invoke('disable');
    return form;
  },

  enable: function(form) {
    form = $(form);
    Form.getElements(form).invoke('enable');
    return form;
  },

  findFirstElement: function(form) {
    var elements = $(form).getElements().findAll(function(element) {
      return 'hidden' != element.type && !element.disabled;
    });
    var firstByIndex = elements.findAll(function(element) {
      return element.hasAttribute('tabIndex') && element.tabIndex >= 0;
    }).sortBy(function(element) { return element.tabIndex }).first();

    return firstByIndex ? firstByIndex : elements.find(function(element) {
      return /^(?:input|select|textarea)$/i.test(element.tagName);
    });
  },

  focusFirstElement: function(form) {
    form = $(form);
    var element = form.findFirstElement();
    if (element) element.activate();
    return form;
  },

  request: function(form, options) {
    form = $(form), options = Object.clone(options || { });

    var params = options.parameters, action = form.readAttribute('action') || '';
    if (action.blank()) action = window.location.href;
    options.parameters = form.serialize(true);

    if (params) {
      if (Object.isString(params)) params = params.toQueryParams();
      Object.extend(options.parameters, params);
    }

    if (form.hasAttribute('method') && !options.method)
      options.method = form.method;

    return new Ajax.Request(action, options);
  }
};

/*--------------------------------------------------------------------------*/


Form.Element = {
  focus: function(element) {
    $(element).focus();
    return element;
  },

  select: function(element) {
    $(element).select();
    return element;
  }
};

Form.Element.Methods = {

  serialize: function(element) {
    element = $(element);
    if (!element.disabled && element.name) {
      var value = element.getValue();
      if (value != undefined) {
        var pair = { };
        pair[element.name] = value;
        return Object.toQueryString(pair);
      }
    }
    return '';
  },

  getValue: function(element) {
    element = $(element);
    var method = element.tagName.toLowerCase();
    return Form.Element.Serializers[method](element);
  },

  setValue: function(element, value) {
    element = $(element);
    var method = element.tagName.toLowerCase();
    Form.Element.Serializers[method](element, value);
    return element;
  },

  clear: function(element) {
    $(element).value = '';
    return element;
  },

  present: function(element) {
    return $(element).value != '';
  },

  activate: function(element) {
    element = $(element);
    try {
      element.focus();
      if (element.select && (element.tagName.toLowerCase() != 'input' ||
          !(/^(?:button|reset|submit)$/i.test(element.type))))
        element.select();
    } catch (e) { }
    return element;
  },

  disable: function(element) {
    element = $(element);
    element.disabled = true;
    return element;
  },

  enable: function(element) {
    element = $(element);
    element.disabled = false;
    return element;
  }
};

/*--------------------------------------------------------------------------*/

var Field = Form.Element;

var $F = Form.Element.Methods.getValue;

/*--------------------------------------------------------------------------*/

Form.Element.Serializers = (function() {
  function input(element, value) {
    switch (element.type.toLowerCase()) {
      case 'checkbox':
      case 'radio':
        return inputSelector(element, value);
      default:
        return valueSelector(element, value);
    }
  }

  function inputSelector(element, value) {
    if (Object.isUndefined(value))
      return element.checked ? element.value : null;
    else element.checked = !!value;
  }

  function valueSelector(element, value) {
    if (Object.isUndefined(value)) return element.value;
    else element.value = value;
  }

  function select(element, value) {
    if (Object.isUndefined(value))
      return (element.type === 'select-one' ? selectOne : selectMany)(element);

    var opt, currentValue, single = !Object.isArray(value);
    for (var i = 0, length = element.length; i < length; i++) {
      opt = element.options[i];
      currentValue = this.optionValue(opt);
      if (single) {
        if (currentValue == value) {
          opt.selected = true;
          return;
        }
      }
      else opt.selected = value.include(currentValue);
    }
  }

  function selectOne(element) {
    var index = element.selectedIndex;
    return index >= 0 ? optionValue(element.options[index]) : null;
  }

  function selectMany(element) {
    var values, length = element.length;
    if (!length) return null;

    for (var i = 0, values = []; i < length; i++) {
      var opt = element.options[i];
      if (opt.selected) values.push(optionValue(opt));
    }
    return values;
  }

  function optionValue(opt) {
    return Element.hasAttribute(opt, 'value') ? opt.value : opt.text;
  }

  return {
    input:         input,
    inputSelector: inputSelector,
    textarea:      valueSelector,
    select:        select,
    selectOne:     selectOne,
    selectMany:    selectMany,
    optionValue:   optionValue,
    button:        valueSelector
  };
})();

/*--------------------------------------------------------------------------*/


Abstract.TimedObserver = Class.create(PeriodicalExecuter, {
  initialize: function($super, element, frequency, callback) {
    $super(callback, frequency);
    this.element   = $(element);
    this.lastValue = this.getValue();
  },

  execute: function() {
    var value = this.getValue();
    if (Object.isString(this.lastValue) && Object.isString(value) ?
        this.lastValue != value : String(this.lastValue) != String(value)) {
      this.callback(this.element, value);
      this.lastValue = value;
    }
  }
});

Form.Element.Observer = Class.create(Abstract.TimedObserver, {
  getValue: function() {
    return Form.Element.getValue(this.element);
  }
});

Form.Observer = Class.create(Abstract.TimedObserver, {
  getValue: function() {
    return Form.serialize(this.element);
  }
});

/*--------------------------------------------------------------------------*/

Abstract.EventObserver = Class.create({
  initialize: function(element, callback) {
    this.element  = $(element);
    this.callback = callback;

    this.lastValue = this.getValue();
    if (this.element.tagName.toLowerCase() == 'form')
      this.registerFormCallbacks();
    else
      this.registerCallback(this.element);
  },

  onElementEvent: function() {
    var value = this.getValue();
    if (this.lastValue != value) {
      this.callback(this.element, value);
      this.lastValue = value;
    }
  },

  registerFormCallbacks: function() {
    Form.getElements(this.element).each(this.registerCallback, this);
  },

  registerCallback: function(element) {
    if (element.type) {
      switch (element.type.toLowerCase()) {
        case 'checkbox':
        case 'radio':
          Event.observe(element, 'click', this.onElementEvent.bind(this));
          break;
        default:
          Event.observe(element, 'change', this.onElementEvent.bind(this));
          break;
      }
    }
  }
});

Form.Element.EventObserver = Class.create(Abstract.EventObserver, {
  getValue: function() {
    return Form.Element.getValue(this.element);
  }
});

Form.EventObserver = Class.create(Abstract.EventObserver, {
  getValue: function() {
    return Form.serialize(this.element);
  }
});
(function() {

  var Event = {
    KEY_BACKSPACE: 8,
    KEY_TAB:       9,
    KEY_RETURN:   13,
    KEY_ESC:      27,
    KEY_LEFT:     37,
    KEY_UP:       38,
    KEY_RIGHT:    39,
    KEY_DOWN:     40,
    KEY_DELETE:   46,
    KEY_HOME:     36,
    KEY_END:      35,
    KEY_PAGEUP:   33,
    KEY_PAGEDOWN: 34,
    KEY_INSERT:   45,

    cache: {}
  };

  var docEl = document.documentElement;
  var MOUSEENTER_MOUSELEAVE_EVENTS_SUPPORTED = 'onmouseenter' in docEl
    && 'onmouseleave' in docEl;



  var isIELegacyEvent = function(event) { return false; };

  if (window.attachEvent) {
    if (window.addEventListener) {
      isIELegacyEvent = function(event) {
        return !(event instanceof window.Event);
      };
    } else {
      isIELegacyEvent = function(event) { return true; };
    }
  }

  var _isButton;

  function _isButtonForDOMEvents(event, code) {
    return event.which ? (event.which === code + 1) : (event.button === code);
  }

  var legacyButtonMap = { 0: 1, 1: 4, 2: 2 };
  function _isButtonForLegacyEvents(event, code) {
    return event.button === legacyButtonMap[code];
  }

  function _isButtonForWebKit(event, code) {
    switch (code) {
      case 0: return event.which == 1 && !event.metaKey;
      case 1: return event.which == 2 || (event.which == 1 && event.metaKey);
      case 2: return event.which == 3;
      default: return false;
    }
  }

  if (window.attachEvent) {
    if (!window.addEventListener) {
      _isButton = _isButtonForLegacyEvents;
    } else {
      _isButton = function(event, code) {
        return isIELegacyEvent(event) ? _isButtonForLegacyEvents(event, code) :
         _isButtonForDOMEvents(event, code);
      }
    }
  } else if (Prototype.Browser.WebKit) {
    _isButton = _isButtonForWebKit;
  } else {
    _isButton = _isButtonForDOMEvents;
  }

  function isLeftClick(event)   { return _isButton(event, 0) }

  function isMiddleClick(event) { return _isButton(event, 1) }

  function isRightClick(event)  { return _isButton(event, 2) }

  function element(event) {
    event = Event.extend(event);

    var node = event.target, type = event.type,
     currentTarget = event.currentTarget;

    if (currentTarget && currentTarget.tagName) {
      if (type === 'load' || type === 'error' ||
        (type === 'click' && currentTarget.tagName.toLowerCase() === 'input'
          && currentTarget.type === 'radio'))
            node = currentTarget;
    }

    if (node.nodeType == Node.TEXT_NODE)
      node = node.parentNode;

    return Element.extend(node);
  }

  function findElement(event, expression) {
    var element = Event.element(event);

    if (!expression) return element;
    while (element) {
      if (Object.isElement(element) && Prototype.Selector.match(element, expression)) {
        return Element.extend(element);
      }
      element = element.parentNode;
    }
  }

  function pointer(event) {
    return { x: pointerX(event), y: pointerY(event) };
  }

  function pointerX(event) {
    var docElement = document.documentElement,
     body = document.body || { scrollLeft: 0 };

    return event.pageX || (event.clientX +
      (docElement.scrollLeft || body.scrollLeft) -
      (docElement.clientLeft || 0));
  }

  function pointerY(event) {
    var docElement = document.documentElement,
     body = document.body || { scrollTop: 0 };

    return  event.pageY || (event.clientY +
       (docElement.scrollTop || body.scrollTop) -
       (docElement.clientTop || 0));
  }


  function stop(event) {
    Event.extend(event);
    event.preventDefault();
    event.stopPropagation();

    event.stopped = true;
  }


  Event.Methods = {
    isLeftClick:   isLeftClick,
    isMiddleClick: isMiddleClick,
    isRightClick:  isRightClick,

    element:     element,
    findElement: findElement,

    pointer:  pointer,
    pointerX: pointerX,
    pointerY: pointerY,

    stop: stop
  };

  var methods = Object.keys(Event.Methods).inject({ }, function(m, name) {
    m[name] = Event.Methods[name].methodize();
    return m;
  });

  if (window.attachEvent) {
    function _relatedTarget(event) {
      var element;
      switch (event.type) {
        case 'mouseover':
        case 'mouseenter':
          element = event.fromElement;
          break;
        case 'mouseout':
        case 'mouseleave':
          element = event.toElement;
          break;
        default:
          return null;
      }
      return Element.extend(element);
    }

    var additionalMethods = {
      stopPropagation: function() { this.cancelBubble = true },
      preventDefault:  function() { this.returnValue = false },
      inspect: function() { return '[object Event]' }
    };

    Event.extend = function(event, element) {
      if (!event) return false;

      if (!isIELegacyEvent(event)) return event;

      if (event._extendedByPrototype) return event;
      event._extendedByPrototype = Prototype.emptyFunction;

      var pointer = Event.pointer(event);

      Object.extend(event, {
        target: event.srcElement || element,
        relatedTarget: _relatedTarget(event),
        pageX:  pointer.x,
        pageY:  pointer.y
      });

      Object.extend(event, methods);
      Object.extend(event, additionalMethods);

      return event;
    };
  } else {
    Event.extend = Prototype.K;
  }

  if (window.addEventListener) {
    Event.prototype = window.Event.prototype || document.createEvent('HTMLEvents').__proto__;
    Object.extend(Event.prototype, methods);
  }

  function _createResponder(element, eventName, handler) {
    var registry = Element.retrieve(element, 'prototype_event_registry');

    if (Object.isUndefined(registry)) {
      CACHE.push(element);
      registry = Element.retrieve(element, 'prototype_event_registry', $H());
    }

    var respondersForEvent = registry.get(eventName);
    if (Object.isUndefined(respondersForEvent)) {
      respondersForEvent = [];
      registry.set(eventName, respondersForEvent);
    }

    if (respondersForEvent.pluck('handler').include(handler)) return false;

    var responder;
    if (eventName.include(":")) {
      responder = function(event) {
        if (Object.isUndefined(event.eventName))
          return false;

        if (event.eventName !== eventName)
          return false;

        Event.extend(event, element);
        handler.call(element, event);
      };
    } else {
      if (!MOUSEENTER_MOUSELEAVE_EVENTS_SUPPORTED &&
       (eventName === "mouseenter" || eventName === "mouseleave")) {
        if (eventName === "mouseenter" || eventName === "mouseleave") {
          responder = function(event) {
            Event.extend(event, element);

            var parent = event.relatedTarget;
            while (parent && parent !== element) {
              try { parent = parent.parentNode; }
              catch(e) { parent = element; }
            }

            if (parent === element) return;

            handler.call(element, event);
          };
        }
      } else {
        responder = function(event) {
          Event.extend(event, element);
          handler.call(element, event);
        };
      }
    }

    responder.handler = handler;
    respondersForEvent.push(responder);
    return responder;
  }

  function _destroyCache() {
    for (var i = 0, length = CACHE.length; i < length; i++) {
      Event.stopObserving(CACHE[i]);
      CACHE[i] = null;
    }
  }

  var CACHE = [];

  if (Prototype.Browser.IE)
    window.attachEvent('onunload', _destroyCache);

  if (Prototype.Browser.WebKit)
    window.addEventListener('unload', Prototype.emptyFunction, false);


  var _getDOMEventName = Prototype.K,
      translations = { mouseenter: "mouseover", mouseleave: "mouseout" };

  if (!MOUSEENTER_MOUSELEAVE_EVENTS_SUPPORTED) {
    _getDOMEventName = function(eventName) {
      return (translations[eventName] || eventName);
    };
  }

  function observe(element, eventName, handler) {
    element = $(element);

    var responder = _createResponder(element, eventName, handler);

    if (!responder) return element;

    if (eventName.include(':')) {
      if (element.addEventListener)
        element.addEventListener("dataavailable", responder, false);
      else {
        element.attachEvent("ondataavailable", responder);
        element.attachEvent("onlosecapture", responder);
      }
    } else {
      var actualEventName = _getDOMEventName(eventName);

      if (element.addEventListener)
        element.addEventListener(actualEventName, responder, false);
      else
        element.attachEvent("on" + actualEventName, responder);
    }

    return element;
  }

  function stopObserving(element, eventName, handler) {
    element = $(element);

    var registry = Element.retrieve(element, 'prototype_event_registry');
    if (!registry) return element;

    if (!eventName) {
      registry.each( function(pair) {
        var eventName = pair.key;
        stopObserving(element, eventName);
      });
      return element;
    }

    var responders = registry.get(eventName);
    if (!responders) return element;

    if (!handler) {
      responders.each(function(r) {
        stopObserving(element, eventName, r.handler);
      });
      return element;
    }

    var i = responders.length, responder;
    while (i--) {
      if (responders[i].handler === handler) {
        responder = responders[i];
        break;
      }
    }
    if (!responder) return element;

    if (eventName.include(':')) {
      if (element.removeEventListener)
        element.removeEventListener("dataavailable", responder, false);
      else {
        element.detachEvent("ondataavailable", responder);
        element.detachEvent("onlosecapture", responder);
      }
    } else {
      var actualEventName = _getDOMEventName(eventName);
      if (element.removeEventListener)
        element.removeEventListener(actualEventName, responder, false);
      else
        element.detachEvent('on' + actualEventName, responder);
    }

    registry.set(eventName, responders.without(responder));

    return element;
  }

  function fire(element, eventName, memo, bubble) {
    element = $(element);

    if (Object.isUndefined(bubble))
      bubble = true;

    if (element == document && document.createEvent && !element.dispatchEvent)
      element = document.documentElement;

    var event;
    if (document.createEvent) {
      event = document.createEvent('HTMLEvents');
      event.initEvent('dataavailable', bubble, true);
    } else {
      event = document.createEventObject();
      event.eventType = bubble ? 'ondataavailable' : 'onlosecapture';
    }

    event.eventName = eventName;
    event.memo = memo || { };

    if (document.createEvent)
      element.dispatchEvent(event);
    else
      element.fireEvent(event.eventType, event);

    return Event.extend(event);
  }

  Event.Handler = Class.create({
    initialize: function(element, eventName, selector, callback) {
      this.element   = $(element);
      this.eventName = eventName;
      this.selector  = selector;
      this.callback  = callback;
      this.handler   = this.handleEvent.bind(this);
    },

    start: function() {
      Event.observe(this.element, this.eventName, this.handler);
      return this;
    },

    stop: function() {
      Event.stopObserving(this.element, this.eventName, this.handler);
      return this;
    },

    handleEvent: function(event) {
      var element = Event.findElement(event, this.selector);
      if (element) this.callback.call(this.element, event, element);
    }
  });

  function on(element, eventName, selector, callback) {
    element = $(element);
    if (Object.isFunction(selector) && Object.isUndefined(callback)) {
      callback = selector, selector = null;
    }

    return new Event.Handler(element, eventName, selector, callback).start();
  }

  Object.extend(Event, Event.Methods);

  Object.extend(Event, {
    fire:          fire,
    observe:       observe,
    stopObserving: stopObserving,
    on:            on
  });

  Element.addMethods({
    fire:          fire,

    observe:       observe,

    stopObserving: stopObserving,

    on:            on
  });

  Object.extend(document, {
    fire:          fire.methodize(),

    observe:       observe.methodize(),

    stopObserving: stopObserving.methodize(),

    on:            on.methodize(),

    loaded:        false
  });

  if (window.Event) Object.extend(window.Event, Event);
  else window.Event = Event;
})();

(function() {
  /* Support for the DOMContentLoaded event is based on work by Dan Webb,
     Matthias Miller, Dean Edwards, John Resig, and Diego Perini. */

  var timer;

  function fireContentLoadedEvent() {
    if (document.loaded) return;
    if (timer) window.clearTimeout(timer);
    document.loaded = true;
    document.fire('dom:loaded');
  }

  function checkReadyState() {
    if (document.readyState === 'complete') {
      document.stopObserving('readystatechange', checkReadyState);
      fireContentLoadedEvent();
    }
  }

  function pollDoScroll() {
    try { document.documentElement.doScroll('left'); }
    catch(e) {
      timer = pollDoScroll.defer();
      return;
    }
    fireContentLoadedEvent();
  }

  if (document.addEventListener) {
    document.addEventListener('DOMContentLoaded', fireContentLoadedEvent, false);
  } else {
    document.observe('readystatechange', checkReadyState);
    if (window == top)
      timer = pollDoScroll.defer();
  }

  Event.observe(window, 'load', fireContentLoadedEvent);
})();

Element.addMethods();

/*------------------------------- DEPRECATED -------------------------------*/

Hash.toQueryString = Object.toQueryString;

var Toggle = { display: Element.toggle };

Element.Methods.childOf = Element.Methods.descendantOf;

var Insertion = {
  Before: function(element, content) {
    return Element.insert(element, {before:content});
  },

  Top: function(element, content) {
    return Element.insert(element, {top:content});
  },

  Bottom: function(element, content) {
    return Element.insert(element, {bottom:content});
  },

  After: function(element, content) {
    return Element.insert(element, {after:content});
  }
};

var $continue = new Error('"throw $continue" is deprecated, use "return" instead');

var Position = {
  includeScrollOffsets: false,

  prepare: function() {
    this.deltaX =  window.pageXOffset
                || document.documentElement.scrollLeft
                || document.body.scrollLeft
                || 0;
    this.deltaY =  window.pageYOffset
                || document.documentElement.scrollTop
                || document.body.scrollTop
                || 0;
  },

  within: function(element, x, y) {
    if (this.includeScrollOffsets)
      return this.withinIncludingScrolloffsets(element, x, y);
    this.xcomp = x;
    this.ycomp = y;
    this.offset = Element.cumulativeOffset(element);

    return (y >= this.offset[1] &&
            y <  this.offset[1] + element.offsetHeight &&
            x >= this.offset[0] &&
            x <  this.offset[0] + element.offsetWidth);
  },

  withinIncludingScrolloffsets: function(element, x, y) {
    var offsetcache = Element.cumulativeScrollOffset(element);

    this.xcomp = x + offsetcache[0] - this.deltaX;
    this.ycomp = y + offsetcache[1] - this.deltaY;
    this.offset = Element.cumulativeOffset(element);

    return (this.ycomp >= this.offset[1] &&
            this.ycomp <  this.offset[1] + element.offsetHeight &&
            this.xcomp >= this.offset[0] &&
            this.xcomp <  this.offset[0] + element.offsetWidth);
  },

  overlap: function(mode, element) {
    if (!mode) return 0;
    if (mode == 'vertical')
      return ((this.offset[1] + element.offsetHeight) - this.ycomp) /
        element.offsetHeight;
    if (mode == 'horizontal')
      return ((this.offset[0] + element.offsetWidth) - this.xcomp) /
        element.offsetWidth;
  },


  cumulativeOffset: Element.Methods.cumulativeOffset,

  positionedOffset: Element.Methods.positionedOffset,

  absolutize: function(element) {
    Position.prepare();
    return Element.absolutize(element);
  },

  relativize: function(element) {
    Position.prepare();
    return Element.relativize(element);
  },

  realOffset: Element.Methods.cumulativeScrollOffset,

  offsetParent: Element.Methods.getOffsetParent,

  page: Element.Methods.viewportOffset,

  clone: function(source, target, options) {
    options = options || { };
    return Element.clonePosition(target, source, options);
  }
};

/*--------------------------------------------------------------------------*/

if (!document.getElementsByClassName) document.getElementsByClassName = function(instanceMethods){
  function iter(name) {
    return name.blank() ? null : "[contains(concat(' ', @class, ' '), ' " + name + " ')]";
  }

  instanceMethods.getElementsByClassName = Prototype.BrowserFeatures.XPath ?
  function(element, className) {
    className = className.toString().strip();
    var cond = /\s/.test(className) ? $w(className).map(iter).join('') : iter(className);
    return cond ? document._getElementsByXPath('.//*' + cond, element) : [];
  } : function(element, className) {
    className = className.toString().strip();
    var elements = [], classNames = (/\s/.test(className) ? $w(className) : null);
    if (!classNames && !className) return elements;

    var nodes = $(element).getElementsByTagName('*');
    className = ' ' + className + ' ';

    for (var i = 0, child, cn; child = nodes[i]; i++) {
      if (child.className && (cn = ' ' + child.className + ' ') && (cn.include(className) ||
          (classNames && classNames.all(function(name) {
            return !name.toString().blank() && cn.include(' ' + name + ' ');
          }))))
        elements.push(Element.extend(child));
    }
    return elements;
  };

  return function(className, parentElement) {
    return $(parentElement || document.body).getElementsByClassName(className);
  };
}(Element.Methods);

/*--------------------------------------------------------------------------*/

Element.ClassNames = Class.create();
Element.ClassNames.prototype = {
  initialize: function(element) {
    this.element = $(element);
  },

  _each: function(iterator) {
    this.element.className.split(/\s+/).select(function(name) {
      return name.length > 0;
    })._each(iterator);
  },

  set: function(className) {
    this.element.className = className;
  },

  add: function(classNameToAdd) {
    if (this.include(classNameToAdd)) return;
    this.set($A(this).concat(classNameToAdd).join(' '));
  },

  remove: function(classNameToRemove) {
    if (!this.include(classNameToRemove)) return;
    this.set($A(this).without(classNameToRemove).join(' '));
  },

  toString: function() {
    return $A(this).join(' ');
  }
};

Object.extend(Element.ClassNames.prototype, Enumerable);

/*--------------------------------------------------------------------------*/

(function() {
  window.Selector = Class.create({
    initialize: function(expression) {
      this.expression = expression.strip();
    },

    findElements: function(rootElement) {
      return Prototype.Selector.select(this.expression, rootElement);
    },

    match: function(element) {
      return Prototype.Selector.match(element, this.expression);
    },

    toString: function() {
      return this.expression;
    },

    inspect: function() {
      return "#<Selector: " + this.expression + ">";
    }
  });

  Object.extend(Selector, {
    matchElements: function(elements, expression) {
      var match = Prototype.Selector.match,
          results = [];

      for (var i = 0, length = elements.length; i < length; i++) {
        var element = elements[i];
        if (match(element, expression)) {
          results.push(Element.extend(element));
        }
      }
      return results;
    },

    findElement: function(elements, expression, index) {
      index = index || 0;
      var matchIndex = 0, element;
      for (var i = 0, length = elements.length; i < length; i++) {
        element = elements[i];
        if (Prototype.Selector.match(element, expression) && index === matchIndex++) {
          return Element.extend(element);
        }
      }
    },

    findChildElements: function(element, expressions) {
      var selector = expressions.toArray().join(', ');
      return Prototype.Selector.select(selector, element || document);
    }
  });
})();