Initial commit — BMP Website 2026

Vollständiges Redesign mit Gold-Formularen, BMP-Logo, multi-step Forms (Bewerbung, Kontakt, Sponsoring), Netlify-Deployment.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

node_modules/embla-carousel-auto-scroll/esm/components/AutoScroll.d.ts

@@ -0,0 +1,23 @@
+import { OptionsType } from './Options.js';
+import { CreatePluginType } from 'embla-carousel';
+declare module 'embla-carousel' {
+    interface EmblaPluginsType {
+        autoScroll: AutoScrollType;
+    }
+    interface EmblaEventListType {
+        autoScrollPlay: 'autoScroll:play';
+        autoScrollStop: 'autoScroll:stop';
+    }
+}
+export type AutoScrollType = CreatePluginType<{
+    play: (delay?: number) => void;
+    stop: () => void;
+    reset: () => void;
+    isPlaying: () => boolean;
+}, OptionsType>;
+export type AutoScrollOptionsType = AutoScrollType['options'];
+declare function AutoScroll(userOptions?: AutoScrollOptionsType): AutoScrollType;
+declare namespace AutoScroll {
+    let globalOptions: AutoScrollOptionsType | undefined;
+}
+export default AutoScroll;

node_modules/embla-carousel-auto-scroll/esm/components/Options.d.ts

@@ -0,0 +1,13 @@
+import { CreateOptionsType } from 'embla-carousel';
+export type RootNodeType = null | ((emblaRoot: HTMLElement) => HTMLElement | null);
+export type OptionsType = CreateOptionsType<{
+    direction: 'forward' | 'backward';
+    speed: number;
+    startDelay: number;
+    playOnInit: boolean;
+    stopOnFocusIn: boolean;
+    stopOnInteraction: boolean;
+    stopOnMouseEnter: boolean;
+    rootNode: RootNodeType;
+}>;
+export declare const defaultOptions: OptionsType;

node_modules/embla-carousel-auto-scroll/esm/components/utils.d.ts

@@ -0,0 +1,3 @@
+import { EmblaCarouselType } from 'embla-carousel/components/EmblaCarousel';
+import { RootNodeType } from './Options.js';
+export declare function getAutoScrollRootNode(emblaApi: EmblaCarouselType, rootNode: RootNodeType): HTMLElement;

node_modules/embla-carousel-auto-scroll/esm/embla-carousel-auto-scroll.esm.js

