italia2024/libraries/scrollin/scrollin.js

Italia 2024 assets

/*!
Scrollin.css (fluffy fadein): https://codepen.io/sarap422/pen/dydBjPY
Author: sarap422
Description: You know why they call it that. It has no particular meaning.
Version: 0.231003%
License: Released under the MIT license.
License URI: https://opensource.org/licenses/MIT
*/

$(function () {
//html読込時（ready）の処理
let coatInBottom = document.querySelectorAll(".scroll-coatInBottom");
$(coatInBottom).wrap('<div class="scroll-wrapper scrapper-coat"></div>');
let coatInLeft = document.querySelectorAll(".scroll-coatInLeft");
$(coatInLeft).wrap('<div class="scroll-wrapper scrapper-coat"></div>');
let coatInRight = document.querySelectorAll(".scroll-coatInRight");
$(coatInRight).wrap('<div class="scroll-wrapper scrapper-coat"></div>');
let coatInBottomOut = document.querySelectorAll(".scroll-coatInBottomOut");
$(coatInBottomOut).wrap('<div class="scroll-wrapper scrapper-coat"></div>');
let coatInLeftOut = document.querySelectorAll(".scroll-coatInLeftOut");
$(coatInLeftOut).wrap('<div class="scroll-wrapper scrapper-coat"></div>');
let coatInRightOut = document.querySelectorAll(".scroll-coatInRightOut");
$(coatInRightOut).wrap('<div class="scroll-wrapper scrapper-coat"></div>');
let coatInBottomLeftOut = document.querySelectorAll(".scroll-coatInBottomLeftOut");
$(coatInBottomLeftOut).wrap('<div class="scroll-wrapper scrapper-coat"></div>');
let coatInBottomRightOut = document.querySelectorAll(".scroll-coatInBottomRightOut");
$(coatInBottomRightOut).wrap('<div class="scroll-wrapper scrapper-coat"></div>');
let coatFadeOut = document.querySelectorAll(".scroll-coatFadeOut");
$(coatFadeOut).wrap('<div class="scroll-wrapper scrapper-coat"></div>');
let coatOutTop = document.querySelectorAll(".scroll-coatOutTop");
$(coatOutTop).wrap('<div class="scroll-wrapper scrapper-coat"></div>');
let coatOutBottom = document.querySelectorAll(".scroll-coatOutBottom");
$(coatOutBottom).wrap('<div class="scroll-wrapper scrapper-coat"></div>');
let coatOutLeft = document.querySelectorAll(".scroll-coatOutLeft");
$(coatOutLeft).wrap('<div class="scroll-wrapper scrapper-coat"></div>');
let coatOutRight = document.querySelectorAll(".scroll-coatOutRight");
$(coatOutRight).wrap('<div class="scroll-wrapper scrapper-coat"></div>');
let tepraInLeft = document.querySelectorAll(".scroll-tepraInLeft");
$(tepraInLeft).wrap('<div class="scroll-wrapper scrapper-tepraInLeft"></div>');
let $parentTepraInLeft = $(".scrapper-tepraInLeft").parent();
$parentTepraInLeft.wrapInner('<div class="overScrapper-tepraInLeft"></div>');
let tepraInRight = document.querySelectorAll(".scroll-tepraInRight");
$(tepraInRight).wrap('<div class="scroll-wrapper scrapper-tepraInRight"></div>');
let $parentTepraInRight = $(".scrapper-tepraInRight").parent();
$parentTepraInRight.wrapInner('<div class="overScrapper-tepraInRight"></div>');
let tepraInTopLeft = document.querySelectorAll(".scroll-tepraInTopLeft");
$(tepraInTopLeft).wrap('<div class="scroll-wrapper scrapper-tepraInTopLeft"></div>');
let $parentTepraInTopLeft = $(".scrapper-tepraInTopLeft").parent();
$parentTepraInTopLeft.wrapInner('<div class="overScrapper-tepraInTopLeft"></div>');
let tepraInTopRight = document.querySelectorAll(".scroll-tepraInTopRight");
$(tepraInTopRight).wrap('<div class="scroll-wrapper scrapper-tepraInTopRight"></div>');
let $parentTepraInTopRight = $(".scrapper-tepraInTopRight").parent();
$parentTepraInTopRight.wrapInner('<div class="overScrapper-tepraInTopRight"></div>');
let $parentLooptationToUp = $(".scroll-looptationToUp").parent();
$parentLooptationToUp.wrapInner('<div class="scroll-wrapper scrapper-loop"></div>');
let $parentLooptationToDown = $(".scroll-looptationToDown").parent();
$parentLooptationToDown.wrapInner('<div class="scroll-wrapper scrapper-loop"></div>');
let $parentLooptationToFore = $(".scroll-looptationToFore").parent();
$parentLooptationToFore.wrapInner('<div class="scroll-wrapper scrapper-loop"></div>');
let $parentLooptationToBack = $(".scroll-looptationToBack").parent();
$parentLooptationToBack.wrapInner('<div class="scroll-wrapper scrapper-loop"></div>');


//調整クラスを持つWrpr要素にも、調整クラスを追加する
let arrScrlWrprs = Array.prototype.slice.call(document.querySelectorAll(".scroll-wrapper")); //Arr.NodeList

let lngtScrlWrpr = arrScrlWrprs.length;
for (let n = 0; n < lngtScrlWrpr; n++) {
  if (arrScrlWrprs[n].querySelector(".delayed-0")) arrScrlWrprs[n].classList.add('delayed-0');
  if (arrScrlWrprs[n].querySelector(".delayed-1")) arrScrlWrprs[n].classList.add('delayed-1');
  if (arrScrlWrprs[n].querySelector(".delayed-2")) arrScrlWrprs[n].classList.add('delayed-2');
  if (arrScrlWrprs[n].querySelector(".delayed-3")) arrScrlWrprs[n].classList.add('delayed-3');
  if (arrScrlWrprs[n].querySelector(".delayed-4")) arrScrlWrprs[n].classList.add('delayed-4');
  if (arrScrlWrprs[n].querySelector(".delayed-5")) arrScrlWrprs[n].classList.add('delayed-5');
  if (arrScrlWrprs[n].querySelector(".delayed-6")) arrScrlWrprs[n].classList.add('delayed-6');
  if (arrScrlWrprs[n].querySelector(".fasted-1")) arrScrlWrprs[n].classList.add('fasted-1');
  if (arrScrlWrprs[n].querySelector(".fasted-2")) arrScrlWrprs[n].classList.add('fasted-2');
  if (arrScrlWrprs[n].querySelector(".fasted-3")) arrScrlWrprs[n].classList.add('fasted-3');
  if (arrScrlWrprs[n].querySelector(".slowed-1")) arrScrlWrprs[n].classList.add('slowed-1');
  if (arrScrlWrprs[n].querySelector(".slowed-2")) arrScrlWrprs[n].classList.add('slowed-2');
  if (arrScrlWrprs[n].querySelector(".slowed-3")) arrScrlWrprs[n].classList.add('slowed-3');
  if (arrScrlWrprs[n].querySelector(".slowed-4")) arrScrlWrprs[n].classList.add('slowed-4');
  if (arrScrlWrprs[n].querySelector(".slowed-5")) arrScrlWrprs[n].classList.add('slowed-5');
  if (arrScrlWrprs[n].querySelector(".slowed-10")) arrScrlWrprs[n].classList.add('slowed-10');
  if (arrScrlWrprs[n].querySelector(".slowed-20")) arrScrlWrprs[n].classList.add('slowed-20');
  if (arrScrlWrprs[n].querySelector(".slowed-30")) arrScrlWrprs[n].classList.add('slowed-30');
  if (arrScrlWrprs[n].querySelector(".slowed-60")) arrScrlWrprs[n].classList.add('slowed-60');
  if (arrScrlWrprs[n].querySelector(".slowed-90")) arrScrlWrprs[n].classList.add('slowed-90');
  if (arrScrlWrprs[n].querySelector(".slowed-120")) arrScrlWrprs[n].classList.add('slowed-120');
}; ///for


//条件を満たしたら実行される関数
let tgtFadeIn = Array.prototype.slice.call(document.querySelectorAll(".scroll-fadeIn"));

function isctFadeIn(entries, obsFadeIn) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
}
let tgtFadeInBottom = Array.prototype.slice.call(document.querySelectorAll(".scroll-fadeInBottom"));

function isctFadeInBottom(entries, obsFadeInBottom) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
}
let tgtFadeInTop = Array.prototype.slice.call(document.querySelectorAll(".scroll-fadeInTop"));

