document.addEventListener(
    'click',
    function (e) {
        if (!(e.target instanceof Element)) return;

        const title = e.target.closest(
            'section[component-id="1562998291"] .home-block-title'
        );

        if (!title) return;

        const rect = title.getBoundingClientRect();

        const clickedLeftSide =
            e.clientX >= rect.left &&
            e.clientX <= rect.left + rect.width * 0.45;

        if (!clickedLeftSide) return;

        e.preventDefault();
        e.stopImmediatePropagation();

        window.location.href =
            'https://camerapoint.store/%D8%A7%D9%84%D9%83%D8%A7%D9%85%D9%8A%D8%B1%D8%A7%D8%AA/c393965654';
    },
    true
);

document.addEventListener(
    'click',
    function (e) {
        if (!(e.target instanceof Element)) return;

        const title = e.target.closest(
            'section[component-id="1653455993"] .home-block-title'
        );

        if (!title) return;

        const rect = title.getBoundingClientRect();

        const clickedLeftSide =
            e.clientX >= rect.left &&
            e.clientX <= rect.left + rect.width * 0.45;

        if (!clickedLeftSide) return;

        e.preventDefault();
        e.stopImmediatePropagation();

        window.location.href =
            'https://camerapoint.store/%D8%B9%D8%B1%D8%B6-%D8%AC%D9%85%D9%8A%D8%B9-%D8%A7%D9%84%D9%85%D9%86%D8%AA%D8%AC%D8%A7%D8%AA/c1154303798';
    },
    true
);
(function () {

function setSecondImage(){

    if(!location.pathname.includes("/products/")) return;


    const slides = document.querySelectorAll(
        '.magnify-wrapper.swiper-slide'
    );


    if(slides.length > 1){

        const gallery = slides[1].closest('.swiper');

        if(gallery && gallery.swiper){

            gallery.swiper.slideTo(1,0);

        }else{

            slides[1].click();

        }

    }

}


window.addEventListener("load",()=>{

    setTimeout(setSecondImage,1200);

    setTimeout(setSecondImage,3000);

});


})();


