Modify the push method

[sie/sie.git] / org / w3c / dom / smil.js

/*SIE-SVG without Plugin under LGPL2.1 & GPL2.0 & Mozilla Public License\r
 *公式ページは http://sie.sourceforge.jp/\r
 *利用方法は <script defer="defer" type="text/javascript" src="sie.js"></script>\r
 *http://sie.sourceforge.jp/\r
 *Usage: <script defer="defer" type="text/javascript" src="sie.js"></script>\r
 */\r
/* ***** BEGIN LICENSE BLOCK *****\r
 * Version: MPL 1.1/GPL 2.0/LGPL 2.1\r
 *\r
 * The contents of this file are subject to the Mozilla Public License Version\r
 * 1.1 (the "License"); you may not use this file except in compliance with\r
 * the License. You may obtain a copy of the License at\r
 * http://www.mozilla.org/MPL/\r
 *\r
 * Software distributed under the License is distributed on an "AS IS" basis,\r
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License\r
 * for the specific language governing rights and limitations under the\r
 * License.\r
 *\r
 * The Original Code is the Mozilla SVG Cairo Renderer project.\r
 *\r
 * The Initial Developer of the Original Code is IBM Corporation.\r
 * Portions created by the Initial Developer are Copyright (C) 2004\r
 * the Initial Developer. All Rights Reserved.\r
 *\r
 * Parts of this file contain code derived from the following files(s)\r
 * of the Mozilla SVG project (these parts are Copyright (C) by their\r
 * respective copyright-holders):\r
 *    layout/svg/renderer/src/libart/nsSVGLibartBPathBuilder.cpp\r
 *\r
 * Contributor(s):DHRNAME revulo\r
 *\r
 * Alternatively, the contents of this file may be used under the terms of\r
 * either of the GNU General Public License Version 2 or later (the "GPL"),\r
 * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),\r
 * in which case the provisions of the GPL or the LGPL are applicable instead\r
 * of those above. If you wish to allow use of your version of this file only\r
 * under the terms of either the GPL or the LGPL, and not to allow others to\r
 * use your version of this file under the terms of the MPL, indicate your\r
 * decision by deleting the provisions above and replace them with the notice\r
 * and other provisions required by the GPL or the LGPL. If you do not delete\r
 * the provisions above, a recipient may use your version of this file under\r
 * the terms of any one of the MPL, the GPL or the LGPL.\r
 *\r
 * ***** END LICENSE BLOCK ***** */\r
/*\r
 * Copyright (c) 2000 World Wide Web Consortium,\r
 * (Massachusetts Institute of Technology, Institut National de\r
 * Recherche en Informatique et en Automatique, Keio University). All\r
 * Rights Reserved. This program is distributed under the W3C's Software\r
 * Intellectual Property License. This program is distributed in the\r
 * hope that it will be useful, but WITHOUT ANY WARRANTY; without even\r
 * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\r
 * PURPOSE.\r
 * See W3C License http://www.w3.org/Consortium/Legal/ for more details.\r
 */\r
\r
\r
/*$frame オブジェクト\r
 * 全体のフレームの管理を行う\r
 */\r