@@ -0,0 +1,217 @@
+const defaultOptions = {
+  direction: 'forward',
+  speed: 2,
+  startDelay: 1000,
+  active: true,
+  breakpoints: {},
+  playOnInit: true,
+  stopOnFocusIn: true,
+  stopOnInteraction: true,
+  stopOnMouseEnter: false,
+  rootNode: null
+};
+
+function getAutoScrollRootNode(emblaApi, rootNode) {
+  const emblaRootNode = emblaApi.rootNode();
+  return rootNode && rootNode(emblaRootNode) || emblaRootNode;
+}
+
+function AutoScroll(userOptions = {}) {
+  let options;
+  let emblaApi;
+  let destroyed;
+  let startDelay;
+  let timerId = 0;
+  let autoScrollActive = false;
+  let mouseIsOver = false;
+  let defaultScrollBehaviour;
+  function init(emblaApiInstance, optionsHandler) {
+    emblaApi = emblaApiInstance;
+    const {
+      mergeOptions,
+      optionsAtMedia
+    } = optionsHandler;
+    const optionsBase = mergeOptions(defaultOptions, AutoScroll.globalOptions);
+    const allOptions = mergeOptions(optionsBase, userOptions);
+    options = optionsAtMedia(allOptions);
+    if (emblaApi.scrollSnapList().length <= 1) return;
+    startDelay = options.startDelay;
+    destroyed = false;
+    defaultScrollBehaviour = emblaApi.internalEngine().scrollBody;
+    const {
+      eventStore
+    } = emblaApi.internalEngine();
+    const isDraggable = !!emblaApi.internalEngine().options.watchDrag;
+    const root = getAutoScrollRootNode(emblaApi, options.rootNode);
+    if (isDraggable) {
+      emblaApi.on('pointerDown', pointerDown);
+    }
+    if (isDraggable && !options.stopOnInteraction) {
+      emblaApi.on('pointerUp', pointerUp);
+    }
+    if (options.stopOnMouseEnter) {
+      eventStore.add(root, 'mouseenter', mouseEnter);
+    }
+    if (options.stopOnMouseEnter && !options.stopOnInteraction) {
+      eventStore.add(root, 'mouseleave', mouseLeave);
+    }
+    if (options.stopOnFocusIn) {
+      emblaApi.on('slideFocusStart', stopAutoScroll);
+    }
+    if (options.stopOnFocusIn && !options.stopOnInteraction) {
+      eventStore.add(emblaApi.containerNode(), 'focusout', startAutoScroll);
+    }
+    if (options.playOnInit) startAutoScroll();
+  }
+  function destroy() {
+    emblaApi.off('pointerDown', pointerDown).off('pointerUp', pointerUp).off('slideFocusStart', stopAutoScroll).off('settle', settle);
+    stopAutoScroll();
+    destroyed = true;
+    autoScrollActive = false;
+  }
+  function startAutoScroll() {
+    if (destroyed) return;
+    if (autoScrollActive) return;
+    emblaApi.emit('autoScroll:play');
+    const engine = emblaApi.internalEngine();
+    const {
+      ownerWindow
+    } = engine;
+    timerId = ownerWindow.setTimeout(() => {
+      engine.scrollBody = createAutoScrollBehaviour(engine);
+      engine.animation.start();
+    }, startDelay);
+    autoScrollActive = true;
+  }
+  function stopAutoScroll() {
+    if (destroyed) return;
+    if (!autoScrollActive) return;
+    emblaApi.emit('autoScroll:stop');
+    const engine = emblaApi.internalEngine();
+    const {
+      ownerWindow
+    } = engine;
+    engine.scrollBody = defaultScrollBehaviour;
+    ownerWindow.clearTimeout(timerId);
+    timerId = 0;
+    autoScrollActive = false;
+  }
+  function createAutoScrollBehaviour(engine) {
+    const {
+      location,
+      previousLocation,
+      offsetLocation,
+      target,
+      scrollTarget,
+      index,
+      indexPrevious,
+      limit: {
+        reachedMin,
+        reachedMax,
+        constrain
+      },
+      options: {
+        loop
+      }
+    } = engine;
+    const directionSign = options.direction === 'forward' ? -1 : 1;
+    const noop = () => self;
+    let bodyVelocity = 0;
+    let scrollDirection = 0;
+    let rawLocation = location.get();
+    let rawLocationPrevious = 0;
+    let hasSettled = false;
+    function seek() {
+      let directionDiff = 0;
+      previousLocation.set(location);
+      bodyVelocity = directionSign * options.speed;
+      rawLocation += bodyVelocity;
+      location.add(bodyVelocity);
+      target.set(location);
+      directionDiff = rawLocation - rawLocationPrevious;
+      scrollDirection = Math.sign(directionDiff);
+      rawLocationPrevious = rawLocation;
+      const currentIndex = scrollTarget.byDistance(0, false).index;
+      if (index.get() !== currentIndex) {
+        indexPrevious.set(index.get());
+        index.set(currentIndex);
+        emblaApi.emit('select');
+      }
+      const reachedEnd = options.direction === 'forward' ? reachedMin(offsetLocation.get()) : reachedMax(offsetLocation.get());
+      if (!loop && reachedEnd) {
+        hasSettled = true;
+        const constrainedLocation = constrain(location.get());
+        location.set(constrainedLocation);
+        target.set(location);
+        stopAutoScroll();
+      }
+      return self;
+    }
+    const self = {
+      direction: () => scrollDirection,
+      duration: () => -1,
+      velocity: () => bodyVelocity,
+      settled: () => hasSettled,
+      seek,
+      useBaseFriction: noop,
+      useBaseDuration: noop,
+      useFriction: noop,
+      useDuration: noop
+    };
+    return self;
+  }
+  function pointerDown() {
+    if (!mouseIsOver) stopAutoScroll();
+  }
+  function pointerUp() {
+    if (!mouseIsOver) startAutoScrollOnSettle();
+  }
+  function mouseEnter() {
+    mouseIsOver = true;
+    stopAutoScroll();
+  }
+  function mouseLeave() {
+    mouseIsOver = false;
+    startAutoScroll();
+  }
+  function settle() {
+    emblaApi.off('settle', settle);
+    startAutoScroll();
+  }
+  function startAutoScrollOnSettle() {
+    emblaApi.on('settle', settle);
+  }
+  function play(startDelayOverride) {
+    if (typeof startDelayOverride !== 'undefined') {
+      startDelay = startDelayOverride;
+    }
+    startAutoScroll();
+  }
+  function stop() {
+    if (autoScrollActive) stopAutoScroll();
+  }
+  function reset() {
+    if (autoScrollActive) {
+      stopAutoScroll();
+      startAutoScrollOnSettle();
+    }
+  }
+  function isPlaying() {
+    return autoScrollActive;
+  }
+  const self = {
+    name: 'autoScroll',
+    options: userOptions,
+    init,
+    destroy,
+    play,
+    stop,
+    reset,
+    isPlaying
+  };
+  return self;
+}
+AutoScroll.globalOptions = undefined;
+
+export { AutoScroll as default };
+//# sourceMappingURL=embla-carousel-auto-scroll.esm.js.map

