https://atone.be/assets/js/form.bundle.js

1/******/ (() => { // webpackBootstrap
2/******/ 	"use strict";
3/******/ 	var __webpack_modules__ = ({
4
5/***/ "./src/js/form/FormValidationModule.js"
6/*!*********************************************!*\
7  !*** ./src/js/form/FormValidationModule.js ***!
8  \*********************************************/
9(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
10
11__webpack_require__.r(__webpack_exports__);
12/* harmony export */ __webpack_require__.d(__webpack_exports__, {
13/* harmony export */   FormValidationModule: () => (/* binding */ FormValidationModule),
14/* harmony export */   Validator: () => (/* binding */ Validator)
15/* harmony export */ });
16function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
17function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
18function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
19function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
20function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
21function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
22function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
23/* ----------------------------------------------
24 * フォームバリデーションjs
25 *
26---------------------------------------------- */
27// module exports
28
29
30/**
31 * フォームバリデーターモジュール
32 *
33 * フォームのバリデート処理を実行するコアプログラム
34 */
35var FormValidationModule = /*#__PURE__*/function () {
36  /**
37   * コンストラクター
38   *
39   * @param {DOM} form バリデート対象にするフォーム要素
40   * @param {Object} config プラグインの設定値
41   * @param {Object} validator バリデータクラス
42   *
43   * @returns {Object} 自身のインスタンス
44   */
45  function FormValidationModule(form, config, validator) {
46    _classCallCheck(this, FormValidationModule);
47    /* 定数 ------------------------------------- */
48    /* デフォルト設定（本体） ------------------------------------- */
49    _defineProperty(this, "DEFAULT_CONFIG", {
50      // このプラグインで使用するカスタム属性
51      pluginPrefix: "data-valid",
52      // エラーブロックのクラス
53      errorClass: "error-message",
54      // エラーメッセージを表示するか
55      displayErrorMessage: true,
56      /**
57       * サブミットボタンをロックするかどうか
58       * true: バリデーションをクリアするまでsubmitボタンがロックされ、送信できない。
59       * false: いつでも送信ボタンが押下できる。
60       */
61      useSubmitLock: true,
62      /* プラグインが使用する各種属性値 ------------------------------------- */
63      // form要素に指定する属性値
64      attributeForm: /* ベース(pluginPrefixの値)+ */"-form",
65      // submitボタンに指定する属性値（ロック判定属性としても使用）
66      attributeSubmitButton: /* ベース(pluginPrefixの値)+ */"-submit",
67      // ステップボタンに指定する属性値（ロック判定属性としても使用）
68      attributeNextButton: /* ベース(pluginPrefixの値)+ */"-next",
69      attributeBackButton: /* ベース(pluginPrefixの値)+ */"-back",
70      // 現在のバリデートステータスを保持する属性値
71      attributeValidateState: /* ベース(pluginPrefixの値)+ */"-state",
72      // Validity(各種バリデートエラーの個別情報)を保持する属性値
73      attributeValidity: /* ベース(pluginPrefixの値)+ */"-validity",
74      // エラー表示のアウター要素であることを示す属性値
75      attributeErrorOuterDom: /* ベース(pluginPrefixの値)+ */"-outer"
76    });
77    /* プラグインが使用するイベント名 ------------------------------------- */
78    _defineProperty(this, "EVENT_NAMES", {
79      // バリデート実行時
80      validate: 'validate'
81    });
82    /* メンバープロパティ ------------------------------------- */
83    // オプション
84    _defineProperty(this, "config", {});

85    // 対象となるフォーム要素が存在しない場合は処理を停止
86    if (_typeof(form) !== 'object') return false;
87
88    // 引数にバリデーターインスタンスがなければ、デフォルトのバリデータークラスを使用する。
89    if (_typeof(validator) === "object" && validator !== null) {
90      this.validator = validator;
91    } else {
92      this.validator = new Validator();
93    }
94    ;
95
96    // 包含classであるvalidatorのsuperに自身をセット
97    this.validator["super"] = this;
98
99    // configがなければ初期化
100    if (_typeof(config) !== 'object') config = {};
101
102    // グローバル設定をマージする。
103    this._mergeConfigs(form, config);
104    console.log("Form Validation:module init");
105
106    // メインプロセススタート
107    this._start();
108    return this;
109  }
110
111  /**
112   * ※private
113   * ユーザー設定を初期設定へマージする。
114   *
115   * @param {object} config
116   */
117  return _createClass(FormValidationModule, [{
118    key: "_mergeConfigs",
119    value: function _mergeConfigs(form, config) {
120      //設定をマージ
121      this.config = Object.assign({}, this.DEFAULT_CONFIG, JSON.parse(JSON.stringify(config)));
122
123      // 定数を作成
124      // プレフィックス定数
125      this.PLUGIN_PREFIX = this.config.pluginPrefix;
126
127      // フォーム属性定数
128      this.ATTR_FORM = this.PLUGIN_PREFIX + this.config.attributeForm;
129
130      // サブミットボタン属性定数
131      this.ATTR_SUBMIT = this.PLUGIN_PREFIX + this.config.attributeSubmitButton;
132
133      // ステップボタン属性定数
134      this.ATTR_NEXT = this.PLUGIN_PREFIX + this.config.attributeNextButton;
135      this.ATTR_BACK = this.PLUGIN_PREFIX + this.config.attributeBackButton;
136
137      // バリデートタイプ定数
138      this.ATTR_TYPE = this.PLUGIN_PREFIX + "-type";
139
140      // state属性定数
141      this.ATTR_STATE = this.PLUGIN_PREFIX + this.config.attributeValidateState;
142
143      // エラー表示アウターボックス定数
144      this.ATTR_OUTER = this.PLUGIN_PREFIX + this.config.attributeErrorOuterDom;
145      // エラーCSSクラス
146      this.ERROR_CLASS = this.config.errorClass;
147
148      // バリデート状況記載属性定数
149      this.ATTR_VALIDITY = this.PLUGIN_PREFIX + this.config.attributeValidity;
150
151      // 要素の格納先
152      // フォームのラッパー要素
153      this.form = form;
154      this.submit = null;
155      this.next = null;
156      this.back = null;
157      this.items = null;
158
159      // フォームの状態変数
160      this.state = false;
161
162      // 発火用イベントの作成
163      this.events = {
164        // バリデート実行時イベント
165        validate: new Event(this.EVENT_NAMES.validate, {
166          bubbles: true,
167          cancelable: false
168        })
169      };
170
171      // bindしたイベントコールバックを変数として保存する。
172      // 個別バリデート実行イベント用処理
173      this.callback_eventExecValidation = this._eventExecValidation.bind(this);
174      // 全要素バリデート実行イベント用処理
175      this.callback_eventExecValidationAll = this._eventExecValidationAll.bind(this);
176    }
177
178    /**
179     * ※private
180     * モジュールを実行
181     * @returns {Boolean} モジュールの起動に失敗した場合、申し訳程度にfalseを返す
182     */
183  }, {
184    key: "_start",
185    value: function _start() {
186      // DOMの初期化を行う
187      this._initElements();
188
189      // 送信ボタンの活性状態を変更
190      this.setSubmitState();
191
192      // イベントを設定
193      this._switchEventListener();
194    }
195
196    /**
197     * ※private
198     * 対象DOM要素の初期化とDOMの確保を実行。
199     */
200  }, {
201    key: "_initElements",
202    value: function _initElements() {
203      // フォーム内のバリデート対象要素をすべて取得
204      this.items = this._pickUpInputElements();
205
206      // get submit button:submitボタンを確保する
207      this.submit = this.form.querySelectorAll("*[" + this.ATTR_SUBMIT + "]");
208
209      // ステップボタンを確保する
210      this.next = this.form.querySelectorAll("*[" + this.ATTR_NEXT + "]");
211      this.back = this.form.querySelectorAll("*[" + this.ATTR_BACK + "]");
212    }
213
214    /**
215     * ※private
216     * バリデート対象となるinput要素の初期化とDOMの確保を実行。
217     */
218  }, {
219    key: "_pickUpInputElements",
220    value: function _pickUpInputElements() {
221      var _this = this;
222      // フォーム内のバリデート対象要素をすべて取得
223      var inputElements = [];
224      inputElements = this.form.querySelectorAll("*[" + this.ATTR_TYPE + "]");
225

226      // 対象要素を初期化して配列として返送する。
227      return Array.from(inputElements).map(function (element) {
228        // バリデート対象かどうかを判定
229        if (!_this.validator.isValidatableItem(element)) return;
230
231        // 入力必須要素なら未検証ステートに変更
232        if (_this.validator.hasValidateAttribute(element, "required")) element.setAttribute(_this.ATTR_STATE, "unvalid");
233
234        // 対象要素を格納
235        return element;
236      })
237      // undefinedを除去する。
238      .filter(Boolean);
239    }
240
241    /**
242     * ※private
243     * DOMへイベントを設定する。
244     */
245  }, {
246    key: "_switchEventListener",
247    value: function _switchEventListener() {
248      var _this2 = this;
249      var mode = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "add";
250      var _self = this;
251
252      // 各種input項目へのバリデート実行イベントの設定
253      Array.from(_self.items).map(function (element) {
254        if (mode == "add") {
255          // イベント付与モード
256          element.addEventListener("change", _this2.callback_eventExecValidation);
257          element.addEventListener("focusout", _this2.callback_eventExecValidation);
258          element.addEventListener("validation", _this2.callback_eventExecValidation);
259        } else {
260          // イベント除去モード
261          element.removeEventListener("change", _this2.callback_eventExecValidation);
262          element.removeEventListener("focusout", _this2.callback_eventExecValidation);
263          element.removeEventListener("validation", _this2.callback_eventExecValidation);
264        }
265      });
266
267      // 全項目へのバリデート実行イベントの設定
268      if (mode == "add") {
269        // イベント付与モード
270        _self.form.addEventListener("validateAll", this.callback_eventExecValidationAll);
271      } else {
272        // イベント除去モード
273        _self.form.removeEventListener("validateAll", this.callback_eventExecValidationAll);
274      }
275    }
276
277    /**
278     * private:個別バリデート実行イベント用処理
279     *
280     * @param {Object} event
281     */
282  }, {
283    key: "_eventExecValidation",
284    value: function _eventExecValidation(event) {
285      var _this3 = this;
286      var target = event.target;
287
288      // exec validation:バリデート実行
289      this.executeValidation(target).then(function () {
290        // エラーを表示
291        _this3.displayValidationResults();
292      });
293    }
294
295    /**
296     * private:全要素バリデート実行イベント用処理
297     *
298     * @param {Object} event
299     */
300  }, {
301    key: "_eventExecValidationAll",
302    value: function _eventExecValidationAll(event) {
303      var _this4 = this;
304      console.log("Form Validation:start all validation");
305
306      // exec validation all:バリデート全実行
307      this.executeValidationAll().then(function () {
308        // エラーを表示
309        _this4.displayValidationResults();
310      });
311    }
312
313    /* ----------------------------------------------
314    * パブリックメソッド
315    ---------------------------------------------- */
316    /**
317     * プラグインを除去する。
318     */
319  }, {
320    key: "destroy",
321    value: function destroy() {
322      console.log("Form Validation:destroy");
323
324      // イベントリスナーを除去する。
325      this._switchEventListener("remove");
326
327      // submitボタンの挙動をリセットする。
328      this.resetSubmitState();
329      var _self = this;
330      this.items.forEach(function (element) {
331        // 属性消去を全ての項目に実行
332        _self.destroyState(element);
333        _self.validator.destroyValidity(element);
334      });
335    }
336
337    /* バリデート処理関連 ------------------------------------- */
338    /**
339     * 個別のバリデートを実行する。
340     *
341     * @param {DOM element} target 対象要素のDOMオブジェクト
342     * @returns {Promise} 結果を内包したプロミスオブジェクト
343     */
344  }, {
345    key: "executeValidation",
346    value: function executeValidation(target) {
347      var _self = this;
348
349      // 非同期処理でバリデート
350      return new Promise(function (resolve, reject) {
351        // バリデート状態をリセット
352        _self.resetValidation(target);
353
354        // バリデートタイプを取得

355        var validationType = target.getAttribute(_self.ATTR_TYPE);
356
357        // 該当するバリデートタイプがあればバリデーションを実行
358        if (typeof _self.validator[validationType] === "function") {
359          // バリデータのバリデートルールメソッドを実行
360          _self.validator[validationType](target);
361        } else if (typeof _self.validator["default"] === "function") {
362          // 該当するルールがなければデフォルトルールメソッドを実行
363          _self.validator["default"](target);
364        }
365
366        // バリデート実行イベントを発火
367        target.dispatchEvent(_self.events.validate);
368        resolve(true);
369      });
370    }
371
372    /**
373     * 全対象にバリデートを実行する。
374     *
375     * @returns {Promise} 結果を内包したプロミスオブジェクト
376     */
377  }, {
378    key: "executeValidationAll",
379    value: function executeValidationAll() {
380      var _self = this;
381
382      // 全項目に非同期処理でバリデートを実行する。
383      return Promise.all(Array.from(_self.items).map(function (element) {
384        return _self.executeValidation(element);
385      }));
386    }
387
388    /**
389     *
390     * @param {DOM element} target 対象要素のDOMオブジェクト
391     * @returns -
392     */
393  }, {
394    key: "resetValidation",
395    value: function resetValidation(target) {
396      var _self = this;
397
398      // バリデートステートを初期化
399      // validityを初期化
400      _self.validator.resetValidity(target);
401
402      // エラーを非表示
403      // エラーアウター要素を走査する。
404      var targetOuter = target.closest("*[" + _self.ATTR_OUTER + "]");
405      // エラーアウターがあればアウターを、なければターゲット要素のみを対象とする。
406      if (targetOuter) {
407        // アウター要素にマージ済みvalidityに準拠したエラーを表示する。
408        _self.deleteError(targetOuter);
409        // validityを初期化
410        _self.validator.resetValidity(targetOuter);
411      } else {
412        _self.deleteError(target);
413      }
414
415      // バリデート状態を初期化
416      target.removeAttribute(_self.ATTR_STATE);
417    }
418
419    /* バリデーション結果関連 ------------------------------------- */
420  }, {
421    key: "getValidationResult",
422    value: function getValidationResult() {
423      var _this5 = this;
424      // 全要素にバリデートを実行する。
425      return this.executeValidationAll().then(function () {
426        // エラーを表示
427        _this5.displayValidationResults();
428      }).then(function () {
429        return _this5.judgeSubmit();
430      });
431    }
432
433    /* エラーメッセージ関連 ------------------------------------- */
434    /**
435     * バリデート結果に応じたエラーメッセージを表示する。
436     *
437     */
438  }, {
439    key: "displayValidationResults",
440    value: function displayValidationResults() {
441      var _self = this;
442
443      // 全要素のエラーステータスをエラーに反映する。
444      Array.from(_self.items).forEach(function (element, i) {
445        // 対象が未検証であればスキップする（バリデートしない）
446        if (!_self.validator.isValidatedItem(element)) return true;
447
448        // 変数を準備する。
449        var target = null,
450          targetValidity = null,
451          targets = null,
452          validity = null;
453
454        // ターゲット要素を格納
455        target = element;
456        // 対象要素のバリデート状態を取得する。
457        targetValidity = _self.validator.getValidity(element);
458
459        // エラーアウター要素を走査する。
460        var targetOuter = element.closest("*[" + _self.ATTR_OUTER + "]");
461
462        // エラーアウターがある場合
463        if (targetOuter) {
464          // outer要素の中に存在するすべてのバリデート対象、かつバリデート済の要素を走査
465          var allElments = targetOuter.querySelectorAll("*[" + _self.ATTR_TYPE + "]");
466          targets = Array.from(allElments).filter(function (element) {
467            if (_self.validator.isValidatableItem(element) && _self.validator.isValidatedItem(element)) return element;
468          });
469
470          // validityを作成

471          // エラー状況（validity）をエラー（false）を優先しつつマージし、エラー内容を統合する。
472          var validities = [];
473          Array.from(targets).forEach(function (element, i) {
474            validities.push(_self.validator.getValidity(element));
475          });
476          // マージしたvalidityを統合validityへ代入。
477          validity = _self.validator.mergeValidity(validities);
478        } else {
479          // エラーアウターがない場合
480          // ターゲットのvalidityを統合validityとして扱う。
481          validity = targetValidity;
482        }
483
484        // エラーがあった場合
485        if (validity.valid == false) {
486          // エラー属性を設定する。
487          // エラーアウターがある場合、アウター要素にマージ済みvalidityに準拠したエラー処理を行う。
488          if (targetOuter) _self.setState(targetOuter, "invalid");
489
490          // 対象要素にエラー処理を行う。
491          if (targetValidity.valid == false) {
492            _self.setState(target, "invalid");
493          }
494
495          // エラーメッセージを表示する設定になっていた場合エラーを表示
496          if (_self.config.displayErrorMessage == true) {
497            // エラーアウターがあればアウターを、なければターゲット要素のみを対象とする。
498            if (targetOuter) {
499              // アウター要素にマージ済みvalidityに準拠したエラーを表示する。
500              _self.displayError(targetOuter, validity);
501            } else {
502              _self.displayError(target, targetValidity);
503            }
504          }
505        }
506
507        // エラーがない場合
508        if (validity.valid == true) {
509          // エラー属性を除去
510          // エラーアウターがあればそちらも対象にする。
511          if (targetOuter) _self.setState(targetOuter, 'valid');
512          _self.setState(target, 'valid');
513
514          // エラーメッセージを表示する設定になっていた場合エラーを除去
515          if (_self.config.displayErrorMessage == true) {
516            // エラーアウターがあればアウターを、なければターゲット要素のみを対象とする。
517            if (targetOuter) {
518              _self.deleteError(targetOuter);
519            } else {
520              _self.deleteError(target);
521            }
522          }
523        }
524      });
525
526      // submitボタンの挙動制御
527      _self.setSubmitState();
528    }
529
530    /**
531     * 対象のvalidityに応じたエラーメッセージを表示
532     *
533     * @param {DOM element} target 対象要素のDOMオブジェクト
534     * @param {Object} validity 対象のバリデートステータス
535     */
536  }, {
537    key: "displayError",
538    value: function displayError(target, validity) {
539      var _self = this;
540
541      // 既に表示されているエラーがあれば除去する
542      this.deleteError(target);
543
544      // カスタムエラー文言を作成して挿入
545      var validationMessage = _self._createErrorMessageArray(validity);
546      target.after(validationMessage);
547    }
548
549    /**
550     * 対象のエラーメッセージを除去
551     *
552     * @param {DOM element} target 対象要素のDOMオブジェクト
553     */
554  }, {
555    key: "deleteError",
556    value: function deleteError(target) {
557      var _self = this;
558
559      // 既に表示されているエラーがあれば除去する
560      var errorMessage = target.nextElementSibling;
561      if (errorMessage && errorMessage.classList.contains(_self.ERROR_CLASS)) errorMessage.parentNode.removeChild(errorMessage);
562    }
563
564    /**
565     * ※private
566     * エラーメッセージのHTML要素を作成する。
567     *
568     * @param {Object} validity 対象要素のバリデートステータス
569     * @returns {Dom Element} validityに応じたエラーメッセージのDOM要素
570     */
571  }, {
572    key: "_createErrorMessageArray",
573    value: function _createErrorMessageArray() {
574      var validity = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
575      var _self = this;
576
577      // カスタムエラー文言を作成

578      var validationMessage = Object.keys(validity).map(function (key) {
579        // エラー内容があればメッセージに追加
580        if (validity[key] === true && key !== "valid") {
581          if (typeof _self.validator.message[key] === "undefined") {
582            // 対応するエラーがなければデフォルトエラーを追加
583            return _self.validator.message["valid"];
584          } else {
585            // 対応するエラーがあればエラーを追加
586            return _self.validator.message[key];
587          }
588        }
589      })
590      // undefinedを削除
591      .filter(Boolean);
592
593      // DOMを作成
594      var message = document.createElement("div");
595      // 複数エラーを改行でjoin
596      message.innerHTML = validationMessage.join("<br>");
597      message.className = _self.ERROR_CLASS;
598      return message;
599    }
600
601    /* state属性関連 ------------------------------------- */
602    /**
603     * 対象にstate属性値をセットする。
604     *
605     * @param {DOM element} target 対象要素のDOMオブジェクト
606     * @param {String} state バリデート状況を表す文字列(valid/invalid)
607     */
608  }, {
609    key: "setState",
610    value: function setState(target) {
611      var state = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
612      // ターゲット要素のバリデートステート属性を変更
613      target.setAttribute(this.ATTR_STATE, state);
614    }
615
616    /**
617     * 対象のエラー属性を除去する。
618     *
619     * @param {DOM element} target 対象要素のDOMオブジェクト
620     */
621  }, {
622    key: "destroyState",
623    value: function destroyState(target) {
624      // ターゲット要素のバリデートステート属性を除去
625      target.removeAttribute(this.ATTR_STATE);
626    }
627
628    /* 送信ボタンの制御関連 ------------------------------------- */
629    /**
630     * フォームの検証状況を精査し、送信可能かどうかを返す
631     * @returns {Boolean}
632     */
633  }, {
634    key: "judgeSubmit",
635    value: function judgeSubmit() {
636      var _self = this;
637
638      // submitボタンがなければ離脱
639      if (!_self.submit) return;
640      var invalidItems = Array.from(_self.items).filter(function (element) {
641        var state = element.getAttribute(_self.ATTR_STATE);
642
643        // 未検証、またはエラーの項目のみを抽出
644        if (state == "unvalid" || state == "invalid") return element;
645      });
646
647      // 未検証、エラー項目が一つでもあればfalseとする
648      if (invalidItems.length == 0) {
649        _self.state = true;
650        return true;
651      } else {
652        _self.state = false;
653        return false;
654      }
655    }
656
657    /**
658     * フォームが送信可能かどうかを判別してsubmitボタンの活性状態を変更
659     * @returns {Boolean}
660     */
661  }, {
662    key: "setSubmitState",
663    value: function setSubmitState() {
664      var _this6 = this;
665      var _self = this;
666      if (this.judgeSubmit()) {
667        // バリデートが通っていればsubmitボタン属性にtrueを設定（活性化）
668        // submitボタン
669        Array.from(this.submit).filter(function (element) {
670          element.setAttribute(_self.ATTR_SUBMIT, "true");
671
672          // サブミットボタンのロック設定がtrueならばボタンのdisabled属性を変更する。
673          if (_this6.config.useSubmitLock == true) element.disabled = false;
674        });
675        // nextボタン
676        Array.from(this.next).filter(function (element) {
677          element.setAttribute(_self.ATTR_NEXT, "true");
678
679          // サブミットボタンのロック設定がtrueならばボタンのdisabled属性を変更する。
680          if (_this6.config.useSubmitLock == true) element.disabled = false;
681        });
682        return true;
683      } else {
684        // バリデートが通っていなければfalseを設定（非活性化）
685        // submitボタン
686        Array.from(this.submit).filter(function (element) {
687          element.setAttribute(_self.ATTR_SUBMIT, "false");
688
689          // サブミットボタンのロック設定がtrueならばボタンのdisabled属性を変更する。
690          if (_this6.config.useSubmitLock == true) element.disabled = true;
691        });
692        // nextボタン
693        Array.from(this.next).filter(function (element) {
694          element.setAttribute(_self.ATTR_NEXT, "false");
695
696          // サブミットボタンのロック設定がtrueならばボタンのdisabled属性を変更する。
697          if (_this6.config.useSubmitLock == true) element.disabled = true;
698        });
699        return false;

700      }
701    }
702
703    /**
704     * submitボタンの活性状態をリセット
705     * @returns {Boolean}
706     */
707  }, {
708    key: "resetSubmitState",
709    value: function resetSubmitState() {
710      var _self = this;
711
712      // submitボタンをリセット
713      Array.from(_self.submit).filter(function (element) {
714        element.disabled = false;
715        element.setAttribute(_self.ATTR_SUBMIT, "");
716      });
717
718      // nextボタンをリセット
719      Array.from(_self.next).filter(function (element) {
720        element.disabled = false;
721        element.setAttribute(_self.ATTR_NEXT, "");
722      });
723    }
724  }]);
725}();
726/**
727 * バリデーターモジュール
728 *
729 * 実際のバリデートを行うルーチン郡。
730 * バリデート処理順序などのルール設定と個別処理を記載する。
731 -------------------------------------------------------------------------- */
732var Validator = /*#__PURE__*/function () {
733  /**
734   * コンストラクター
735   */
736  function Validator() {
737    var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
738    _classCallCheck(this, Validator);
739    /* 定数 ------------------------------------- */
740    /* デフォルト設定（バリデーター） ------------------------------------- */
741    // バリデーションステータス（バリデーションの状況の定義に使用する属性値）
742    _defineProperty(this, "DEFAULT_VALIDITY", {
743      badInput: false,
744      notNumeric: false,
745      customError: false,
746      patternMismatch: false,
747      mailMismatch: false,
748      rangeOverflow: false,
749      rangeUnderflow: false,
750      stepMismatch: false,
751      tooLong: false,
752      tooShort: false,
753      typeMismatch: false,
754      valid: true,
755      valueMissing: false,
756      notEqual: false,
757      notCheck: false,
758      notSelect: false
759    });
760    // バリデーションメッセージ（ステータスとkeyを揃えて対応するエラーメッセージを設定）
761    _defineProperty(this, "DEFAULT_MESSAGE", {
762      // 不完全な値だと判断した場合
763      badInput: "入力内容が不適切です。",
764      // 数字以外が入力されている場合
765      notNumeric: "半角数字以外が入力されています。",
766      // 独自エラーメッセージがセットされている場合
767      customError: "入力内容に誤りがあります。",
768      // pattern属性で指定した要件を満たさない場合
769      patternMismatch: "入力内容が条件に適していません。",
770      // メールの要件を満たさない場合
771      mailMismatch: "メールアドレスとして不適切です。",
772      // max、min属性で指定した最大値、最小値を超えている、満たない場合
773      rangeOverflow: "入力値が大きすぎます。",
774      rangeUnderflow: "入力値が小さすぎます。",
775      // step属性で指定した規則に一致しない場合
776      stepMismatch: "入力内容が条件に適していません。",
777      // maxlength、minlength属性で指定した長さを超えているとき、満たない場合
778      tooLong: "入力内容が長すぎます。",
779      tooShort: "入力内容が短すぎます。",
780      // 入力値が要件を満たさない場合
781      typeMismatch: "入力内容が条件に適していません。",
782      // 値の妥当性にひとつでも問題がある場合
783      valid: "入力内容に誤りがあります。",
784      // 必須なのに値がない場合
785      valueMissing: "この項目は必須です。",
786      // 対象項目と一致しない場合
787      notEqual: "入力値が一致しません。",
788      // チェックされていない場合
789      notCheck: "この項目は必須です。",
790      // チェックされていない場合
791      notSelect: "この項目は必須です。"
792    });
793    /* メンバープロパティ ------------------------------------- */
794    _defineProperty(this, "validity", {});
795    _defineProperty(this, "message", {});
796    //設定をマージ
797
798    // validityキーが存在していなければ空で作成

799    if (!("validity" in config)) config.validity = {};
800    this.validity = Object.assign({}, this.DEFAULT_VALIDITY, JSON.parse(JSON.stringify(config.validity)));
801
802    // messageキーが存在していなければ空で作成
803    if (!("message" in config)) config.message = {};
804    this.message = Object.assign({}, this.DEFAULT_MESSAGE, JSON.parse(JSON.stringify(config.message)));
805  }
806
807  /**
808   * バリデートルール関数群
809   * 定義した処理が上から順に適用される。
810   */
811
812  /**
813   * デフォルトルール
814   * @param {DOM element} target
815   */
816  return _createClass(Validator, [{
817    key: "default",
818    value: function _default(target) {
819      // required属性があった場合
820      this._judgeAndExecuteValidation(target, "required");
821
822      // has number:number属性だった場合
823      if (target.getAttribute("type") === "number") this.number(target);
824
825      // has min:min属性があった場合
826      this._judgeAndExecuteValidation(target, "min");
827
828      // has max:max属性があった場合
829      this._judgeAndExecuteValidation(target, "max");
830
831      // has minlength:minlength属性があった場合
832      this._judgeAndExecuteValidation(target, "minlength");
833
834      // has maxlength:maxlength属性があった場合
835      this._judgeAndExecuteValidation(target, "maxlength");
836
837      // has pattern:pattern属性があった場合
838      this._judgeAndExecuteValidation(target, "pattern");
839
840      // has equal:equal属性があった場合
841      this._judgeAndExecuteValidation(target, "equal");
842
843      // バリデーション結果をもとにvalid属性の値をセットする。
844      this.setValidityValid(target);
845    }
846
847    /**
848     * テキストルール
849     * @param {DOM element} target
850     */
851  }, {
852    key: "text",
853    value: function text(target) {
854      // required属性があった場合
855      this._judgeAndExecuteValidation(target, "required");
856
857      // has minlength:minlength属性があった場合
858      this._judgeAndExecuteValidation(target, "minlength");
859
860      // has maxlength:maxlength属性があった場合
861      this._judgeAndExecuteValidation(target, "maxlength");
862
863      // has pattern:pattern属性があった場合
864      this._judgeAndExecuteValidation(target, "pattern");
865
866      // has equal:equal属性があった場合
867      this._judgeAndExecuteValidation(target, "equal");
868
869      // バリデーション結果をもとにvalid属性の値をセットする。
870      this.setValidityValid(target);
871    }
872
873    /**
874     * メールルール
875     * @param {DOM element} target
876     */
877  }, {
878    key: "email",
879    value: function email(target) {
880      // required属性があった場合
881      this._judgeAndExecuteValidation(target, "required");
882
883      // 半角英数記号のみかをチェック（強制）
884      this.halfWidth(target);
885
886      // has minlength:minlength属性があった場合
887      this._judgeAndExecuteValidation(target, "minlength");
888
889      // has maxlength:maxlength属性があった場合
890      this._judgeAndExecuteValidation(target, "maxlength");
891
892      // has pattern:pattern属性があった場合
893      this._judgeAndExecuteValidation(target, "pattern");
894
895      // メールアドレスとして正しいかどうかをチェック（強制）
896      this.emailpattern(target);
897
898      // has equal:equal属性があった場合
899      this._judgeAndExecuteValidation(target, "equal");
900
901      // バリデーション結果をもとにvalid属性の値をセットする。
902      this.setValidityValid(target);
903    }
904
905    /**
906     * numericルール
907     * @param {DOM element} target
908     */
909  }, {
910    key: "numeric",
911    value: function numeric(target) {
912      // required属性があった場合
913      this._judgeAndExecuteValidation(target, "required");
914
915      // 半角数字のみかチェック（強制）
916      this.number(target);
917
918      // has min:min属性があった場合
919      this._judgeAndExecuteValidation(target, "min");
920
921      // has max:max属性があった場合
922      this._judgeAndExecuteValidation(target, "max");
923
924      // has minlength:minlength属性があった場合
925      this._judgeAndExecuteValidation(target, "minlength");
926
927      // has maxlength:maxlength属性があった場合
928      this._judgeAndExecuteValidation(target, "maxlength");
929
930      // has pattern:pattern属性があった場合
931      this._judgeAndExecuteValidation(target, "pattern");
932
933      // has equal:equal属性があった場合
934      this._judgeAndExecuteValidation(target, "equal");
935
936      // バリデーション結果をもとにvalid属性の値をセットする。
937      this.setValidityValid(target);
938    }
939
940    /**
941     * ラジオボタンルール
942     * @param {DOM element} target
943     */
944  }, {
945    key: "radio",
946    value: function radio(target) {
947      // required属性があった場合
948      if (this.hasValidateAttribute(target, "required")) this.radioRequired(target);
949
950      // バリデーション結果をもとにvalid属性の値をセットする。
951      this.setValidityValid(target);
952    }
953
954    /**
955     * チェックルール
956     * @param {DOM element} target
957     */
958  }, {
959    key: "check",
960    value: function check(target) {
961      // required属性があった場合
962      if (this.hasValidateAttribute(target, "required")) this.checkRequired(target);
963
964      // バリデーション結果をもとにvalid属性の値をセットする。
965      this.setValidityValid(target);
966    }
967
968    /**
969     * セレクトルール
970     * @param {DOM element} target
971     */
972  }, {
973    key: "select",
974    value: function select(target) {
975      // required属性があった場合
976      if (this.hasValidateAttribute(target, "required")) this.selectRequired(target);
977
978      // バリデーション結果をもとにvalid属性の値をセットする。
979      this.setValidityValid(target);
980    }
981
982    /**
983     * バリデート処理関数群
984     * 定義したバリデートルールの中で使用する処理の一覧
985    ------------------------------------- */
986    /**
987     * 必須項目が入力されているかをチェックする。（input）
988     *
989     * @param {DOM element} target
990     * @returns {boolean}
991     */
992  }, {
993    key: "required",
994    value: function required(target) {
995      // 入力値がない場合、missingエラー
996      if (target.value.length == 0) {
997        // validityを作成しエラーを設定

998        var validity = this.getValidity(target);
999        validity.valueMissing = true;
1000
1001        // エラー状態を属性に反映
1002        this.setValidity(target, validity);
1003        return false;
1004      }
1005      return true;
1006    }
1007
1008    /**
1009     * 数字のみかどうかをチェックする。
1010     *
1011     * @param {DOM element} target
1012     * @returns {boolean}
1013     */
1014  }, {
1015    key: "number",
1016    value: function number(target) {
1017      // 入力値が数字でない場合、badInputエラー
1018      if (isNaN(target.value) && target.value.length > 0) {
1019        // validityを作成
1020        var validity = this.getValidity(target);
1021        validity.notNumeric = true;
1022
1023        // エラー状態を属性に反映
1024        this.setValidity(target, validity);
1025        return false;
1026      }
1027      return true;
1028    }
1029
1030    /**
1031     * 半角英数記号のみ
1032     * @param {DOM element} target
1033     * @returns {boolean}
1034     */
1035  }, {
1036    key: "halfWidth",
1037    value: function halfWidth(target) {
1038      // 入力値がマッチしない場合、patternMismatchエラー
1039      if (!target.value.match(/^[\x20-\x7e]+$/) && target.value.length > 0) {
1040        // validityを作成
1041        var validity = this.getValidity(target);
1042        validity.patternMismatch = true;
1043
1044        // エラー状態を属性に反映
1045        this.setValidity(target, validity);
1046        return false;
1047      }
1048      return true;
1049    }
1050
1051    /**
1052     * 最小数値
1053     * @param {DOM element} target
1054     * @returns {boolean}
1055     */
1056  }, {
1057    key: "min",
1058    value: function min(target) {
1059      // 最小値を属性から取得
1060      var attr = this.getValidateAttribute(target, "min");
1061
1062      // 値がなければ離脱
1063      if (typeof attr === "undefined") return true;
1064
1065      // 入力値が小さい場合、rangeUnderflowエラー
1066      if (Number(target.value) < Number(attr) && target.value.length > 0) {
1067        // validityを作成
1068        var validity = this.getValidity(target);
1069        validity.rangeUnderflow = true;
1070
1071        // エラー状態を属性に反映
1072        this.setValidity(target, validity);
1073        return false;
1074      }
1075      return true;
1076    }
1077
1078    /**
1079     * 最大数値
1080     * @param {DOM element} target
1081     * @returns {boolean}
1082     */
1083  }, {
1084    key: "max",
1085    value: function max(target) {
1086      // 最大値を属性から取得
1087      var attr = this.getValidateAttribute(target, "max");
1088
1089      // 値がなければ離脱
1090      if (typeof attr === "undefined") return true;
1091
1092      // 入力値が大きい場合、rangeOverflowエラー
1093      if (Number(target.value) >= Number(attr)) {
1094        // validityを作成
1095        var validity = this.getValidity(target);
1096        validity.rangeOverflow = true;
1097
1098        // エラー状態を属性に反映
1099        this.setValidity(target, validity);
1100        return false;
1101      }
1102      return true;
1103    }
1104
1105    /**
1106     * 最小の文字列長
1107     * @param {DOM element} target
1108     * @returns {boolean}
1109     */
1110  }, {
1111    key: "minlength",
1112    value: function minlength(target) {
1113      // 最短値を属性から取得
1114      var attr = this.getValidateAttribute(target, "minlength");
1115
1116      // 値がなければ離脱
1117      if (typeof attr === "undefined") return false;
1118
1119      // 入力値が短い場合、tooShortエラー
1120      if (target.value.length < attr && target.value.length > 0) {
1121        // validityを作成
1122        var validity = this.getValidity(target);
1123        validity.tooShort = true;
1124
1125        // エラー状態を属性に反映
1126        this.setValidity(target, validity);
1127        return false;
1128      }
1129      return true;
1130    }
1131
1132    /**
1133     * 最大の文字列長
1134     * @param {DOM element} target
1135     * @returns {boolean}
1136     */
1137  }, {
1138    key: "maxlength",
1139    value: function maxlength(target) {
1140      // 最長値を属性から取得
1141      var attr = this.getValidateAttribute(target, "maxlength");
1142
1143      // 値がなければ離脱
1144      if (typeof attr === "undefined") return false;
1145
1146      // 入力値が長い場合、tooLongエラー
1147      if (target.value.length > attr) {
1148        // validityを作成

1149        var validity = this.getValidity(target);
1150        validity.tooLong = true;
1151
1152        // エラー状態を属性に反映
1153        this.setValidity(target, validity);
1154        return false;
1155      }
1156      return true;
1157    }
1158
1159    /**
1160     * 正規表現パターン
1161     * @param {DOM element} target
1162     * @returns {boolean}
1163     */
1164  }, {
1165    key: "pattern",
1166    value: function pattern(target) {
1167      var attr = this.getValidateAttribute(target, "pattern");
1168      var pattern = RegExp(attr);
1169
1170      // 入力値がマッチしない場合、patternMismatchエラー
1171      if (!target.value.match(pattern) && target.value.length > 0) {
1172        // validityを作成
1173        var validity = this.getValidity(target);
1174        validity.patternMismatch = true;
1175
1176        // エラー状態を属性に反映
1177        this.setValidity(target, validity);
1178        return false;
1179      }
1180      return true;
1181    }
1182
1183    /**
1184     * メールアドレスパターン
1185     * @param {DOM element} target
1186     * @returns {boolean}
1187     */
1188  }, {
1189    key: "emailpattern",
1190    value: function emailpattern(target) {
1191      var pattern = RegExp(".+@.+...+");
1192
1193      // 入力値がマッチしない場合、mailMismatchエラー
1194      if (!target.value.match(pattern) && target.value.length > 0) {
1195        // validityを作成
1196        var validity = this.getValidity(target);
1197        validity.mailMismatch = true;
1198
1199        // エラー状態を属性に反映
1200        this.setValidity(target, validity);
1201        return false;
1202      }
1203      return true;
1204    }
1205
1206    /**
1207     * 必須項目（select）
1208     * @param {DOM element} target
1209     * @returns {boolean}
1210     */
1211  }, {
1212    key: "selectRequired",
1213    value: function selectRequired(target) {
1214      var val = target.options[target.selectedIndex].value;
1215
1216      // 入力値がデフォルトの場合、notSelectエラー
1217      if (val === "default" || val === "") {
1218        // validityを作成
1219        var validity = this.getValidity(target);
1220        validity.notSelect = true;
1221
1222        // エラー状態を属性に反映
1223        this.setValidity(target, validity);
1224        return false;
1225      }
1226      return true;
1227    }
1228
1229    /**
1230     * 必須項目（radio）
1231     * @param {DOM element} target
1232     * @returns {boolean}
1233     */
1234  }, {
1235    key: "radioRequired",
1236    value: function radioRequired(target) {
1237      var _self = this;
1238
1239      // 同じnameの要素をフィルター
1240      var name = target.getAttribute("name");
1241      var radioButtons = document.querySelectorAll('input[type="radio"][name="' + name + '"]');
1242
1243      // チェック済みフラグ
1244      var validFlug = false;
1245
1246      // チェック要素があるかを確認
1247      Array.from(radioButtons).forEach(function (element, i) {
1248        // その要素がチェックされていた場合
1249        if (element.checked) validFlug = true;
1250      });
1251      Array.from(radioButtons).forEach(function (element, i) {
1252        // validityを作成
1253        var validity = _self.getValidity(element);
1254        if (validFlug) {
1255          // ステータスを変更
1256          element.setAttribute(_self["super"].ATTR_STATE, "valid");
1257          // エラーの詳細を設定
1258          validity.notCheck = false;
1259        } else {
1260          // ステータスを変更
1261          element.setAttribute(_self["super"].ATTR_STATE, "invalid");
1262          // エラーの詳細を設定
1263          validity.notCheck = true;
1264        }
1265
1266        // エラー状態を属性に反映
1267        _self.setValidity(element, validity);
1268      });
1269      if (validFlug) {
1270        return true;
1271      }
1272      return false;
1273    }
1274
1275    /**
1276     * 必須項目（checkbox）
1277     * @param {DOM element} target
1278     * @returns {boolean}
1279     */
1280  }, {
1281    key: "checkRequired",
1282    value: function checkRequired(target) {
1283      var _self = this;
1284
1285      // 同じnameの要素をフィルター
1286      var name = target.getAttribute("name");
1287      var checkBoxes = document.querySelectorAll('input[type="checkbox"][name="' + name + '"]');
1288
1289      // チェックフラグ
1290      var validFlug = false;
1291
1292      // チェック要素があるかを確認

1293      Array.from(checkBoxes).forEach(function (element, i) {
1294        // その要素がチェックされていた場合
1295        if (element.checked) validFlug = true;
1296      });
1297      Array.from(checkBoxes).forEach(function (element, i) {
1298        // validityを作成
1299        var validity = _self.getValidity(element);
1300        if (validFlug) {
1301          // ステータスを変更
1302          element.setAttribute(_self["super"].ATTR_STATE, "valid");
1303          // エラーの詳細を設定
1304          validity.notCheck = false;
1305        } else {
1306          // ステータスを変更
1307          element.setAttribute(_self["super"].ATTR_STATE, "invalid");
1308          // エラーの詳細を設定
1309          validity.notCheck = true;
1310        }
1311
1312        // エラー状態を属性に反映
1313        _self.setValidity(element, validity);
1314      });
1315      if (validFlug) {
1316        return true;
1317      }
1318      return false;
1319    }
1320
1321    /**
1322     * 同じ値かどうか
1323     * @param {DOM element} target
1324     * @returns {boolean}
1325     */
1326  }, {
1327    key: "equal",
1328    value: function equal(target) {
1329      var _self = this;
1330
1331      // nameを取得
1332      var name = _self.getValidateAttribute(target, "equal");
1333
1334      // 他方の要素を取得
1335      var setInputs = document.querySelectorAll("*[" + _self["super"].PLUGIN_PREFIX + "-equal=" + name + "]");
1336      var inputQuantity = Array.from(setInputs).length;
1337
1338      // 要素が一つの場合は比較できないためtrueとして離脱
1339      if (inputQuantity == 1) return true;
1340
1341      // バリデートが未完の要素があるかどうかをチェック
1342      var notValidated = Array.from(setInputs).filter(function (element) {
1343        // ステータスを取得
1344        var state = element.getAttribute(_self["super"].ATTR_STATE);
1345
1346        // 未検証ステータスの要素を返送
1347        if (!_self.isValidatedItem(element)) return element;
1348      });
1349
1350      // まだ一度も触れていない要素がある場合は検証出来ないためtrueとして離脱
1351      if (notValidated.length > 0) return true;
1352
1353      // 対象要素全ての値を取得
1354      var values = Array.from(setInputs).map(function (element) {
1355        return element.value;
1356      });
1357      // 全項目の値が一致しているかチェック
1358      var isAllEqual = values.every(function (value) {
1359        return value === values[0];
1360      });
1361
1362      // バリデート結果によって処理を実行
1363      if (isAllEqual) {
1364        // 全ての値が一致している場合
1365        // エラー状態を属性に反映
1366        Array.from(setInputs).forEach(function (element) {
1367          // equal項目をクリアしたvalidityを作成
1368          var validity = _self.getValidity(element);
1369          validity.notEqual = false;
1370
1371          // エラー状態を属性に反映
1372          _self.setValidity(element, validity);
1373
1374          // エラー属性を除去
1375          _self["super"].setState(element, 'valid');
1376        });
1377        return true;
1378      } else {
1379        // 一致していない値がある場合
1380
1381        Array.from(setInputs).forEach(function (element) {
1382          // equal項目がエラーのvalidityを作成
1383          var validity = _self.getValidity(element);
1384          validity.notEqual = true;
1385
1386          // 対象要素以外の場合、validをfalseに変更し、エラー属性の付与まã

1386§è¡Œã†ã€‚
1387          if (!target.isEqualNode(element)) {
1388            validity.validity = false;
1389            // エラー属性を付与
1390            _self["super"].setState(element, "invalid");
1391          }
1392
1393          // エラー状態を属性に反映
1394          _self.setValidity(element, validity);
1395        });
1396        return false;
1397      }
1398    }
1399
1400    /* ----------------------------------------------
1401    * サブルーチン
1402    ---------------------------------------------- */
1403    /**
1404     * ※private
1405     * 属性値の存在をチェックし、属性値があればバリデーションを実行する。
1406     *
1407     * @param {DOM element} target 対象要素のDOMオブジェクト
1408     * @param {String} attr バリデーションを実行したい属性値
1409     */
1410  }, {
1411    key: "_judgeAndExecuteValidation",
1412    value: function _judgeAndExecuteValidation(target, validProperty) {
1413      if (this.hasValidateAttribute(target, validProperty)) this[validProperty](target);
1414    }
1415
1416    /* 要素判定関連 ------------------------------------- */
1417    /**
1418     * 対象要素がバリデート可能かを判定
1419     * @param {DOM element} target 対象要素のDOMオブジェクト
1420     * @returns {Boolean}
1421     */
1422  }, {
1423    key: "isValidatableItem",
1424    value: function isValidatableItem(target) {
1425      // HTML要素でなければ除外
1426      if (target instanceof HTMLElement === false) return false;
1427
1428      // フォームパーツHTML以外を除外
1429      var tagName = target.tagName;
1430      var matchTags = ["INPUT", "TEXTAREA", "SELECT"];
1431      if (!matchTags.includes(tagName)) {
1432        return false;
1433      }
1434
1435      // submit、resetタイプを除外
1436      var type = target.getAttribute("type");
1437      var matchType = ["submit", "reset"];
1438      if (matchType.includes(type)) return false;
1439
1440      // すべての除外対象でなければバリデート対象とする。
1441      return true;
1442    }
1443
1444    /**
1445     * 対象要素が一度でもバリデートされているかを判定
1446     * @param {DOM element} target 対象要素のDOMオブジェクト
1447     * @returns {Boolean}
1448     */
1449  }, {
1450    key: "isValidatedItem",
1451    value: function isValidatedItem(target) {
1452      // validityを取得
1453      var validity = this.getValidity(target);
1454
1455      // validityが空であれば一度もバリデートされていない項目と見なしfalseを返す
1456      if (Object.keys(validity).length == 0) return false;
1457
1458      // validityがあればバリデート済みとしてtrueを返す。
1459      return true;
1460    }
1461
1462    /* バリデーション用属性制御関連 ------------------------------------- */
1463    /**
1464     * バリデーション用属性の存在チェックする
1465     *
1466     * @param {DOM element} target 対象要素のDOMオブジェクト
1467     * @param {String} attr 存在確認を行いたい属性
1468     * @returns {Boolean}
1469     */
1470  }, {
1471    key: "hasValidateAttribute",
1472    value: function hasValidateAttribute(target, attr) {
1473      // 対象がHTML要素でなければfalse
1474      if (target instanceof HTMLElement === false) return false;
1475      if (target.hasAttribute(attr) || target.hasAttribute(this["super"].PLUGIN_PREFIX + "-" + attr)) {
1476        // 通常のフォーム規則、またはカスタム属性があったはバリデート属性ありと判別
1477        return true;
1478      } else {
1479        // どちらもなかった場合
1480        return false;
1481      }
1482    }
1483
1484    /**
1485     * バリデーション用属性の値を取得
1486     * @param {DOM element} target 対象要素のDOMオブジェクト
1487     * @param {String} attr 取得したい属性
1488     * @returns {Boolean}
1489     */
1490  }, {
1491    key: "getValidateAttribute",
1492    value: function getValidateAttribute(target, attr) {
1493      // 対象がHTML要素でなければfalse
1494      if (target instanceof HTMLElement === false) return false;
1495      if (target.hasAttribute(attr)) {
1496        // 通常のフォーム規則があった場合
1497        return target.getAttribute(attr);
1498      } else if (target.hasAttribute(this["super"].PLUGIN_PREFIX + "-" + attr)) {
1499        // カスタム属性があった場合
1500        return target.getAttribute(this["super"].PLUGIN_PREFIX + "-" + attr);
1501      } else {
1502        return false;

1503      }
1504    }
1505
1506    /* Validity属性制御関連 ------------------------------------- */
1507    /**
1508     * 対象要素のバリデート状態を取得
1509     * @param {DOM element} target バリデート対象のDOMオブジェクト
1510     * @returns {Object} 対象要素のバリデートステータス
1511     */
1512  }, {
1513    key: "getValidity",
1514    value: function getValidity(target) {
1515      // 属性値を取得
1516      var validityString = target.getAttribute(this["super"].ATTR_VALIDITY);
1517
1518      // JSON文字列をvalidityオブジェクトに変換
1519      // {"valid":false,"valueMissing":true} → Object
1520      var validity = JSON.parse(validityString);
1521
1522      // 属性値がない場合は空配列を返す。
1523      if (validity == null) validity = {};
1524      return validity;
1525    }
1526
1527    /**
1528     * 対象要素にバリデート状態をセット
1529     * @param {DOM element} target バリデート対象のDOMオブジェクト
1530     * @param {Object} validity 変更したいバリデートステータス
1531     * @returns -
1532     */
1533  }, {
1534    key: "setValidity",
1535    value: function setValidity(target, validity) {
1536      // validityをJSON文字列に変換
1537      // Object → {"valid":false,"valueMissing":true}
1538      var validityString = JSON.stringify(validity);
1539
1540      // 属性値をセット
1541      target.setAttribute(this["super"].ATTR_VALIDITY, validityString);
1542    }
1543
1544    /**
1545     * 対象要素のバリデート状態を初期状態にリセット
1546     * @param {DOM element} target バリデート対象のDOMオブジェクト
1547     * @returns -
1548     */
1549  }, {
1550    key: "resetValidity",
1551    value: function resetValidity(target) {
1552      // デフォルトのvalidityをJSON文字列に変換
1553      // Object → {"valid":false,"valueMissing":true}
1554      var validityString = JSON.stringify(this.validity);
1555
1556      // 属性値をセット
1557      target.setAttribute(this["super"].ATTR_VALIDITY, validityString);
1558    }
1559
1560    /**
1561     * バリデート状態（validityのfalse状況）を、エラーを優先（＝エラーが上書きされない）してマージする。
1562     * @param {Array} validities
1563     * @returns {Object} validity マージされたバリデートステータス
1564     */
1565  }, {
1566    key: "mergeValidity",
1567    value: function mergeValidity(validities) {
1568      // デフォルトのvalidityをマージベースとしてセット
1569      var mergedValidity = Object.assign({}, this.validity);
1570      validities.forEach(function (validity) {
1571        // validityの全項目に対して、マージを実行
1572        // ※デフォルトのvalidityのキーが基準になるためeachはデフォルト基準で実行
1573        Object.keys(mergedValidity).forEach(function (key) {
1574          // valid属性は他の属性値の値をもって決定するのでスキップ
1575          if (key == "valid") return;
1576
1577          // エラー項目があった場合
1578          if (validity[key] == true) {
1579            // エラーの項目が一つでもあればvalidをfalseに変更
1580            mergedValidity.valid = false;
1581            // validityの同項目をエラー状態に変更
1582            mergedValidity[key] = true;
1583          }
1584        });
1585      });
1586      return mergedValidity;
1587    }
1588
1589    /**
1590     * validityの各項目のエラー状況を元に対象要素のvalid属性の判断を行う。
1591     * （※複数のvalidityにエラー項目がある際に、処理が後の項目での結果で全体がvalidになってしまうのを防ぐため。）
1592     *
1593     * @param {DOM element} target バリデート対象のDOMオブジェクト
1594     * @returns -
1595     */
1596  }, {
1597    key: "setValidityValid",
1598    value: function setValidityValid(target) {
1599      var validity = this.getValidity(target);
1600
1601      // valid属性を初期化
1602      validity.valid = true;
1603
1604      // validityの全項目に対して、エラーがあるかのチェックを実行
1605      Object.keys(validity).forEach(function (key) {
1606        // valid属性は他の属性値の値をもって決定するのでスキップ
1607        if (key == "valid") return;
1608
1609        // エラーの項目が一つでもあればvalidをfalseに変更
1610        if (validity[key] == true) validity.valid = false;

1611      });
1612
1613      // エラー状態を属性に反映
1614      this.setValidity(target, validity);
1615    }
1616
1617    /**
1618     * 対象要素のバリデート状態を消去する。
1619     * @param {DOM element} target バリデート対象のDOMオブジェクト
1620     * @returns -
1621     */
1622  }, {
1623    key: "destroyValidity",
1624    value: function destroyValidity(target) {
1625      // 属性を消去
1626      target.removeAttribute(this["super"].ATTR_VALIDITY);
1627    }
1628  }]);
1629}();
1630
1631/***/ },
1632
1633/***/ "./src/js/form/ParseFormQuery.js"
1634/*!***************************************!*\
1635  !*** ./src/js/form/ParseFormQuery.js ***!
1636  \***************************************/
1637(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
1638
1639__webpack_require__.r(__webpack_exports__);
1640/* harmony export */ __webpack_require__.d(__webpack_exports__, {
1641/* harmony export */   ParceFormQuery: () => (/* binding */ ParceFormQuery)
1642/* harmony export */ });
1643function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
1644function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
1645function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
1646function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
1647function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
1648function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
1649function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
1650function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
1651function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
1652/* ----------------------------------------------
1653 * フォームバリデーションjs
1654 *
1655---------------------------------------------- */
1656// module exports
1657
1658
1659/* 定数
1660------------------------------------- */
1661var ParceFormQuery = /*#__PURE__*/function () {
1662  function ParceFormQuery() {
1663    _classCallCheck(this, ParceFormQuery);
1664    _defineProperty(this, "errorFlug", void 0);
1665    _defineProperty(this, "queryStrings", void 0);
1666    // フラグを初期化
1667    this.errorFlug = false;
1668    //
1669    this.parceUri();
1670  }
1671
1672  /**
1673   * URIをパースしてクエリーをフォームに復帰、エラーフラグをセットする
1674   */
1675  return _createClass(ParceFormQuery, [{
1676    key: "parceUri",
1677    value: function parceUri() {
1678      var _this = this;
1679      // クエリーを処理
1680      var search = location.search;
1681
1682      //クエリーがなければskip
1683      if (search.length > 0) {
1684        // クエリストリングをパース
1685        this.queryStrings = search.split("?")[1].split("&").map(function (p) {
1686          return p.split("=");
1687        }).reduce(function (obj, e) {
1688          return _objectSpread(_objectSpread({}, obj), {}, _defineProperty({}, e[0], e[1]));
1689        }, {});
1690
1691        // フラグを初期化
1692        this.errorFlug = false;

1693
1694        // errorsにtrueが入っていればエラーとみなす。
1695        if (this.queryStrings['errors'] == 'true') {
1696          this.errorFlug = true;
1697        }
1698
1699        // GETパラメータの配列を回し、同名項目があれば値を復帰
1700        Object.keys(this.queryStrings).forEach(function (key) {
1701          var originValue = _this.queryStrings[key];
1702
1703          // 値をデコードする
1704          var value = unescape(decodeURI(originValue));
1705
1706          // ターゲットを走査する。
1707          var target = document.querySelectorAll('*[name="' + key + '"]');
1708
1709          // 同じnameの要素が存在する場合、値を展開する
1710          if (target.length > 0) {
1711            var type = target[0].getAttribute("type");
1712            var tagName = target[0].tagName;
1713            switch (tagName) {
1714              case "INPUT":
1715                if (type === "checkbox" || type === "radio") {
1716                  target.forEach(function (element) {
1717                    if (element.value == value) element.checked = true;
1718                  });
1719                }
1720                if (type === "text" || type === "number" || type === "email" || type === "tel" || type === "hidden") {
1721                  target[0].value = value;
1722                }
1723                break;
1724              case "SELECT":
1725                target[0].value = value;
1726                break;
1727              case "TEXTAREA":
1728                target[0].value = value;
1729                break;
1730            }
1731          }
1732        });
1733      }
1734    }
1735
1736    /**
1737     * pardotエラーが有ったかどうかのチェッカー
1738     * @returns {Boolean} Pardotのエラーがあったかどうかの真偽値
1739     */
1740  }, {
1741    key: "hasPardotError",
1742    value: function hasPardotError() {
1743      return this.errorFlug;
1744    }
1745  }]);
1746}();
1747
1748/***/ },
1749
1750/***/ "./src/js/form/ReCaptchaModule.js"
1751/*!****************************************!*\
1752  !*** ./src/js/form/ReCaptchaModule.js ***!
1753  \****************************************/
1754(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
1755
1756__webpack_require__.r(__webpack_exports__);
1757/* harmony export */ __webpack_require__.d(__webpack_exports__, {
1758/* harmony export */   ReCaptchaModule: () => (/* binding */ ReCaptchaModule)
1759/* harmony export */ });
1760function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
1761function _regeneratorRuntime() { "use strict"; var r = _regenerator(), e = r.m(_regeneratorRuntime), t = (Object.getPrototypeOf ? Object.getPrototypeOf(e) : e.__proto__).constructor; function n(r) { var e = "function" == typeof r && r.constructor; return !!e && (e === t || "GeneratorFunction" === (e.displayName || e.name)); } var o = { "throw": 1, "return": 2, "break": 3, "continue": 3 }; function a(r) { var e, t; return function (n) { e || (e = { stop: function stop() { return t(n.a, 2); }, "catch": function _catch() { return n.v; }, abrupt: function abrupt(r, e) { return t(n.a, o[r], e); }, delegateYield: function delegateYield(r, o, a) { return e.resultName = o, t(n.d, _regeneratorValues(r), a); }, finish: function finish(r) { return t(n.f, r); } }, t = function t(r, _t, o) { n.p = e.prev, n.n = e.next; try { return r(_t, o); } finally { e.next = n.n; } }), e.resultName && (e[e.resultName] = n.v, e.resultName = void 0), e.sent = n.v, e.next = n.n; try { return r.call(this, e); } finally { n.p = e.prev, n.n = e.next; } }; } return (_regeneratorRuntime = function _regeneratorRuntime() { return { wrap: function wrap(e, t, n, o) { return r.w(a(e), t, n, o && o.reverse()); }, isGeneratorFunction: n, mark: r.m, awrap: function awrap(r, e) { return new _OverloadYield(r, e); }, AsyncIterator: _regeneratorAsyncIterator, async: function async(r, e, t, o, u) { return (n(e) ? _regeneratorAsyncGen : _regeneratorAsync)(a(r), e, t, o, u); }, keys: _regeneratorKeys, values: _regeneratorValues }; })(); }
1762function _regeneratorValues(e) { if (null != e) { var t = e["function" == typeof Symbol && Symbol.iterator || "@@iterator"], r = 0; if (t) return t.call(e); if ("function" == typeof e.next) return e; if (!isNaN(e.length)) return { next: function next() { return e && r >= e.length && (e = void 0), { value: e && e[r++], done: !e }; } }; } throw new TypeError(_typeof(e) + " is not iterable"); }
1763function _regeneratorKeys(e) { var n = Object(e), r = []; for (var t in n) r.unshift(t); return function e() { for (; r.length;) if ((t = r.pop()) in n) return e.value = t, e.done = !1, e; return e.done = !0, e; }; }
1764function _regeneratorAsync(n, e, r, t, o) { var a = _regeneratorAsyncGen(n, e, r, t, o); return a.next().then(function (n) { return n.done ? n.value : a.next(); }); }
1765function _regeneratorAsyncGen(r, e, t, o, n) { return new _regeneratorAsyncIterator(_regenerator().w(r, e, t, o), n || Promise); }
1766function _regeneratorAsyncIterator(t, e) { function n(r, o, i, f) { tr

1766y { var c = t[r](o), u = c.value; return u instanceof _OverloadYield ? e.resolve(u.v).then(function (t) { n("next", t, i, f); }, function (t) { n("throw", t, i, f); }) : e.resolve(u).then(function (t) { c.value = t, i(c); }, function (t) { return n("throw", t, i, f); }); } catch (t) { f(t); } } var r; this.next || (_regeneratorDefine2(_regeneratorAsyncIterator.prototype), _regeneratorDefine2(_regeneratorAsyncIterator.prototype, "function" == typeof Symbol && Symbol.asyncIterator || "@asyncIterator", function () { return this; })), _regeneratorDefine2(this, "_invoke", function (t, o, i) { function f() { return new e(function (e, r) { n(t, i, e, r); }); } return r = r ? r.then(f, f) : f(); }, !0); }
1767function _regenerator() { /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/babel/babel/blob/main/packages/babel-helpers/LICENSE */ var e, t, r = "function" == typeof Symbol ? Symbol : {}, n = r.iterator || "@@iterator", o = r.toStringTag || "@@toStringTag"; function i(r, n, o, i) { var c = n && n.prototype instanceof Generator ? n : Generator, u = Object.create(c.prototype); return _regeneratorDefine2(u, "_invoke", function (r, n, o) { var i, c, u, f = 0, p = o || [], y = !1, G = { p: 0, n: 0, v: e, a: d, f: d.bind(e, 4), d: function d(t, r) { return i = t, c = 0, u = e, G.n = r, a; } }; function d(r, n) { for (c = r, u = n, t = 0; !y && f && !o && t < p.length; t++) { var o, i = p[t], d = G.p, l = i[2]; r > 3 ? (o = l === n) && (u = i[(c = i[4]) ? 5 : (c = 3, 3)], i[4] = i[5] = e) : i[0] <= d && ((o = r < 2 && d < i[1]) ? (c = 0, G.v = n, G.n = i[1]) : d < l && (o = r < 3 || i[0] > n || n > l) && (i[4] = r, i[5] = n, G.n = l, c = 0)); } if (o || r > 1) return a; throw y = !0, n; } return function (o, p, l) { if (f > 1) throw TypeError("Generator is already running"); for (y && 1 === p && d(p, l), c = p, u = l; (t = c < 2 ? e : u) || !y;) { i || (c ? c < 3 ? (c > 1 && (G.n = -1), d(c, u)) : G.n = u : G.v = u); try { if (f = 2, i) { if (c || (o = "next"), t = i[o]) { if (!(t = t.call(i, u))) throw TypeError("iterator result is not an object"); if (!t.done) return t; u = t.value, c < 2 && (c = 0); } else 1 === c && (t = i["return"]) && t.call(i), c < 2 && (u = TypeError("The iterator does not provide a '" + o + "' method"), c = 1); i = e; } else if ((t = (y = G.n < 0) ? u : r.call(n, G)) !== a) break; } catch (t) { i = e, c = 1, u = t; } finally { f = 1; } } return { value: t, done: y }; }; }(r, o, i), !0), u; } var a = {}; function Generator() {} function GeneratorFunction() {} function GeneratorFunctionPrototype() {} t = Object.getPrototypeOf; var c = [][n] ? t(t([][n]())) : (_regeneratorDefine2(t = {}, n, function () { return this; }), t), u = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(c); function f(e) { return Object.setPrototypeOf ? Object.setPrototypeOf(e, GeneratorFunctionPrototype) : (e.__proto__ = GeneratorFunctionPrototype, _regeneratorDefine2(e, o, "GeneratorFunction")), e.prototype = Object.create(u), e; } return GeneratorFunction.prototype = GeneratorFunctionPrototype, _regeneratorDefine2(u, "constructor", GeneratorFunctionPrototype), _regeneratorDefine2(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = "GeneratorFunction", _regeneratorDefine2(GeneratorFunctionPrototype, o, "GeneratorFunction"), _regeneratorDefine2(u), _regeneratorDefine2(u, o, "Generator"), _regeneratorDefine2(u, n, function () { return this; }), _regeneratorDefine2(u, "toString", function () { return "[object Generator]"; }), (_regenerator = function _regenerator() { return { w: i, m: f }; })(); }
1768function _regeneratorDefine2(e, r, n, t) { var i = Object.defineProperty; try { i({}, "", {}); } catch (e) { i = 0; } _regeneratorDefine2 = function _regeneratorDefine(e, r, n, t) { function o(r, n) { _regeneratorDefine2(e, r, function (e) { return this._invoke(r, n, e); }); } r ? i ? i(e, r, { value: n, enumerable: !t, configurable: !t, writable: !t }) : e[r] = n : (o("next", 0), o("throw", 1), o("return", 2)); }, _regeneratorDefine2(e, r, n, t); }
1769function _OverloadYield(e, d) { this.v = e, this.k = d; }
1770function asyncGeneratorStep(n, t, e, r, o, a, c) { try { var i = n[a](c), u = i.value; } catch (n) { return void e(n); } i.done ? t(u) : Promise.resolve(u).then(r, o); }
1771function _asyncToGenerator(n) { return function () { var t = this, e = arguments; return new Promise(function (r, o) { var a = n.apply(t, e); function _next(n) { asyncGeneratorStep(a, r, o, _next, _throw, "next", n); } function _throw(n) { asyncGeneratorStep(a, r, o, _next, _throw, "throw", n); } _next(void 0); }); }; }
1772function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
1773function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
1774function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
1775function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
1776function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
1777function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
1778/* ----------------------------------------------
1779 * reCaptchaへの問い合わせ機能を管理するモジュール
1780 *
1781 * このファイルで、サイトキーや、htmlに付記するreCaptchaの<scrpt>も挿入する
1782---------------------------------------------- */
1783// module exports
1784
1785var ReCaptchaModule = /*#__PURE__*/function () {
1786  /**
1787   * コンストラクター
1788   *
1789   * @param {Object} config 初期値を使用しない場合の設定
1790   * @returns {Object} オブジェクト
1791   */
1792  function ReCaptchaModule() {
1793    var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
1794    _classCallCheck(this, ReCaptchaModule);
1795    /* 定数 ------------------------------------- */
1796    _defineProperty(this, "AJAX_STATE_DONE", 4);
1797    _defineProperty(this, "AJAX_RESPONSE_DONE", 200);
1798    /* デフォルト設定 ------------------------------------- */
1799    _defineProperty(this, "DEFAULT_CONFIG", {
1800      // reCaptchaのコンパネで取得するキー、「HTMLコードで使用します」と書いてある方
1801      reCaptchaSiteKey: "6LdrvXEcAAAAAFXPRIYwnoC6fskx_xcupOFtZm16",
1802      // reCaptcha問い合わせ用のPHP側ファイルへのパス
1803      // reCaptchaのコンパネで取得するシークレットキー(サイトと reCAPTCHA 間の通信で使用しますと書いてある方)は、isHuman.phpに記載する
1804      reCaptchaPhpFile: "/form/libs/isHuman.php"
1805    });
1806    //設定をマージ
1807    this.config = Object.assign({}, this.DEFAULT_CONFIG, JSON.parse(JSON.stringify(config)));
1808
1809    // DomにrecaptchaAPIスクリプトを挿入する
1810    this.insertReCaptchaScript();
1811    return this;
1812  }
1813
1814  /**
1815   * DomにrecaptchaAPIスクリプトを挿入する
1816   */
1817  return _createClass(ReCaptchaModule, [{
1818    key: "insertReCaptchaScript",
1819    value: function insertReCaptchaScript() {
1820      // DOMにreCaptchaAPIのスクリプトを挿入
1821      var recaptchaDom = document.createElement('script');
1822      recaptchaDom.src = 'https://www.google.com/recaptcha/api.js?render=' + this.config.reC

1822aptchaSiteKey;
1823      document.body.appendChild(recaptchaDom);
1824    }
1825
1826    /**
1827     * トークン取得、bot判定実行まで一気通貫で処理する関数
1828     * @return array {'status':isHuman.phpが発行するエラーコード,'isHuman':bot判定}
1829     */
1830  }, {
1831    key: "run",
1832    value: function run() {
1833      return this.stepMng();
1834    }
1835
1836    /**
1837     * 処理ステップを管理
1838     * 多重非同期を走らせるが、await付加での実行ができるのはトップレイヤーの関数のみのため
1839     * @return array {'status':isHuman.phpが発行するエラーコード,'isHuman':bot判定}
1840     */
1841  }, {
1842    key: "stepMng",
1843    value: (function () {
1844      var _stepMng = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
1845        var token, result;
1846        return _regeneratorRuntime().wrap(function _callee$(_context) {
1847          while (1) switch (_context.prev = _context.next) {
1848            case 0:
1849              _context.next = 2;
1850              return this.getToken();
1851            case 2:
1852              token = _context.sent;
1853              _context.next = 5;
1854              return this.getIsHuman(token);
1855            case 5:
1856              result = _context.sent;
1857              return _context.abrupt("return", result);
1858            case 7:
1859            case "end":
1860              return _context.stop();
1861          }
1862        }, _callee, this);
1863      }));
1864      function stepMng() {
1865        return _stepMng.apply(this, arguments);
1866      }
1867      return stepMng;
1868    }()
1869    /**
1870     * reCaptchaトークンを取得して返す
1871     * @return string token recaptchaAPIが発行するトークン文字列
1872     */
1873    )
1874  }, {
1875    key: "getToken",
1876    value: (function () {
1877      var _getToken = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2() {
1878        var _self;
1879        return _regeneratorRuntime().wrap(function _callee2$(_context2) {
1880          while (1) switch (_context2.prev = _context2.next) {
1881            case 0:
1882              _self = this; // APIへの非同期処理
1883              return _context2.abrupt("return", grecaptcha.execute(_self.config.reC

1883aptchaSiteKey, {
1884                action: "sent"
1885              }).then(function (token) {
1886                return token;
1887              }));
1888            case 2:
1889            case "end":
1890              return _context2.stop();
1891          }
1892        }, _callee2, this);
1893      }));
1894      function getToken() {
1895        return _getToken.apply(this, arguments);
1896      }
1897      return getToken;
1898    }()
1899    /**
1900     * isHuman.phpをAJAXで実行
1901     * @param _token recaptchaAPIが発行し、getTokenで取得した文字列トークン
1902     * @return array {'status':isHuman.phpが発行するエラーコード,'isHuman':bot判定}
1903     */
1904    )
1905  }, {
1906    key: "getIsHuman",
1907    value: (function () {
1908      var _getIsHuman = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee3(_token) {
1909        var _this = this;
1910        var _self;
1911        return _regeneratorRuntime().wrap(function _callee3$(_context3) {
1912          while (1) switch (_context3.prev = _context3.next) {
1913            case 0:
1914              _self = this;
1915              return _context3.abrupt("return", new Promise(function (resolve, reject) {
1916                var _ajax = new XMLHttpRequest();
1917                _ajax.open("GET", _this.config.reCaptchaPhpFile + "?recaptchaResponse=" + _token, true);
1918                _ajax.onload = function (e) {
1919                  console.log(" - AJAX 通信開始 -");
1920
1921                  // AJAX通信が完了していなければ終了
1922                  if (_ajax.readyState != _self.AJAX_STATE_DONE) return;
1923
1924                  // AJAX通信でレスポンスがきていなければ、AJX通信エラーとして告知、終了
1925                  if (_ajax.status != _self.AJAX_RESPONSE_DONE) {
1926                    console.log(" - AJAX通信エラー発生 -");
1927                    reject({
1928                      "status": "XX-001 AJAXエラー"
1929                    });
1930                    return;
1931                  }
1932                  console.log(" - AJAX通信正常完了 -");
1933                  try {
1934                    // AJAXのレスポンスをパースしてresolve
1935                    var _response = JSON.parse(_ajax.responseText);
1936                    console.log(" isHumanレスポンス : ", _response);
1937                    resolve(_response);
1938                  } catch (e) {
1939                    // パースエラーの場合は告知、reject
1940                    reject({
1941                      "status": "XX-002 PARSEエラー"
1942                    });
1943                  }
1944                };
1945                _ajax.onerror = function (e) {
1946                  // XMLHttpRequestの実行時エラー
1947                  // 構文エラー、パラメータエラーなど
1948                  console.log("++ AJAX ERROR ++");
1949                  console.log(_ajax.statusText);
1950                };
1951                _ajax.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
1952
1953                // 引数のトークンをそのまま使用
1954                _ajax.send();
1955              }));
1956            case 2:
1957            case "end":
1958              return _context3.stop();
1959          }
1960        }, _callee3, this);
1961      }));
1962      function getIsHuman(_x) {
1963        return _getIsHuman.apply(this, arguments);
1964      }
1965      return getIsHuman;
1966    }()
1967    /**
1968     * モジュールを除去する。
1969     */
1970    )
1971  }, {
1972    key: "destroy",
1973    value: function destroy() {}
1974  }]);
1975}();
1976
1977/***/ },
1978
1979/***/ "./src/js/util/Modernizr/modernizr-custom.js"
1980/*!***************************************************!*\
1981  !*** ./src/js/util/Modernizr/modernizr-custom.js ***!
1982  \***************************************************/
1983(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
1984
1985__webpack_require__.r(__webpack_exports__);
1986function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
1987/*! modernizr 3.6.0 (Custom Build) | MIT *

1988 * https://modernizr.com/download/?-audio-contextmenu-cookies-cssanimations-csscalc-customevent-eventlistener-flexbox-forcetouch-history-svg-touchevents-webp-webpalpha-webpanimation-webplossless_webp_lossless-domprefixes-hasevent-mq-prefixes-testallprops-testprop-teststyles !*/
1989!function (e, n, t) {
1990  function o(e, n) {
1991    return _typeof(e) === n;
1992  }
1993  function r() {
1994    var e, n, t, r, a, i, s;
1995    for (var A in w) if (w.hasOwnProperty(A)) {
1996      if (e = [], n = w[A], n.name && (e.push(n.name.toLowerCase()), n.options && n.options.aliases && n.options.aliases.length)) for (t = 0; t < n.options.aliases.length; t++) e.push(n.options.aliases[t].toLowerCase());
1997      for (r = o(n.fn, 'function') ? n.fn() : n.fn, a = 0; a < e.length; a++) i = e[a], s = i.split('.'), 1 === s.length ? Modernizr[s[0]] = r : (!Modernizr[s[0]] || Modernizr[s[0]] instanceof Boolean || (Modernizr[s[0]] = new Boolean(Modernizr[s[0]])), Modernizr[s[0]][s[1]] = r), x.push((r ? '' : 'no-') + s.join('-'));
1998    }
1999  }
2000  function a() {
2001    return 'function' != typeof n.createElement ? n.createElement(arguments[0]) : S ? n.createElementNS.call(n, 'http://www.w3.org/2000/svg', arguments[0]) : n.createElement.apply(n, arguments);
2002  }
2003  function i() {
2004    var e = n.body;
2005    return e || (e = a(S ? 'svg' : 'body'), e.fake = !0), e;
2006  }
2007  function s(e, t, o, r) {
2008    var s,
2009      A,
2010      l,
2011      u,
2012      c = 'modernizr',
2013      f = a('div'),
2014      d = i();
2015    if (parseInt(o, 10)) for (; o--;) l = a('div'), l.id = r ? r[o] : c + (o + 1), f.appendChild(l);
2016    return s = a('style'), s.type = 'text/css', s.id = 's' + c, (d.fake ? d : f).appendChild(s), d.appendChild(f), s.styleSheet ? s.styleSheet.cssText = e : s.appendChild(n.createTextNode(e)), f.id = c, d.fake && (d.style.background = '', d.style.overflow = 'hidden', u = B.style.overflow, B.style.overflow = 'hidden', B.appendChild(d)), A = t(f, e), d.fake ? (d.parentNode.removeChild(d), B.style.overflow = u, B.offsetHeight) : f.parentNode.removeChild(f), !!A;
2017  }
2018  function A(e, n) {
2019    return !!~('' + e).indexOf(n);
2020  }
2021  function l(e) {
2022    var n = B.className,
2023      t = Modernizr._config.classPrefix || '';
2024    if (S && (n = n.baseVal), Modernizr._config.enableJSClass) {
2025      var o = new RegExp('(^|\\s)' + t + 'no-js(\\s|$)');
2026      n = n.replace(o, '$1' + t + 'js$2');
2027    }
2028    Modernizr._config.enableClasses && (n += ' ' + t + e.join(' ' + t), S ? B.className.baseVal = n : B.className = n);
2029  }
2030  function u(e, n) {
2031    if ('object' == _typeof(e)) for (var t in e) P(e, t) && u(t, e[t]);else {
2032      e = e.toLowerCase();
2033      var o = e.split('.'),
2034        r = Modernizr[o[0]];
2035      if (2 == o.length && (r = r[o[1]]), 'undefined' != typeof r) return Modernizr;
2036      n = 'function' == typeof n ? n() : n, 1 == o.length ? Modernizr[o[0]] = n : (!Modernizr[o[0]] || Modernizr[o[0]] instanceof Boolean || (Modernizr[o[0]] = new Boolean(Modernizr[o[0]])), Modernizr[o[0]][o[1]] = n), l([(n && 0 != n ? '' : 'no-') + o.join('-')]), Modernizr._trigger(e, n);
2037    }
2038    return Modernizr;
2039  }
2040  function c(e) {
2041    return e.replace(/([a-z])-([a-z])/g, function (e, n, t) {
2042      return n + t.toUpperCase();
2043    }).replace(/^-/, '');
2044  }
2045  function f(e, n) {
2046    return function () {
2047      return e.apply(n, arguments);
2048    };
2049  }
2050  function d(e, n, t) {
2051    var r;
2052    for (var a in e) if (e[a] in n) return t === !1 ? e[a] : (r = n[e[a]], o(r, 'function') ? f(r, t || n) : r);
2053    return !1;
2054  }
2055  function p(n, t, o) {
2056    var r;
2057    if ('getComputedStyle' in e) {
2058      r = getComputedStyle.call(e, n, t);
2059      var a = e.console;
2060      if (null !== r) o && (r = r.getPropertyValue(o));else if (a) {
2061        var i = a.error ? 'error' : 'log';
2062        a[i].call(a, 'getComputedStyle returning null, its possible modernizr test results are inaccurate');
2063      }
2064    } else r = !t && n.currentStyle && n.currentStyle[o];
2065    return r;
2066  }
2067  function m(e) {
2068    return e.replace(/([A-Z])/g, function (e, n) {
2069      return '-' + n.toLowerCase();
2070    }).replace(/^ms-/, '-ms-');
2071  }
2072  function v(n, o) {
2073    var r = n.length;
2074    if ('CSS' in e && 'supports' in e.CSS) {
2075      for (; r--;) if (e.CSS.supports(m(n[r]), o)) return !0;
2076      return !1;
2077    }
2078    if ('CSSSupportsRule' in e) {
2079      for (var a = []; r--;) a.push('(' + m(n[r]) + ':' + o + ')');
2080      return a = a.join(' or '), s('@supports (' + a + ') { #modernizr { position: absolute; } }', function (e) {
2081        return 'absolute' == p(e, null, 'position');
2082      });
2083    }
2084    return t;
2085  }
2086  function h(e, n, r, i) {
2087    function s() {
2088      u && (delete O.style, delete O.modElem);
2089    }

2090    if (i = o(i, 'undefined') ? !1 : i, !o(r, 'undefined')) {
2091      var l = v(e, r);
2092      if (!o(l, 'undefined')) return l;
2093    }
2094    for (var u, f, d, p, m, h = ['modernizr', 'tspan', 'samp']; !O.style && h.length;) u = !0, O.modElem = a(h.shift()), O.style = O.modElem.style;
2095    for (d = e.length, f = 0; d > f; f++) if (p = e[f], m = O.style[p], A(p, '-') && (p = c(p)), O.style[p] !== t) {
2096      if (i || o(r, 'undefined')) return s(), 'pfx' == n ? p : !0;
2097      try {
2098        O.style[p] = r;
2099      } catch (g) {}
2100      if (O.style[p] != m) return s(), 'pfx' == n ? p : !0;
2101    }
2102    return s(), !1;
2103  }
2104  function g(e, n, t, r, a) {
2105    var i = e.charAt(0).toUpperCase() + e.slice(1),
2106      s = (e + ' ' + U.join(i + ' ') + i).split(' ');
2107    return o(n, 'string') || o(n, 'undefined') ? h(s, n, r, a) : (s = (e + ' ' + C.join(i + ' ') + i).split(' '), d(s, n, t));
2108  }
2109  function y(e, n, o) {
2110    return g(e, t, t, n, o);
2111  }
2112  var w = [],
2113    b = {
2114      _version: '3.6.0',
2115      _config: {
2116        classPrefix: '',
2117        enableClasses: !0,
2118        enableJSClass: !0,
2119        usePrefixes: !0
2120      },
2121      _q: [],
2122      on: function on(e, n) {
2123        var t = this;
2124        setTimeout(function () {
2125          n(t[e]);
2126        }, 0);
2127      },
2128      addTest: function addTest(e, n, t) {
2129        w.push({
2130          name: e,
2131          fn: n,
2132          options: t
2133        });
2134      },
2135      addAsyncTest: function addAsyncTest(e) {
2136        w.push({
2137          name: null,
2138          fn: e
2139        });
2140      }
2141    },
2142    Modernizr = function Modernizr() {};
2143  Modernizr.prototype = b, Modernizr = new Modernizr(), Modernizr.addTest('cookies', function () {
2144    try {
2145      n.cookie = 'cookietest=1';
2146      var e = -1 != n.cookie.indexOf('cookietest=');
2147      return n.cookie = 'cookietest=1; expires=Thu, 01-Jan-1970 00:00:01 GMT', e;
2148    } catch (t) {
2149      return !1;
2150    }
2151  }), Modernizr.addTest('customevent', 'CustomEvent' in e && 'function' == typeof e.CustomEvent), Modernizr.addTest('eventlistener', 'addEventListener' in e), Modernizr.addTest('history', function () {
2152    var n = navigator.userAgent;
2153    return -1 === n.indexOf('Android 2.') && -1 === n.indexOf('Android 4.0') || -1 === n.indexOf('Mobile Safari') || -1 !== n.indexOf('Chrome') || -1 !== n.indexOf('Windows Phone') || 'file:' === location.protocol ? e.history && 'pushState' in e.history : !1;
2154  }), Modernizr.addTest('svg', !!n.createElementNS && !!n.createElementNS('http://www.w3.org/2000/svg', 'svg').createSVGRect);
2155  var T = b._config.usePrefixes ? ' -webkit- -moz- -o- -ms- '.split(' ') : ['', ''];
2156  b._prefixes = T;
2157  var x = [],
2158    _ = 'Moz O ms Webkit',
2159    C = b._config.usePrefixes ? _.toLowerCase().split(' ') : [];
2160  b._domPrefixes = C;
2161  var B = n.documentElement;
2162  Modernizr.addTest('contextmenu', 'contextMenu' in B && 'HTMLMenuItemElement' in e);
2163  var S = 'svg' === B.nodeName.toLowerCase(),
2164    E = function () {
2165      function e(e, n) {
2166        var r;
2167        return e ? (n && 'string' != typeof n || (n = a(n || 'div')), e = 'on' + e, r = e in n, !r && o && (n.setAttribute || (n = a('div')), n.setAttribute(e, ''), r = 'function' == typeof n[e], n[e] !== t && (n[e] = t), n.removeAttribute(e)), r) : !1;
2168      }
2169      var o = !('onblur' in n.documentElement);
2170      return e;
2171    }();
2172  b.hasEvent = E, Modernizr.addTest('audio', function () {
2173    var e = a('audio'),
2174      n = !1;
2175    try {
2176      n = !!e.canPlayType, n && (n = new Boolean(n), n.ogg = e.canPlayType('audio/ogg; codecs="vorbis"').replace(/^no$/, ''), n.mp3 = e.canPlayType('audio/mpeg; codecs="mp3"').replace(/^no$/, ''), n.opus = e.canPlayType('audio/ogg; codecs="opus"') || e.canPlayType('audio/webm; codecs="opus"').replace(/^no$/, ''), n.wav = e.canPlayType('audio/wav; codecs="1"').replace(/^no$/, ''), n.m4a = (e.canPlayType('audio/x-m4a;') || e.canPlayType('audio/aac;')).replace(/^no$/, ''));
2177    } catch (t) {}
2178    return n;
2179  }), Modernizr.addTest('csscalc', function () {
2180    var e = 'width:',
2181      n = 'calc(10px);',
2182      t = a('a');
2183    return t.style.cssText = e + T.join(n + e), !!t.style.length;
2184  });
2185  var Q = function () {
2186    var n = e.matchMedia || e.msMatchMedia;
2187    return n ? function (e) {
2188      var t = n(e);
2189      return t && t.matches || !1;
2190    } : function (n) {
2191      var t = !1;
2192      return s('@media ' + n + ' { #modernizr { position: absolute; } }', function (n) {
2193        t = 'absolute' == (e.getComputedStyle ? e.getComputedStyle(n, null) : n.currentStyle).position;
2194      }), t;
2195    };
2196  }();
2197  b.mq = Q;
2198  var R = b.testStyles = s;
2199  Modernizr.addTest('touchevents', function () {
2200    var t;
2201    if ('ontouchstart' in e || e.DocumentTouch && n instanceof DocumentTouch) t = !0;else {
2202      var o = ['@media (', T.join('touch-enabled),('), 'heartz', ')', '{#modernizr{top:9px;position:absolute}}'].join('');
2203      R(o, function (e) {
2204        t = 9 === e.offsetTop;
2205      });
2206    }
2207    return t;
2208  });
2209  var U = b._config.usePrefixes ? _.split(' ') : [];
2210  b._cssomPrefixes = U;
2211  var P;
2212  !function () {
2213    var e = {}.hasOwnProperty;
2214    P = o(e, 'undefined') || o(e.call, 'undefined') ? function (e, n) {
2215      return n in e && o(e.constructor.prototype[n], 'undefined');
2216    } : function (n, t) {
2217      return e.call(n, t);
2218    };
2219  }(), b._l = {}

2219, b.on = function (e, n) {
2220    this._l[e] || (this._l[e] = []), this._l[e].push(n), Modernizr.hasOwnProperty(e) && setTimeout(function () {
2221      Modernizr._trigger(e, Modernizr[e]);
2222    }, 0);
2223  }, b._trigger = function (e, n) {
2224    if (this._l[e]) {
2225      var t = this._l[e];
2226      setTimeout(function () {
2227        var e, o;
2228        for (e = 0; e < t.length; e++) (o = t[e])(n);
2229      }, 0), delete this._l[e];
2230    }
2231  }, Modernizr._q.push(function () {
2232    b.addTest = u;
2233  }), Modernizr.addAsyncTest(function () {
2234    var e = new Image();
2235    e.onerror = function () {
2236      u('webpalpha', !1, {
2237        aliases: ['webp-alpha']
2238      });
2239    }, e.onload = function () {
2240      u('webpalpha', 1 == e.width, {
2241        aliases: ['webp-alpha']
2242      });
2243    }, e.src = 'data:image/webp;base64,UklGRkoAAABXRUJQVlA4WAoAAAAQAAAAAAAAAAAAQUxQSAwAAAABBxAR/Q9ERP8DAABWUDggGAAAADABAJ0BKgEAAQADADQlpAADcAD++/1QAA==';
2244  }), Modernizr.addAsyncTest(function () {
2245    var e = new Image();
2246    e.onerror = function () {
2247      u('webpanimation', !1, {
2248        aliases: ['webp-animation']
2249      });
2250    }, e.onload = function () {
2251      u('webpanimation', 1 == e.width, {
2252        aliases: ['webp-animation']
2253      });
2254    }, e.src = 'data:image/webp;base64,UklGRlIAAABXRUJQVlA4WAoAAAASAAAAAAAAAAAAQU5JTQYAAAD/////AABBTk1GJgAAAAAAAAAAAAAAAAAAAGQAAABWUDhMDQAAAC8AAAAQBxAREYiI/gcA';
2255  }), Modernizr.addAsyncTest(function () {
2256    var e = new Image();
2257    e.onerror = function () {
2258      u('webplossless', !1, {
2259        aliases: ['webp-lossless']
2260      });
2261    }, e.onload = function () {
2262      u('webplossless', 1 == e.width, {
2263        aliases: ['webp-lossless']
2264      });
2265    }, e.src = 'data:image/webp;base64,UklGRh4AAABXRUJQVlA4TBEAAAAvAAAAAAfQ//73v/+BiOh/AAA=';
2266  }), Modernizr.addAsyncTest(function () {
2267    function e(e, n, t) {
2268      function o(n) {
2269        var o = n && 'load' === n.type ? 1 == r.width : !1,
2270          a = 'webp' === e;
2271        u(e, a && o ? new Boolean(o) : o), t && t(n);
2272      }
2273      var r = new Image();
2274      r.onerror = o, r.onload = o, r.src = n;
2275    }
2276    var n = [{
2277        uri: 'data:image/webp;base64,UklGRiQAAABXRUJQVlA4IBgAAAAwAQCdASoBAAEAAwA0JaQAA3AA/vuUAAA=',
2278        name: 'webp'
2279      }, {
2280        uri: 'data:image/webp;base64,UklGRkoAAABXRUJQVlA4WAoAAAAQAAAAAAAAAAAAQUxQSAwAAAABBxAR/Q9ERP8DAABWUDggGAAAADABAJ0BKgEAAQADADQlpAADcAD++/1QAA==',
2281        name: 'webp.alpha'
2282      }, {
2283        uri: 'data:image/webp;base64,UklGRlIAAABXRUJQVlA4WAoAAAASAAAAAAAAAAAAQU5JTQYAAAD/////AABBTk1GJgAAAAAAAAAAAAAAAAAAAGQAAABWUDhMDQAAAC8AAAAQBxAREYiI/gcA',
2284        name: 'webp.animation'
2285      }, {
2286        uri: 'data:image/webp;base64,UklGRh4AAABXRUJQVlA4TBEAAAAvAAAAAAfQ//73v/+BiOh/AAA=',
2287        name: 'webp.lossless'
2288      }],
2289      t = n.shift();
2290    e(t.name, t.uri, function (t) {
2291      if (t && 'load' === t.type) for (var o = 0; o < n.length; o++) e(n[o].name, n[o].uri);
2292    });
2293  });
2294  var k = function k(n) {
2295    var o,
2296      r = T.length,
2297      a = e.CSSRule;
2298    if ('undefined' == typeof a) return t;
2299    if (!n) return !1;
2300    if (n = n.replace(/^@/, ''), o = n.replace(/-/g, '_').toUpperCase() + '_RULE', o in a) return '@' + n;
2301    for (var i = 0; r > i; i++) {
2302      var s = T[i],
2303        A = s.toUpperCase() + '_' + o;
2304      if (A in a) return '@-' + s.toLowerCase() + '-' + n;
2305    }
2306    return !1;
2307  };
2308  b.atRule = k;
2309  var D = {
2310    elem: a('modernizr')
2311  };
2312  Modernizr._q.push(function () {
2313    delete D.elem;
2314  });
2315  var O = {
2316    style: D.elem.style
2317  };
2318  Modernizr._q.unshift(function () {
2319    delete O.style;
2320  });
2321  b.testProp = function (e, n, o) {
2322    return h([e], t, n, o);
2323  };
2324  b.testAllProps = g, b.testAllProps = y, Modernizr.addTest('cssanimations', y('animationName', 'a', !0)), Modernizr.addTest('flexbox', y('flexBasis', '1px', !0));
2325  var J = b.prefixed = function (e, n, t) {
2326    return 0 === e.indexOf('@') ? k(e) : (-1 != e.indexOf('-') && (e = c(e)), n ? g(e, n, t) : g(e, 'pfx'));
2327  };
2328  Modernizr.addTest('forcetouch', function () {
2329    return E(J('mouseforcewillbegin', e, !1), e) ? MouseEvent.WEBKIT_FORCE_AT_MOUSE_DOWN && MouseEvent.WEBKIT_FORCE_AT_FORCE_MOUSE_DOWN : !1;
2330  }), r(), delete b.addTest, delete b.addAsyncTest;
2331  for (var M = 0; M < Modernizr._q.length; M++) Modernizr._q[M]();
2332  e.Modernizr = Modernizr;
2333}(window, document);
2334
2335/***/ },
2336
2337/***/ "./src/js/util/modernizr.js"
2338/*!**********************************!*\
2339  !*** ./src/js/util/modernizr.js ***!
2340  \**********************************/
2341(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
2342
2343__webpack_require__.r(__webpack_exports__);
2344/* harmony export */ __webpack_require__.d(__webpack_exports__, {
2345/* harmony export */   modernizr: () => (/* binding */ modernizr)
2346/* harmony export */ });
2347/* harmony import */ var _Modernizr_modernizr_custom__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./Modernizr/modernizr-custom */ "./src/js/util/Modernizr/modernizr-custom.js");
2348
2349
2350
2351
2352/* ==========================================================================
2353 * custom theme template
2354 *
2355 * Modernizr
2356 *
2357========================================================================== */
2358