/* CAMERA POINT — LIGHTWEIGHT STORE ENHANCEMENTS v1.0.0
   Paste this code into Salla Custom JavaScript, without <script> tags.
   Keep any unrelated JavaScript that your store already needs.
   No libraries, analytics, fetch calls, cart overrides or color changes.

   Options: set a feature to false below to switch it off.
   Gallery controls: Tab to a thumbnail, then use arrows, Home/End or Enter.
*/
(() => {
  'use strict';

  const VERSION = '1.0.0';
  const KEY = '__cameraPointStoreEnhancements';
  const OPTIONS = Object.freeze({
    refreshGalleries: true,
    keyboardThumbnails: true,
    imageLoadingHints: true,
    rememberListPosition: true,
    smoothScrolling: true,
    revealOnScroll: true
  });

  if (window[KEY]?.version === VERSION) return;
  if (typeof window[KEY]?.destroy === 'function') window[KEY].destroy();

  const GALLERY = 'salla-slider.details-slider';
  const CARD = 'custom-salla-product-card, salla-product-card, .product-card, .s-product-card-entry';
  const IMAGE = [
    `${GALLERY} img.product-single__slide-image`,
    `${GALLERY} img.product-single__thumb-image`,
    'custom-salla-product-card .product-card__image img',
    'salla-product-card .s-product-card-image img',
    '.product-card .product-card__image img',
    '.s-product-card-entry .s-product-card-image img'
  ].join(',');
  const STORAGE_KEY = 'camera-point:return-position:v1';
  const REVEAL = `${CARD}, .home-block-title, .s-block__title, .similar-products__header`;
  const galleries = new Map();
  const pendingGalleries = new Set();
  const pendingRoots = new Set();
  const handledImages = new WeakSet();
  const revealed = new WeakSet();
  const revealTargets = new Set();
  const changedAttributes = new Map();
  const cleanups = [];
  const timers = new Set();
  const reducedMotion = window.matchMedia('(prefers-reduced-motion: reduce)');
  let stopped = false;
  let started = false;
  let frame = 0;
  let scanTimer = 0;
  let resizeTimer = 0;
  let observer = null;
  let sizeObserver = null;
  let revealObserver = null;
  let restore = null;
  let restoreTimer = 0;

  function listen(target, name, handler, options) {
    target.addEventListener(name, handler, options);
    cleanups.push(() => target.removeEventListener(name, handler, options));
  }

  function later(callback, delay) {
    const id = window.setTimeout(() => {
      timers.delete(id);
      if (!stopped) callback();
    }, delay);
    timers.add(id);
    return id;
  }

  function cancelTimer(id) {
    window.clearTimeout(id);
    timers.delete(id);
  }

  function attribute(element, name, value) {
    const next = value === null ? null : String(value);
    if (element.getAttribute(name) === next) return;
    let changes = changedAttributes.get(element);
    if (!changes) changedAttributes.set(element, changes = new Map());
    const change = changes.get(name) || { before: element.getAttribute(name), after: null };
    change.after = next;
    changes.set(name, change);
    if (next === null) element.removeAttribute(name);
    else element.setAttribute(name, next);
  }

  function all(root, selector) {
    const items = [];
    if (root instanceof Element && root.matches(selector)) items.push(root);
    if (root.querySelectorAll) items.push(...root.querySelectorAll(selector));
    return items;
  }

  function swiper(element) {
    const instance = element?.swiper;
    return instance && !instance.destroyed && instance.initialized !== false ? instance : null;
  }

  function mainElement(host) {
    return host.querySelector(':scope > .s-slider-container');
  }

  function thumbnailSlides(host) {
    return [...host.querySelectorAll('.s-slider-thumbs-container > .swiper-wrapper > .swiper-slide')];
  }

  function syncThumbnailAccess(host) {
    if (!OPTIONS.keyboardThumbnails) return;
    const slides = thumbnailSlides(host);
    const active = slides.findIndex(el => el.classList.contains('swiper-slide-thumb-active'));
    const arabic = document.documentElement.lang.toLowerCase().startsWith('ar');
    slides.forEach((slide, index) => {
      // Native links/buttons already have keyboard behavior; leave them alone.
      if (slide.matches('a, button') || slide.querySelector('a, button, input, select, textarea, [contenteditable]')) return;
      if (slide.hasAttribute('role') && !['group', 'button'].includes(slide.getAttribute('role'))) return;
      const img = slide.querySelector('img');
      if (!img) return;
      attribute(slide, 'data-cp-gallery-thumb', '');
      attribute(slide, 'role', 'button');
      attribute(slide, 'tabindex', index === Math.max(0, active) ? '0' : '-1');
      attribute(slide, 'aria-current', index === active ? 'true' : null);
      const label = arabic ? `عرض الصورة ${index + 1} من ${slides.length}` : `View image ${index + 1} of ${slides.length}`;
      attribute(slide, 'aria-label', `${label}${img.alt ? ': ' + img.alt : ''}`);
    });
  }

  function bindSlideEvents(host, state, main) {
    if (state.main === main) return;
    if (state.main && typeof state.main.off === 'function') state.main.off('slideChange', state.onSlide);
    state.main = main;
    if (main && typeof main.on === 'function') main.on('slideChange', state.onSlide);
  }

  function queueGallery(host, force = false) {
    const state = galleries.get(host);
    if (stopped || !state) return;
    state.force ||= force;
    pendingGalleries.add(host);
    if (frame) return;
    frame = requestAnimationFrame(() => {
      frame = 0;
      const work = [...pendingGalleries];
      pendingGalleries.clear();
      for (const gallery of work) refreshGallery(gallery);
    });
  }

  function refreshGallery(host) {
    const state = galleries.get(host);
    if (!state || !host.isConnected) return;
    const mainNode = mainElement(host);
    const thumbNode = host.querySelector('.s-slider-thumbs-container');
    const main = swiper(mainNode);
    const thumbs = swiper(thumbNode);
    const changedInstance = main !== state.main || thumbs !== state.thumbs;
    bindSlideEvents(host, state, main);
    state.thumbs = thumbs;
    syncThumbnailAccess(host);
    if (!mainNode || mainNode.clientWidth === 0 || mainNode.clientHeight === 0) return;
    const signature = [mainNode.clientWidth, mainNode.clientHeight, thumbNode?.clientWidth || 0,
      thumbNode?.clientHeight || 0, thumbnailSlides(host).length].join(':');
    const needsUpdate = state.force || changedInstance || signature !== state.signature;
    state.signature = signature;
    state.force = false;
    if (!OPTIONS.refreshGalleries || !needsUpdate) return;
    // Use the theme's instances, preserving its listeners, selected image and controls.
    for (const instance of [thumbs, main]) {
      if (typeof instance?.update === 'function') {
        try { instance.update(); } catch { /* A component may be unmounting. */ }
      }
    }
    syncThumbnailAccess(host);
  }

  function registerGallery(host) {
    if (!galleries.has(host)) {
      const state = { main: null, thumbs: null, signature: '', force: true,
        onSlide: () => { syncThumbnailAccess(host); queueGallery(host); } };
      galleries.set(host, state);
      sizeObserver?.observe(host);
    }
    queueGallery(host);
  }

  function cleanDetached() {
    for (const [host, state] of galleries) {
      if (host.isConnected) continue;
      sizeObserver?.unobserve(host);
      if (typeof state.main?.off === 'function') state.main.off('slideChange', state.onSlide);
      galleries.delete(host);
      pendingGalleries.delete(host);
    }
    for (const element of changedAttributes.keys()) {
      if (!element.isConnected) changedAttributes.delete(element);
    }
    for (const element of revealTargets) {
      if (!element.isConnected) { revealObserver?.unobserve(element); revealTargets.delete(element); }
    }
  }

  function prepareReveal(element) {
    if (!revealObserver || revealed.has(element) || revealTargets.has(element)) return;
    // Animate the outer card only, never its nested card wrapper or initial content.
    if (element.parentElement?.closest(CARD)) return;
    if (element.closest('[hidden], [aria-hidden="true"], .hidden, .is-hidden')) return;
    const box = element.getBoundingClientRect();
    if (box.width <= 0 || box.height <= 0) return;
    if (box.top < innerHeight && box.bottom > 0 && box.left < innerWidth && box.right > 0) {
      revealed.add(element);
      return;
    }
    revealTargets.add(element);
    revealObserver.observe(element);
  }

  function hintImage(img) {
    if (!OPTIONS.imageLoadingHints || handledImages.has(img)) return;
    // Never replace src/srcset/data-src or interfere with Salla's lazy loader.
    if (!img.hasAttribute('decoding')) attribute(img, 'decoding', 'async');
    if (img.complete && img.naturalWidth > 0) { handledImages.add(img); return; }
    const box = img.getBoundingClientRect();
    if (box.width <= 0 || box.height <= 0) return;
    handledImages.add(img);
    const host = img.closest(GALLERY);
    const main = host && mainElement(host)?.querySelector('img.product-single__slide-image');
    if (img === main && box.bottom > 0 && box.top < innerHeight) {
      if (!img.hasAttribute('fetchpriority')) attribute(img, 'fetchpriority', 'high');
      if (!img.hasAttribute('loading')) attribute(img, 'loading', 'eager');
    } else if (!img.hasAttribute('loading') && !img.hasAttribute('fetchpriority') &&
      (box.top > innerHeight + 500 || box.left > innerWidth + 500 || box.right < -500)) {
      attribute(img, 'loading', 'lazy');
    }
  }

  function scan(root) {
    if (stopped || (root instanceof Element && !root.isConnected)) return;
    all(root, GALLERY).forEach(registerGallery);
    all(root, IMAGE).forEach(hintImage);
    if (OPTIONS.revealOnScroll) all(root, REVEAL).forEach(prepareReveal);
    const owner = root instanceof Element ? root.closest(GALLERY) : null;
    if (owner) registerGallery(owner);
  }

  function queueScan(root) {
    pendingRoots.add(root);
    if (scanTimer) return;
    scanTimer = later(() => {
      scanTimer = 0;
      const roots = new Set(pendingRoots);
      pendingRoots.clear();
      for (const item of roots) {
        let covered = false;
        for (let parent = item.parentNode; parent; parent = parent.parentNode) {
          if (roots.has(parent)) { covered = true; break; }
        }
        if (!covered) scan(item);
      }
      cleanDetached();
      scheduleRestore();
    }, 80);
  }

  function selectThumbnail(host, slide, index) {
    const main = swiper(mainElement(host));
    const speed = reducedMotion.matches ? 0 : undefined;
    if (main && typeof main.slideTo === 'function') {
      if (main.params?.loop && typeof main.slideToLoop === 'function') main.slideToLoop(index, speed);
      else main.slideTo(index, speed);
    } else {
      slide.click();
    }
    const rail = host.querySelector('.s-slider-thumbs-container');
    const thumbs = swiper(rail);
    if (rail && typeof thumbs?.slideTo === 'function') {
      const a = slide.getBoundingClientRect(), b = rail.getBoundingClientRect();
      if (a.top < b.top || a.bottom > b.bottom || a.left < b.left || a.right > b.right) thumbs.slideTo(index, speed);
    }
    syncThumbnailAccess(host);
    slide.focus({ preventScroll: true });
  }

  function onKey(event) {
    if (!OPTIONS.keyboardThumbnails || event.defaultPrevented || event.altKey || event.ctrlKey || event.metaKey) return;
    const target = event.target instanceof Element ? event.target : null;
    const slide = target?.closest('[data-cp-gallery-thumb]');
    if (!slide || target.closest('input, textarea, select, [contenteditable]')) return;
    const host = slide.closest(GALLERY);
    if (!host) return;
    const slides = thumbnailSlides(host);
    const index = slides.indexOf(slide);
    const vertical = !!host.querySelector('.s-slider-thumbs-container.swiper-vertical');
    const rtl = getComputedStyle(host.querySelector('.s-slider-thumbs-container')).direction === 'rtl';
    let next = index;
    if (event.key === 'Home') next = 0;
    else if (event.key === 'End') next = slides.length - 1;
    else if (vertical && event.key === 'ArrowDown') next++;
    else if (vertical && event.key === 'ArrowUp') next--;
    else if (!vertical && event.key === 'ArrowRight') next += rtl ? -1 : 1;
    else if (!vertical && event.key === 'ArrowLeft') next += rtl ? 1 : -1;
    else if (event.key !== 'Enter' && event.key !== ' ') return;
    next = Math.max(0, Math.min(slides.length - 1, next));
    if (!slides[next]?.hasAttribute('data-cp-gallery-thumb')) return;
    event.preventDefault();
    event.stopPropagation();
    selectThumbnail(host, slides[next], next);
  }

  function pageKey() { return location.pathname + location.search; }
  function removeSaved() { try { sessionStorage.removeItem(STORAGE_KEY); } catch {} }

  function rememberPosition(event) {
    if (!OPTIONS.rememberListPosition || event.defaultPrevented || event.button !== 0 ||
      event.metaKey || event.ctrlKey || event.shiftKey || event.altKey || location.hash) return;
    const link = event.target instanceof Element ? event.target.closest('a[href]') : null;
    const card = link?.closest(CARD);
    if (!link || !card || link.hasAttribute('download') || (link.target && link.target !== '_self')) return;
    let url;
    try { url = new URL(link.href, location.href); } catch { return; }
    if (url.origin !== location.origin || !/\/p\d+(?:\/|$)/.test(url.pathname)) return;
    const saved = { page: pageKey(), product: url.pathname, id: card.id || '',
      y: scrollY, offset: card.getBoundingClientRect().top, time: Date.now() };
    try { sessionStorage.setItem(STORAGE_KEY, JSON.stringify(saved)); } catch { /* Storage can be disabled. */ }
  }

  function cancelRestore() {
    if (!restore) return;
    restore = null;
    cancelTimer(restoreTimer);
    restoreTimer = 0;
    removeSaved();
  }

  function beginRestore(event) {
    if (!OPTIONS.rememberListPosition || location.hash) return;
    // Let the browser handle its back/forward cache and native scroll restoration.
    if (event?.persisted) return;
    if (performance.getEntriesByType('navigation')[0]?.type !== 'back_forward') return;
    let saved;
    try { saved = JSON.parse(sessionStorage.getItem(STORAGE_KEY) || 'null'); } catch { return; }
    if (!saved || saved.page !== pageKey() || !Number.isFinite(saved.y) || saved.y < 150 ||
      !Number.isFinite(saved.offset) || typeof saved.product !== 'string' ||
      !Number.isFinite(saved.time) || Date.now() - saved.time > 30 * 60 * 1000) return;
    restore = { saved, deadline: Date.now() + 4000 };
    scheduleRestore();
  }

  function scheduleRestore() {
    if (!restore || restoreTimer) return;
    restoreTimer = later(() => {
      restoreTimer = 0;
      if (!restore) return;
      if (scrollY > 4 || Date.now() > restore.deadline) { cancelRestore(); return; }
      const saved = restore.saved;
      let card = saved.id ? document.getElementById(saved.id) : null;
      const matches = el => !!el?.matches(CARD) && [...el.querySelectorAll('a[href]')].some(a => {
        try { const url = new URL(a.href, location.href); return url.origin === location.origin && url.pathname === saved.product; } catch { return false; }
      });
      if (!matches(card)) card = [...document.querySelectorAll(CARD)].find(matches);
      if (card && card.getClientRects().length && card.getBoundingClientRect().height > 0) {
        const y = Math.max(0, scrollY + card.getBoundingClientRect().top - saved.offset);
        // Restore only a product already present; never request extra product pages.
        if (y <= document.documentElement.scrollHeight - innerHeight + 4) {
          window.scrollTo({ top: y, left: scrollX, behavior: 'instant' });
          cancelRestore();
          return;
        }
      }
      scheduleRestore();
    }, 250);
  }

  function start() {
    if (started || stopped) return;
    started = true;
    if (OPTIONS.smoothScrolling) attribute(document.documentElement, 'data-cp-smooth-scroll', '');
    if (OPTIONS.revealOnScroll && typeof window.IntersectionObserver === 'function') {
      revealObserver = new IntersectionObserver(entries => {
        for (const entry of entries) {
          if (!entry.isIntersecting) continue;
          const element = entry.target;
          revealObserver.unobserve(element);
          revealTargets.delete(element);
          revealed.add(element);
          if (reducedMotion.matches) continue;
          attribute(element, 'data-cp-reveal', 'animate');
          later(() => attribute(element, 'data-cp-reveal', null), 650);
        }
      }, { threshold: 0.08, rootMargin: '0px 0px -24px 0px' });
    }
    if (typeof window.ResizeObserver === 'function') sizeObserver = new ResizeObserver(entries => {
      for (const entry of entries) queueGallery(entry.target);
    });
    scan(document);
    observer = new MutationObserver(records => {
      for (const record of records) {
        const owner = record.target instanceof Element ? record.target.closest(GALLERY) : null;
        if (owner) queueScan(owner);
        for (const node of record.addedNodes) if (node instanceof Element) queueScan(node);
        if (record.removedNodes.length && record.target instanceof Element) queueScan(record.target);
      }
    });
    observer.observe(document.body, { childList: true, subtree: true });
    listen(document, 'keydown', onKey);
    listen(document, 'click', rememberPosition);
    listen(document, 'click', event => {
      const host = event.target instanceof Element ? event.target.closest(GALLERY) : null;
      if (host) queueGallery(host);
    });
    listen(document, 'load', event => {
      const host = event.target instanceof Element ? event.target.closest(GALLERY) : null;
      if (host) { registerGallery(host); queueGallery(host, true); }
    }, true);
    listen(window, 'resize', () => {
      cancelTimer(resizeTimer);
      resizeTimer = later(() => galleries.forEach((_, host) => queueGallery(host)), 150);
    }, { passive: true });
    listen(window, 'pageshow', event => {
      galleries.forEach((_, host) => queueGallery(host, true));
      beginRestore(event);
    });
    for (const name of ['wheel', 'touchstart', 'pointerdown', 'keydown']) {
      listen(window, name, cancelRestore, { passive: true, capture: true });
    }
    listen(document, 'theme::ready', () => queueScan(document.body));
    // Bounded retries cover a slider whose instance attaches after its markup.
    for (const delay of [300, 1200]) later(() => galleries.forEach((_, host) => queueGallery(host)), delay);
    if (document.readyState === 'complete') later(() => beginRestore(), 0);
  }

  function destroy() {
    stopped = true;
    observer?.disconnect();
    sizeObserver?.disconnect();
    revealObserver?.disconnect();
    cancelAnimationFrame(frame);
    timers.forEach(id => window.clearTimeout(id));
    timers.clear();
    cleanups.forEach(cleanup => cleanup());
    for (const state of galleries.values()) if (typeof state.main?.off === 'function') state.main.off('slideChange', state.onSlide);
    for (const [element, changes] of changedAttributes) for (const [name, change] of changes) {
      if (element.getAttribute(name) !== change.after) continue;
      if (change.before === null) element.removeAttribute(name);
      else element.setAttribute(name, change.before);
    }
    changedAttributes.clear();
    galleries.clear();
    pendingRoots.clear();
    pendingGalleries.clear();
    revealTargets.clear();
    if (window[KEY]?.destroy === destroy) delete window[KEY];
  }

  window[KEY] = Object.freeze({ version: VERSION, options: OPTIONS, destroy });
  if (document.readyState === 'loading') listen(document, 'DOMContentLoaded', start, { once: true });
  else start();
})();