function isctFadeInTop(entries, obsFadeInTop) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
}
let tgtFadeInLeft = Array.prototype.slice.call(document.querySelectorAll(".scroll-fadeInLeft"));

function isctFadeInLeft(entries, obsFadeInLeft) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
}
let tgtFadeInRight = Array.prototype.slice.call(document.querySelectorAll(".scroll-fadeInRight"));

function isctFadeInRight(entries, obsFadeInRight) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
}

let tgtBlurIn = Array.prototype.slice.call(document.querySelectorAll(".scroll-blurIn"));

function isctBlurIn(entries, obsBlurIn) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
}
let tgtBlurInBottom = Array.prototype.slice.call(document.querySelectorAll(".scroll-blurInBottom"));

function isctBlurInBottom(entries, obsBlurInBottom) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
}
let tgtBlurInTop = Array.prototype.slice.call(document.querySelectorAll(".scroll-blurInTop"));

function isctBlurInTop(entries, obsBlurInTop) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
}
let tgtBlurInLeft = Array.prototype.slice.call(document.querySelectorAll(".scroll-blurInLeft"));

function isctBlurInLeft(entries, obsBlurInLeft) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
}
let tgtBlurInRight = Array.prototype.slice.call(document.querySelectorAll(".scroll-blurInRight"));

function isctBlurInRight(entries, obsBlurInRight) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
}



let tgtBgFadeIn = Array.prototype.slice.call(document.querySelectorAll(".scroll-bgFadeIn"));

function isctBgFadeIn(entries, obsBgFadeIn) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
};

let tgtBgInBottom = Array.prototype.slice.call(document.querySelectorAll(".scroll-bgInBottom"));