base("$frame").mix ( {\r
  /*フレームレート。１ミリ秒何フレームか。計算を省略するためミリ秒使用*/\r
  fpms: 0.024,\r
\r
  /*タイムラインのリスト (時間区間の設定ができる）*/\r
  timelines: [],\r
\r
  /*開始フレーム数。アニメーションの開始条件となる\r
   * 単位はフレーム数であって、秒数ではない*/\r
  begin: 0,\r
\r
  /*活動継続時間 (Active Duration)のフレーム数。アニメーションの継続条件となる\r
   * 単位はフレーム数であって、秒数ではない*/\r
  activeTime: Number.MAX_VALUE,\r
  \r
  /*現在のフレーム数*/\r
  currentFrame: 0,\r
  \r
  /*タイムラインの優先度*/\r
  rank: 0,\r
  \r
  /*アニメーションを開始させるメソッド*/\r
  startAnimation: function() {\r
    /*__step関数は最後に書く*/\r
    __step();\r
  },\r
  \r
  /*アニメーションが停止した状態かどうか、停止しているならばtrue*/\r
  isPaused: false,\r
\r
  /*アニメーションを停止させるメソッド*/\r
  pauseAnimation: function() {\r
    this.isPaused = true;\r
  },\r
\r
  /*setFrame メソッド\r
   * フレーム数を数値num まで進めるか、戻す*/\r
  setFrame: function( /*number*/ num) {\r
    if((num < this.begin) || (num >= (this.begin+this.activeTime))) {\r
      return;\r
    }\r
    this.currentFrame = num;\r
    var timelines = this.timelines;\r
    for (var i=0;i<timelines.length;++i) {\r
      if (timelines[i] === this) {\r
        /*自分自身が含まれていると、永久に再帰を繰り返して、「スタック領域が不足」してしまう*/\r
        continue;\r
      }\r
      timelines[i].setFrame(num);\r
    }\r
  },\r
  \r
  /*addLineメソッド\r
   * タイムラインを追加したあと、trueを返す\r
   * ただし、引数objのobj.beginとobj.activeTimeが定まっていない場合はfalseを返す*/\r
  addLine: function( /*$frame*/ obj ) {\r
    if(!obj || (!obj.begin && (obj.begin !== 0))\r
    || (!obj.activeTime && (obj.activeTime !== 0)) ) {\r
      /*どちらのプロパティも未確認の場合、タイムラインは追加されない*/\r
      return false;\r
    }\r
    var timelines = this.timelines;\r
    if ( timelines.indexOf(obj) >= 0 ) {\r
      this.removeLine(obj);\r
    }\r
    /*ランクをソートしておくことで、タイムラインを実行する順序を決める\r
     *配列の後になればなるほど、ランクが高い\r
     * 主に、begin用のタイムラインの前に、end用のタイムラインが実行されるのを防ぐのが目的\r
     * なお、sortメソッドを使うよりも、以下のような処理を使って、5倍程度高速化する*/\r
    if (!timelines.length\r
        || (timelines[timelines.length-1].rank <= obj.rank) \r
        || !obj.rank) {\r
      timelines.push(obj);\r
      timelines = void 0;\r
      return true;\r
    }\r
    for (var i=timelines.length-1;i<0;--i) {\r
      /*後ろから検索して、i番目のrankプロパティが同じか大きい場合であれば、その項目に追加*/\r
      if (timelines[i].rank <= obj.rank) {\r
        timelines.splice(i+1, 0, obj);\r
        timelines = void 0;\r
        return true;\r
      }\r
    }\r
    if (obj.rank < timelines[0].rank) {\r
      /*objが一番低いランクの場合*/\r
      timelines.unshift(obj);\r
    }\r
    timelines = void 0;
    return true;\r
  },\r
  \r
  /*removeLine メソッド\r
   * 指定されたタイムラインのオブジェクトを、リストから削除する*/\r
  removeLine: function( /*$frame*/ timeline ) {\r
    var list = this.timelines,\r
        j = list.indexOf(timeline);\r
    if (j > -1) {\r
      list.splice(j, 1);      //Arrayのspliceを利用して、リストからtimelineを排除\r
    }\r
    list = j = void 0;\r
  }\r
} ).mix( function($frame) {  \r
  /*$begin オブジェクト\r
   * 開始のタイミングを計算する*/\r
  $frame.up("$begin").mix( {\r
\r
    /*開始時刻やタイミングが書かれた文字列*/\r
    string: "",\r
\r
    /*イベントやindefinteで未解決かどうか*/\r
    isResolved: false,\r
    \r
    /*イベントが適用される要素*/\r
    eventTarget: document.documentElement,\r
    \r
    /*現在のフレーム数を改めて初期化*/\r
    currentFrame: 0,\r
    \r
    /*イベント同期で使う時間差のフレーム数*/\r
    eventOffset: 0,\r
    \r
    /*repeat(1)など文字列内に書かれたリピート回数*/\r
    repeat: 0,\r
    \r
    /*accessKey(a)の"a"などキーイベントの対象となる文字列*/\r
    accessKey: "",\r
\r
    /*trim メソッド\r
     * 文字列中の空白を除去*/\r
    trim: function(str) {\r
      /*strがString型以外のときは必ずエラーを出す*/\r
      return str.replace(/[\s\n]+/g, "");\r
    },\r
\r
    /*offset メソッド\r
     * 引数に渡された文字列から、ミリ秒単位に変換した時間を、解析して返す*/\r
    offset: function(str) {\r
      str = str || "0";\r
      var plusminus = str.charAt(0),\r
          /*parseFloatのエイリアス*/\r
          _float = parseFloat,\r
          s = _float( str.match(/[\d.]+ms$/) || "0") + sec() + min() + h();\r
      if (plusminus === "-") {\r
        s *= -1;\r
      }\r
      plusminus = _float = sec = min = h = void 0;\r
      return s;\r
      \r
      /*00:00:0と00:0と、0sなどの文字列をミリ秒へ変換*/\r
      function sec() {\r
        return str2num( 1000, /[\d.]+s$/, /[\d.]+$/ );\r
      };\r
      function min() {\r
        return str2num( 60000, /[\d.]+min$/, /\d\d:[^:]+$/ );\r
      };\r
      function h() {\r
        return str2num( 3600000, /\d+:\d\d:/, /[\d.]+h$/ );\r
      };\r
      function str2num(s, /*RegExp*/ a, /*RegExp*/ b) {\r
        return s*( _float(str.match(a) || "0") || _float(str.match(b) || "0") );\r
      };\r
    },\r
\r
    /*event メソッド\r
     * 引数の文字列から、idとイベントに相当する文字列のプロパティを持ったオブジェクトを返す\r
     * idがない場合や、イベントがない場合は空文字列を該当のプロパティに入れる*/\r
    event: function(str) {\r
      str = str || "";\r
      if (/[\+\-]/.test(str)) {\r
        /*数値がある場合は切り取っておく*/\r
        str = str.slice(0, str.search(/[\+\-]/));\r
      }\r
      if (str.indexOf(".") > -1) {\r
        /*ドットが見つかった場合、IDとイベントに分けておく*/\r
        var ide = str.split(".");\r
        /* エラーが起きて、idが空文字列ならば、evtも空文字列。逆も然り*/\r
        return {\r
          id: (ide[1] && ide[0]),\r
          event: (ide[0] && ide[1])\r
        };\r
      } else {\r
        return {\r
          id: "",\r
          event: str\r
        };\r
      }\r
    },\r
    \r
    /*parse メソッド\r
     * stringプロパティを解析して、フレーム数を算出し、結果を$frame.beginプロパティに出力\r
     * また、イベントリスナーに登録をしておく*/\r
    parse: function() {\r
      /*初期値を設定*/\r
      this.begin = 0;\r
      this.isResolved = false;\r
      var str = this.trim(this.string),\r
          plusminus = str.search(/[\+\-]/),\r
          event = null,\r
          ele;\r
      if (str === "indefinite") {\r
        this.begin = Number.MAX_VALUE;\r
      } else if (plusminus > 0) {\r
        /*Event-Value +/- Clock-Value の場合*/\r
        this.begin = this.offset( str.slice(plusminus) );\r
        event = this.event(str);\r
      } else if ( /[^\+\-\d]/.test(str.charAt(0)) ) {\r
        /*Event-Valuen　のみの場合*/\r
        event = this.event(str);\r
      } else {\r
        /*+/- Clock-Value のみの場合*/\r
        this.begin = this.offset( str );\r
        /*イベントもindefiniteもないので、解決済みと考える*/\r
        this.isResolved = true;\r
      }\r
      /*もしもあれば、リピートの回数を求める*/\r
      this.repeat = /repeat\((\d+)\)/.test(str) ? +RegExp.$1 : 0;\r
      /*もしもあれば、押されるはずのキーを求める*/\r
      this.accessKey = /accessKey\(([^\)]+?)\)/.test(str) ? RegExp.$1 : "";\r
      this.begin = Math.floor( this.begin * this.fpms);\r
      if (event) {\r
        ele = event.id ? this.eventTarget.ownerDocument.getElementById(event.id)\r
                        : this.eventTarget;\r
        /*イベントの時間差を設定しておく*/\r
        this.eventOffset = this.begin;\r
        if (this.repeat > 0) {\r
          ele && ele.addEventListener("repeatEvent", (function(evt) {\r
            if (evt.detail === this.repeat) {\r
              this.listener(evt);\r
            } }).bind(this), true);\r
        } else if (this.accessKey) {\r
          document.documentElement.addEventListener("keydown", (function(evt) {\r
            if (evt.char === this.accessKey) {\r
                this.listener(evt);\r
              } }).bind(this), false);\r
        } else {\r
          var evtName = /^(?:begin|end|repeat)$/.test(event.event) ? event.event + "Event"\r
                          : event.event;\r
          ele && ele.addEventListener(evtName, this.listener.bind(this), false);\r
        }\r
      } else {\r
        /*イベントの影響を防ぐため\r
         * すでに、フレームオブジェクトのタイムラインには登録済みなので、\r
         * フレームではなく、自分独自のタイムラインに登録しておけばよい*/\r
        this.$frame = this;\r
      }\r
      s = event = str = plusminus = ele = void 0;\r
      return this;\r
    },\r
    \r
    /*イベントのリスナーとして、parseメソッドで使う*/\r
    listener: function(evt) {\r
      this.begin = this.eventOffset + this.$frame.currentFrame;\r
      var s = this.$activate;\r
      s.begin = this.begin;\r
      this.activeTime = s.call() || Number.MAX_VALUE;\r
      this.simpleDuration = s.simpleDur;\r
      s = void 0;\r
      this.$frame.addLine(this);\r
      this.isResolved = true;\r
    }\r
    \r
  /*$activate オブジェクト\r
   * 活動継続時間などを計算するための計算実体\r
   * $begin オブジェクトからの継承*/\r
  } ).up("$activate").of( {\r
    \r
    /*単純継続時間のパースされる前の文字列*/\r
    dur: "indefinite",\r
    \r
    /*活動をストップさせるためのオブジェクト*/\r
    end: $frame.$begin.up("$end"),\r
\r
    /*リピート回数*/\r
    repeatCount: null,\r
    \r
    /*繰り返し時間*/\r
    repeatDur: null,\r
\r
    /*単純継続時間 (単位はフレーム数)*/\r
    simpleDur: function() {\r
      return ( (this.dur === "indefinite") || !this.dur ) ?\r
                null\r
              : Math.floor(this.offset(this.dur) * this.fpms) ;\r
    },\r
\r
    /*最小値に制限される\r
     * 最小値 <= 活動継続時間 とならなければならない*/\r
     min: "0",\r
     \r
    /*最大値に制限される\r
     * 活動継続時間 <= 最大値 とならなければならない*/\r
     max: "indefinite",\r
    \r
    /*解決した(計算する)ときの時間*/\r
    resolvedTime: function() {\r
      return Date.now();\r
    },\r
    \r
    /*関数型の呼び出しメソッド\r
     * base.jsのofメソッドを活用して、関数型っぽい処理をする\r
     * 以下では、活動継続時間を算出\r
     * 計算方法はSMILアニメーション 3.3.4節を参照\r
     * http://www.w3.org/TR/smil-animation/#ComputingActiveDur\r
     */\r
    call: function() {\r
      var ind = "indefinite",\r
          dur = this.simpleDur,\r
          isIndefRepeatCount = (this.repeatCount === ind),\r
          isIndefRepeatDur = (this.repeatDur === ind),\r
          isIndefEnd = (this.end === ind),\r
          isDur = dur || (dur === 0),\r
          isEnd = this.end || (this.end === 0),\r
          isRepeatCount = this.repeatCount || (this.repeatCount === 0),\r
          isRepeatDur = this.repeatDur || (this.repeatDur === 0),\r
          actList = [],\r
          min = Math.floor(this.offset(this.min) * this.fpms),\r
          max = (this.max === ind) ? null : Math.floor(this.offset(this.max) * this.fpms),\r
          s;\r
      if (indef()) {\r
        return null;\r
      }\r
      if (isDur && this.repeatCount && !isIndefRepeatCount) {\r
        actList.push( dur * this.repeatCount );\r
      }\r
      if (isRepeatDur && !isIndefRepeatDur) {\r
        actList.push( Math.floor( this.offset(this.repeatDur) * this.fpms) );\r
      }\r
      if (isEnd && !isIndefEnd) {\r
        actList.push( this.end - this.begin );\r
      }\r
      if (isDur && !isRepeatCount && !isRepeatDur) {\r
        /*repeatCountやrepeatDur属性が指定されていない場合*/\r
        actList.push( dur );\r
      }\r
\r
      /*長くなるため、インライン関数を活用\r
       * indef関数は活動継続時間が不定かどうか、もし、不定なら真を返す*/\r
      function indef() {\r
        if(isIndefEnd) {\r
          return true;\r
        } else if (isEnd) {\r
          return false;\r
        }\r
        return !!( (!isDur && !isRepeatDur)\r
                   || (isIndefRepeatCount && !isRepeatDur)\r
                   || (isIndefRepeatDur && !isRepeatCount)\r
                   || (isIndefRepeatCount && isIndefRepeatDur)\r
                 );\r
      };\r
      \r
      ind = dur = isIndefRepeatCount = isIndefRepeatDurindef = isDur = isEnd = isRepeatDur = isRepeatCount = indef = void 0;\r
\r
      if (actList.length === 1) {\r
        s = actList[0];\r
      } else if(actList.length > 1) {\r
        /*属性が競合するときは、最小値をとること (SMILアニメーション 3.3.4節)*/\r
        s = Math.min.apply(Math, actList);\r
      } else {\r
        return null;\r
      }\r
      if ( max && (min > max) ) {\r
        return s;\r
      }\r
      min && (min > s) && (s = min);\r
      max && (max < s) && (s = max);\r
      return s;\r
    }\r
  } );\r
  $frame.$begin.$end.of( {\r
    call: function() {\r
      if (!this.string) {\r
        return null;\r
      }\r
      this.parse(this.string);\r
      return this.isResolved ? this.begin\r
                             : "indefinite";\r
    }\r
  } ).mix( {\r
    /*イベントリスナー用の関数*/\r
    listener: function(evt) {\r
      if (this.begin <= 0) {\r
        /*強制的に終了させる*/\r
        this.removeLine(this.$begin);\r
      }\r
      this.begin = this.eventOffset + this.$frame.currentFrame;\r
      var s = this.$begin.$activate;\r
      s.end = this.begin;\r
      /*未解決だったendの値が、イベントの発生により、解決して再定義されたとき、\r
       * $activateオブジェクトを使って活動継続時間を再計算する*/\r
      this.$begin.activeTime = s.call();\r
      this.isResolved = true;\r
      s = void 0;\r
    }\r
  } );\r
} );\r
/*$from オブジェクト\r
 * 呈示値 (presentation value)の計算をする。値そのものを返すための計算実体*/\r