2359/* ブラウザー判定関数の追加
2360---------------------------------------------- */
2361// UA文字列を確保
2362var ua = new String(window.navigator.userAgent.toLowerCase());
2363
2364// ブラウザ判定のための文字列検索
2365if (ua.indexOf('edge') != -1 || ua.indexOf('edg') != -1) {
2366  Modernizr.browser = 'Microsoft Edge';
2367} else if (ua.indexOf('trident') != -1 || ua.indexOf('msie') != -1) {
2368  Modernizr.browser = 'Microsoft Internet Explorer';
2369} else if (ua.indexOf('opr') != -1 || ua.indexOf('opera') != -1) {
2370  Modernizr.browser = 'Opera';
2371} else if (ua.indexOf('chrome') != -1) {
2372  Modernizr.browser = 'Google Chrome';
2373} else if (ua.indexOf('firefox') != -1) {
2374  Modernizr.browser = 'FireFox';
2375} else if (ua.indexOf('safari') != -1) {
2376  Modernizr.browser = 'Safari';
2377} else {
2378  Modernizr.browser = 'Unknown';
2379}
2380
2381// htmlへブラウザーclassを追加
2382var root = document.getElementsByTagName('html')[0];
2383var rootClass = Modernizr.browser.replace(' ', '-');
2384root.classList.add(rootClass);
2385
2386// UA判定文字列検索関数
2387ua.has = function (cond) {
2388  return this.indexOf(cond) != -1;
2389};
2390
2391// ブラウザー判定
2392Modernizr.browserDetection = {
2393  'edge': function edge() {
2394    return modernizr.browser == 'Microsoft Edge';
2395  },
2396  'msie': function msie() {
2397    return modernizr.browser == 'Microsoft Internet Explorer';
2398  },
2399  'chrome': function chrome() {
2400    return modernizr.browser == 'Google Chrome';
2401  },
2402  'safari': function safari() {
2403    return modernizr.browser == 'Safari';
2404  },
2405  'firefox': function firefox() {
2406    return modernizr.browser == 'FireFox';
2407  },
2408  'opera': function opera() {
2409    return modernizr.browser == 'Opera';
2410  }
2411};
2412
2413// デバイス判定のための文字列検索
2414var _iphone = ua.has('iphone');
2415var _ipod = ua.has('ipod');
2416var _ipad = ua.has('ipad');
2417var _macosx = ua.has('mac os x');
2418var _android = ua.has('android');
2419var _androidPhone = _android && ua.has('mobile');
2420var _androidTablet = _android && !ua.has('mobile');
2421var _windows = ua.has('windows');
2422var _windowsPhone = _windows && ua.has('phone');
2423var _windowsTablet = _windows && ua.has('touch');
2424Modernizr.deviceDetection = {
2425  'ios': function ios() {
2426    return _iphone || _ipod || _ipad;
2427  },
2428  'iphone': function iphone() {
2429    return _iphone;
2430  },
2431  'ipod': function ipod() {
2432    return _ipod;
2433  },
2434  'ipad': function ipad() {
2435    return _ipad;
2436  },
2437  'macosx': function macosx() {
2438    return _macosx;
2439  },
2440  'android': function android() {
2441    return _android;
2442  },
2443  'androidPhone': function androidPhone() {
2444    return _androidPhone;
2445  },
2446  'androidTablet': function androidTablet() {
2447    return _androidTablet;
2448  },
2449  'windows': function windows() {
2450    return _windows;
2451  },
2452  'windowsPhone': function windowsPhone() {
2453    return _windowsPhone;
2454  },
2455  'windowsTablet': function windowsTablet() {
2456    return _windowsTablet;
2457  }
2458};
2459var modernizr = Modernizr;
2460window.modernizr = Modernizr;
2461
2462
2463/***/ }
2464
2465/******/ 	});
2466/************************************************************************/
2467/******/ 	// The module cache
2468/******/ 	const __webpack_module_cache__ = {};
2469/******/ 	
2470/******/ 	// The require function
2471/******/ 	function __webpack_require__(moduleId) {
2472/******/ 		// Check if module is in cache
2473/******/ 		const cachedModule = __webpack_module_cache__[moduleId];
2474/******/ 		if (cachedModule !== undefined) {
2475/******/ 			return cachedModule.exports;
2476/******/ 		}
2477/******/ 		// Create a new module (and put it into the cache)
2478/******/ 		const module = __webpack_module_cache__[moduleId] = {
2479/******/ 			// no module.id needed
2480/******/ 			// no module.loaded needed
2481/******/ 			exports: {}
2482/******/ 		};
2483/******/ 	
2484/******/ 		// Execute the module function
2485/******/ 		if (!(moduleId in __webpack_modules__)) {
2486/******/ 			delete __webpack_module_cache__[moduleId];
2487/******/ 			const e = new Error("Cannot find module '" + moduleId + "'");
2488/******/ 			e.code = 'MODULE_NOT_FOUND';
2489/******/ 			throw e;
2490/******/ 		}
2491/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
2492/******/ 	
2493/******/ 		// Return the exports of the module
2494/******/ 		return module.exports;
2495/******/ 	}
2496/******/ 	
2497/************************************************************************/
2498/******/ 	/* webpack/runtime/define property getters */
2499/******/ 	(() => {
2500/******/ 		// define getter/value functions for harmony exports
2501/******/ 		__webpack_require__.d = (exports, definition) => {
2502/******/ 			if(Array.isArray(definition)) {
2503/******/ 				var i = 0;
2504/******/ 				while(i < definition.length) {
2505/******/ 					var key = definition[i++];
2506/******/ 					var binding = definition[i++];
2507/******/ 					if(!__webpack_require__.o(exports, key)) {
2508/******/ 						if(binding === 0) {
2509/******/ 							Object.defineProperty(exports, key, { enumerable: true, value: definition[i++] });
2510/******/ 						} else {
2511/******/ 							Object.defineProperty(exports, key, { enumerable: true, get: binding });
2512/******/ 						}
2513/******/ 					} else if(binding === 0) { i++; }
2514/******/ 				}
2515/******/ 			} else {
2516/******/ 				for(var key in definition) {
2517/******/ 					if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
2518/******/ 						Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
2519/******/ 					}
2520/******/ 				}
2521/******/ 			}
2522/******/ 		};
2523/******/ 	})();
2524/******/ 	
2525/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
2526/******/ 	(() => {
2527/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
2528/******/ 	})();
2529/******/ 	
2530/******/ 	/* webpack/runtime/make namespace object */
2531/******/ 	(() => {
2532/******/ 		// define __esModule on exports
2533/******/ 		__webpack_require__.r = (exports) => {
2534/******/ 			if(Symbol.toStringTag) {
2535/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
2536/******/ 			}
2537/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
2538/******/ 		};
2539/******/ 	})();
2540/******/ 	
2541/************************************************************************/
2542let __webpack_exports__ = {};
2543// This entry needs to be wrapped in an IIFE because it needs to be isolated against other modules in the chunk.
2544(() => {
2545/*!************************!*\
2546  !*** ./src/js/form.js ***!
2547  \************************/
2548__webpack_require__.r(__webpack_exports__);
2549/* harmony import */ var _util_modernizr__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./util/modernizr */ "./src/js/util/modernizr.js");
2550/* harmony import */ var _form_ParseFormQuery__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./form/ParseFormQuery */ "./src/js/form/ParseFormQuery.js");
2551/* harmony import */ var _form_FormValidationModule__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./form/FormValidationModule */ "./src/js/form/FormValidationModule.js");
2552/* harmony import */ var _form_ReCaptchaModule__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./form/ReCaptchaModule */ "./src/js/form/ReCaptchaModule.js");
2553function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
2554function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
2555function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {};