function isctBgInBottom(entries, obsBgInBottom) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
};

let tgtBgInLeft = Array.prototype.slice.call(document.querySelectorAll(".scroll-bgInLeft"));

function isctBgInLeft(entries, obsBgInLeft) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
};
let tgtBgOpenIn = Array.prototype.slice.call(document.querySelectorAll(".scroll-bgOpenIn"));

function isctBgOpenIn(entries, obsBgOpenIn) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
}
let tgtMoveInBottom = Array.prototype.slice.call(document.querySelectorAll(".scroll-moveInBottom"));

function isctMoveInBottom(entries, obsMoveInBottom) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
}
let tgtMoveInDown = Array.prototype.slice.call(document.querySelectorAll(".scroll-moveInDown"));

function isctMoveInDown(entries, obsMoveInDown) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
}
let tgtMoveInLeft = Array.prototype.slice.call(document.querySelectorAll(".scroll-moveInLeft"));

function isctMoveInLeft(entries, obsMoveInLeft) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
}
let tgtMoveInRight = Array.prototype.slice.call(document.querySelectorAll(".scroll-moveInRight"));

function isctMoveInRight(entries, obsMoveInRight) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
}
let tgtGrowIn = Array.prototype.slice.call(document.querySelectorAll(".scroll-growIn"));

function isctGrowIn(entries, obsGrowIn) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
}
let tgtGrowOut = Array.prototype.slice.call(document.querySelectorAll(".scroll-growOut"));

function isctGrowOut(entries, obsGrowOut) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
}
let tgtShrinkIn = Array.prototype.slice.call(document.querySelectorAll(".scroll-shrinkIn"));

function isctShrinkIn(entries, obsShrinkIn) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
}
let tgtShrinkOut = Array.prototype.slice.call(document.querySelectorAll(".scroll-shrinkOut"));

function isctShrinkOut(entries, obsShrinkOut) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
}
let tgtWipeInCentral = Array.prototype.slice.call(document.querySelectorAll(".scroll-wipeInCentral"));

function isctWipeInCentral(entries, obsWipeInCentral) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
}
let tgtWipeInBottom = Array.prototype.slice.call(document.querySelectorAll(".scroll-wipeInBottom"));

function isctWipeInBottom(entries, obsWipeInBottom) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
}
let tgtWipeInTop = Array.prototype.slice.call(document.querySelectorAll(".scroll-wipeInTop"));

function isctWipeInTop(entries, obsWipeInTop) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
}
let tgtWipeInLeft = Array.prototype.slice.call(document.querySelectorAll(".scroll-wipeInLeft"));

function isctWipeInLeft(entries, obsWipeInLeft) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
}
let tgtWipeInRight = Array.prototype.slice.call(document.querySelectorAll(".scroll-wipeInRight"));

function isctWipeInRight(entries, obsWipeInRight) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
}
let tgtCoatInBottom = Array.prototype.slice.call(document.querySelectorAll(".scroll-coatInBottom"));

function isctCoatInBottom(entries, obsCoatInBottom) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
};

let tgtCoatInLeft = Array.prototype.slice.call(document.querySelectorAll(".scroll-coatInLeft"));

function isctCoatInLeft(entries, obsCoatInLeft) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
};
let tgtCoatInRight = Array.prototype.slice.call(document.querySelectorAll(".scroll-coatInRight"));

function isctCoatInRight(entries, obsCoatInRight) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
}

let tgtCoatInBottomOut = Array.prototype.slice.call(document.querySelectorAll(".scroll-coatInBottomOut"));

function isctCoatInBottomOut(entries, obsCoatInBottomOut) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
};

let tgtCoatInLeftOut = Array.prototype.slice.call(document.querySelectorAll(".scroll-coatInLeftOut"));

function isctCoatInLeftOut(entries, obsCoatInLeftOut) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
};
let tgtCoatInRightOut = Array.prototype.slice.call(document.querySelectorAll(".scroll-coatInRightOut"));

function isctCoatInRightOut(entries, obsCoatInRightOut) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
}
let tgtCoatInBottomLeftOut = Array.prototype.slice.call(document.querySelectorAll(".scroll-coatInBottomLeftOut"));

function isctCoatInBottomLeftOut(entries, obsCoatInBottomLeftOut) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
};
let tgtCoatInBottomRightOut = Array.prototype.slice.call(document.querySelectorAll(".scroll-coatInBottomRightOut"));

function isctCoatInBottomRightOut(entries, obsCoatInBottomRightOut) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
}
let tgtCoatFadeOut = Array.prototype.slice.call(document.querySelectorAll(".scroll-coatFadeOut"));

function isctCoatFadeOut(entries, obsCoatFadeOut) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
};

let tgtCoatOutTop = Array.prototype.slice.call(document.querySelectorAll(".scroll-coatOutTop"));

function isctCoatOutTop(entries, obsCoatOutTop) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
};
let tgtCoatOutBottom = Array.prototype.slice.call(document.querySelectorAll(".scroll-coatOutBottom"));

function isctCoatOutBottom(entries, obsCoatOutBottom) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
};