base("$from").of( {\r
  /*呈示値が書かれた文字列*/\r
  string: "",\r
  \r
  /*呈示値の数値の部分だけを抜き出した配列を返す*/\r
  numList: function() {\r
    var s  = this.string.match(/[\-\+]?[\d\.]+(?:[eE][\-\+]?[\d\.]+)?/g)\r
             || [];\r
    if (s) {\r
      /*mapメソッドで代用してもよい*/\r
      for (var i=0;i<s.length;++i) {\r
        s[i] = parseFloat(s[i]);\r
      }\r
    }\r
    return s;\r
  },\r
  \r
  /*呈示値の文字部分だけを抜き出した配列を返す*/\r
  strList: function() {\r
    /*replaceメソッドで1E-10などの対策*/\r
    return this.string.replace(/\d[eE][\-\+\d]/g, "")\r
                      .match(/[^\d\-\+\.]+/g);\r
  },\r
  \r
  from: base("$from").up().mix( {\r
          from: null\r
        } ),\r
  \r
  /*$toオブジェクトにこのオブジェクトを適用させる関数*/\r
  call: function() {\r
    /*advanceメソッドで使うために、stringを保持*/\r
    this.numList.string = this.string;\r
    if (this.numList.length\r
          && (this.additive[0] === 0)\r
          && (this.accumulate[0] === 0)\r
          ) {\r
      /*配列の項目がundefinedだと困るので、配列を初期化する*/\r
      var additive = [],\r
          accumulate = [];\r
      for (var i=0;i<this.numList.length;++i) {\r
        /*0で配列を初期化しておく*/\r
        additive[i] = accumulate[i] = 0;\r
      }\r
      this.additive = additive;\r
      this.accumulate = accumulate;\r
    }\r
    /*文字部分の配置パターンは4通りあるので、ここでstrListを処理\r
     * (1) a 0 の場合\r
     * (2) 0 a\r
     * (3) a 0 a (ノーマルパターン)\r
     * (4) 0 a 0\r
     * これらのパターンのうち、(1)(2)(4)を(3)のパターンに統一したのが以下の処理*/\r
    /*文字列が1aのように、数値で始まるかどうか。始まったら真*/\r
    if (!this.string || !this.numList.length || !this.strList) {\r
      return this.numList;\r
    }\r
    var isNormal = (this.numList.length < this.strList.length);\r
    if (/^[\-\+]?[\d\.]/.test(this.string) && !isNormal) {\r
      /*文字列が1aのように、数値で始まる場合*/\r
      this.strList.unshift("");\r
    }\r
    if (/\d$/.test(this.string) && !isNormal) {\r
      /*文字列がa1のように、数値で終わる場合*/\r
      this.strList.push("");\r
    }\r
    return this.numList;\r
  }\r
    \r
} )\r
 .mix( {\r
   /*advanceメソッドで使われる有効数字の桁数 (小数点の桁数を決めるときに使う)*/\r
   degit: 0,\r
   \r
   /*additve属性やaccumulate属性が設定された、累積アニメーションか、加法アニメーションで使われる*/\r
   additive: [0],\r
   accumulate: [0],\r
   \r
   /*advance メソッド\r
    * アニメーションの進行具合を示す進捗率 t (0 <= t <= 1)をもとに、現在の呈示値を算出するためのもの\r
    * callメソッドが前もって呼び出されていることが前提となる*/\r
    advance: function(t) {\r
      if ( (t < 0) || (1 < t)) {\r
        throw new Error("An Invalid Number Error");\r
      }\r
      if (!this.string) {\r
        return "";\r
      } else if (!this.from.length) {\r
        /*discreteのために、this.stringに数値が入っていない場合の対処*/\r
        if (t === 1) {\r
          return this.string;\r
        }\r
        return this.from.string;\r
      }\r
      var str = "",\r
          numList = this.numList,\r
          strList = this.strList,\r
          fromNumList = this.from,\r
          deg = this.degit,\r
          additive = this.additive,\r
          accumulate = this.accumulate;\r
      for (var i=0,nuli=numList.length;i<nuli;++i) {\r
        /*原点Oを(0,0,...0)とおく\r
         *$fromと$toを、原点Oからの二つのベクトル (n次空間のベクトル)、ベクトルOFとベクトルOTと考える\r
         *$fromと$toの二つの端の点FとTを結ぶ線分を、t : 1-t で内分する点をPとおく\r
         * このときのベクトルOPを求めたのが以下の式*/\r
        str += ( t * numList[i] + (1 - t) * fromNumList[i] + additive[i] + accumulate[i]).toFixed(deg);\r
        strList && ( str += strList[i+1] );\r
      }\r
      /*文字列はcallメソッドにより、a0aのパターンになっているので、aの部分を追加*/\r
      str = (strList ? strList[0] : "") + str;\r
      numList = strList = fromNumList = i = nuli = deg = additive = accumulate = void 0;\r
      return str;\r
    },\r
    \r
    /*distanceメソッド\r
     * fromベクトルから自分自身のベクトルへの距離 (ノルム)の数値を返す。callメソッドを使うので注意すること*/\r
     distance: function(from) {\r
       if (!from) {\r
          return 0;\r
       }\r
       var toList = this.call(),\r
           fromList = from.call ? from.call() : from,\r
           s = 0;\r
       if (!toList || !fromList) {\r
         return 0;\r
       }\r
       for (var i=0, tli=toList.length; i<tli; ++i) {\r
         s += (toList[i] - fromList[i])*(toList[i] - fromList[i]);\r
       }\r
       return Math.sqrt(s);\r
     },\r
     \r
     /*setAdditive メソッド\r
      * additve属性がsumのときに使われるメソッド\r
      * 引数は親要素の、現在の属性値*/\r
      setAdditive: function(str) {\r
        if (!str) {\r
          return 0;\r
        }\r
        var from = this.$from.up();\r
        from.string = str;\r
        return ( this.additive = from.call() );\r
      },\r
     \r
     /*setAccumulate メソッド\r
      * accumulate属性がsumのときに使われるメソッド\r
      * 引数は現在のリピート回数*/\r
      setAccumulate: function(num) {\r
        if (!num || isNaN(num)) {\r
          return 0;\r
        }\r
        return ( this.accumulate = this.numList.map( function(d) {\r
          return d * num;\r
        } ) );\r
      }\r
  } )\r
  /*fromプロパティの初期化*/\r
 .up("$to").from = null;\r
 \r
 /*計算モードを定めるための計算実体\r
  *補間の細かい制御などを行う*/\r
 base("$calcMode").mix({\r
   /*計算モード　(calcMode属性の値)*/\r
   mode: "linear",\r
\r
   /*keyTimesの区間\r
    * たとえば、"0, 0.5, 0.7, 1"の場合、時間の区間はそれぞれ、0.5 (=0.5-0)  0.2 (=0.7-0.5)  0.3 (=1-0.7)である\r
    * このうち、どれか一つが値として入力される*/\r
   keyTime: 1,\r
   \r
   /*keySpline属性の値を設定*/\r
   keySplines: null,\r
\r
   /*callメソッドで使う関数\r
    * 進捗率を時間の圧縮率( = keyTimeプロパティ)で割ることで、現在、どこまで進んでいるのかを求めることができる*/\r
   _f: function (t) {\r
         /*tは進捗率*/\r
         var tkey = this.keyTime;\r
         if ( (tkey === 0) && t) {\r
           t = 0; \r
         } else if (!tkey || !isFinite(tkey) ) {\r
           return this.string;\r
         } else {\r
           t = t / tkey;\r
           t = (t > 1) ? Math.floor(t) : t;\r
         }\r
         tkey = void 0;\r
         return isNaN(t) ? this.string\r
                         : this.to.advance(t);\r
     }\r
 }).of( {\r
   \r
   /*全体の行列ノルム（距離）*/\r
   norm: 1,\r
\r
   /*無効だった場合の呈示値*/\r
   string: "",\r
   \r
   /*与えられたアニメーションの進捗率を使った時間の圧縮率を計算して呈示値を返すための関数を作る*/\r
   call: function() {\r
     var f = this._f.bind(this);\r
     if (this.mode === "linear") {\r
       this.to.call();\r
       return f;\r
     } else if (this.mode === "paced") {\r
       /*keyTimes属性は無視され、ベクトルの距離の割合から計算される*/\r
       this.keyTime = this.to.distance(this.to.from) / this.norm;\r
       return f;\r
     } else if (this.mode === "spline") {\r
       var tk = this.keySplines,\r
           /*必ず関数を返すようにするため、円周率を返す関数tfを返して、nullの代わりとする*/\r
           tf = function(x) {\r
                 return Math.PI;\r
           };\r
      tf.isNotAnimate = true;\r
      if (!tk) {\r
         return tf;\r
       }\r
      for (var i=0,tki = NaN;i<tk.length;++i) {\r
       tki = tk[i];\r
       if (isNaN(tki)) {\r
         return tf;\r
       }\r
       if ( (tki < 0) || (1 < tki)) {\r
         return tf;\r
       }\r
     }\r
     this.to.call();\r
     var x2 = tk[0],\r
         y2 = tk[1],\r
         x3 = tk[2],\r
         y3 = tk[3],\r
         x4 = 1,\r
         y4 = 1,\r
         Ax = x4-3*(x3-x2),\r
         Bx = 3*(x3-2*x2),\r
         Cx = 3*x2,\r
         Ay = y4-3*(y3-y2),\r
         By = 3*(y3-2*y2),\r
         Cy = 3*y2,\r
         _newton = Math.qubicnewton; //高速化のためのエイリアス\r
     if ( ( (x2 === 0) || (x2 === 1) )\r
          && (y2 === 0)\r
          && ( (x3 === 1) || (x3 === 0) )\r
          && (y3 === 1) ) {\r
            /*linearモードと同じ効果 (収束ではない可能性を考慮)*/\r
            this.to.call();\r
            return f;\r
     }\r
     var tkey = this.keyTime;\r
     if (tkey || isFinite(tkey) ) {\r
       /*keyTimeから時間の収縮率を3次ベジェ曲線に適用しておく*/\r
       Ax *= tkey;\r
       Bx *= tkey;\r
       Cx *= tkey;\r
       Ay *= tkey;\r
       By *= tkey;\r
       Cy *= tkey;\r
     }\r
     tkey = tk = x2 = y2 = x3 = y3 = x4 = y4 = void 0;\r
     return function (x) {\r
        /*3次ベジェ曲線は媒介曲線\r
         *x = (x4-3*(x3-x2)-x1)*t*t*t + 3*(x3-2*x2+x1)*t*t + 3*(x2-x1)*t + x1\r
         *y = (y4-3*(y3-y2)-y1)*t*t*t + 3*(y3-2*y2+y1)*t*t + 3*(y2-y1)*t + y1\r
         * ただし、0 <= t <= 1\r
         * スプラインモードの場合、x1 = y1 = 0, x4 = y4 = 1\r
         * ベジェ曲線のxの式が三次方程式であるため、その解 t から、ベジェ曲線の y を求める\r
         * なお、ニュートン法の初期値はxとする\r
         * なぜなら、xの式をみると、xが増加傾向となるスプラインモードでは、係数が負となる可能性が低いため*/\r
        var t = _newton(Ax, Bx, Cx, -x, x);\r
        return f(Ay*t*t*t + By*t*t + Cy*t);\r
      };\r
    } else if (this.mode === "discrete") {\r
      this.to.call();\r
      return function (t) {\r
        if (isNaN(t)) {\r
          return this.string;\r
        } else if (t === 1) {\r
          return this.to.string;\r
        } else {\r
          return this.to.advance(0);\r
        }\r
      }.bind(this);\r
    }\r
  }\r
} ).to = base("$from").$to;\r
\r
\r
/*ニュートン法により、三次方程式 a0x^3 + a1x^2 + a2x + a3 の解を求める\r
 * 引数bは初期値*/\r
