Junior Python-разработчик
МедРокетот 77 657 ₽Краснодар, р-н ЦентральныйHH.ru
Описание вакансии
Выводим цифровую медицину на космический уровень и приближаем к пациенту!
МедРокет — уникальная платформа IT-решений для медицины.
- создаем удобные продукты для клиник, врачей и пациентов c 2011 года;
- развиваем открытую информационную среду в сфере здравоохранения;
- являемся аккредитованной IT-компанией.
Продукты:
ПроДокторов - всероссийский сайт отзывов о врачах и клиниках;
МедТочка - личный кабинет пациента;
МедЛок - медицинская информационная система;
МедФлекс - защищённая облачная платформа обмена данными.
Мы продолжаем развиваться и ищем в команду амбициозного начинающего специалиста в сфере разработки , чтобы вместе выводить цифровую медицину на космический уровень!
Наш стек:
- GitLab (репозиторий, CodeReview, CI/CD, task-менеджер, bug-менеджер, документация)
- IDE PyCharm
- Python 3
- Django
- Redis (кэш и очереди задач)
- ClickHouse
- PostgreSQL
Требования:
- знание Python3
- базовое владение HTML, CSS. В компании есть отдельные FrontEnd разработчики, но желательно уметь читать их код
- высшее (или неоконченное высшее) техническое образование, в приоритете - программирование
- желание развиваться в области программирования
Плюсом будет:
- наличие коммерческого опыта работы
- знание основ Django, но можно подучить его и после собеседования
- знание Git (GitLab)
- знание SQL
- знание английского языка на уровне чтения технической документации
Условия работы при получении оффера:
- справедливую оценку вашего труда: полностью "белая" оплата труда, заработная плата 77 657 руб, до вычета НДФЛ; в среднем через 6 месяцев перевод c младшего программиста на должность программиста 1-й ступени с окладом 156 225 руб. до вычета НДФЛ
- уверенное завтра: соблюдение законодательства, гибкий график работы (от 20 часов в неделю), трудоустройство по ТК РФ с 1 дня, - полный социальный пакет
- заботу о вас: ДМС после прохождения испытательного срока, полезные завтраки, кофемашины, фруктовые дни, свободный дресс-код - в офисе можно ходить в тапочках
- атмосферу с прозрачными и этичными процессами: слушаем обратную связь, учимся на ошибках и горим общим делом
- работу над значимым делом: создаём и развиваем социально значимые проекты, которыми можно гордиться
Мы верим, что будущее медицины – за цифровыми технологиями.
Отправляйте свой отклик и присоединяйтесь к нам!
С нами хорошо
-
Белое и «пушистое» оформление
-
Социально значимые проекты
-
Обучение и развитие сотрудников
-
Офис в самом центре Краснодара
-
Насыщенная корпоративная жизнь
-
ДМС
-
Белое и «пушистое» оформление
-
Социально значимые проекты
-
Обучение и развитие сотрудников
-
Офис в самом центре Краснодара
-
Насыщенная корпоративная жизнь
-
ДМС
-
-
-
-
-
Мы верим, что будущее медицины —
за цифровыми технологиями.
Присоединяйтесь к нам!
ООО «МЕДРОКЕТ» представляет бренд МедРокет
window.jqueryMigrateLTROnLoad = function() {try {
jQuery.UNSAFE_restoreLegacyHtmlPrefilter();
;
(function polyfill() {
const relList = document.createElement("link").relList;
if (relList && relList.supports && relList.supports("modulepreload")) {
return;
}
for (const link of document.querySelectorAll('link[rel="modulepreload"]')) {
processPreload(link);
}
new MutationObserver((mutations) => {
for (const mutation of mutations) {
if (mutation.type !== "childList") {
continue;
}
for (const node of mutation.addedNodes) {
if (node.tagName === "LINK" && node.rel === "modulepreload")
processPreload(node);
}
}
}).observe(document, { childList: true, subtree: true });
function getFetchOpts(link) {
const fetchOpts = {};
if (link.integrity)
fetchOpts.integrity = link.integrity;
if (link.referrerPolicy)
fetchOpts.referrerPolicy = link.referrerPolicy;
if (link.crossOrigin === "use-credentials")
fetchOpts.credentials = "include";
else if (link.crossOrigin === "anonymous")
fetchOpts.credentials = "omit";
else
fetchOpts.credentials = "same-origin";
return fetchOpts;
}
function processPreload(link) {
if (link.ep)
return;
link.ep = true;
const fetchOpts = getFetchOpts(link);
fetch(link.href, fetchOpts);
}
})();
const index = "";
function _defineProperties(target, props) {
for (var i = 0; i -1;
}
function push(array, items) {
array.push.apply(array, toArray(items));
return array;
}
function toggleClass(elm, classes, add) {
if (elm) {
forEach(classes, function(name) {
if (name) {
elm.classList[add ? "add" : "remove"](name);
}
});
}
}
function addClass(elm, classes) {
toggleClass(elm, isString(classes) ? classes.split(" ") : classes, true);
}
function append(parent, children2) {
forEach(children2, parent.appendChild.bind(parent));
}
function before(nodes, ref) {
forEach(nodes, function(node) {
var parent = (ref || node).parentNode;
if (parent) {
parent.insertBefore(node, ref);
}
});
}
function matches(elm, selector) {
return isHTMLElement(elm) && (elm["msMatchesSelector"] || elm.matches).call(elm, selector);
}
function children(parent, selector) {
var children2 = parent ? slice(parent.children) : [];
return selector ? children2.filter(function(child2) {
return matches(child2, selector);
}) : children2;
}
function child(parent, selector) {
return selector ? children(parent, selector)[0] : parent.firstElementChild;
}
var ownKeys = Object.keys;
function forOwn(object, iteratee, right) {
if (object) {
(right ? ownKeys(object).reverse() : ownKeys(object)).forEach(function(key) {
key !== "__proto__" && iteratee(object[key], key);
});
}
return object;
}
function assign(object) {
slice(arguments, 1).forEach(function(source) {
forOwn(source, function(value, key) {
object[key] = source[key];
});
});
return object;
}
function merge(object) {
slice(arguments, 1).forEach(function(source) {
forOwn(source, function(value, key) {
if (isArray(value)) {
object[key] = value.slice();
} else if (isObject(value)) {
object[key] = merge({}, isObject(object[key]) ? object[key] : {}, value);
} else {
object[key] = value;
}
});
});
return object;
}
function omit(object, keys) {
forEach(keys || ownKeys(object), function(key) {
delete object[key];
});
}
function removeAttribute(elms, attrs) {
forEach(elms, function(elm) {
forEach(attrs, function(attr) {
elm && elm.removeAttribute(attr);
});
});
}
function setAttribute(elms, attrs, value) {
if (isObject(attrs)) {
forOwn(attrs, function(value2, name) {
setAttribute(elms, name, value2);
});
} else {
forEach(elms, function(elm) {
isNull(value) || value === "" ? removeAttribute(elm, attrs) : elm.setAttribute(attrs, String(value));
});
}
}
function create(tag, attrs, parent) {
var elm = document.createElement(tag);
if (attrs) {
isString(attrs) ? addClass(elm, attrs) : setAttribute(elm, attrs);
}
parent && append(parent, elm);
return elm;
}
function style(elm, prop, value) {
if (isUndefined(value)) {
return getComputedStyle(elm)[prop];
}
if (!isNull(value)) {
elm.style[prop] = "" + value;
}
}
function display(elm, display2) {
style(elm, "display", display2);
}
function focus(elm) {
elm["setActive"] && elm["setActive"]() || elm.focus({
preventScroll: true
});
}
function getAttribute(elm, attr) {
return elm.getAttribute(attr);
}
function hasClass(elm, className) {
return elm && elm.classList.contains(className);
}
function rect(target) {
return target.getBoundingClientRect();
}
function remove(nodes) {
forEach(nodes, function(node) {
if (node && node.parentNode) {
node.parentNode.removeChild(node);
}
});
}
function parseHtml(html) {
return child(new DOMParser().parseFromString(html, "text/html").body);
}
function prevent(e, stopPropagation) {
e.preventDefault();
if (stopPropagation) {
e.stopPropagation();
e.stopImmediatePropagation();
}
}
function query(parent, selector) {
return parent && parent.querySelector(selector);
}
function queryAll(parent, selector) {
return selector ? slice(parent.querySelectorAll(selector)) : [];
}
function removeClass(elm, classes) {
toggleClass(elm, classes, false);
}
function timeOf(e) {
return e.timeStamp;
}
function unit(value) {
return isString(value) ? value : value ? value + "px" : "";
}
var PROJECT_CODE = "splide";
var DATA_ATTRIBUTE = "data-" + PROJECT_CODE;
function assert(condition, message) {
if (!condition) {
throw new Error("[" + PROJECT_CODE + "] " + (message || ""));
}
}
var min = Math.min, max = Math.max, floor = Math.floor, ceil = Math.ceil, abs = Math.abs;
function approximatelyEqual(x, y, epsilon) {
return abs(x - y) 0) - +(x = 1) {
onInterval();
startTime = now();
if (limit && ++count >= limit) {
return pause();
}
}
id = raf(update);
}
}
function start(resume) {
resume || cancel();
startTime = now() - (resume ? rate * interval : 0);
paused = false;
id = raf(update);
}
function pause() {
paused = true;
}
function rewind() {
startTime = now();
rate = 0;
if (onUpdate) {
onUpdate(rate);
}
}
function cancel() {
id && cancelAnimationFrame(id);
rate = 0;
id = 0;
paused = true;
}
function set(time) {
interval = time;
}
function isPaused() {
return paused;
}
return {
start,
rewind,
pause,
cancel,
set,
isPaused
};
}
function State(initialState) {
var state = initialState;
function set(value) {
state = value;
}
function is(states) {
return includes(toArray(states), state);
}
return {
set,
is
};
}
function Throttle(func, duration) {
var interval = RequestInterval(duration || 0, func, null, 1);
return function() {
interval.isPaused() && interval.start();
};
}
function Media(Splide2, Components2, options) {
var state = Splide2.state;
var breakpoints = options.breakpoints || {};
var reducedMotion = options.reducedMotion || {};
var binder = EventBinder();
var queries = [];
function setup() {
var isMin = options.mediaQuery === "min";
ownKeys(breakpoints).sort(function(n, m) {
return isMin ? +n - +m : +m - +n;
}).forEach(function(key) {
register(breakpoints[key], "(" + (isMin ? "min" : "max") + "-width:" + key + "px)");
});
register(reducedMotion, MEDIA_PREFERS_REDUCED_MOTION);
update();
}
function destroy(completely) {
if (completely) {
binder.destroy();
}
}
function register(options2, query2) {
var queryList = matchMedia(query2);
binder.bind(queryList, "change", update);
queries.push([options2, queryList]);
}
function update() {
var destroyed = state.is(DESTROYED);
var direction = options.direction;
var merged = queries.reduce(function(merged2, entry) {
return merge(merged2, entry[1].matches ? entry[0] : {});
}, {});
omit(options);
set(merged);
if (options.destroy) {
Splide2.destroy(options.destroy === "completely");
} else if (destroyed) {
destroy(true);
Splide2.mount();
} else {
direction !== options.direction && Splide2.refresh();
}
}
function reduce(enable) {
if (matchMedia(MEDIA_PREFERS_REDUCED_MOTION).matches) {
enable ? merge(options, reducedMotion) : omit(options, ownKeys(reducedMotion));
}
}
function set(opts, base, notify) {
merge(options, opts);
base && merge(Object.getPrototypeOf(options), opts);
if (notify || !state.is(CREATED)) {
Splide2.emit(EVENT_UPDATED, options);
}
}
return {
setup,
destroy,
reduce,
set
};
}
var ARROW = "Arrow";
var ARROW_LEFT = ARROW + "Left";
var ARROW_RIGHT = ARROW + "Right";
var ARROW_UP = ARROW + "Up";
var ARROW_DOWN = ARROW + "Down";
var RTL = "rtl";
var TTB = "ttb";
var ORIENTATION_MAP = {
width: ["height"],
left: ["top", "right"],
right: ["bottom", "left"],
x: ["y"],
X: ["Y"],
Y: ["X"],
ArrowLeft: [ARROW_UP, ARROW_RIGHT],
ArrowRight: [ARROW_DOWN, ARROW_LEFT]
};
function Direction(Splide2, Components2, options) {
function resolve(prop, axisOnly, direction) {
direction = direction || options.direction;
var index2 = direction === RTL && !axisOnly ? 1 : direction === TTB ? 0 : -1;
return ORIENTATION_MAP[prop] && ORIENTATION_MAP[prop][index2] || prop.replace(/width|left|right/i, function(match, offset) {
var replacement = ORIENTATION_MAP[match.toLowerCase()][index2] || match;
return offset > 0 ? replacement.charAt(0).toUpperCase() + replacement.slice(1) : replacement;
});
}
function orient(value) {
return value * (options.direction === RTL ? 1 : -1);
}
return {
resolve,
orient
};
}
var ROLE = "role";
var TAB_INDEX = "tabindex";
var DISABLED = "disabled";
var ARIA_PREFIX = "aria-";
var ARIA_CONTROLS = ARIA_PREFIX + "controls";
var ARIA_CURRENT = ARIA_PREFIX + "current";
var ARIA_SELECTED = ARIA_PREFIX + "selected";
var ARIA_LABEL = ARIA_PREFIX + "label";
var ARIA_LABELLEDBY = ARIA_PREFIX + "labelledby";
var ARIA_HIDDEN = ARIA_PREFIX + "hidden";
var ARIA_ORIENTATION = ARIA_PREFIX + "orientation";
var ARIA_ROLEDESCRIPTION = ARIA_PREFIX + "roledescription";
var ARIA_LIVE = ARIA_PREFIX + "live";
var ARIA_BUSY = ARIA_PREFIX + "busy";
var ARIA_ATOMIC = ARIA_PREFIX + "atomic";
var ALL_ATTRIBUTES = [ROLE, TAB_INDEX, DISABLED, ARIA_CONTROLS, ARIA_CURRENT, ARIA_LABEL, ARIA_LABELLEDBY, ARIA_HIDDEN, ARIA_ORIENTATION, ARIA_ROLEDESCRIPTION];
var CLASS_PREFIX = PROJECT_CODE + "__";
var STATUS_CLASS_PREFIX = "is-";
var CLASS_ROOT = PROJECT_CODE;
var CLASS_TRACK = CLASS_PREFIX + "track";
var CLASS_LIST = CLASS_PREFIX + "list";
var CLASS_SLIDE = CLASS_PREFIX + "slide";
var CLASS_CLONE = CLASS_SLIDE + "--clone";
var CLASS_CONTAINER = CLASS_SLIDE + "__container";
var CLASS_ARROWS = CLASS_PREFIX + "arrows";
var CLASS_ARROW = CLASS_PREFIX + "arrow";
var CLASS_ARROW_PREV = CLASS_ARROW + "--prev";
var CLASS_ARROW_NEXT = CLASS_ARROW + "--next";
var CLASS_PAGINATION = CLASS_PREFIX + "pagination";
var CLASS_PAGINATION_PAGE = CLASS_PAGINATION + "__page";
var CLASS_PROGRESS = CLASS_PREFIX + "progress";
var CLASS_PROGRESS_BAR = CLASS_PROGRESS + "__bar";
var CLASS_TOGGLE = CLASS_PREFIX + "toggle";
var CLASS_SPINNER = CLASS_PREFIX + "spinner";
var CLASS_SR = CLASS_PREFIX + "sr";
var CLASS_INITIALIZED = STATUS_CLASS_PREFIX + "initialized";
var CLASS_ACTIVE = STATUS_CLASS_PREFIX + "active";
var CLASS_PREV = STATUS_CLASS_PREFIX + "prev";
var CLASS_NEXT = STATUS_CLASS_PREFIX + "next";
var CLASS_VISIBLE = STATUS_CLASS_PREFIX + "visible";
var CLASS_LOADING = STATUS_CLASS_PREFIX + "loading";
var CLASS_FOCUS_IN = STATUS_CLASS_PREFIX + "focus-in";
var CLASS_OVERFLOW = STATUS_CLASS_PREFIX + "overflow";
var STATUS_CLASSES = [CLASS_ACTIVE, CLASS_VISIBLE, CLASS_PREV, CLASS_NEXT, CLASS_LOADING, CLASS_FOCUS_IN, CLASS_OVERFLOW];
var CLASSES = {
slide: CLASS_SLIDE,
clone: CLASS_CLONE,
arrows: CLASS_ARROWS,
arrow: CLASS_ARROW,
prev: CLASS_ARROW_PREV,
next: CLASS_ARROW_NEXT,
pagination: CLASS_PAGINATION,
page: CLASS_PAGINATION_PAGE,
spinner: CLASS_SPINNER
};
function closest(from, selector) {
if (isFunction(from.closest)) {
return from.closest(selector);
}
var elm = from;
while (elm && elm.nodeType === 1) {
if (matches(elm, selector)) {
break;
}
elm = elm.parentElement;
}
return elm;
}
var FRICTION = 5;
var LOG_INTERVAL = 200;
var POINTER_DOWN_EVENTS = "touchstart mousedown";
var POINTER_MOVE_EVENTS = "touchmove mousemove";
var POINTER_UP_EVENTS = "touchend touchcancel mouseup click";
function Elements(Splide2, Components2, options) {
var _EventInterface = EventInterface(Splide2), on = _EventInterface.on, bind = _EventInterface.bind;
var root = Splide2.root;
var i18n = options.i18n;
var elements = {};
var slides = [];
var rootClasses = [];
var trackClasses = [];
var track;
var list;
var isUsingKey;
function setup() {
collect();
init();
update();
}
function mount() {
on(EVENT_REFRESH, destroy);
on(EVENT_REFRESH, setup);
on(EVENT_UPDATED, update);
bind(document, POINTER_DOWN_EVENTS + " keydown", function(e) {
isUsingKey = e.type === "keydown";
}, {
capture: true
});
bind(root, "focusin", function() {
toggleClass(root, CLASS_FOCUS_IN, !!isUsingKey);
});
}
function destroy(completely) {
var attrs = ALL_ATTRIBUTES.concat("style");
empty(slides);
removeClass(root, rootClasses);
removeClass(track, trackClasses);
removeAttribute([track, list], attrs);
removeAttribute(root, completely ? attrs : ["style", ARIA_ROLEDESCRIPTION]);
}
function update() {
removeClass(root, rootClasses);
removeClass(track, trackClasses);
rootClasses = getClasses(CLASS_ROOT);
trackClasses = getClasses(CLASS_TRACK);
addClass(root, rootClasses);
addClass(track, trackClasses);
setAttribute(root, ARIA_LABEL, options.label);
setAttribute(root, ARIA_LABELLEDBY, options.labelledby);
}
function collect() {
track = find("." + CLASS_TRACK);
list = child(track, "." + CLASS_LIST);
assert(track && list, "A track/list element is missing.");
push(slides, children(list, "." + CLASS_SLIDE + ":not(." + CLASS_CLONE + ")"));
forOwn({
arrows: CLASS_ARROWS,
pagination: CLASS_PAGINATION,
prev: CLASS_ARROW_PREV,
next: CLASS_ARROW_NEXT,
bar: CLASS_PROGRESS_BAR,
toggle: CLASS_TOGGLE
}, function(className, key) {
elements[key] = find("." + className);
});
assign(elements, {
root,
track,
list,
slides
});
}
function init() {
var id = root.id || uniqueId(PROJECT_CODE);
var role = options.role;
root.id = id;
track.id = track.id || id + "-track";
list.id = list.id || id + "-list";
if (!getAttribute(root, ROLE) && root.tagName !== "SECTION" && role) {
setAttribute(root, ROLE, role);
}
setAttribute(root, ARIA_ROLEDESCRIPTION, i18n.carousel);
setAttribute(list, ROLE, "presentation");
}
function find(selector) {
var elm = query(root, selector);
return elm && closest(elm, "." + CLASS_ROOT) === root ? elm : void 0;
}
function getClasses(base) {
return [base + "--" + options.type, base + "--" + options.direction, options.drag && base + "--draggable", options.isNavigation && base + "--nav", base === CLASS_ROOT && CLASS_ACTIVE];
}
return assign(elements, {
setup,
mount,
destroy
});
}
var SLIDE = "slide";
var LOOP = "loop";
var FADE = "fade";
function Slide$1(Splide2, index2, slideIndex, slide) {
var event = EventInterface(Splide2);
var on = event.on, emit = event.emit, bind = event.bind;
var Components = Splide2.Components, root = Splide2.root, options = Splide2.options;
var isNavigation = options.isNavigation, updateOnMove = options.updateOnMove, i18n = options.i18n, pagination = options.pagination, slideFocus = options.slideFocus;
var resolve = Components.Direction.resolve;
var styles = getAttribute(slide, "style");
var label = getAttribute(slide, ARIA_LABEL);
var isClone = slideIndex > -1;
var container = child(slide, "." + CLASS_CONTAINER);
var destroyed;
function mount() {
if (!isClone) {
slide.id = root.id + "-slide" + pad(index2 + 1);
setAttribute(slide, ROLE, pagination ? "tabpanel" : "group");
setAttribute(slide, ARIA_ROLEDESCRIPTION, i18n.slide);
setAttribute(slide, ARIA_LABEL, label || format(i18n.slideLabel, [index2 + 1, Splide2.length]));
}
listen();
}
function listen() {
bind(slide, "click", apply(emit, EVENT_CLICK, self));
bind(slide, "keydown", apply(emit, EVENT_SLIDE_KEYDOWN, self));
on([EVENT_MOVED, EVENT_SHIFTED, EVENT_SCROLLED], update);
on(EVENT_NAVIGATION_MOUNTED, initNavigation);
if (updateOnMove) {
on(EVENT_MOVE, onMove);
}
}
function destroy() {
destroyed = true;
event.destroy();
removeClass(slide, STATUS_CLASSES);
removeAttribute(slide, ALL_ATTRIBUTES);
setAttribute(slide, "style", styles);
setAttribute(slide, ARIA_LABEL, label || "");
}
function initNavigation() {
var controls = Splide2.splides.map(function(target) {
var Slide2 = target.splide.Components.Slides.getAt(index2);
return Slide2 ? Slide2.slide.id : "";
}).join(" ");
setAttribute(slide, ARIA_LABEL, format(i18n.slideX, (isClone ? slideIndex : index2) + 1));
setAttribute(slide, ARIA_CONTROLS, controls);
setAttribute(slide, ROLE, slideFocus ? "button" : "");
slideFocus && removeAttribute(slide, ARIA_ROLEDESCRIPTION);
}
function onMove() {
if (!destroyed) {
update();
}
}
function update() {
if (!destroyed) {
var curr = Splide2.index;
updateActivity();
updateVisibility();
toggleClass(slide, CLASS_PREV, index2 === curr - 1);
toggleClass(slide, CLASS_NEXT, index2 === curr + 1);
}
}
function updateActivity() {
var active = isActive();
if (active !== hasClass(slide, CLASS_ACTIVE)) {
toggleClass(slide, CLASS_ACTIVE, active);
setAttribute(slide, ARIA_CURRENT, isNavigation && active || "");
emit(active ? EVENT_ACTIVE : EVENT_INACTIVE, self);
}
}
function updateVisibility() {
var visible = isVisible();
var hidden = !visible && (!isActive() || isClone);
if (!Splide2.state.is([MOVING, SCROLLING])) {
setAttribute(slide, ARIA_HIDDEN, hidden || "");
}
setAttribute(queryAll(slide, options.focusableNodes || ""), TAB_INDEX, hidden ? -1 : "");
if (slideFocus) {
setAttribute(slide, TAB_INDEX, hidden ? -1 : 0);
}
if (visible !== hasClass(slide, CLASS_VISIBLE)) {
toggleClass(slide, CLASS_VISIBLE, visible);
emit(visible ? EVENT_VISIBLE : EVENT_HIDDEN, self);
}
if (!visible && document.activeElement === slide) {
var Slide2 = Components.Slides.getAt(Splide2.index);
Slide2 && focus(Slide2.slide);
}
}
function style$1(prop, value, useContainer) {
style(useContainer && container || slide, prop, value);
}
function isActive() {
var curr = Splide2.index;
return curr === index2 || options.cloneStatus && curr === slideIndex;
}
function isVisible() {
if (Splide2.is(FADE)) {
return isActive();
}
var trackRect = rect(Components.Elements.track);
var slideRect = rect(slide);
var left = resolve("left", true);
var right = resolve("right", true);
return floor(trackRect[left]) options.perPage;
}
return {
mount,
destroy,
update,
register,
get,
getIn,
getAt,
add,
remove: remove$1,
forEach: forEach$1,
filter,
style: style2,
getLength,
isEnough
};
}
function Layout(Splide2, Components2, options) {
var _EventInterface3 = EventInterface(Splide2), on = _EventInterface3.on, bind = _EventInterface3.bind, emit = _EventInterface3.emit;
var Slides2 = Components2.Slides;
var resolve = Components2.Direction.resolve;
var _Components2$Elements2 = Components2.Elements, root = _Components2$Elements2.root, track = _Components2$Elements2.track, list = _Components2$Elements2.list;
var getAt = Slides2.getAt, styleSlides = Slides2.style;
var vertical;
var rootRect;
var overflow;
function mount() {
init();
bind(window, "resize load", Throttle(apply(emit, EVENT_RESIZE)));
on([EVENT_UPDATED, EVENT_REFRESH], init);
on(EVENT_RESIZE, resize);
}
function init() {
vertical = options.direction === TTB;
style(root, "maxWidth", unit(options.width));
style(track, resolve("paddingLeft"), cssPadding(false));
style(track, resolve("paddingRight"), cssPadding(true));
resize(true);
}
function resize(force) {
var newRect = rect(root);
if (force || rootRect.width !== newRect.width || rootRect.height !== newRect.height) {
style(track, "height", cssTrackHeight());
styleSlides(resolve("marginRight"), unit(options.gap));
styleSlides("width", cssSlideWidth());
styleSlides("height", cssSlideHeight(), true);
rootRect = newRect;
emit(EVENT_RESIZED);
if (overflow !== (overflow = isOverflow())) {
toggleClass(root, CLASS_OVERFLOW, overflow);
emit(EVENT_OVERFLOW, overflow);
}
}
}
function cssPadding(right) {
var padding = options.padding;
var prop = resolve(right ? "right" : "left");
return padding && unit(padding[prop] || (isObject(padding) ? 0 : padding)) || "0px";
}
function cssTrackHeight() {
var height = "";
if (vertical) {
height = cssHeight();
assert(height, "height or heightRatio is missing.");
height = "calc(" + height + " - " + cssPadding(false) + " - " + cssPadding(true) + ")";
}
return height;
}
function cssHeight() {
return unit(options.height || rect(list).width * options.heightRatio);
}
function cssSlideWidth() {
return options.autoWidth ? null : unit(options.fixedWidth) || (vertical ? "" : cssSlideSize());
}
function cssSlideHeight() {
return unit(options.fixedHeight) || (vertical ? options.autoHeight ? null : cssSlideSize() : cssHeight());
}
function cssSlideSize() {
var gap = unit(options.gap);
return "calc((100%" + (gap && " + " + gap) + ")/" + (options.perPage || 1) + (gap && " - " + gap) + ")";
}
function listSize() {
return rect(list)[resolve("width")];
}
function slideSize(index2, withoutGap) {
var Slide2 = getAt(index2 || 0);
return Slide2 ? rect(Slide2.slide)[resolve("width")] + (withoutGap ? 0 : getGap()) : 0;
}
function totalSize(index2, withoutGap) {
var Slide2 = getAt(index2);
if (Slide2) {
var right = rect(Slide2.slide)[resolve("right")];
var left = rect(list)[resolve("left")];
return abs(right - left) + (withoutGap ? 0 : getGap());
}
return 0;
}
function sliderSize(withoutGap) {
return totalSize(Splide2.length - 1) - totalSize(0) + slideSize(0, withoutGap);
}
function getGap() {
var Slide2 = getAt(0);
return Slide2 && parseFloat(style(Slide2.slide, resolve("marginRight"))) || 0;
}
function getPadding(right) {
return parseFloat(style(track, resolve("padding" + (right ? "Right" : "Left")))) || 0;
}
function isOverflow() {
return Splide2.is(FADE) || sliderSize(true) > listSize();
}
return {
mount,
resize,
listSize,
slideSize,
sliderSize,
totalSize,
getPadding,
isOverflow
};
}
var MULTIPLIER = 2;
function Clones(Splide2, Components2, options) {
var event = EventInterface(Splide2);
var on = event.on;
var Elements2 = Components2.Elements, Slides2 = Components2.Slides;
var resolve = Components2.Direction.resolve;
var clones = [];
var cloneCount;
function mount() {
on(EVENT_REFRESH, remount);
on([EVENT_UPDATED, EVENT_RESIZE], observe);
if (cloneCount = computeCloneCount()) {
generate(cloneCount);
Components2.Layout.resize(true);
}
}
function remount() {
destroy();
mount();
}
function destroy() {
remove(clones);
empty(clones);
event.destroy();
}
function observe() {
var count = computeCloneCount();
if (cloneCount !== count) {
if (cloneCount prev)) {
cancel();
translate(shift(getPosition(), dest > prev), true);
}
set(MOVING);
emit(EVENT_MOVE, index2, prev, dest);
Transition.start(index2, function() {
set(IDLE);
emit(EVENT_MOVED, index2, prev, dest);
callback && callback();
});
}
function jump(index2) {
translate(toPosition(index2, true));
}
function translate(position, preventLoop) {
if (!Splide2.is(FADE)) {
var destination = preventLoop ? position : loop(position);
style(list, "transform", "translate" + resolve("X") + "(" + destination + "px)");
position !== destination && emit(EVENT_SHIFTED);
}
}
function loop(position) {
if (Splide2.is(LOOP)) {
var index2 = toIndex(position);
var exceededMax = index2 > Components2.Controller.getEnd();
var exceededMin = index2 = 0 : shifted orient(getLimit(true));
return exceededMin || exceededMax;
}
return {
mount,
move,
jump,
translate,
shift,
cancel,
toIndex,
toPosition,
getPosition,
getLimit,
exceededLimit,
reposition
};
}
function Controller(Splide2, Components2, options) {
var _EventInterface5 = EventInterface(Splide2), on = _EventInterface5.on, emit = _EventInterface5.emit;
var Move2 = Components2.Move;
var getPosition = Move2.getPosition, getLimit = Move2.getLimit, toPosition = Move2.toPosition;
var _Components2$Slides = Components2.Slides, isEnough = _Components2$Slides.isEnough, getLength = _Components2$Slides.getLength;
var omitEnd = options.omitEnd;
var isLoop = Splide2.is(LOOP);
var isSlide = Splide2.is(SLIDE);
var getNext = apply(getAdjacent, false);
var getPrev = apply(getAdjacent, true);
var currIndex = options.start || 0;
var endIndex;
var prevIndex = currIndex;
var slideCount;
var perMove;
var perPage;
function mount() {
init();
on([EVENT_UPDATED, EVENT_REFRESH, EVENT_END_INDEX_CHANGED], init);
on(EVENT_RESIZED, onResized);
}
function init() {
slideCount = getLength(true);
perMove = options.perMove;
perPage = options.perPage;
endIndex = getEnd();
var index2 = clamp(currIndex, 0, omitEnd ? endIndex : slideCount - 1);
if (index2 !== currIndex) {
currIndex = index2;
Move2.reposition();
}
}
function onResized() {
if (endIndex !== getEnd()) {
emit(EVENT_END_INDEX_CHANGED);
}
}
function go(control, allowSameIndex, callback) {
if (!isBusy()) {
var dest = parse(control);
var index2 = loop(dest);
if (index2 > -1 && (allowSameIndex || index2 !== currIndex)) {
setIndex(index2);
Move2.move(dest, index2, prevIndex, callback);
}
}
}
function scroll(destination, duration, snap, callback) {
Components2.Scroll.scroll(destination, duration, snap, function() {
var index2 = loop(Move2.toIndex(getPosition()));
setIndex(omitEnd ? min(index2, endIndex) : index2);
callback && callback();
});
}
function parse(control) {
var index2 = currIndex;
if (isString(control)) {
var _ref = control.match(/([+\-<>])(\d+)?/) || [], indicator = _ref[1], number = _ref[2];
if (indicator === "+" || indicator === "-") {
index2 = computeDestIndex(currIndex + +("" + indicator + (+number || 1)), currIndex);
} else if (indicator === ">") {
index2 = number ? toIndex(+number) : getNext(true);
} else if (indicator === " endIndex) {
if (!perMove && (between(0, dest, from, true) || between(endIndex, from, dest, true))) {
dest = toIndex(toPage(dest));
} else {
if (isLoop) {
dest = snapPage ? dest 0) {
if (toPosition(slideCount - 1, true) !== toPosition(end, true)) {
end++;
break;
}
}
return clamp(end, 0, slideCount - 1);
}
function toIndex(page) {
return clamp(hasFocus() ? page : perPage * page, 0, endIndex);
}
function toPage(index2) {
return hasFocus() ? min(index2, endIndex) : floor((index2 >= endIndex ? slideCount - 1 : index2) / perPage);
}
function toDest(destination) {
var closest2 = Move2.toIndex(destination);
return isSlide ? clamp(closest2, 0, endIndex) : closest2;
}
function setIndex(index2) {
if (index2 !== currIndex) {
prevIndex = currIndex;
currIndex = index2;
}
}
function getIndex(prev) {
return prev ? prevIndex : currIndex;
}
function hasFocus() {
return !isUndefined(options.focus) || options.isNavigation;
}
function isBusy() {
return Splide2.state.is([MOVING, SCROLLING]) && !!options.waitForTransition;
}
return {
mount,
go,
scroll,
getNext,
getPrev,
getAdjacent,
getEnd,
setIndex,
getIndex,
toIndex,
toPage,
toDest,
hasFocus,
isBusy
};
}
var XML_NAME_SPACE = "http://www.w3.org/2000/svg";
var PATH = "m15.5 0.932-4.3 4.38 14.5 14.6-14.5 14.5 4.3 4.4 14.6-14.6 4.4-4.3-4.4-4.4-14.6-14.6z";
var SIZE = 40;
function Arrows(Splide2, Components2, options) {
var event = EventInterface(Splide2);
var on = event.on, bind = event.bind, emit = event.emit;
var classes = options.classes, i18n = options.i18n;
var Elements2 = Components2.Elements, Controller2 = Components2.Controller;
var placeholder = Elements2.arrows, track = Elements2.track;
var wrapper = placeholder;
var prev = Elements2.prev;
var next = Elements2.next;
var created;
var wrapperClasses;
var arrows = {};
function mount() {
init();
on(EVENT_UPDATED, remount);
}
function remount() {
destroy();
mount();
}
function init() {
var enabled = options.arrows;
if (enabled && !(prev && next)) {
createArrows();
}
if (prev && next) {
assign(arrows, {
prev,
next
});
display(wrapper, enabled ? "" : "none");
addClass(wrapper, wrapperClasses = CLASS_ARROWS + "--" + options.direction);
if (enabled) {
listen();
update();
setAttribute([prev, next], ARIA_CONTROLS, track.id);
emit(EVENT_ARROWS_MOUNTED, prev, next);
}
}
}
function destroy() {
event.destroy();
removeClass(wrapper, wrapperClasses);
if (created) {
remove(placeholder ? [prev, next] : wrapper);
prev = next = null;
} else {
removeAttribute([prev, next], ALL_ATTRIBUTES);
}
}
function listen() {
on([EVENT_MOUNTED, EVENT_MOVED, EVENT_REFRESH, EVENT_SCROLLED, EVENT_END_INDEX_CHANGED], update);
bind(next, "click", apply(go, ">"));
bind(prev, "click", apply(go, "';
return parseHtml(arrow);
}
function update() {
if (prev && next) {
var index2 = Splide2.index;
var prevIndex = Controller2.getPrev();
var nextIndex = Controller2.getNext();
var prevLabel = prevIndex > -1 && index2 -1 && index2 > nextIndex ? i18n.first : i18n.next;
prev.disabled = prevIndex "), onAnimationFrame);
var isPaused = interval.isPaused;
var Elements2 = Components2.Elements, _Components2$Elements4 = Components2.Elements, root = _Components2$Elements4.root, toggle = _Components2$Elements4.toggle;
var autoplay = options.autoplay;
var hovered;
var focused;
var stopped = autoplay === "pause";
function mount() {
if (autoplay) {
listen();
toggle && setAttribute(toggle, ARIA_CONTROLS, Elements2.track.id);
stopped || play();
update();
}
}
function listen() {
if (options.pauseOnHover) {
bind(root, "mouseenter mouseleave", function(e) {
hovered = e.type === "mouseenter";
autoToggle();
});
}
if (options.pauseOnFocus) {
bind(root, "focusin focusout", function(e) {
focused = e.type === "focusin";
autoToggle();
});
}
if (toggle) {
bind(toggle, "click", function() {
stopped ? play() : pause(true);
});
}
on([EVENT_MOVE, EVENT_SCROLL, EVENT_REFRESH], interval.rewind);
on(EVENT_MOVE, onMove);
}
function play() {
if (isPaused() && Components2.Slides.isEnough()) {
interval.start(!options.resetProgress);
focused = hovered = stopped = false;
update();
emit(EVENT_AUTOPLAY_PLAY);
}
}
function pause(stop) {
if (stop === void 0) {
stop = true;
}
stopped = !!stop;
update();
if (!isPaused()) {
interval.pause();
emit(EVENT_AUTOPLAY_PAUSE);
}
}
function autoToggle() {
if (!stopped) {
hovered || focused ? pause(false) : play();
}
}
function update() {
if (toggle) {
toggleClass(toggle, CLASS_ACTIVE, !stopped);
setAttribute(toggle, ARIA_LABEL, options.i18n[stopped ? "play" : "pause"]);
}
}
function onAnimationFrame(rate) {
var bar = Elements2.bar;
bar && style(bar, "width", rate * 100 + "%");
emit(EVENT_AUTOPLAY_PLAYING, rate);
}
function onMove(index2) {
var Slide2 = Components2.Slides.getAt(index2);
interval.set(Slide2 && +getAttribute(Slide2.slide, INTERVAL_DATA_ATTRIBUTE) || options.interval);
}
return {
mount,
destroy: interval.cancel,
play,
pause,
isPaused
};
}
function Cover(Splide2, Components2, options) {
var _EventInterface7 = EventInterface(Splide2), on = _EventInterface7.on;
function mount() {
if (options.cover) {
on(EVENT_LAZYLOAD_LOADED, apply(toggle, true));
on([EVENT_MOUNTED, EVENT_UPDATED, EVENT_REFRESH], apply(cover, true));
}
}
function cover(cover2) {
Components2.Slides.forEach(function(Slide2) {
var img = child(Slide2.container || Slide2.slide, "img");
if (img && img.src) {
toggle(cover2, img, Slide2);
}
});
}
function toggle(cover2, img, Slide2) {
Slide2.style("background", cover2 ? 'center/cover no-repeat url("' + img.src + '")' : "", true);
display(img, cover2 ? "none" : "");
}
return {
mount,
destroy: apply(cover, false)
};
}
var BOUNCE_DIFF_THRESHOLD = 10;
var BOUNCE_DURATION = 600;
var FRICTION_FACTOR = 0.6;
var BASE_VELOCITY = 1.5;
var MIN_DURATION = 800;
function Scroll(Splide2, Components2, options) {
var _EventInterface8 = EventInterface(Splide2), on = _EventInterface8.on, emit = _EventInterface8.emit;
var set = Splide2.state.set;
var Move2 = Components2.Move;
var getPosition = Move2.getPosition, getLimit = Move2.getLimit, exceededLimit = Move2.exceededLimit, translate = Move2.translate;
var isSlide = Splide2.is(SLIDE);
var interval;
var callback;
var friction = 1;
function mount() {
on(EVENT_MOVE, clear);
on([EVENT_UPDATED, EVENT_REFRESH], cancel);
}
function scroll(destination, duration, snap, onScrolled, noConstrain) {
var from = getPosition();
clear();
if (snap && (!isSlide || !exceededLimit())) {
var size = Components2.Layout.sliderSize();
var offset = sign(destination) * size * floor(abs(destination) / size) || 0;
destination = Move2.toPosition(Components2.Controller.toDest(destination % size)) + offset;
}
var noDistance = approximatelyEqual(from, destination, 1);
friction = 1;
duration = noDistance ? 0 : duration || max(abs(destination - from) / BASE_VELOCITY, MIN_DURATION);
callback = onScrolled;
interval = RequestInterval(duration, onEnd, apply(update, from, destination, noConstrain), 1);
set(SCROLLING);
emit(EVENT_SCROLL);
interval.start();
}
function onEnd() {
set(IDLE);
callback && callback();
emit(EVENT_SCROLLED);
}
function update(from, to, noConstrain, rate) {
var position = getPosition();
var target = from + (to - from) * easing(rate);
var diff = (target - position) * friction;
translate(position + diff);
if (isSlide && !noConstrain && exceededLimit()) {
friction *= FRICTION_FACTOR;
if (abs(diff) LOG_INTERVAL;
var hasExceeded = exceeded !== (exceeded = exceededLimit());
if (expired || hasExceeded) {
save(e);
}
clickPrevented = true;
emit(EVENT_DRAGGING);
prevent(e);
} else if (isSliderDirection(e)) {
dragging = shouldStart(e);
prevent(e);
}
}
}
function onPointerUp(e) {
if (state.is(DRAGGING)) {
state.set(IDLE);
emit(EVENT_DRAGGED);
}
if (dragging) {
move(e);
prevent(e);
}
unbind(target, POINTER_MOVE_EVENTS, onPointerMove);
unbind(target, POINTER_UP_EVENTS, onPointerUp);
dragging = false;
}
function onClick(e) {
if (!disabled && clickPrevented) {
prevent(e, true);
}
}
function save(e) {
prevBaseEvent = baseEvent;
baseEvent = e;
basePosition = getPosition();
}
function move(e) {
var velocity = computeVelocity(e);
var destination = computeDestination(velocity);
var rewind = options.rewind && options.rewindByDrag;
reduce(false);
if (isFree) {
Controller2.scroll(destination, 0, options.snap);
} else if (Splide2.is(FADE)) {
Controller2.go(orient(sign(velocity)) " : "+");
} else if (Splide2.is(SLIDE) && exceeded && rewind) {
Controller2.go(exceededLimit(true) ? ">" : " (isTouchEvent(e) ? touch : mouse);
}
function isSliderDirection(e) {
return abs(diffCoord(e)) > abs(diffCoord(e, true));
}
function computeVelocity(e) {
if (Splide2.is(LOOP) || !exceeded) {
var time = diffTime(e);
if (time && time ");
}
}
}
return {
mount,
destroy,
disable
};
}
var SRC_DATA_ATTRIBUTE = DATA_ATTRIBUTE + "-lazy";
var SRCSET_DATA_ATTRIBUTE = SRC_DATA_ATTRIBUTE + "-srcset";
var IMAGE_SELECTOR = "[" + SRC_DATA_ATTRIBUTE + "], [" + SRCSET_DATA_ATTRIBUTE + "]";
function LazyLoad(Splide2, Components2, options) {
var _EventInterface11 = EventInterface(Splide2), on = _EventInterface11.on, off = _EventInterface11.off, bind = _EventInterface11.bind, emit = _EventInterface11.emit;
var isSequential = options.lazyLoad === "sequential";
var events = [EVENT_MOVED, EVENT_SCROLLED];
var entries = [];
function mount() {
if (options.lazyLoad) {
init();
on(EVENT_REFRESH, init);
}
}
function init() {
empty(entries);
register();
if (isSequential) {
loadNext();
} else {
off(events);
on(events, check);
check();
}
}
function register() {
Components2.Slides.forEach(function(Slide2) {
queryAll(Slide2.slide, IMAGE_SELECTOR).forEach(function(img) {
var src = getAttribute(img, SRC_DATA_ATTRIBUTE);
var srcset = getAttribute(img, SRCSET_DATA_ATTRIBUTE);
if (src !== img.src || srcset !== img.srcset) {
var className = options.classes.spinner;
var parent = img.parentElement;
var spinner = child(parent, "." + className) || create("span", className, parent);
entries.push([img, Slide2, spinner]);
img.src || display(img, "none");
}
});
});
}
function check() {
entries = entries.filter(function(data) {
var distance = options.perPage * ((options.preloadPages || 1) + 1) - 1;
return data[1].isWithin(Splide2.index, distance) ? load(data) : true;
});
entries.length || off(events);
}
function load(data) {
var img = data[0];
addClass(data[1].slide, CLASS_LOADING);
bind(img, "load error", apply(onLoad, data));
setAttribute(img, "src", getAttribute(img, SRC_DATA_ATTRIBUTE));
setAttribute(img, "srcset", getAttribute(img, SRCSET_DATA_ATTRIBUTE));
removeAttribute(img, SRC_DATA_ATTRIBUTE);
removeAttribute(img, SRCSET_DATA_ATTRIBUTE);
}
function onLoad(data, e) {
var img = data[0], Slide2 = data[1];
removeClass(Slide2.slide, CLASS_LOADING);
if (e.type !== "error") {
remove(data[2]);
display(img, "");
emit(EVENT_LAZYLOAD_LOADED, img, Slide2);
emit(EVENT_RESIZE);
}
isSequential && loadNext();
}
function loadNext() {
entries.length && load(entries.shift());
}
return {
mount,
destroy: apply(empty, entries),
check
};
}
function Pagination(Splide2, Components2, options) {
var event = EventInterface(Splide2);
var on = event.on, emit = event.emit, bind = event.bind;
var Slides2 = Components2.Slides, Elements2 = Components2.Elements, Controller2 = Components2.Controller;
var hasFocus = Controller2.hasFocus, getIndex = Controller2.getIndex, go = Controller2.go;
var resolve = Components2.Direction.resolve;
var placeholder = Elements2.pagination;
var items = [];
var list;
var paginationClasses;
function mount() {
destroy();
on([EVENT_UPDATED, EVENT_REFRESH, EVENT_END_INDEX_CHANGED], mount);
var enabled = options.pagination;
placeholder && display(placeholder, enabled ? "" : "none");
if (enabled) {
on([EVENT_MOVE, EVENT_SCROLL, EVENT_SCROLLED], update);
createPagination();
update();
emit(EVENT_PAGINATION_MOUNTED, {
list,
items
}, getAt(Splide2.index));
}
}
function destroy() {
if (list) {
remove(placeholder ? slice(list.children) : list);
removeClass(list, paginationClasses);
empty(items);
list = null;
}
event.destroy();
}
function createPagination() {
var length = Splide2.length;
var classes = options.classes, i18n = options.i18n, perPage = options.perPage;
var max2 = hasFocus() ? Controller2.getEnd() + 1 : ceil(length / perPage);
list = placeholder || create("ul", classes.pagination, Elements2.track.parentElement);
addClass(list, paginationClasses = CLASS_PAGINATION + "--" + getDirection());
setAttribute(list, ROLE, "tablist");
setAttribute(list, ARIA_LABEL, i18n.select);
setAttribute(list, ARIA_ORIENTATION, getDirection() === TTB ? "vertical" : "");
for (var i = 0; i 1 ? i18n.pageX : i18n.slideX;
bind(button, "click", apply(onClick, i));
if (options.paginationKeyboard) {
bind(button, "keydown", apply(onKeydown, i));
}
setAttribute(li, ROLE, "presentation");
setAttribute(button, ROLE, "tab");
setAttribute(button, ARIA_CONTROLS, controls.join(" "));
setAttribute(button, ARIA_LABEL, format(text, i + 1));
setAttribute(button, TAB_INDEX, -1);
items.push({
li,
button,
page: i
});
}
}
function onClick(page) {
go(">" + page, true);
}
function onKeydown(page, e) {
var length = items.length;
var key = normalizeKey(e);
var dir = getDirection();
var nextPage = -1;
if (key === resolve(ARROW_RIGHT, false, dir)) {
nextPage = ++page % length;
} else if (key === resolve(ARROW_LEFT, false, dir)) {
nextPage = (--page + length) % length;
} else if (key === "Home") {
nextPage = 0;
} else if (key === "End") {
nextPage = length - 1;
}
var item = items[nextPage];
if (item) {
focus(item.button);
go(">" + nextPage);
prevent(e, true);
}
}
function getDirection() {
return options.paginationDirection || options.direction;
}
function getAt(index2) {
return items[Controller2.toPage(index2)];
}
function update() {
var prev = getAt(getIndex(true));
var curr = getAt(getIndex());
if (prev) {
var button = prev.button;
removeClass(button, CLASS_ACTIVE);
removeAttribute(button, ARIA_SELECTED);
setAttribute(button, TAB_INDEX, -1);
}
if (curr) {
var _button = curr.button;
addClass(_button, CLASS_ACTIVE);
setAttribute(_button, ARIA_SELECTED, true);
setAttribute(_button, TAB_INDEX, "");
}
emit(EVENT_PAGINATION_UPDATED, {
list,
items
}, prev, curr);
}
return {
items,
mount,
destroy,
getAt,
update
};
}
var TRIGGER_KEYS = [" ", "Enter"];
function Sync(Splide2, Components2, options) {
var isNavigation = options.isNavigation, slideFocus = options.slideFocus;
var events = [];
function mount() {
Splide2.splides.forEach(function(target) {
if (!target.isParent) {
sync(Splide2, target.splide);
sync(target.splide, Splide2);
}
});
if (isNavigation) {
navigate();
}
}
function destroy() {
events.forEach(function(event) {
event.destroy();
});
empty(events);
}
function remount() {
destroy();
mount();
}
function sync(splide, target) {
var event = EventInterface(splide);
event.on(EVENT_MOVE, function(index2, prev, dest) {
target.go(target.is(LOOP) ? dest : index2);
});
events.push(event);
}
function navigate() {
var event = EventInterface(Splide2);
var on = event.on;
on(EVENT_CLICK, onClick);
on(EVENT_SLIDE_KEYDOWN, onKeydown);
on([EVENT_MOUNTED, EVENT_UPDATED], update);
events.push(event);
event.emit(EVENT_NAVIGATION_MOUNTED, Splide2.splides);
}
function update() {
setAttribute(Components2.Elements.list, ARIA_ORIENTATION, options.direction === TTB ? "vertical" : "");
}
function onClick(Slide2) {
Splide2.go(Slide2.index);
}
function onKeydown(Slide2, e) {
if (includes(TRIGGER_KEYS, normalizeKey(e))) {
onClick(Slide2);
prevent(e);
}
}
return {
setup: apply(Components2.Media.set, {
slideFocus: isUndefined(slideFocus) ? isNavigation : slideFocus
}, true),
mount,
destroy,
remount
};
}
function Wheel(Splide2, Components2, options) {
var _EventInterface12 = EventInterface(Splide2), bind = _EventInterface12.bind;
var lastTime = 0;
function mount() {
if (options.wheel) {
bind(Components2.Elements.track, "wheel", onWheel, SCROLL_LISTENER_OPTIONS);
}
}
function onWheel(e) {
if (e.cancelable) {
var deltaY = e.deltaY;
var backwards = deltaY _min && timeStamp - lastTime > sleep) {
Splide2.go(backwards ? "");
lastTime = timeStamp;
}
shouldPrevent(backwards) && prevent(e);
}
}
function shouldPrevent(backwards) {
return !options.releaseWheel || Splide2.state.is(MOVING) || Components2.Controller.getAdjacent(backwards) !== -1;
}
return {
mount
};
}
var SR_REMOVAL_DELAY = 90;
function Live(Splide2, Components2, options) {
var _EventInterface13 = EventInterface(Splide2), on = _EventInterface13.on;
var track = Components2.Elements.track;
var enabled = options.live && !options.isNavigation;
var sr = create("span", CLASS_SR);
var interval = RequestInterval(SR_REMOVAL_DELAY, apply(toggle, false));
function mount() {
if (enabled) {
disable(!Components2.Autoplay.isPaused());
setAttribute(track, ARIA_ATOMIC, true);
sr.textContent = "…";
on(EVENT_AUTOPLAY_PLAY, apply(disable, true));
on(EVENT_AUTOPLAY_PAUSE, apply(disable, false));
on([EVENT_MOVED, EVENT_SCROLLED], apply(toggle, true));
}
}
function toggle(active) {
setAttribute(track, ARIA_BUSY, active);
if (active) {
append(track, sr);
interval.start();
} else {
remove(sr);
interval.cancel();
}
}
function destroy() {
removeAttribute(track, [ARIA_LIVE, ARIA_ATOMIC, ARIA_BUSY]);
remove(sr);
}
function disable(disabled) {
if (enabled) {
setAttribute(track, ARIA_LIVE, disabled ? "off" : "polite");
}
}
return {
mount,
disable,
destroy
};
}
var ComponentConstructors = /* @__PURE__ */ Object.freeze({
__proto__: null,
Media,
Direction,
Elements,
Slides,
Layout,
Clones,
Move,
Controller,
Arrows,
Autoplay,
Cover,
Scroll,
Drag,
Keyboard,
LazyLoad,
Pagination,
Sync,
Wheel,
Live
});
var I18N = {
prev: "Previous slide",
next: "Next slide",
first: "Go to first slide",
last: "Go to last slide",
slideX: "Go to slide %s",
pageX: "Go to page %s",
play: "Start autoplay",
pause: "Pause autoplay",
carousel: "carousel",
slide: "slide",
select: "Select a slide to show",
slideLabel: "%s of %s"
};
var DEFAULTS = {
type: "slide",
role: "region",
speed: 400,
perPage: 1,
cloneStatus: true,
arrows: true,
pagination: true,
paginationKeyboard: true,
interval: 5e3,
pauseOnHover: true,
pauseOnFocus: true,
resetProgress: true,
easing: "cubic-bezier(0.25, 1, 0.5, 1)",
drag: true,
direction: "ltr",
trimSpace: true,
focusableNodes: "a, button, textarea, input, select, iframe",
live: true,
classes: CLASSES,
i18n: I18N,
reducedMotion: {
speed: 0,
rewindSpeed: 0,
autoplay: "pause"
}
};
function Fade(Splide2, Components2, options) {
var Slides2 = Components2.Slides;
function mount() {
EventInterface(Splide2).on([EVENT_MOUNTED, EVENT_REFRESH], init);
}
function init() {
Slides2.forEach(function(Slide2) {
Slide2.style("transform", "translateX(-" + 100 * Slide2.index + "%)");
});
}
function start(index2, done) {
Slides2.style("transition", "opacity " + options.speed + "ms " + options.easing);
nextTick(done);
}
return {
mount,
start,
cancel: noop
};
}
function Slide(Splide2, Components2, options) {
var Move2 = Components2.Move, Controller2 = Components2.Controller, Scroll2 = Components2.Scroll;
var list = Components2.Elements.list;
var transition = apply(style, list, "transition");
var endCallback;
function mount() {
EventInterface(Splide2).bind(list, "transitionend", function(e) {
if (e.target === list && endCallback) {
cancel();
endCallback();
}
});
}
function start(index2, done) {
var destination = Move2.toPosition(index2, true);
var position = Move2.getPosition();
var speed = getSpeed(index2);
if (abs(destination - position) >= 1 && speed >= 1) {
if (options.useScroll) {
Scroll2.scroll(destination, speed, false, done);
} else {
transition("transform " + speed + "ms " + options.easing);
Move2.translate(destination, true);
endCallback = done;
}
} else {
Move2.jump(index2);
done();
}
}
function cancel() {
transition("");
Scroll2.cancel();
}
function getSpeed(index2) {
var rewindSpeed = options.rewindSpeed;
if (Splide2.is(SLIDE) && rewindSpeed) {
var prev = Controller2.getIndex(true);
var end = Controller2.getEnd();
if (prev === 0 && index2 >= end || prev >= end && index2 === 0) {
return rewindSpeed;
}
}
return options.speed;
}
return {
mount,
start,
cancel
};
}
var _Splide = /* @__PURE__ */ function() {
function _Splide2(target, options) {
this.event = EventInterface();
this.Components = {};
this.state = State(CREATED);
this.splides = [];
this._o = {};
this._E = {};
var root = isString(target) ? query(document, target) : target;
assert(root, root + " is invalid.");
this.root = root;
options = merge({
label: getAttribute(root, ARIA_LABEL) || "",
labelledby: getAttribute(root, ARIA_LABELLEDBY) || ""
}, DEFAULTS, _Splide2.defaults, options || {});
try {
merge(options, JSON.parse(getAttribute(root, DATA_ATTRIBUTE)));
} catch (e) {
assert(false, "Invalid JSON");
}
this._o = Object.create(merge({}, options));
}
var _proto = _Splide2.prototype;
_proto.mount = function mount(Extensions, Transition) {
var _this = this;
var state = this.state, Components2 = this.Components;
assert(state.is([CREATED, DESTROYED]), "Already mounted!");
state.set(CREATED);
this._C = Components2;
this._T = Transition || this._T || (this.is(FADE) ? Fade : Slide);
this._E = Extensions || this._E;
var Constructors = assign({}, ComponentConstructors, this._E, {
Transition: this._T
});
forOwn(Constructors, function(Component, key) {
var component = Component(_this, Components2, _this._o);
Components2[key] = component;
component.setup && component.setup();
});
forOwn(Components2, function(component) {
component.mount && component.mount();
});
this.emit(EVENT_MOUNTED);
addClass(this.root, CLASS_INITIALIZED);
state.set(IDLE);
this.emit(EVENT_READY);
return this;
};
_proto.sync = function sync(splide) {
this.splides.push({
splide
});
splide.splides.push({
splide: this,
isParent: true
});
if (this.state.is(IDLE)) {
this._C.Sync.remount();
splide.Components.Sync.remount();
}
return this;
};
_proto.go = function go(control) {
this._C.Controller.go(control);
return this;
};
_proto.on = function on(events, callback) {
this.event.on(events, callback);
return this;
};
_proto.off = function off(events) {
this.event.off(events);
return this;
};
_proto.emit = function emit(event) {
var _this$event;
(_this$event = this.event).emit.apply(_this$event, [event].concat(slice(arguments, 1)));
return this;
};
_proto.add = function add(slides, index2) {
this._C.Slides.add(slides, index2);
return this;
};
_proto.remove = function remove2(matcher) {
this._C.Slides.remove(matcher);
return this;
};
_proto.is = function is(type) {
return this._o.type === type;
};
_proto.refresh = function refresh() {
this.emit(EVENT_REFRESH);
return this;
};
_proto.destroy = function destroy(completely) {
if (completely === void 0) {
completely = true;
}
var event = this.event, state = this.state;
if (state.is(CREATED)) {
EventInterface(this).on(EVENT_READY, this.destroy.bind(this, completely));
} else {
forOwn(this._C, function(component) {
component.destroy && component.destroy(completely);
}, true);
event.emit(EVENT_DESTROY);
event.destroy();
completely && empty(this.splides);
state.set(DESTROYED);
}
return this;
};
_createClass(_Splide2, [{
key: "options",
get: function get() {
return this._o;
},
set: function set(options) {
this._C.Media.set(options, true, true);
}
}, {
key: "length",
get: function get() {
return this._C.Slides.getLength(true);
}
}, {
key: "index",
get: function get() {
return this._C.Controller.getIndex();
}
}]);
return _Splide2;
}();
var Splide = _Splide;
Splide.defaults = {};
Splide.STATES = STATES;
const splide_min = "";
window.addEventListener("DOMContentLoaded", () => {
new Splide(".header-splide", {
type: "loop",
speed: 800,
pagination: true,
arrows: false
}).mount();
new Splide(".cards-splide", {
type: "loop",
speed: 800,
gap: "20px",
pagination: true,
arrows: false
}).mount();
new Splide(".footer-splide", {
type: "loop",
speed: 800,
pagination: false,
arrows: true
}).mount();
});
} catch (e) {console.error(e);}};
Ключевые навыки
- Redis
- Gitlab
- Python
- Django Rest Framework
- Celery
- PostgreSQL
- Clickhouse
- RabbitMQ
- Наставничество