let tgtCoatOutLeft = Array.prototype.slice.call(document.querySelectorAll(".scroll-coatOutLeft"));

function isctCoatOutLeft(entries, obsCoatOutLeft) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
};
let tgtCoatOutRight = Array.prototype.slice.call(document.querySelectorAll(".scroll-coatOutRight"));

function isctCoatOutRight(entries, obsCoatOutRight) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
}
let tgtBlurfadeOut = Array.prototype.slice.call(document.querySelectorAll(".scroll-blurFadeOut"));

function isctBlurfadeOut(entries, obsBlurfadeOut) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
};

let tgtBlurOutTop = Array.prototype.slice.call(document.querySelectorAll(".scroll-blurOutTop"));

function isctBlurOutTop(entries, obsBlurOutTop) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
};
let tgtBlurOutBottom = Array.prototype.slice.call(document.querySelectorAll(".scroll-blurOutBottom"));

function isctBlurOutBottom(entries, obsBlurOutBottom) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
};

let tgtBlurOutLeft = Array.prototype.slice.call(document.querySelectorAll(".scroll-blurOutLeft"));

function isctBlurOutLeft(entries, obsBlurOutLeft) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
};
let tgtBlurOutRight = Array.prototype.slice.call(document.querySelectorAll(".scroll-blurOutRight"));

function isctBlurOutRight(entries, obsBlurOutRight) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
}

let tgtMirageInBottom = Array.prototype.slice.call(document.querySelectorAll(".scroll-mirageInBottom"));

function isctMirageInBottom(entries, obsMirageInBottom) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
};
let tgtMirageInTop = Array.prototype.slice.call(document.querySelectorAll(".scroll-mirageInTop"));

function isctMirageInTop(entries, obsMirageInTop) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
};

let tgtMirageInRight = Array.prototype.slice.call(document.querySelectorAll(".scroll-mirageInRight"));

function isctMirageInRight(entries, obsMirageInRight) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
};
let tgtMirageInLeft = Array.prototype.slice.call(document.querySelectorAll(".scroll-mirageInLeft"));

function isctMirageInLeft(entries, obsMirageInLeft) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
}

let tgtWrprTepraInLeft = Array.prototype.slice.call(document.querySelectorAll(".scrapper-tepraInLeft"));

function isctWrprTepraInLeft(entries, obsWrprTepraInLeft) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
}
let tgtWrprTepraInRight = Array.prototype.slice.call(document.querySelectorAll(".scrapper-tepraInRight"));

function isctWrprTepraInRight(entries, obsWrprTepraInRight) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
}
let tgtWrprTepraInTopLeft = Array.prototype.slice.call(document.querySelectorAll(".scrapper-tepraInTopLeft"));

function isctWrprTepraInTopLeft(entries, obsWrprTepraInTopLeft) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
}
let tgtWrprTepraInTopRight = Array.prototype.slice.call(document.querySelectorAll(".scrapper-tepraInTopRight"));

function isctWrprTepraInTopRight(entries, obsWrprTepraInTopRight) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
}

let tgtBdfBlurIn = Array.prototype.slice.call(document.querySelectorAll(".scroll-bdfBlurIn"));

function isctBdfBlurIn(entries, obsBdfBlurIn) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
}
let tgtFlipInXDown = Array.prototype.slice.call(document.querySelectorAll(".scroll-flipInXDown"));

function isctFlipInXDown(entries, obsFlipInXDown) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
};
let tgtBackFlipInX = Array.prototype.slice.call(document.querySelectorAll(".scroll-flipInXUp"));

function isctBackFlipInX(entries, obsBackFlipInX) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
};
let tgtFlipInYFore = Array.prototype.slice.call(document.querySelectorAll(".scroll-flipInYFore"));

function isctFlipInYFore(entries, obsFlipInYFore) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
};

let tgtFlipInYBack = Array.prototype.slice.call(document.querySelectorAll(".scroll-flipInYBack"));

function isctFlipInYBack(entries, obsFlipInYBack) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
};

let tgtRotationDext = Array.prototype.slice.call(document.querySelectorAll(".scroll-rotationDext"));

function isctRotationDext(entries, obsRotationDext) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
};

let tgtRotationLevo = Array.prototype.slice.call(document.querySelectorAll(".scroll-rotationLevo"));

function isctRotationLevo(entries, obsRotationLevo) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
};

let tgtClockationDext = Array.prototype.slice.call(document.querySelectorAll(".scroll-clockationDext"));

function isctClockationDext(entries, obsClockationDext) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
};

let tgtClockationLevo = Array.prototype.slice.call(document.querySelectorAll(".scroll-clockationLevo"));

function isctClockationLevo(entries, obsClockationLevo) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
};

let tgtEncourationToUp = Array.prototype.slice.call(document.querySelectorAll(".scroll-encourationToUp"));

function isctEncourationToUp(entries, obsEncourationToUp) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
};

let tgtEncourationToDown = Array.prototype.slice.call(document.querySelectorAll(".scroll-encourationToDown"));

function isctEncourationToDown(entries, obsEncourationToDown) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
};

let tgtEncourationToFore = Array.prototype.slice.call(document.querySelectorAll(".scroll-encourationToFore"));