Math.qubicnewton = function(a0, a1, a2, a3, b) {\r
  var eps = 1e-10,                          //収束誤差\r
      fb = a0 *b*b*b + a1 *b*b + a2*b + a3; //方程式の結果\r
  if (fb === 0) {\r
    return b;\r
  }\r
  /*限界の収束回数は100回*/\r
  for (var i=0;i<100;++i) {\r
    /*数値nは与えられた三次方程式を微分したもの*/\r
    var n = 3* a0 *b*b + 2 * a1 *b + a2;\r
    if (!n || ( (fb < eps) && (fb > -eps) )) {\r
      fb = eps = void 0;\r
      return b;\r
    } else {\r
      /*以下は収束の漸化式*/\r
      b =  b - fb / n;\r
      fb = a0 *b*b*b + a1 *b*b + a2*b + a3;\r
    }\r
  }\r
  return b; //収束しなかった結果\r
};\r
\r
/*$attribute オブジェクト\r
 * アニメーションの時間調整と、呈示値の調整を一つのオブジェクトにまとめて行うことで、\r
 * アニメーションサンドイッチの実装をする\r
 * $calcModeオブジェクトから継承*/\r
base("$calcMode").up("$attribute").mix( {\r
  \r
  /*アニメーションの対象となる要素。たとえば、animate要素の親要素*/\r
  element: null,\r
  \r
  /*$fromオブジェクトを作るためのひな形となるオブジェクト*/\r
  $from: base("$from").up(),\r
  \r
  /*attributeName属性の値*/\r
  attrName: "",\r
  \r
  /*属性の名前空間*/\r
  attrNameSpace: null,\r
  \r
    /*指定された属性の規定値*/\r
  defaultValue: "",\r
  \r
  /*もともと属性がターゲットの要素につけられていたかどうか*/\r
  isDefault: false,\r
  \r
  /*attributeType属性がCSSだったときや、autoで属性名がCSSプロパティ名だったときには、true*/\r
  isCSS: false,\r
  \r
  /*指定した要素の属性値を取得するメソッド*/\r
  getAttr: function(/*string*/ name, def) {\r
    var nameSpace = null;\r
    if (name.indexOf("xlink:") > -1) {\r
      nameSpace = "http://www.w3.org/1999/xlink";\r
    }\r
    var s = this._ele.getAttributeNS(nameSpace, name);\r
    if (this.element) {\r
        var view = this.element.ownerDocument.defaultView;\r
      if (s === "inherit") {\r
        return view.getComputedStyle(this.element.parentNode, "").getPropertyValue(this.attrName);\r
      } else if (s === "currentColor") {\r
        return view.getComputedStyle(this._ele, "").getPropertyValue("color");\r
      }\r
    }\r
    /*DOM Level2やIE11では、getAttributeNSメソッドは空文字を返す。他のブラウザではnullを返すことが多い\r
     * \r
     * >the empty string if that attribute does not have a specified or default value\r
     * http://www.w3.org/TR/DOM-Level-2-Core/core.html#ID-ElGetAttrNS*/\r
    return (s || def);\r
  },\r
  \r
  _ele: document.documentElement,\r
  \r
  /*指定された要素にvalues属性が付いているかどうかのチェックできるメソッド*/\r
  hasAttrValues: function () {\r
    var ele = this._ele;\r
    if (!ele) {\r
      return false;\r
    } else {\r
      return ( ele.hasAttribute("from") || ele.hasAttribute("to")\r
         || ele.hasAttribute("by") || ele.hasAttribute("values") );\r
    }\r
  },\r
  \r
  /*後述のsetAttributeメソッドで使うキャッシュ\r
   * これを使うことで、二度同じ値を設定せずにすむので、高速化できる*/\r
  __cacheAttr: "",\r
  \r
  /*アニメーションするために、対象の属性やプロパティを変化させるメソッド*/\r
  setAttribute: function (value) {\r
    var attrName = this.attrName;\r
    if (!attrName) {\r
      return;\r
    }\r
    if (this.__cacheAttr === value) {\r
      /*同じ値であれば、再設定しない*/\r
      return;\r
    } else {\r
      this.__cacheAttr = value;\r
    }\r
    var ele = this.element;\r
    if (this.isCSS) {\r
      /*スタイルシートのプロパティを上書きしておく*/\r
      ele.style.setProperty(attrName, value, "");\r
    } else {\r
      ele.setAttributeNS(this.attrNameSpace, attrName, value);\r
    }\r
    value = attrName = ele = void 0;\r
  },\r
  \r
  /*setAttributeメソッドとは逆の効果で、無効化させるメソッド*/\r
  removeAttribute: function () {\r
    var attrName = this.attrName;\r
    if (!attrName) {\r
      return;\r
    }\r
    var ele = this.element;\r
    if (this.isDefault) {\r
      this.setAttribute(this.defaultValue);\r
    } else {\r
      /*初期段階でターゲットの要素に属性が指定されていない場合は、\r
       * 現在の属性値を削除するだけでよい*/\r
      ele.removeAttributeNS(this.attrNameSpace, attrName);\r
      /*スタイルシートのプロパティも削除しておく。removePropertyでないことに注意*/\r
      this.isCSS && ele.style.setProperty(attrName, this.defaultValue, "");\r
    }\r
    this.__cacheAttr = "";\r
    value = attrName = ele = void 0;\r
  },\r
\r
  /*引数で指定した要素 ele の属性を解析して、フレームに追加する*/\r
  push: function(/*Element Node*/ ele) {\r
    if (!ele || !ele.hasAttribute) {\r
      return null;\r
    }\r
    /*キャッシュを初期化しておく*/\r
    this.__cacheAttr = "";\r
    this.element = ele.parentNode || null;\r
    var id;\r
    if ( id = ele.getAttributeNS(null, "targetElement") ) {\r
      this.element = ele.ownerDocument.getElementById(id);\r
    }\r
    /*getAttributeNSメソッドでうまくいかなかったため、NSなしで代用*/\r
    if ( id = ele.getAttribute("xlink:href") ) {\r
      this.element = ele.ownerDocument.getElementById(id.slice(1));\r
    }\r
   /*getAttrメソッドとhasAttrValuesメソッドで必要*/\r
    this._ele = ele;\r
    if (!this.hasAttrValues()) {\r
      /*from属性、to、by、values属性が指定されていない場合、アニメーションの効果が出ないように調整する\r
       *SMILアニメーションの仕様を参照\r
       *\r
       *>if none of the from, to, by or values attributes are specified, the animation will have no effect\r
       *「3.2.2. Animation function values」より引用\r
       *http://www.w3.org/TR/2001/REC-smil-animation-20010904/#AnimFuncValues\r
      */\r
      return null;\r
    }\r
    \r
    /*属性値の設定*/\r
    this.attrName = this.getAttr("attributeName", "");\r
    var attrName = this.attrName;\r
    \r
    /*属性タイプの設定*/\r
    var attrType = this.getAttr("attributeType", "auto");\r
    var computedStyle = this.element && this.element.ownerDocument.defaultView.getComputedStyle(this.element, "");\r
    if ( (attrType === "CSS")\r
         || ( (attrType === "auto") && this.element \r
             && computedStyle.getPropertyValue(attrName)\r
             && !/^(width|height|transform)$/.test(attrName)\r
            )\r
        ) {\r
        this.isCSS = true;\r
    }\r
    \r
    /*xlink関連の属性のときは名前空間を変更しておく*/\r
    if (attrName.indexOf("xlink") > -1) {\r
      this.attrNameSpace = "http://www.w3.org/1999/xlink";\r
    }\r
    /*thiseleはターゲットとなる要素（たとえば、親要素）*/\r
    var thisele = this.element;\r
    if (thisele) {\r
      /*規定値を設定しておく。属性を初期化するときに使われる*/\r
      this._ele = thisele;\r
      this.isDefault = thisele.hasAttributeNS(this.attrNameSpace, attrName);\r
      this.defaultValue = this.getAttr(attrName,\r
       computedStyle.getPropertyValue(attrName) );\r
      this._ele = ele; /*_eleプロパティを元に戻しておく*/\r
    }\r
    /*eleの属性の値を、それぞれオブジェクトに割り当て*/\r
    var $frame = base("$frame"),\r
        begin = $frame.$begin,\r
        frame = begin.up().mix( {\r
                  /*targetプロパティはbeginEventなどの発火で使う*/\r
                  target: ele,\r
                  eventTarget: (this.element || begin.eventTarget),\r
                  string: this.getAttr("begin", "0"),\r
                  $activate: begin.$activate.up().mix( {\r
                    dur: this.getAttr("dur", null),\r
                    end: begin.$end.up().mix( {\r
                          eventTarget: (this.element || begin.eventTarget),\r
                          string: this.getAttr("end", null)\r
                        } ),\r
                    repeatCount: this.getAttr("repeatCount", null),\r
                    repeatDur: this.getAttr("repeatDur", null),\r
                    min: this.getAttr("min", "0"),\r
                    max: this.getAttr("max", "indefinite")\r
                  } )\r
                } ).parse();\r
    frame.$activate.end.$begin = frame;\r
    /*beginElementメソッドを追加*/\r
    function eleMethod (obj, eventName) {\r
      return (obj.string !== "indefinite") ? function(){}\r
                        : function() {\r
                            obj.listener( {\r
                              /*アニメーションの開始をこのメソッドが呼ばれた時点とする*/\r
                              timeStamp: Date.now()\r
                            } );\r
                            var evt = this.ownerDocument.createEvent("MouseEvents");\r
                            evt.initMouseEvent(eventName + "Event" ,true, true, window, 0, 0, 0, 0, 0, false, false, false, false, 0, this);\r
                            this.dispatchEvent(evt);\r
                          };\r
    };\r
    ele.beginElement = eleMethod(frame, "begin");\r
    /*endElementメソッドを追加*/\r
    ele.endElement = eleMethod(frame.$activate.end, "end");\r
    if (frame.isResolved) {\r
      /*開始時間が初期化されてしまうのを防ぐ*/\r
      var cacheBegin = frame.begin;\r
      frame.listener( {\r
        /*アニメーションの開始をこのメソッドが呼ばれた時点とする*/\r
        timeStamp: Date.now()\r
      } );\r
      frame.begin = cacheBegin;\r
    }\r
    /*setFrameメソッドを使ったときの、再帰スタックの使いすぎを防ぐため*/\r
    frame.timelines = [];\r
    begin = ele = id = void 0;\r
    return frame;\r
  },\r
  \r
  /*setValuesメソッド\r
   * values属性やfrom属性やto属性を処理するためのメソッド\r
   * valuesは配列、それ以外の引数は文字列\r
   * 返り値は、values属性は配列、それ以外の属性のときは、\r
   * 自分自身となる$attributeオブジェクトのコピーを返す*/\r
   setValues: function(values, from, to, by) {\r
     var $from = this.$from,\r
         s = [this.up().mix( {\r
               to: $from.up().mix( {\r
                 from: $from.up()\r
               } )\r
             } )],\r
         sto = s[0].to;\r
     values = values && values.split(";");\r
     /*from属性はオプションなので、条件には付け加えない*/\r
     if (values && values.length) {\r
       /*values属性が指定された場合、他の属性は無視される\r
        * W3C仕様　SMIL アニメーション 3.2.2. アニメーション関数の値*/\r
        s = [];\r
       for (var i=1;i<values.length;++i) {\r
         s.push( this.up().mix( {\r
               to: $from.up().mix( {\r
                 from: $from.up()\r
               } )\r
             } ) );\r
         sto = s[s.length-1].to;\r
         sto.string = values[i];\r
         sto.from.string = values[i-1];\r
       }\r
     } else if (to) {\r
       sto.string = to;\r
       sto.from.string = from || "0";\r
     } else if (by) {\r
       sto.string = by;\r
       sto.from.string = from || "0";\r
       var toNumList = sto.call(),\r
           fromNumList = sto.from;\r
       for (var i=0;i<toNumList.length;++i) {\r
         /*初期値と差分を足していく*/\r
         toNumList[i] += fromNumList[i];\r
       }\r
     } else {\r
       return null;\r
     }\r
     $from = sto = toNumList = fromNumList = void 0;\r
     return s;\r
   },\r
   \r
   /*setKeyメソッド\r
    * 引数の要素のkeyTimes属性やkeySplines属性を処理するためのメソッド\r
    * 必要な他の属性処理はsetValuesメソッドに任せている*/\r
   setKey: function(ele) {\r
     this._ele = ele;\r
     var to = this.setValues(this.getAttr("values", null),\r
          this.getAttr("from", null),\r
          this.getAttr("to", null),\r
          this.getAttr("by", null) ),\r
         keyTimes = this.getAttr("keyTimes", null),\r
         keySplines = this.getAttr("keySplines", null),\r
         keys,\r
         splines = keySplines && keySplines.split(";"),\r
         isDiscrete = (this.mode === "discrete"),\r
         toiKeySplines;\r
    if (!isDiscrete && keyTimes && to) {\r
      keys = this.$from.numList.call( {\r
        string: keyTimes\r
      } );\r
      /*keysTime属性の最初は0でなければならない。そうでなければエラー（SVG 1.1 2ndの仕様を参照)*/\r
      if (keys.length && (keys[0] !== 0)) {\r
        return null;\r
      }\r
      /*toオブジェクトはtoとfromで一組となっているのでlengthが加算される*/\r
      if (keys.length && (keys.length !== (to.length+1))) {\r
        /*keyTimes属性とvalues属性のリストの個数が合致しない場合、アニメーションの効果がない\r
         * 仕様を参照 SMIL Animation 3.2.3. Animation function calculation modes\r
         * http://www.w3.org/TR/smil-animation/#AnimFuncCalcMode*/\r
        return null;\r
      }\r
      for (var i=0;i<to.length;++i) {\r
        to[i].keyTime = keys[i+1] - keys[i];\r
        if (splines) {\r
          toiKeySplines = this.$from.numList.call( {\r
            string: splines[i]\r
          } );\r
          /*空配列を返すため、nullに変えておく*/\r
          to[i].keySplines = toiKeySplines.length ? toiKeySplines : null;\r
        }\r
      }\r
    } else if (!isDiscrete && to) {\r
      var per = 1 / to.length;\r
      for (var i=0;i<to.length;++i) {\r
        to[i].keyTime = per;\r
        if (splines) {\r
          toiKeySplines = this.$from.numList.call( {\r
            string: splines[i]\r
          } );\r
          to[i].keySplines = toiKeySplines.length ? toiKeySplines : null;\r
        }\r
      }\r
    } else if (to) {\r
        /*discreteモードの処理*/\r
      if (keyTimes) {\r
        keys = this.$from.numList.call( {\r
          string: keyTimes\r
        } );\r
      /*keysTime属性の最初は0でなければならない。そうでなければエラー（SVG 1.1 2ndの仕様を参照)*/\r
        if (keys.length && (keys[0] !== 0)) {\r
          return null;\r
        }\r
        if (keys.length && (keys.length !== (to.length+1))) {\r
          return null;\r
        }\r
        for (var i=0;i<to.length;++i) {\r
          to[i].keyTime = keys[i+1] - keys[i];\r
        }\r
      } else {\r
        var per = 1 / (to.length+1);\r
        for (var i=0;i<to.length;++i) {\r
          to[i].keyTime = per;\r
        }\r
      }\r
      /*toオブジェクトが足らないので、一つ追加しておく*/\r
      to.push( to[to.length-1].up().mix( function(){\r
          if (!keys) {\r
            return;\r
          }\r
          this.keyTime = 1-keys[keys.length-1];\r
        } ).of( {\r
            call: function() {\r
              return function (t) {\r
                 return isNaN(t) ? this.string\r
                                 : this.to.advance(1);\r
              }.bind(this);\r
            }\r
          } \r
        ) );\r
    }\r
    if (this.mode === "paced") {\r
      /*ベクトル全体の距離を算出*/\r
      var norm = 0;\r
      to.forEach( function(x) {\r
        norm += x.to.distance(x.to.from);\r
      } );\r
      to.forEach( function(x) {\r
         x.norm = norm;\r
      } );\r
    }\r
    ele = keyTimes = keys = per = splines = void 0;\r
    return to;\r
   }\r
} ).up("$setElement").mix( {\r
  /*to属性の値、文字列*/\r
  to: "",\r
  \r
  /*initメソッドで使われるアニメーション関数*/\r
  _setFrame: function (frame) {\r
    this.state = "playing";\r
    this.setAttribute(this.to);\r
  },\r
  \r
  /*アニメーション中かどうかの判別\r
   * 1, idling アニメがまだ始まっていない待機状態 (規定値)\r
   * 2, playing アニメーションの再生中\r
   */\r
  state: "idling",\r
  \r
  /*開始を設定されたタイムライン ($beginオブジェクト)*/\r
  timeline: base("$frame").$begin,\r
  \r
  /*アニメが終了した際の後処理\r
   * 終了処理をしたいときは、falseを値として返す*/\r
  _setEndFrame: function(frame) {\r
              var line = this.timeline,\r
                  end = line.begin + line.activeTime;\r
              if (!line.isResolved || isNaN(end)) {\r
                /*未解決など問題が発生したとき*/\r
                line = frame = void 0;\r
                return true;\r
              } else if (\r
                    ( ( frame < line.begin )\r
                      || ( (end) <= frame )\r
                    ) && (this.state === "playing") ) {\r
                /*removeの場合、アニメーションを凍結せずに、もとに戻す*/\r
                if (this.fill === "remove") {\r
                  this.removeAttribute();\r
                }\r
                /*stateプロパティを書き換えることで、一度のみ、終了処理させる*/\r
                this.state = "idling";\r
                line = frame = void 0;\r
                return false;\r
              } else {\r
                line = frame = void 0;\r
                return true;\r
              }\r
  },\r
  \r
  /*アニメーションの呈示値を呼び出す関数*/\r
  tocall: function() {},\r
  \r
  init: function(ele) {\r
    var line = this.push(ele);\r
    if (ele && ele.getAttributeNS) {\r
      this._ele = ele;\r
      this.to = this.getAttr("to", "");\r
      this.fill = this.getAttr("fill", "remove");\r
    }\r
    var thisele = this.element;\r
    if (line && thisele) {\r
      this.timeline = line;\r
      /*ラインの中に、属性処理をするためのラインを追加*/\r
      line.addLine(\r
       { setFrame: this._setFrame.bind(this),\r
         begin: 1,\r
         activeTime: 1,\r
         rank: 0\r
       }\r
      );\r
      base("$frame").addLine(\r
        { setFrame: this._setEndFrame.bind(this),\r
          begin: 1,\r
          activeTime: 1,\r
          rank: 1 //ランクを低くすることで、最後にタイムラインを実行させる\r
        }\r
      );\r
    }\r
    /*アニメーションが再起動する可能性もあるため、stateプロパティはここで初期化*/\r
    this.state = "idling";\r
    line = thisele = void 0;\r
  }\r
}).up("$animateElement").mix( {\r
  /*アニメ関数の配列*/\r
  funcs: [],\r
\r
  /*進捗率advanceから、呈示値を求める*/\r
  tocall: function(advance) {\r
    var tf = this.funcs;\r
    for (var i=0;i<tf.length;++i) {\r
      var tfi = tf[i];\r
      /*keyTime（keyTimes属性で指定されたような値）で実行するかどうかを判別*/\r
      if (tfi.endKeyTime >= advance) {\r
        return tfi(advance - tfi.startKeyTime);\r
      }\r
    }\r
    tf = i = tfi = void 0;\r
    return "";\r
  },\r
  \r
  _setFrame: function(currentTime) {\r
    /*durationは単純継続時間\r
     *advanceは継続時間内での、進捗率\r
     * 　仕様を参照　http://www.w3.org/TR/smil-animation/#AnimFuncValues\r
     *進捗率advanceは、durationと進捗フレーム数とを割った余り(REMAINDER)で算出する\r
     * 仕様を参照　SMIL Animation 3.6.2　Interval timing\r
     * http://www.w3.org/TR/2001/REC-smil-animation-20010904/#IntervalTiming*/\r
    var line = this.timeline,\r
        duration = line.simpleDuration,\r
        /*単純継続時間が不定の場合、補間はせずに初期値が採用されるため、advanceは0となる\r
         * 仕様を参照　SMIL Animation 3.2.2. Animation function values のInterpolation and indefinite simple durations\r
         * http://www.w3.org/TR/2001/REC-smil-animation-20010904/#AnimFuncValues*/\r
        advance = duration ? ( (currentTime - line.begin) % duration ) / duration\r
                    : 0;\r
    this.setAttribute(this.tocall(advance));\r
    this.state = "playing";\r
    line = duration = advance = void 0;\r
  },\r
  \r
  _setEndFrame: function(frame) {\r
    /*上書きされたメソッドを呼び出してアニメーションの凍結作業をする*/\r
    if (!this.$setElement._setEndFrame.call(this, frame)\r
     && (this.fill === "freeze")) {\r
      var line = this.timeline,\r
          duration = line.simpleDuration;\r
      if (duration) {\r
        var advance = ( line.activeTime % duration ) / duration;\r
        /*例外が発生するため、進捗率が1を超えないように処理*/\r
        advance = (advance > 1) ? 1 : advance;\r
         /*活動継続時間と単純継続時間が一致すると、余りは0となるため以下の処理*/\r
        advance = advance || 1;\r
      } else {\r
        advance = 0;\r
      }\r
      this.setAttribute(this.tocall(advance));\r
      line = duration = advance = void 0;\r
    }\r
  },\r
  \r
  /*getAttrメソッドをオーバライド*/\r
  getAttr: function (name, def) {\r
    var s= this.$attribute.getAttr.apply(this, arguments);\r
    if ((name === "from") && !s && this.defaultValue) {\r
      /*from属性がない場合、対象要素の既定値を返す*/\r
      return this.defaultValue;\r
    }\r
    return s;\r
  },\r
  \r
  _keywords: {\r
    aliceblue:    [240,248,255],\r
    antiquewhite: [250,235,215],\r
    aqua:         [0,255,255],\r
    aquamarine:   [127,255,212],\r
    azure:        [240,255,255],\r
    beige:        [245,245,220],\r
    bisque:       [255,228,196],\r
    black:        [0,0,0],\r
    blanchedalmond:[255,235,205],\r
    blue:         [0,0,255],\r
    blueviolet:   [138,43,226],\r
    brown:        [165,42,42],\r
    burlywood:    [222,184,135],\r
    cadetblue:    [95,158,160],\r
    chartreuse:   [127,255,0],\r
    chocolate:    [210,105,30],\r
    coral:        [255,127,80],\r
    cornflowerblue:[100,149,237],\r
    cornsilk:     [255,248,220],\r
    crimson:      [220,20,60],\r
    cyan:         [0,255,255],\r
    darkblue:     [0,0,139],\r
    darkcyan:     [0,139,139],\r
    darkgoldenrod:[184,134,11],\r
    darkgray:     [169,169,169],\r
    darkgreen:    [0,100,0],\r
    darkgrey:     [169,169,169],\r
    darkkhaki:    [189,183,107],\r
    darkmagenta:  [139,0,139],\r
    darkolivegreen:[85,107,47],\r
    darkorange:    [255,140,0],\r
    darkorchid:   [153,50,204],\r
    darkred:      [139,0,0],\r
    darksalmon:   [233,150,122],\r
    darkseagreen: [143,188,143],\r
    darkslateblue:[72,61,139],\r
    darkslategray:[47,79,79],\r
    darkslategrey:[47,79,79],\r
    darkturquoise:[0,206,209],\r
    darkviolet:   [148,0,211],\r
    deeppink:     [255,20,147],\r
    deepskyblue:  [0,191,255],\r
    dimgray:      [105,105,105],\r
    dimgrey:      [105,105,105],\r
    dodgerblue:   [30,144,255],\r
    firebrick:    [178,34,34],\r
    floralwhite:  [255,250,240],\r
    forestgreen:  [34,139,34],\r
    fuchsia:      [255,0,255],\r
    gainsboro:    [220,220,220],\r
    ghostwhite:   [248,248,255],\r
    gold:         [255,215,0],\r
    goldenrod:    [218,165,32],\r
    gray:         [128,128,128],\r
    grey:         [128,128,128],\r
    green:        [0,128,0],\r
    greenyellow:  [173,255,47],\r
    honeydew:     [240,255,240],\r
    hotpink:      [255,105,180],\r
    indianred:    [205,92,92],\r
    indigo:       [75,0,130],\r
    ivory:        [255,255,240],\r
    khaki:        [240,230,140],\r
    lavender:     [230,230,250],\r
    lavenderblush:[255,240,245],\r
    lawngreen:    [124,252,0],\r
    lemonchiffon: [255,250,205],\r
    lightblue:    [173,216,230],\r
    lightcoral:   [240,128,128],\r
    lightcyan:    [224,255,255],\r
    lightgoldenrodyellow:[250,250,210],\r
    lightgray:    [211,211,211],\r
    lightgreen:   [144,238,144],\r
    lightgrey:    [211,211,211],\r
    lightpink:    [255,182,193],\r
    lightsalmon:  [255,160,122],\r
    lightseagree: [32,178,170],\r
    lightskyblue: [135,206,250],\r
    lightslategray:[119,136,153],\r
    lightslategrey:[119,136,153],\r
    lightsteelblue:[176,196,222],\r
    lightyellow:  [255,255,224],\r
    lime:         [0,255,0],\r
    limegreen:    [50,205,50],\r
    linen:        [250,240,230],\r
    magenta:      [255,0,255],\r
    maroon:       [128,0,0],\r
    mediumaquamarine:[102,205,170],\r
    mediumblue:    [0,0,205],\r
    mediumorchid:  [186,85,211],\r
    mediumpurple:  [147,112,219],\r
    mediumseagreen:[60,179,113],\r
    mediumslateblue:[123,104,238],\r
    mediumspringgreen:[0,250,154],\r
    mediumturquoise:[72,209,204],\r
    mediumvioletred:[199,21,133],\r
    midnightblue:  [25,25,112],\r
    mintcream:     [245,255,250],\r
    mistyrose:     [255,228,225],\r
    moccasin:      [255,228,181],\r
    navajowhite:   [255,222,173],\r
    navy:          [0,0,128],\r
    oldlace:       [253,245,230],\r
    olive:         [128,128,0],\r
    olivedrab:     [107,142,35],\r
    orange:        [255,165,0],\r
    orangered:     [255,69,0],\r
    orchid:        [218,112,214],\r
    palegoldenrod: [238,232,170],\r
    palegreen:     [152,251,152],\r
    paleturquoise: [175,238,238],\r
    palevioletred: [219,112,147],\r
    papayawhip:    [255,239,213],\r
    peachpuff:     [255,218,185],\r
    peru:          [205,133,63],\r
    pink:          [255,192,203],\r
    plum:          [221,160,221],\r
    powderblue:    [176,224,230],\r
    purple:        [128,0,128],\r
    red:           [255,0,0],\r
    rosybrown:     [188,143,143],\r
    royalblue:     [65,105,225],\r
    saddlebrown:   [139,69,19],\r
    salmon:        [250,128,114],\r
    sandybrown:    [244,164,96],\r
    seagreen:      [46,139,87],\r
    seashell:      [255,245,238],\r
    sienna:        [160,82,45],\r
    silver:        [192,192,192],\r
    skyblue:       [135,206,235],\r
    slateblue:     [106,90,205],\r
    slategray:     [112,128,144],\r
    slategrey:     [112,128,144],\r
    snow:          [255,250,250],\r
    springgreen:   [0,255,127],\r
    steelblue:     [70,130,180],\r
    tan:           [210,180,140],\r
    teal:          [0,128,128],\r
    thistle:       [216,191,216],\r
    tomato:        [255,99,71],\r
    turquoise:     [64,224,208],\r
    violet:        [238,130,238],\r
    wheat:         [245,222,179],\r
    white:         [255,255,255],\r
    whitesmoke:    [245,245,245],\r
    yellow:        [255,255,0],\r
    yellowgreen:   [154,205,50]\r
  },\r
  \r
  setAdd: function (ele, to) {\r
    /*additive属性がsum (加法アニメーション)の場合*/\r
    if (ele.getAttributeNS(null, "additive") === "sum") {\r
      var attrValue = ele.parentNode.getAttributeNS(null, this.attrName);\r
      ele.addEventListener("beginEvent", function(evt) {\r
        to.forEach( function(x) {\r
          x.to.setAdditive(attrValue);\r
        } )\r
      }, false);\r
    }\r
  },\r
  setAccum: function (ele, to) {\r
    /*accumulate属性がsum (蓄積アニメーション)の場合*/\r
    if (ele.getAttributeNS(null, "accumulate") === "sum") {\r
      ele.addEventListener("repeatEvent", function(evt) {\r
        to.forEach( function(x) {\r
          x.to.call();\r
          x.to.setAccumulate(evt.detail);\r
        } )\r
      }, false);\r
    }\r
  },\r
  \r
  /*displayなど補間をしなくてもよい属性への対処するためのメソッド*/\r
  setString: function() {\r
    if (/^(?:display|class|edgeMode|(gradient|marker|pattern|maskContent|mask|patternContent|primitive)Units|in|in2|method|mode|operator|preserveAspectRatio|result|spacing|spreadMethod|stitchTiles|target|type|xlink:href|yChannelSelector|color-interpolation|(clip|fill)-rule|cursor|filter|font-(family|stretch|style|variant)|image-rendering|marker-(end|mid|start)|mask|overflow|pointer-events|shape-rendering|stroke-(linecap|linejoin)|text-(anchor|decoration|rendering)|visibility)$/.test(this.attrName) ) {\r
      this.mode = "discrete";\r
    }\r
  },\r
  \r
  /*discreteモードのために、setKeyメソッドをオーバライド*/\r
  setKey: function() {\r
    var s = this.$attribute.setKey.apply(this, arguments);\r
    if (this.mode === "discrete") {\r
      this._tocall = this.tocall;\r
      this.tocall = function (advance) {\r
                      var tf = this.funcs;\r
                      var result = "";\r
                      for (var i=0;i<tf.length;++i) {\r
                        var tfi = tf[i];\r
                        if (advance >= tfi.startKeyTime) {\r
                          result = tfi(advance);\r
                        }\r
                      }\r
                      advance = tf = tfi = void 0;\r
                      return result;\r
      };\r
    } else {\r
      this.tocall = this._tocall || this.tocall;\r
    }\r
    return s;\r
  }\r
    \r
\r
/*initメソッドに追加処理\r
 * onメソッドについては、base.jsを参照のこと*/\r
} ).on ("init", function(ele) {\r
  var isColor = /^(?:fill|stroke|stop-color|color)$/.test(this.attrName);\r
  if (isColor) {\r
    this.setValues = function() {\r
      /*RGB形式では補間に、小数を使わない*/\r
      var s = this.$attribute.setValues.apply(this, arguments);\r
      s.forEach(function(x) {\r
        x.to.degit = 0;\r
      } );\r
      return s;\r
    };\r
  }\r
  var to, \r
      keyTime = 0,\r
      /*関数toRGBはrgbColor形式への変換処理で使う*/\r
      toRGB = function(x) { return x; };\r
  if (ele) {\r
    this.mode = ele.getAttributeNS(null, "calcMode") || "linear";\r
    this.setString();\r
    to = this.setKey(ele);\r
  }\r
  if (isColor) {\r
    this.setValues = this.$attribute.setValues;\r
    /*#から始まる文字列を、rgb(.., .., ..,)形式へと変換するための関数*/\r
    var keywords = this._keywords;\r
    toRGB = function(rgbColor) {\r
           var keyword = keywords[rgbColor];\r
           if (keyword) {\r
             return "rgb(" + keyword.join(", ") + ")";\r
           }\r
           if (rgbColor && (rgbColor[0] === "#")) {  //#を含む場合\r
              var s = "rgb(",\r
                  _parseInt = parseInt;\r
              if (rgbColor.length < 5) {\r
                var r = rgbColor[1],\r
                    g = rgbColor[2],\r
                    b = rgbColor[3],\r
                rgbColor = "#" + r + r + g + g + b + b;\r
              }\r
              rgbColor.match(/\#(\w{2})(\w{2})(\w{2})/);\r
              s += _parseInt(RegExp.$1, 16)\r
                + ", "\r
                + _parseInt(RegExp.$2, 16)\r
                + ", "\r
                + _parseInt(RegExp.$3, 16)\r
                + ")";\r
              r = g = b = void 0;\r
              return s;\r
           }\r
           return rgbColor;\r
        };\r
  }\r
  if (to) {\r
    this.funcs = to.map( function(x) {\r
      x.to.string = toRGB(x.to.string);\r
      x.to.from.string = toRGB(x.to.from.string);\r
      var s = x.call();\r
      /*x.keyTimeプロパティは区間を示しているため、区切り時刻に変換しておく\r
       * startKeyTimeプロパティは区間のスタート時点\r
       * endKeyTimeプロパティは区間のエンド地点*/\r
      s.startKeyTime = keyTime;\r
      keyTime = s.endKeyTime = keyTime + x.keyTime;\r
      return s;\r
    } )\r
     .filter( function(s) {\r
       if (!this.timeline.isResolved) {\r
         /*begin属性などにイベントを設定していた（未解決の）場合、後のs(0.1)がうまく作動せず、\r
          * 例外を出してしまうため、ここで返しておく*/\r
         return true;\r
       }\r
       /*splineモードで、かつ、アニメーションが無効な関数の場合は配列から外しておく\r
        * 無効な場合に関しては、$calcModeオブジェクトのcallメソッドを参照*/\r
       return (this.mode !== "spline") || !s.isNotAnimate;\r
    }, this );\r
    this.setAdd(ele, to);\r
    this.setAccum(ele, to);\r
  }\r
  keywords = toRGB = isColor = void 0;\r
} )\r
/*$animateTranformElementオブジェクト\r
 * animateTransform要素に関連するオブジェクト*/\r
 .up("$animateTransformElement")\r
 .mix({\r
   /*__transformListで何番目のアイテムかを示すプロパティ*/\r
   numberOfList: -1,\r
   \r
   /*type属性の値*/\r
   type: "translate",\r
   \r
   /*明確にisCSSプロパティを設定しておくことで、プロトタイプチェーンを使わせず最適化*/\r
   isCSS: false,\r
   \r
   /*$animateElementオブジェクトのtocallメソッドをオーバライド*/\r
   tocall: function (advance) {\r
     if (this.numberOfList < 0) {\r
       throw new Error("Number of The List Error");\r
     }\r
     var list = this.element.__transformList,\r
         currentList = list[this.numberOfList];\r
     currentList.value = this.type+ "(" +this.$animateElement.tocall.call(this, advance)+ ")";\r
     currentList.isPlaying = true;\r
     var playList = list.filter( function(x) {\r
           /*playListは現在、再生中の項目のみをピックアップしたリスト*/\r
             return (x && x.isPlaying);\r
           } )\r
     var s = this.defaultValue || "";\r
     /*他のanimateTransform要素がadditive属性の値にreplaceをすでに設定していた、\r
      *かつ、その要素がアニメーション再生中の場合、\r
      *初期値であるsは反映されなくなる*/\r
     for (var i=0;i<playList.length;++i) {\r
       var value = playList[i].value;\r
       if (playList[i].isSum) {\r
         s += " " + value;\r
       } else {\r
         /*additvie属性にreplaceが設定されている場合は初期化*/\r
         s = value;\r
       }\r
     }\r
     return s;\r
   },\r
   \r
   _setEndFrame: function(frame) {\r
     /*上書きされたメソッドを呼び出してアニメーションの凍結作業をする*/\r
     this.$animateElement._setEndFrame.call(this, frame);\r
     this.element.__transformList[this.numberOfList].isPlaying = false;\r
   },\r
   \r
   /*setAddメソッドのオーバライド\r
    * additive属性のsumに対する振る舞いが異なるため*/\r
    setAdd: function() {}\r
  })\r
 .on("init", function (ele) {\r
   if (!ele || !ele.parentNode) {\r
     return;\r
   }\r
   this.getAttr = this.$attribute.getAttr;\r
   this.type = this.getAttr("type", "translate");\r
   var parent = this.element;\r
   this.isDefault = parent.hasAttributeNS(null, "transform");\r
   this.defaultValue = parent.getAttributeNS(null, "transform") || "";\r
   if (!parent.__transformList) {\r
     parent.__transformList = [];\r
   }\r
   if (this.hasAttrValues()\r
    && (this.numberOfList < 0) ) {\r
     /*もし、今まで、このオブジェクトで、initメソッドを実行していなければ*/\r
     this.numberOfList = parent.__transformList.length;\r
     parent.__transformList.push( {isPlaying: false,\r
                                   value: "translate(0)",\r
                                   isSum: (this.getAttr("additive", "replace") === "sum")\r
                                  } );\r
   }\r
  } )\r
  .up("$motionElement")\r
  .mix( {\r
    numberOfList: 1,\r
    tocall: function (advance) {\r
      var value = this.type+ "(" +this.$animateElement.tocall.call(this, advance)+ ")";\r
      var d = this.defaultValue;\r
      if (!this.element) {\r
        return value;\r
      }\r
      var list = this.element.__transformList;\r
      d = d && (d + " ");\r
      /*他のanimateTransform要素がadditive属性の値にreplaceをすでに設定していた場合、\r
      *初期値であるdは反映されなくなる*/\r
      if ( (list.numberOfReplace !== void 0) && (list.numberOfReplace >= 0) ) {\r
        d = "";\r
      }\r
      /*他のanimateTransform要素で、additive属性に\r
       * replaceが指定されていた要素の変更は反映されないため、sliceメソッドを使う*/\r
      return d + list.slice(list.numberOfReplace || 0).join(" ") + value;\r
    }\r
  } )\r
  .on("init", function (ele) {\r
    /*type属性で変更されないように（$animateTransformElementのinitメソッドを参照のこと）*/\r
    this.type = "translate";\r
  } );\r
\r
/*$svgEventオブジェクトは、SVGEvent発火を監視するためのオブジェクト*/\r
base("$frame").up("$svgEvent").mix( {\r
  /*イベントのスケジュール記録*/\r
  first: null,\r
  \r
  /*タイムラインの最後のキャッシュ*/\r
  lastTimeLine: null,\r
  \r
  /*setTimeTable メソッドはスケジュールの記録をつけるためのメソッド*/\r
  setTimeTable: function () {\r
    var timelines = this.timelines;\r
      for (var i=0, obj = null;i<timelines.length;++i) {\r
        if (!timelines[i].target) {\r
          /*target オブジェクトがないものは除外*/\r
          continue;\r
        }\r
        /*タイムラインから、beginEventとendEventを発火するスケジュールを作成*/\r
        var timeline = timelines[i],\r
            begin = timeline.begin,\r
            target = timeline.target,\r
            simpleDur = timeline.simpleDuration,\r
            activeTime = timeline.activeTime,\r
            first = {\r
              frame: begin,\r
              eventType: "begin",\r
              target: target,\r
              next: {\r
                frame: begin+activeTime,\r
                eventType: "end",\r
                target: target,\r
                next: null\r
              }\r
            };\r
        if (obj) {\r
          obj = obj.next.next = first;\r
        } else {\r
          obj = this.first = first;\r
        }\r
        if (simpleDur && (activeTime !== simpleDur)) {\r
          /*活動継続時間と単純持続時間が異なるとき、repeatイベントを設定\r
           * ただし、repeatイベントはendイベントが発生する前に起きるものと仮定*/\r
          first.next = {\r
            firstFrame: begin + simpleDur,\r
            frame: begin + simpleDur,\r
            eventType: "repeat",\r
            target: target,\r
            /*リピートの制限時間*/\r
            limit: begin + activeTime,\r
            /*リピートの回数 (n >= 1)*/\r
            count: 1,\r
            simpleDuration: simpleDur,\r
            next: first.next\r
          };\r
        }\r
      }\r
    timelines = obj = first = begin = target = simpleDur = activeTime = void 0;\r
  },\r
  \r
  $frame: base("$frame"),\r
  \r
  setFrame: function (num) {\r
    var timelines = this.timelines,\r
        lastTimeLine = timelines[timelines.length-1],\r
        s = this.$frame.setFrame(num);\r
    /*キャッシュのlastTimeLineプロパティを使って、再びスケジュールの計算をさせないようにする*/\r
    if (this.lastTimeLine !== lastTimeLine) {\r
      this.lastTimeLine = lastTimeLine;\r
      this.setTimeTable();\r
    }\r
    /*スケジュールに記録しておいたものを実行して、イベントを発火\r
     * また、発火した場合は記録から取り除いて、次回から再び発火しないようにする*/\r
    var obj = this.first,\r
        cobj = obj,\r
        floor = Math.floor;\r
    while(obj) {\r
      var frame = obj.frame,\r
          target = obj.target\r
          detail = 0;\r
      if (frame <= num) {\r
        /*IE11ではSVGEventsやDOMEventsを使うと問題が起きるため、MouseEventsで代用する*/\r
        if (obj.eventType === "repeat") {\r
          var simpleDuration = obj.simpleDuration;\r
          /*リピートイベントが、リピート制限内である場合\r
           *numの段階で、何回リピートしたかを求める*/\r
          detail = obj.count = floor( (num - obj.firstFrame) / simpleDuration) + 1;\r
          /*simpleDurationを足すことによって、リピートイベントが\r
           * 単純継続時間内に何度も繰り返されることを防ぐ*/\r
          frame += simpleDuration;\r
          obj.frame = frame;\r
        }\r
        /*obj.limitはrepeatイベントの制限で使われるもの*/\r
        if ((obj.eventType !== "repeat") || (frame >= obj.limit)) {\r
          /*ポインタの連結を変更することで、リストからobj を除去*/\r
          cobj.next = obj.next;\r
          if (this.first === obj) {\r
            cobj = this.first = obj.next;\r
          }\r
        } else {\r
          cobj = obj;\r
        }\r
        var evt = target.ownerDocument.createEvent("MouseEvents");\r
        evt.initMouseEvent(obj.eventType+"Event" ,true, true, window, detail, 0, 0, 0, 0, false, false, false, false, 0, target);\r
        target.dispatchEvent(evt);\r
      } else {\r
        /*next プロパティを書き換えるためのobj オブジェクトのキャッシュ*/\r
        cobj = obj;\r
      }\r
      obj = obj.next;\r
    }\r
    obj = num = first = frame = target = cobj = simpleDuration = detail = void 0;\r
    return s;\r
  }\r
} );\r
\r
function getDocument() \r
{\r
  var svg = document.getElementsByTagName("object"),\r
      svgns = "http://www.w3.org/2000/svg";\r
  if (svg) {\r
    for (var i=0;i<svg.length;++i) {\r
      getElement( svg[i].getSVGDocument() );\r
    }\r
  }\r
  /*SVG文書から呼び出されたときも処理する*/\r
  getElement(document);\r
  /*idはアニメの中止ハンドル*/\r
  var id = __step(),\r
      idstop = function() {\r
        /*アニメーションを中止する関数*/\r
        window.cancelAnimationRequest && cancelAnimationRequest(id);\r
      };\r
  base("$frame").on("pauseAnimation", idstop);\r
  window.addEventListener("unload", idstop);\r
  \r
  /*文書からアニメーション関連要素を取り出して、オブジェクトを初期化*/\r
  function getElement (svgDoc) {\r
      var $set = base("$calcMode").$attribute.$setElement;\r
      init($set, "set");\r
      init($set.$animateElement, "animate");\r
      init($set.$animateElement, "animateColor");\r
      init($set.$animateElement.$animateTransformElement, "animateTransform");\r
        /*リンクのハッシュ読み取りで、ハイパーリンクのイベント処理\r
       * たとえば、a要素のxlink:href="#hoge"で、<animate id="hoge"のとき、\r
       * animate要素がハイパーリンク作動と同時に動くようになる\r
       * \r
       * ただし、SMIL アニメーションの仕様では、\r
       * animate要素の開始時刻まで、時を進める操作をするだけ*/\r
       svgDoc.defaultView.addEventListener("hashchange", function() {\r
           var hash = svgDoc.defaultView.location.hash.slice(1);\r
           svgDoc.getElementById(hash).beginElement();\r
         });\r
\r
      function init (obj, name) {\r
        var eles = svgDoc.getElementsByTagNameNS(svgns, name)\r
        for (var i=0;i<eles.length;++i) {\r
          obj.up().init(eles.item(i));\r
        }\r
        eles = obj = void 0;\r
      };\r
  };\r
}\r
\r
window.addEventListener && window.addEventListener("load", getDocument);\r
\r
function __step() {\r
if (!document.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#Animation", "1.1")) {\r
  if (window.requestAnimationFrame && requestAnimationFrame) {\r
    /*IE11などSMILアニメーションに対応していないブラウザ用*/\r
    /*cancelはアニメーションの中止ハンドル*/\r
    var cancel = {\r
       handle: null\r
      };\r
    (function(frame) {\r
      var $frame = base("$frame"),\r
          $f = $frame.$svgEvent,\r
          _cancel = cancel; /*cancelのエイリアス*/\r
      _cancel.handle = requestAnimationFrame(step);\r
      function step() {\r
        if (!$frame.isPaused) {\r
          frame++;\r
          try {\r
            $f.setFrame(frame);\r
          } catch(e) {\r
          }\r
          _cancel.handle = requestAnimationFrame(step);\r
        }\r
      };\r
    })(-1);\r
    return cancel;\r
  } else {\r
    setInterval( (function(frame) {\r
      var $f = base("$frame").$svgEvent;\r
      return function () {\r
        frame++;\r
        $f.setFrame(frame);\r
      };\r
    })(-1), 1 );\r
  }\r
}\r
}\r
//#endif // _SMIL_IDL_\r