node_modules/embla-carousel-auto-scroll/esm/index.d.ts

@@ -0,0 +1,2 @@
+export { AutoScrollType, AutoScrollOptionsType } from './components/AutoScroll.js';
+export { default } from './components/AutoScroll.js';

node_modules/embla-carousel-auto-scroll/esm/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "embla-carousel-auto-scroll",
+  "version": "8.6.0",
+  "author": "David Jerleke",
+  "description": "An auto scroll plugin for Embla Carousel",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/davidjerleke/embla-carousel"
+  },
+  "bugs": {
+    "url": "https://github.com/davidjerleke/embla-carousel/issues"
+  },
+  "homepage": "https://www.embla-carousel.com",
+  "license": "MIT",
+  "keywords": [
+    "slider",
+    "carousel",
+    "slideshow",
+    "gallery",
+    "lightweight",
+    "touch",
+    "javascript",
+    "typescript",
+    "react",
+    "vue",
+    "svelte",
+    "solid"
+  ],
+  "types": "index.d.ts",
+  "sideEffects": false,
+  "files": [
+    "embla-carousel-auto-scroll*",
+    "components/**/*",
+    "index.d.ts"
+  ],
+  "devDependencies": {
+    "@types/jest": "^29.5.6",
+    "@typescript-eslint/eslint-plugin": "^6.9.0",
+    "@typescript-eslint/parser": "^6.9.0",
+    "eslint": "^8.52.0",
+    "eslint-config-prettier": "^9.0.0",
+    "eslint-plugin-prettier": "^4.0.0",
+    "jest": "^29.5.0",
+    "jest-environment-jsdom": "^29.5.0",
+    "prettier": "2.8.8",
+    "rollup": "^4.22.4",
+    "ts-jest": "^29.1.1",
+    "typescript": "^5.2.2"
+  },
+  "peerDependencies": {
+    "embla-carousel": "8.6.0"
+  },
+  "module": "embla-carousel-auto-scroll.esm.js",
+  "type": "module"
+}