function isctEncourationToFore(entries, obsEncourationToFore) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
};

let tgtEncourationToBack = Array.prototype.slice.call(document.querySelectorAll(".scroll-encourationToBack"));

function isctEncourationToBack(entries, obsEncourationToBack) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
};

let tgtLooptationToUp = Array.prototype.slice.call(document.querySelectorAll(".scroll-looptationToUp"));

function isctLooptationToUp(entries, obsLooptationToUp) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
};

let tgtLooptationToDown = Array.prototype.slice.call(document.querySelectorAll(".scroll-looptationToDown"));

function isctLooptationToDown(entries, obsLooptationToDown) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
};

let tgtLooptationToFore = Array.prototype.slice.call(document.querySelectorAll(".scroll-looptationToFore"));

function isctLooptationToFore(entries, obsLooptationToFore) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
};

let tgtLooptationToBack = Array.prototype.slice.call(document.querySelectorAll(".scroll-looptationToBack"));

function isctLooptationToBack(entries, obsLooptationToBack) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
};

//chartThumbOffset.js
let triggerNE5As = Array.prototype.slice.call(document.querySelectorAll(".scroll-chartation .chartbar-thumb")); //Arr.NodeList

let fnChartPieNE5A = function fnChartPieNE5A() {
  //Triggers から、IDとdata属性を取り出して、ループ処理
  let lngtNE5A = triggerNE5As.length;
  for (let n = 0; n < lngtNE5A; n++) {
    var targetNE5A = triggerNE5As[n].getAttribute('id');
    var targetNE5A = document.getElementById(targetNE5A);
    //.is-scloaded
    let perctNE5A = targetNE5A.dataset.percent;
    targetNE5A.style.strokeDashoffset = "calc( (100% * 3.142) * ((100 - " + perctNE5A + ") / 100) )";
  }; //for{}
}();

let tgtChartPie = Array.prototype.slice.call(document.querySelectorAll(".scroll-chartation")); //Arr.NodeList

function isctChartPie(entries, obsChartPie) {
  entries.forEach((entry, n) => {
    const nowElement = entry.target;
    if (entry.isIntersecting) {
      nowElement.classList.add('is-scloaded');
    }
  });
};