2555 r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
2556function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
2557function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
2558function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
2559function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
2560function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
2561function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
2562function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
2563function _possibleConstructorReturn(t, e) { if (e && ("object" == _typeof(e) || "function" == typeof e)) return e; if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined"); return _assertThisInitialized(t); }
2564function _assertThisInitialized(e) { if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); return e; }
2565function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
2566function _getPrototypeOf(t) { return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) { return t.__proto__ || Object.getPrototypeOf(t); }, _getPrototypeOf(t); }
2567function _inherits(t, e) { if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function"); t.prototype = Object.create(e && e.prototype, { constructor: { value: t, writable: !0, configurable: !0 } }), Object.defineProperty(t, "prototype", { writable: !1 }), e && _setPrototypeOf(t, e); }
2568function _setPrototypeOf(t, e) { return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, _setPrototypeOf(t, e); }
2569// モジュールをインポート
2570// Modernizrの読み込み
2571;
2572
2573// GETパラメータパーサー
2574
2575
2576// フォームバリデーター
2577
2578
2579// reCaptcha
2580
2581
2582/* ==========================================================================
2583 *
2584 * お問い合わせページjs
2585 *
2586========================================================================== */
2587/* エラーメッセージ出力関数をaatone用にオーバーライド。 ------------------------------------- */
2588var FormValidationModuleAtone = /*#__PURE__*/function (_FormValidationModule) {
2589  function FormValidationModuleAtone() {
2590    _classCallCheck(this, FormValidationModuleAtone);
2591    return _callSuper(this, FormValidationModuleAtone, arguments);
2592  }
2593  _inherits(FormValidationModuleAtone, _FormValidationModule);
2594  return _createClass(FormValidationModuleAtone, [{
2595    key: "_createErrorMessageArray",
2596    value: function _createErrorMessageArray() {
2597      var validity = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
2598      var _self = this;
2599
2600      // カスタムエラー文言を作成

2601      var validationMessage = Object.keys(validity).map(function (key) {
2602        // エラー内容があればメッセージに追加
2603        if (validity[key] === true && key !== "valid") {
2604          if (typeof _self.validator.message[key] === "undefined") {
2605            // 対応するエラーがなければデフォルトエラーを追加
2606            return _self.validator.message["valid"];
2607          } else {
2608            // 対応するエラーがあればエラーを追加
2609            return _self.validator.message[key];
2610          }
2611        }
2612      })
2613      // undefinedを削除
2614      .filter(Boolean);
2615
2616      // DOMを作成
2617      var messageInner = document.createElement("p");
2618      messageInner.className = 'c-error-text';
2619      // 複数エラーを改行でjoin
2620      messageInner.innerHTML = validationMessage.join("<br>");
2621      var message = document.createElement("div");
2622      message.className = _self.ERROR_CLASS;
2623      message.append(messageInner);
2624      return message;
2625    }
2626  }]);
2627}(_form_FormValidationModule__WEBPACK_IMPORTED_MODULE_2__.FormValidationModule);
2628var PardotFormIntegrator = /*#__PURE__*/function () {
2629  /**
2630   * コンストラクター
2631   */
2632  function PardotFormIntegrator() {
2633    _classCallCheck(this, PardotFormIntegrator);
2634    /* 変数宣言 ------------------------------------- */
2635    _defineProperty(this, "defaultButtonHtml", void 0);
2636    // 離脱抑制を行うかどうかのフラグ
2637    _defineProperty(this, "leaveAlertFlug", void 0);
2638    // 現在のステップを保存
2639    _defineProperty(this, "currentStep", void 0);
2640    // DOM用メンバー
2641    _defineProperty(this, "formElm", void 0);
2642    _defineProperty(this, "formElms", void 0);
2643    _defineProperty(this, "submitElm", void 0);
2644    _defineProperty(this, "stepElms", void 0);
2645    _defineProperty(this, "nextButtons", void 0);
2646    _defineProperty(this, "backButtons", void 0);
2647    // インスタンス用メンバー
2648    _defineProperty(this, "ValidatorModule", void 0);
2649    _defineProperty(this, "FormValidationModule", void 0);
2650    _defineProperty(this, "ReCaptchaModule", void 0);
2651    _defineProperty(this, "ParceFormQuery", void 0);
2652    // DOMの確保
2653    this.formElm = document.getElementById("form");
2654    this.formElms = document.querySelectorAll("*[data-valid-form]");
2655    this.submitElm = document.querySelector("*[data-valid-submit]");
2656    this.stepElms = document.querySelectorAll(".step");
2657    this.nextButtons = document.querySelectorAll("*[data-valid-next]");
2658    this.backButtons = document.querySelectorAll("*[data-valid-back]");
2659    this.initialize();
2660  }
2661
2662  /**
2663   * フォーム管理クラスを初期化
2664   */
2665  return _createClass(PardotFormIntegrator, [{
2666    key: "initialize",
2667    value: function initialize() {
2668      var _self = this;
2669
2670      // 必須要素がない場合離脱
2671      if (this.formElm == null) return;
2672
2673      // フォームバリデーターを起動する
2674      this.ValidatorModule = new _form_FormValidationModule__WEBPACK_IMPORTED_MODULE_2__.Validator({
2675        // エラーメッセージの変更
2676        message: {
2677          rangeOverflow: "文字数が多すぎます。",
2678          rangeUnderflow: "文字数が少すぎます。"
2679        }
2680      });
2681
2682      // 各ステップに対してバリデータインスタンスを生成
2683      this.FormValidationModule = [];
2684      for (var i = 0, len = this.formElms.length; i < len; i++) {
2685        this.FormValidationModule.push(new FormValidationModuleAtone(
2686        // 対象要素
2687        this.formElms[i],
2688        // オプション
2689        {
2690          errorClass: "p-form-item__error",
2691          displayErrorMessage: true,
2692          useSubmitLock: true
2693        },
2694        // バリデーターインスタンス
2695        this.ValidatorModule));
2696      }
2697
2698      // reCaptcha問い合わせモジュールインスタンス生成
2699      this.ReCaptchaModule = new _form_ReCaptchaModule__WEBPACK_IMPORTED_MODULE_3__.ReCaptchaModule({
2700        reCaptchaSiteKey: "6LfgiFsaAAAAAAvbEsguIyAiuDhKXqoliw_0AY1_",
2701        reCaptchaPhpFile: "/form/libs/isHuman.php"
2702      });
2703
2704      // Pardotからの返送エラーの解析
2705      this.parceFormError();
2706
2707      // UTMパラメータのHTMLへの挿入
2708      this.setInputUtmParams();
2709