//IntersectionObserverを作成する関数
function makeObsScrollin() {
  //IntersectionObserverのオプション設定
  let optScrollin = {
    root: null, //nullでブラウザ画面を対象にする
    rootMargin: '0% 0% 0% 0%', //ターゲットとの交差位置を指定
    threshold: '0' //ターゲットが画面に0%入るとイベント発生
  };
  //IntersectionObserverの作成
  let obsFadeIn = new IntersectionObserver(isctFadeIn, optScrollin);
  for (let n = 0; n < tgtFadeIn.length; n++) {
    obsFadeIn.observe(tgtFadeIn[n]); //複数の対象要素を監視
  }
  let obsFadeInBottom = new IntersectionObserver(isctFadeInBottom, optScrollin);
  for (let n = 0; n < tgtFadeInBottom.length; n++) {
    obsFadeInBottom.observe(tgtFadeInBottom[n]);
  }
  let obsFadeInTop = new IntersectionObserver(isctFadeInTop, optScrollin);
  for (let n = 0; n < tgtFadeInTop.length; n++) {
    obsFadeInTop.observe(tgtFadeInTop[n]);
  }
  let obsFadeInLeft = new IntersectionObserver(isctFadeInLeft, optScrollin);
  for (let n = 0; n < tgtFadeInLeft.length; n++) {
    obsFadeInLeft.observe(tgtFadeInLeft[n]);
  }
  let obsFadeInRight = new IntersectionObserver(isctFadeInRight, optScrollin);
  for (let n = 0; n < tgtFadeInRight.length; n++) {
    obsFadeInRight.observe(tgtFadeInRight[n]);
  }
  let obsBlurIn = new IntersectionObserver(isctBlurIn, optScrollin);
  for (let n = 0; n < tgtBlurIn.length; n++) {
    obsBlurIn.observe(tgtBlurIn[n]);
  }
  let obsBlurInBottom = new IntersectionObserver(isctBlurInBottom, optScrollin);
  for (let n = 0; n < tgtBlurInBottom.length; n++) {
    obsBlurInBottom.observe(tgtBlurInBottom[n]);
  }
  let obsBlurInTop = new IntersectionObserver(isctBlurInTop, optScrollin);
  for (let n = 0; n < tgtBlurInTop.length; n++) {
    obsBlurInTop.observe(tgtBlurInTop[n]);
  }
  let obsBlurInLeft = new IntersectionObserver(isctBlurInLeft, optScrollin);
  for (let n = 0; n < tgtBlurInLeft.length; n++) {
    obsBlurInLeft.observe(tgtBlurInLeft[n]);
  }
  let obsBlurInRight = new IntersectionObserver(isctBlurInRight, optScrollin);
  for (let n = 0; n < tgtBlurInRight.length; n++) {
    obsBlurInRight.observe(tgtBlurInRight[n]);
  }
  let obsBgFadeIn = new IntersectionObserver(isctBgFadeIn, optScrollin);
  for (let n = 0; n < tgtBgFadeIn.length; n++) {
    obsBgFadeIn.observe(tgtBgFadeIn[n]);
  }
  let obsBgInBottom = new IntersectionObserver(isctBgInBottom, optScrollin);
  for (let n = 0; n < tgtBgInBottom.length; n++) {
    obsBgInBottom.observe(tgtBgInBottom[n]);
  }
  let obsBgInLeft = new IntersectionObserver(isctBgInLeft, optScrollin);
  for (let n = 0; n < tgtBgInLeft.length; n++) {
    obsBgInLeft.observe(tgtBgInLeft[n]);
  }
  let obsBgOpenIn = new IntersectionObserver(isctBgOpenIn, optScrollin);
  for (let n = 0; n < tgtBgOpenIn.length; n++) {
    obsBgOpenIn.observe(tgtBgOpenIn[n]);
  }
  let obsMoveInBottom = new IntersectionObserver(isctMoveInBottom, optScrollin);
  for (let n = 0; n < tgtMoveInBottom.length; n++) {
    obsMoveInBottom.observe(tgtMoveInBottom[n]);
  }
  let obsMoveInDown = new IntersectionObserver(isctMoveInDown, optScrollin);
  for (let n = 0; n < tgtMoveInDown.length; n++) {
    obsMoveInDown.observe(tgtMoveInDown[n]);
  }
  let obsMoveInLeft = new IntersectionObserver(isctMoveInLeft, optScrollin);
  for (let n = 0; n < tgtMoveInLeft.length; n++) {
    obsMoveInLeft.observe(tgtMoveInLeft[n]);
  }
  let obsMoveInRight = new IntersectionObserver(isctMoveInRight, optScrollin);
  for (let n = 0; n < tgtMoveInRight.length; n++) {
    obsMoveInRight.observe(tgtMoveInRight[n]);
  }
  let obsGrowIn = new IntersectionObserver(isctGrowIn, optScrollin);
  for (let n = 0; n < tgtGrowIn.length; n++) {
    obsGrowIn.observe(tgtGrowIn[n]);
  }
  let obsGrowOut = new IntersectionObserver(isctGrowOut, optScrollin);
  for (let n = 0; n < tgtGrowOut.length; n++) {
    obsGrowOut.observe(tgtGrowOut[n]);
  }
  let obsShrinkIn = new IntersectionObserver(isctShrinkIn, optScrollin);
  for (let n = 0; n < tgtShrinkIn.length; n++) {
    obsShrinkIn.observe(tgtShrinkIn[n]);
  }
  let obsShrinkOut = new IntersectionObserver(isctShrinkOut, optScrollin);
  for (let n = 0; n < tgtShrinkOut.length; n++) {
    obsShrinkOut.observe(tgtShrinkOut[n]);
  }
  let obsWipeInCentral = new IntersectionObserver(isctWipeInCentral, optScrollin);
  for (let n = 0; n < tgtWipeInCentral.length; n++) {
    obsWipeInCentral.observe(tgtWipeInCentral[n]);
  }
  let obsWipeInBottom = new IntersectionObserver(isctWipeInBottom, optScrollin);
  for (let n = 0; n < tgtWipeInBottom.length; n++) {
    obsWipeInBottom.observe(tgtWipeInBottom[n]);
  }
  let obsWipeInTop = new IntersectionObserver(isctWipeInTop, optScrollin);
  for (let n = 0; n < tgtWipeInTop.length; n++) {
    obsWipeInTop.observe(tgtWipeInTop[n]);
  }
  let obsWipeInLeft = new IntersectionObserver(isctWipeInLeft, optScrollin);
  for (let n = 0; n < tgtWipeInLeft.length; n++) {
    obsWipeInLeft.observe(tgtWipeInLeft[n]);
  }
  let obsWipeInRight = new IntersectionObserver(isctWipeInRight, optScrollin);
  for (let n = 0; n < tgtWipeInRight.length; n++) {
    obsWipeInRight.observe(tgtWipeInRight[n]);
  }
  let obsCoatInBottom = new IntersectionObserver(isctCoatInBottom, optScrollin);
  for (let n = 0; n < tgtCoatInBottom.length; n++) {
    obsCoatInBottom.observe(tgtCoatInBottom[n]);
  }
  let obsCoatInLeft = new IntersectionObserver(isctCoatInLeft, optScrollin);
  for (let n = 0; n < tgtCoatInLeft.length; n++) {
    obsCoatInLeft.observe(tgtCoatInLeft[n]);
  }
  let obsCoatInRight = new IntersectionObserver(isctCoatInRight, optScrollin);
  for (let n = 0; n < tgtCoatInRight.length; n++) {
    obsCoatInRight.observe(tgtCoatInRight[n]);
  }
  let obsCoatInBottomOut = new IntersectionObserver(isctCoatInBottomOut, optScrollin);
  for (let n = 0; n < tgtCoatInBottomOut.length; n++) {
    obsCoatInBottomOut.observe(tgtCoatInBottomOut[n]);
  }
  let obsCoatInLeftOut = new IntersectionObserver(isctCoatInLeftOut, optScrollin);
  for (let n = 0; n < tgtCoatInLeftOut.length; n++) {
    obsCoatInLeftOut.observe(tgtCoatInLeftOut[n]);
  }
  let obsCoatInRightOut = new IntersectionObserver(isctCoatInRightOut, optScrollin);
  for (let n = 0; n < tgtCoatInRightOut.length; n++) {
    obsCoatInRightOut.observe(tgtCoatInRightOut[n]);
  }
  let obsCoatInBottomLeftOut = new IntersectionObserver(isctCoatInBottomLeftOut, optScrollin);
  for (let n = 0; n < tgtCoatInBottomLeftOut.length; n++) {
    obsCoatInBottomLeftOut.observe(tgtCoatInBottomLeftOut[n]);
  }
  let obsCoatInBottomRightOut = new IntersectionObserver(isctCoatInBottomRightOut, optScrollin);
  for (let n = 0; n < tgtCoatInBottomRightOut.length; n++) {
    obsCoatInBottomRightOut.observe(tgtCoatInBottomRightOut[n]);
  }
  let obsCoatFadeOut = new IntersectionObserver(isctCoatFadeOut, optScrollin);
  for (let n = 0; n < tgtCoatFadeOut.length; n++) {
    obsCoatFadeOut.observe(tgtCoatFadeOut[n]);
  }
  let obsCoatOutTop = new IntersectionObserver(isctCoatOutTop, optScrollin);
  for (let n = 0; n < tgtCoatOutTop.length; n++) {
    obsCoatOutTop.observe(tgtCoatOutTop[n]);
  }
  let obsCoatOutBottom = new IntersectionObserver(isctCoatOutBottom, optScrollin);
  for (let n = 0; n < tgtCoatOutBottom.length; n++) {
    obsCoatOutBottom.observe(tgtCoatOutBottom[n]);
  }
  let obsCoatOutLeft = new IntersectionObserver(isctCoatOutLeft, optScrollin);
  for (let n = 0; n < tgtCoatOutLeft.length; n++) {
    obsCoatOutLeft.observe(tgtCoatOutLeft[n]);
  }
  let obsCoatOutRight = new IntersectionObserver(isctCoatOutRight, optScrollin);
  for (let n = 0; n < tgtCoatOutRight.length; n++) {
    obsCoatOutRight.observe(tgtCoatOutRight[n]);
  }
  let obsBlurfadeOut = new IntersectionObserver(isctBlurfadeOut, optScrollin);
  for (let n = 0; n < tgtBlurfadeOut.length; n++) {
    obsBlurfadeOut.observe(tgtBlurfadeOut[n]);
  }
  let obsBlurOutTop = new IntersectionObserver(isctBlurOutTop, optScrollin);
  for (let n = 0; n < tgtBlurOutTop.length; n++) {
    obsBlurOutTop.observe(tgtBlurOutTop[n]);
  }
  let obsBlurOutBottom = new IntersectionObserver(isctBlurOutBottom, optScrollin);
  for (let n = 0; n < tgtBlurOutBottom.length; n++) {
    obsBlurOutBottom.observe(tgtBlurOutBottom[n]);
  }
  let obsBlurOutLeft = new IntersectionObserver(isctBlurOutLeft, optScrollin);
  for (let n = 0; n < tgtBlurOutLeft.length; n++) {
    obsBlurOutLeft.observe(tgtBlurOutLeft[n]);
  }
  let obsBlurOutRight = new IntersectionObserver(isctBlurOutRight, optScrollin);
  for (let n = 0; n < tgtBlurOutRight.length; n++) {
    obsBlurOutRight.observe(tgtBlurOutRight[n]);
  }
  let obsMirageInBottom = new IntersectionObserver(isctMirageInBottom, optScrollin);
  for (let n = 0; n < tgtMirageInBottom.length; n++) {
    obsMirageInBottom.observe(tgtMirageInBottom[n]);
  }
  let obsMirageInTop = new IntersectionObserver(isctMirageInTop, optScrollin);
  for (let n = 0; n < tgtMirageInTop.length; n++) {
    obsMirageInTop.observe(tgtMirageInTop[n]);
  }
  let obsMirageInRight = new IntersectionObserver(isctMirageInRight, optScrollin);
  for (let n = 0; n < tgtMirageInRight.length; n++) {
    obsMirageInRight.observe(tgtMirageInRight[n]);
  }
  let obsMirageInLeft = new IntersectionObserver(isctMirageInLeft, optScrollin);
  for (let n = 0; n < tgtMirageInLeft.length; n++) {
    obsMirageInLeft.observe(tgtMirageInLeft[n]);
  }
  let obsWrprTepraInLeft = new IntersectionObserver(isctWrprTepraInLeft, optScrollin);
  for (let n = 0; n < tgtWrprTepraInLeft.length; n++) {
    obsWrprTepraInLeft.observe(tgtWrprTepraInLeft[n]);
  }
  let obsWrprTepraInRight = new IntersectionObserver(isctWrprTepraInRight, optScrollin);
  for (let n = 0; n < tgtWrprTepraInRight.length; n++) {
    obsWrprTepraInRight.observe(tgtWrprTepraInRight[n]);
  }
  let obsWrprTepraInTopLeft = new IntersectionObserver(isctWrprTepraInTopLeft, optScrollin);
  for (let n = 0; n < tgtWrprTepraInTopLeft.length; n++) {
    obsWrprTepraInTopLeft.observe(tgtWrprTepraInTopLeft[n]);
  }
  let obsWrprTepraInTopRight = new IntersectionObserver(isctWrprTepraInTopRight, optScrollin);
  for (let n = 0; n < tgtWrprTepraInTopRight.length; n++) {
    obsWrprTepraInTopRight.observe(tgtWrprTepraInTopRight[n]);
  }
  let obsBdfBlurIn = new IntersectionObserver(isctBdfBlurIn, optScrollin);
  for (let n = 0; n < tgtBdfBlurIn.length; n++) {
    obsBdfBlurIn.observe(tgtBdfBlurIn[n]);
  }
  let obsFlipInXDown = new IntersectionObserver(isctFlipInXDown, optScrollin);
  for (let n = 0; n < tgtFlipInXDown.length; n++) {
    obsFlipInXDown.observe(tgtFlipInXDown[n]);
  }
  let obsBackFlipInX = new IntersectionObserver(isctBackFlipInX, optScrollin);
  for (let n = 0; n < tgtBackFlipInX.length; n++) {
    obsBackFlipInX.observe(tgtBackFlipInX[n]);
  }
  let obsFlipInYFore = new IntersectionObserver(isctFlipInYFore, optScrollin);
  for (let n = 0; n < tgtFlipInYFore.length; n++) {
    obsFlipInYFore.observe(tgtFlipInYFore[n]);
  }
  let obsFlipInYBack = new IntersectionObserver(isctFlipInYBack, optScrollin);
  for (let n = 0; n < tgtFlipInYBack.length; n++) {
    obsFlipInYBack.observe(tgtFlipInYBack[n]);
  }
  let obsRotationDext = new IntersectionObserver(isctRotationDext, optScrollin);
  for (let n = 0; n < tgtRotationDext.length; n++) {
    obsRotationDext.observe(tgtRotationDext[n]);
  }
  let obsRotationLevo = new IntersectionObserver(isctRotationLevo, optScrollin);
  for (let n = 0; n < tgtRotationLevo.length; n++) {
    obsRotationLevo.observe(tgtRotationLevo[n]);
  }
  let obsClockationDext = new IntersectionObserver(isctClockationDext, optScrollin);
  for (let n = 0; n < tgtClockationDext.length; n++) {
    obsClockationDext.observe(tgtClockationDext[n]);
  }
  let obsClockationLevo = new IntersectionObserver(isctClockationLevo, optScrollin);
  for (let n = 0; n < tgtClockationLevo.length; n++) {
    obsClockationLevo.observe(tgtClockationLevo[n]);
  }
  let obsEncourationToUp = new IntersectionObserver(isctEncourationToUp, optScrollin);
  for (let n = 0; n < tgtEncourationToUp.length; n++) {
    obsEncourationToUp.observe(tgtEncourationToUp[n]);
  }
  let obsEncourationToDown = new IntersectionObserver(isctEncourationToDown, optScrollin);
  for (let n = 0; n < tgtEncourationToDown.length; n++) {
    obsEncourationToDown.observe(tgtEncourationToDown[n]);
  }
  let obsEncourationToFore = new IntersectionObserver(isctEncourationToFore, optScrollin);
  for (let n = 0; n < tgtEncourationToFore.length; n++) {
    obsEncourationToFore.observe(tgtEncourationToFore[n]);
  }
  let obsEncourationToBack = new IntersectionObserver(isctEncourationToBack, optScrollin);
  for (let n = 0; n < tgtEncourationToBack.length; n++) {
    obsEncourationToBack.observe(tgtEncourationToBack[n]);
  }
  let obsLooptationToUp = new IntersectionObserver(isctLooptationToUp, optScrollin);
  for (let n = 0; n < tgtLooptationToUp.length; n++) {
    obsLooptationToUp.observe(tgtLooptationToUp[n]);
  }
  let obsLooptationToDown = new IntersectionObserver(isctLooptationToDown, optScrollin);
  for (let n = 0; n < tgtLooptationToDown.length; n++) {
    obsLooptationToDown.observe(tgtLooptationToDown[n]);
  }
  let obsLooptationToFore = new IntersectionObserver(isctLooptationToFore, optScrollin);
  for (let n = 0; n < tgtLooptationToFore.length; n++) {
    obsLooptationToFore.observe(tgtLooptationToFore[n]);
  }
  let obsLooptationToBack = new IntersectionObserver(isctLooptationToBack, optScrollin);
  for (let n = 0; n < tgtLooptationToBack.length; n++) {
    obsLooptationToBack.observe(tgtLooptationToBack[n]);
  }
  let obsChartPie = new IntersectionObserver(isctChartPie, optScrollin);
  for (let n = 0; n < tgtChartPie.length; n++) {
    obsChartPie.observe(tgtChartPie[n]);
  }
}
//functionの実行
makeObsScrollin();
});