(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 orichiLimitGetVariants = () => {
  return new Promise((resolve) => {
    const cache = "?v=";
    $.ajax({
      url: "/cart.json" + cache,
      type: "GET",
      async: false,
      dataType: "json",
      success: (res) => {
        resolve({
          ProductID: res.items == void 0 ? [] : res.items.map((a) => a.product_id),
          ProductTitle: res.items == void 0 ? [] : res.items.map((a) => a.product_title),
          Variants: res.items == void 0 ? [] : res.items.map((a) => a.id),
          Quantities: res.items == void 0 ? [] : res.items.map((a) => a.quantity),
          Prices: res.items == void 0 ? [] : res.items.map((a) => a.price / 100),
          OriginalPrices: res.items == void 0 ? [] : res.items.map((a) => a.original_price / 100),
          FinalPrices: res.items == void 0 ? [] : res.items.map((a) => a.final_price / 100),
          Grams: res.items == void 0 ? [] : res.items.map((a) => a.grams),
          shopid: __st.a,
          token: res.token,
          shop: Shopify.shop,
          customerEmail: $(".OrichiCustomerEmail").val(),
          customerTags: $(".OrichiCustomerTags").val(),
          DiscountShopify: res.cart_level_discount_applications,
          Note: res.note == void 0 || res.note == null ? "" : res.note,
          ListItems: res.items,
          Totalprice: res.total_price / 100,
          OriginalTotalprice: res.original_total_price / 100,
          Attributes: Object.keys(res.attributes == null ? {} : res.attributes).map((key) => {
            return key + "|||" + res.attributes[key];
          }).join("???"),
          Properties: (res.items == void 0 ? [] : res.items.map((a) => a.properties)).map(
            (p) => Object.keys(p == null ? {} : p).map((key) => {
              return key + "|||" + p[key];
            }).join("???")
          )
        });
      }
    });
  });
};
const parameter = () => {
  var _a;
  const parameters = ((_a = window.orichiLimit) == null ? void 0 : _a.parameters) ?? [];
  const parameterCache = /* @__PURE__ */ new Map();
  const findParameter = (key) => {
    if (parameterCache.has(key)) {
      return parameterCache.get(key);
    }
    const param = parameters.find((p) => p.Key === key);
    parameterCache.set(key, param);
    return param;
  };
  const getValue = (key) => {
    var _a2;
    return (_a2 = findParameter(key)) == null ? void 0 : _a2.Value;
  };
  const checkValue = (key, value) => {
    var _a2;
    return ((_a2 = findParameter(key)) == null ? void 0 : _a2.Value) === value;
  };
  const getValueIfMatches = (key, value) => {
    const paramValue = getValue(key);
    return paramValue === value ? paramValue : void 0;
  };
  return {
    getValue,
    checkValue,
    getValueIfMatches
  };
};
const initParameter = () => {
  const { getValue } = parameter();
  if (getValue("All-Css-Custom")) {
    const styleElement = document.createElement("style");
    styleElement.textContent = getValue("All-Css-Custom");
    document.head.appendChild(styleElement);
  }
  if (getValue("All-Js-Custom")) {
    const scriptElement = document.createElement("script");
    scriptElement.textContent = getValue("All-Js-Custom");
    document.head.appendChild(scriptElement);
  }
};
const SELECTOR_CONFIG = [
  {
    key: "QUANTITY_INPUT",
    append: "All_QUANTITY_INPUT_APPEND",
    override: "All_QUANTITY_INPUT_OVR"
  },
  {
    key: "ORICHI_BUTTON_IN_FORM_CART",
    append: "All_BUTTON_IN_FORM_CART_APPEND",
    override: "All_BUTTON_IN_FORM_CART_OVR"
  },
  {
    key: "ORICHI_VARIANT_SELECTOR",
    append: "All_VARIANT_SELECTOR_APPEND",
    override: "All_VARIANT_SELECTOR_OVR"
  },
  {
    key: "ORICHI_BUTTON_CHECKOUT",
    append: "All_BUTTON_CHECKOUT_APPEND",
    override: "All_BUTTON_CHECKOUT_OVR"
  },
  {
    key: "ORICHI_BUTTON_PLUS_MINUS",
    append: "All_BUTTON_PLUS_MINUS_APPEND",
    override: "All_BUTTON_PLUS_MINUS_OVR"
  },
  {
    key: "CART_REMOVE_BUTTON",
    append: "All_REMOVE_BUTTON_APPEND",
    override: "All_REMOVE_BUTTON_OVR"
  },
  {
    key: "ORICHI_CART_POPUP_SELECTOR",
    append: "All_CART_POPUP_SELECTOR_APPEND",
    override: "All_CART_POPUP_SELECTOR_OVR"
  },
  {
    key: "ORICHI_DISABLE_BUTTON_APP_IF_LIMITED",
    append: "All_DISABLE_BUTTON_APP_IF_LIMITED_APPEND",
    override: "All_DISABLE_BUTTON_APP_IF_LIMITED_OVR"
  }
];
const overrideSelector = () => {
  const { getValue } = parameter();
  SELECTOR_CONFIG.forEach(({ key, append, override }) => {
    const appendValue = getValue(append);
    const overrideValue = getValue(override);
    if (appendValue) {
      SELECTOR_ELEMENT.appendSelector(key, appendValue);
    }
    if (overrideValue) {
      SELECTOR_ELEMENT.setSelector(key, overrideValue);
    }
  });
};
const overrideApi = async (func) => {
  let isProcessing = false;
  let timeoutId = null;
  const handleCartUpdate = () => {
    if (isProcessing) return;
    isProcessing = true;
    if (timeoutId) clearTimeout(timeoutId);
    timeoutId = setTimeout(async () => {
      await func();
      isProcessing = false;
    }, 100);
  };
  try {
    const originalOpen = XMLHttpRequest.prototype.open;
    XMLHttpRequest.prototype.open = function(...args) {
      this.addEventListener("loadend", function() {
        if (this._url && this._url.search(/cart\/add|cart\/change/) >= 0 && this._method && this._method.toUpperCase() !== "GET") {
          handleCartUpdate();
        }
      });
      originalOpen.apply(this, args);
    };
  } catch (error) {
    console.error("Error overriding XMLHttpRequest:", error);
  }
  try {
    const originalFetch = fetch;
    window.fetch = function(input, init) {
      const isCartUpdate = typeof input.search === "function" && (input.search(/cart\/add|cart\/change/) >= 0 || input.search("/api/2023-07/graphql.json") >= 0) && input.search("ba_request") < 0;
      const isPostOrPut = init && ["POST", "PUT"].includes((init.method || "").toUpperCase());
      const response = originalFetch(input, init);
      if (isCartUpdate && isPostOrPut) {
        response.then(() => {
          handleCartUpdate();
        });
      }
      return response;
    };
  } catch (error) {
    console.error("Error overriding fetch:", error);
  }
  if (typeof ShopifyAPI !== "undefined" && ShopifyAPI.changeItem && !ShopifyAPI.changeItem.toString().includes("func")) {
    const originalChangeItem = ShopifyAPI.changeItem;
    ShopifyAPI.changeItem = function(line, quantity, callback) {
      originalChangeItem(line, quantity, (...args) => {
        callback(...args);
        handleCartUpdate();
      });
    };
  }
};
const TargetEnum = {
  CART: "cart",
  PRODUCT: "product",
  COLLECTION: "collection",
  VARIANT: "variant",
  PRODUCT_TAG: "product_tag"
};
const ValidationRuleEnum = {
  MINIMUM_QUANTITY: "minimum_quantity",
  MAXIMUM_QUANTITY: "maximum_quantity",
  MINIMUM_VALUE: "minimum_value",
  MAXIMUM_VALUE: "maximum_value",
  SPECIFIC_QUANTITY: "specific_quantity",
  MULTIPLES: "multiples"
};
const calculateTagQuantityOrValue = (currentLimit, fieldInCartJson) => {
  const isFieldQuantity = fieldInCartJson === "quantity";
  const productTagsInCart = window.orichiLimit.cart;
  const cartItems = window.orichiLimit.cartItems;
  const value = productTagsInCart.reduce((sum, itemInCartLiquid) => {
    const matchingProduct = cartItems.ListItems.find(
      (item) => item.product_id === itemInCartLiquid.productId
    );
    if (matchingProduct && itemInCartLiquid.tags.some((tag) => {
      var _a;
      return (_a = currentLimit == null ? void 0 : currentLimit.ProductTags) == null ? void 0 : _a.includes(tag);
    })) {
      return sum + (isFieldQuantity ? matchingProduct.quantity : matchingProduct.discounted_price * matchingProduct.quantity);
    }
    return sum;
  }, 0);
  return isFieldQuantity ? value : value / 100;
};
const html = String.raw;
const getMultiplesQuantity = (currentQuantity, value) => {
  return currentQuantity % value === 0;
};
const wait = (time) => {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve();
    }, time);
  });
};
const removeDuplicateErrors = (errors) => {
  return Array.from(new Set(errors.map(JSON.stringify))).map(JSON.parse);
};
const calculateValueInCart = () => {
  const listItems = window.orichiLimit.cartItems.ListItems;
  return listItems.reduce((sum, item) => sum + item.discounted_price * item.quantity, 0) / 100;
};
const validateRule = (rule, totalQuantity, currentLimit) => {
  const totalQuantityTag = calculateTagQuantityOrValue(currentLimit, "quantity");
  const totalTagValueInCart = calculateTagQuantityOrValue(currentLimit, "discounted_price");
  const totalValueInCart = calculateValueInCart();
  const { Type, Value } = rule;
  const numericValue = parseFloat((Value * Number(window.Shopify.currency.rate)).toFixed(2));
  const isTagTarget = currentLimit.Target === TargetEnum.PRODUCT_TAG;
  const quantity = isTagTarget ? totalQuantityTag : totalQuantity;
  const value = isTagTarget ? totalTagValueInCart : totalValueInCart;
  switch (Type) {
    case ValidationRuleEnum.MINIMUM_QUANTITY:
      return quantity < numericValue ? { type: Type, value: Value } : null;
    case ValidationRuleEnum.MAXIMUM_QUANTITY:
      return quantity > numericValue ? { type: Type, value: Value } : null;
    case ValidationRuleEnum.MINIMUM_VALUE:
      return value < numericValue ? { type: Type, value: Value } : null;
    case ValidationRuleEnum.MAXIMUM_VALUE:
      return value > numericValue ? { type: Type, value: Value } : null;
    case ValidationRuleEnum.MULTIPLES:
      $(SELECTOR_ELEMENT.QUANTITY_INPUT).attr("step", numericValue);
      return !getMultiplesQuantity(totalQuantity, numericValue) ? { type: Type, value: Value } : null;
    case ValidationRuleEnum.SPECIFIC_QUANTITY:
      return quantity !== numericValue ? { type: Type, value: Value } : null;
    default:
      return null;
  }
};
const Validation = async ({ currentLimit, totalQuantity }) => {
  if (!currentLimit) return;
  const errors = currentLimit.ValidationRules.map(
    (rule) => validateRule(rule, totalQuantity, currentLimit)
  ).filter((error) => error !== null).map((error) => {
    var _a;
    return {
      ...error,
      messageCheckoutPage: ((_a = currentLimit.AlertMessages) == null ? void 0 : _a[0].Value) || ""
    };
  });
  return { errors, currentLimit };
};
const findProductInLimit = (currentProductId, target) => {
  var _a;
  var limits = window.orichiLimit.limits;
  let productTags = (_a = window.orichiLimit.currentProduct) == null ? void 0 : _a.tags;
  const cartLiquid = window.orichiLimit.cart;
  const productTagsInCart = cartLiquid.find(
    (item) => item.productId === parseInt(currentProductId)
  );
  if (productTagsInCart && !productTags) {
    productTags = productTagsInCart.tags;
  }
  if (window.Shopify.shop == "fluwelcom.myshopify.com" && limits) {
    limits = limits.sort(
      (a, b) => parseInt(a.ValidationRules[0].Value) - parseInt(b.ValidationRules[0].Value)
    );
  }
  const targetProducts = limits.find(
    (limit) => limit.ShopifyObjects.some((obj) => obj.Id === parseInt(currentProductId)) && limit.Status
  );
  if (target === TargetEnum.PRODUCT_TAG) {
    const targetTags = limits.find(
      (limit) => {
        var _a2;
        return ((_a2 = limit == null ? void 0 : limit.ProductTags) == null ? void 0 : _a2.some((tag) => productTags == null ? void 0 : productTags.includes(tag))) && limit.Status;
      }
    );
    return targetProducts || targetTags;
  }
  return targetProducts;
};
const ModalError = (allErrors) => {
  $("<div/>", {
    id: "error-modal",
    html: html`
      <div class="modal-content">
        <ul class="list-error">
          ${allErrors == null ? void 0 : allErrors.map((error) => `<li>${error.messageCheckoutPage}</li>`).join("")}
        </ul>
        <button id="close-modal">
          <svg
            width="20"
            height="20"
            viewBox="0 0 20 20"
            fill="none"
            xmlns="http://www.w3.org/2000/svg"
          >
            <path
              d="M13.9697 15.0303C14.2626 15.3232 14.7374 15.3232 15.0303 15.0303C15.3232 14.7374 15.3232 14.2626 15.0303 13.9697L11.0607 10L15.0303 6.03033C15.3232 5.73744 15.3232 5.26256 15.0303 4.96967C14.7374 4.67678 14.2626 4.67678 13.9697 4.96967L10 8.93934L6.03033 4.96967C5.73744 4.67678 5.26256 4.67678 4.96967 4.96967C4.67678 5.26256 4.67678 5.73744 4.96967 6.03033L8.93934 10L4.96967 13.9697C4.67678 14.2626 4.67678 14.7374 4.96967 15.0303C5.26256 15.3232 5.73744 15.3232 6.03033 15.0303L10 11.0607L13.9697 15.0303Z"
              fill="#4A4A4A"
            />
          </svg>
        </button>
      </div>
    `
  }).appendTo("body").hide();
};
const TEXT = {
  ORDER_INVALID: "Order is not valid"
};
let buttonCheckoutInterval;
const handleButtonCheckout = (errors) => {
  const buttonCheckout = $(SELECTOR_ELEMENT.ORICHI_BUTTON_CHECKOUT);
  const existingCloneElement = $(".orichi-limit-modal-error");
  if (errors.length > 0 && buttonCheckout.length && !existingCloneElement.length) {
    const cloneElement = $("<button>").text(TEXT.ORDER_INVALID).attr("class", buttonCheckout.attr("class") + " orichi-limit-modal-error").on("click", function() {
      $("#error-modal").css("display", "flex");
      $("body").css("overflow", "hidden");
    });
    buttonCheckout.hide().after(cloneElement);
  }
};
const updateErrorDisplay$1 = (errors, isFirstRender2 = false) => {
  const { getValue } = parameter();
  const shouldCheckButtonInterval = getValue("CART_BUTTON_CHECKOUT_CHECK_INTERVAL");
  const checkButtonDelay = getValue("CART_BUTTON_CHECKOUT_DELAY_CHECK_INTERVAL");
  if (buttonCheckoutInterval) {
    clearInterval(buttonCheckoutInterval);
  }
  if (errors.length > 0) {
    const existingModal = $("#error-modal");
    if (!existingModal.length) {
      ModalError(errors);
      $("#close-modal").on("click", function() {
        $("#error-modal").css("display", "none");
        $("body").css("overflow", "auto");
      });
    } else {
      existingModal.find(".list-error").html(errors.map((error) => `<li>${error.messageCheckoutPage}</li>`).join(""));
    }
    if (!isFirstRender2) {
      $("#error-modal").css("display", "flex");
      $("body").css("overflow", "hidden");
    }
    if (shouldCheckButtonInterval) {
      buttonCheckoutInterval = setInterval(() => {
        handleButtonCheckout(errors);
      }, checkButtonDelay || 500);
      return;
    }
    handleButtonCheckout(errors);
  } else {
    if (buttonCheckoutInterval) {
      clearInterval(buttonCheckoutInterval);
    }
    const existingModal = $("#error-modal");
    existingModal.remove();
    const existingCloneElement = $(".orichi-limit-modal-error");
    const buttonCheckout = $(SELECTOR_ELEMENT.ORICHI_BUTTON_CHECKOUT);
    if (existingCloneElement.length) {
      existingCloneElement.remove();
      buttonCheckout.show();
      buttonCheckout.attr("disabled", false);
    }
  }
};
const validateCartItems = async (isFirstRender2 = false) => {
  const cartItems = window.orichiLimit.cartItems;
  const { totalProductQuantities, totalVariantQuantities } = calculateTotalQuantities(cartItems);
  const allErrors = await validateAllItems(
    cartItems,
    totalProductQuantities,
    totalVariantQuantities
  );
  updateErrorDisplay$1(allErrors, isFirstRender2);
};
const calculateTotalQuantities = (cartItems) => {
  const totalProductQuantities = {};
  const totalVariantQuantities = {};
  for (const item of cartItems.ListItems) {
    const { product_id, variant_id, quantity } = item;
    totalProductQuantities[product_id] = (totalProductQuantities[product_id] || 0) + quantity;
    totalVariantQuantities[variant_id] = (totalVariantQuantities[variant_id] || 0) + quantity;
  }
  return { totalProductQuantities, totalVariantQuantities };
};
const validateAllItems = async (cartItems, totalProductQuantities, totalVariantQuantities) => {
  const allErrors = [];
  for (const item of cartItems.ListItems) {
    const { product_id, variant_id, product_title, variant_title } = item;
    const itemErrors = await validateItem(
      product_id,
      variant_id,
      product_title,
      variant_title,
      totalProductQuantities,
      totalVariantQuantities
    );
    allErrors.push(...itemErrors);
  }
  return removeDuplicateErrors(allErrors);
};
const validateItem = async (productId, variantId, product_title, variant_title, totalProductQuantities, totalVariantQuantities) => {
  const cartPage = __st.p === "cart";
  const itemErrors = [];
  const totalQuantityProduct = Object.values(totalProductQuantities).reduce(
    (acc, curr) => acc + curr,
    0
  );
  const productLimit = findProductInLimit(productId, cartPage ? TargetEnum.PRODUCT_TAG : void 0);
  if (productLimit) {
    const { errors: productErrors } = await Validation({
      currentLimit: productLimit,
      totalQuantity: totalProductQuantities[productId]
    });
    productErrors.forEach((e) => {
      e.messageCheckoutPage = e.messageCheckoutPage.replaceAll("{product_name}", product_title).replaceAll("{variant_name}", variant_title).replaceAll("{quantity}", e.value);
    });
    itemErrors.push(...productErrors);
  }
  const variantLimit = findProductInLimit(variantId, cartPage ? TargetEnum.PRODUCT_TAG : void 0);
  if (variantLimit) {
    const { errors: variantErrors } = await Validation({
      currentLimit: variantLimit,
      totalQuantity: totalVariantQuantities[variantId]
    });
    variantErrors.forEach((e) => {
      e.messageCheckoutPage = e.messageCheckoutPage.replaceAll("{product_name}", product_title).replaceAll("{variant_name}", variant_title).replaceAll("{quantity}", e.value);
    });
    itemErrors.push(...variantErrors);
  }
  const targetOrder = window.orichiLimit.limits.find(
    (limit) => limit.Status && limit.Target === TargetEnum.CART
  );
  if (targetOrder) {
    const { errors: orderErrors } = await Validation({
      currentLimit: targetOrder,
      totalQuantity: totalQuantityProduct
    });
    itemErrors.push(...orderErrors);
  }
  return itemErrors;
};
const CartPage = async () => {
  if (__st.p !== "cart") return;
  console.log("cart page");
  await validateCartItems();
  $(SELECTOR_ELEMENT.ORICHI_BUTTON_PLUS_MINUS).on("click", async () => {
    $(SELECTOR_ELEMENT.ORICHI_BUTTON_CHECKOUT).not(SELECTOR_ELEMENT.ORICHI_BUTTON_PLUS_MINUS, SELECTOR_ELEMENT.CART_REMOVE_BUTTON).attr("disabled", true);
    overrideApi(async () => {
      const cartItems = await orichiLimitGetVariants();
      window.orichiLimit.cartItems = cartItems;
      await validateCartItems();
    });
  });
  $(SELECTOR_ELEMENT.CART_REMOVE_BUTTON).on("click", async () => {
    $(SELECTOR_ELEMENT.ORICHI_BUTTON_CHECKOUT).not(SELECTOR_ELEMENT.ORICHI_BUTTON_PLUS_MINUS, SELECTOR_ELEMENT.CART_REMOVE_BUTTON).attr("disabled", true);
    overrideApi(async () => {
      const cartItems = await orichiLimitGetVariants();
      window.orichiLimit.cartItems = cartItems;
      await validateCartItems();
    });
  });
  if (Shopify.shop == "doopfragrance.myshopify.com") {
    setInterval(() => {
      if ($(".cart__footer__checkout .orichi-limit-modal-error").length > 0) {
        $(".cart__footer__checkout").find(".checkout__button").hide();
      } else {
        $(".cart__footer__checkout").find(".checkout__button").show();
      }
    }, 200);
  }
};
const hasCartDrawer = () => {
  if ($("#cart-drawer, .cart-drawer, [data-cart-drawer]")) return true;
  if ($(".mini-cart, .minicart, #mini-cart")) return true;
  if ($(".cart-popup, .cart-modal, #cart-popup")) return true;
  if ($('[data-cart-type="drawer"]')) return true;
  if ($('[data-section-type="cart-drawer"]')) return true;
  if ($('[class*="cart-drawer"]')) return true;
  if ($('[class*="cart-popup"]')) return true;
  if (window.themeSettings) {
    const settings = window.themeSettings;
    if (settings.cartType === "drawer") return true;
    if (settings.enableCartDrawer === true) return true;
  }
  return false;
};
let isFirstRender = true;
const CartPopup = async () => {
  const isCartDrawer = hasCartDrawer();
  if (!isCartDrawer) return;
  overrideApi(async () => {
    const cartItems = await orichiLimitGetVariants();
    window.orichiLimit.cartItems = cartItems;
    await validateCartItems(isFirstRender);
    isFirstRender = false;
  });
};
const checkAndAdjustValueByValidationRules = (currentLimit, currentQuantity) => {
  if (currentLimit == null ? void 0 : currentLimit.ValidationRules) {
    const maxRule = currentLimit.ValidationRules.find(
      (rule) => rule.Type === ValidationRuleEnum.MAXIMUM_QUANTITY
    );
    const specificRule = currentLimit.ValidationRules.find(
      (rule) => rule.Type === ValidationRuleEnum.SPECIFIC_QUANTITY
    );
    const multiplesRule = currentLimit.ValidationRules.find(
      (rule) => rule.Type === ValidationRuleEnum.MULTIPLES
    );
    if (maxRule && specificRule) {
      const maxValue = parseInt(maxRule.Value);
      const specificValue = parseInt(specificRule.Value);
      if (specificValue > maxValue) {
        currentQuantity = maxValue;
        $(SELECTOR_ELEMENT.QUANTITY_INPUT).val(currentQuantity);
        return currentQuantity;
      }
    }
    for (const rule of currentLimit.ValidationRules) {
      if (rule.Type === ValidationRuleEnum.MAXIMUM_QUANTITY && currentQuantity > parseInt(rule.Value)) {
        currentQuantity = parseInt(rule.Value);
        if (multiplesRule) {
          const multiplesValue = parseInt(multiplesRule.Value);
          currentQuantity = Math.floor(currentQuantity / multiplesValue) * multiplesValue;
        }
        $(SELECTOR_ELEMENT.QUANTITY_INPUT).val(currentQuantity);
      } else if (rule.Type === ValidationRuleEnum.MINIMUM_QUANTITY && currentQuantity < parseInt(rule.Value)) {
        currentQuantity = parseInt(rule.Value);
        if (multiplesRule) {
          const multiplesValue = parseInt(multiplesRule.Value);
          currentQuantity = Math.ceil(currentQuantity / multiplesValue) * multiplesValue;
        }
        $(SELECTOR_ELEMENT.QUANTITY_INPUT).val(currentQuantity);
      }
    }
  }
  return currentQuantity;
};
const orichiLimitGetQuantityProductInCart = async (productId) => {
  let cartInfo = window.orichiLimit.cartItems;
  var res = 0;
  if (cartInfo.ListItems != void 0 && cartInfo.ListItems != null) {
    for (var i = 0; i < cartInfo.ListItems.length; i++) {
      if (cartInfo.ListItems[i].product_id == productId) {
        res += cartInfo.ListItems[i].quantity;
      }
    }
  }
  return res;
};
const orichiLimitGetQuantityVariantInCart = async (variantId) => {
  let cartInfo = window.orichiLimit.cartItems;
  var res = 0;
  if (cartInfo.ListItems != void 0 && cartInfo.ListItems != null) {
    for (var i = 0; i < cartInfo.ListItems.length; i++) {
      if (cartInfo.ListItems[i].variant_id == variantId) {
        res += cartInfo.ListItems[i].quantity;
      }
    }
  }
  return res;
};
const ValidationProduct = async (currentLimit, step = 0) => {
  const { getValue } = parameter();
  const currentProduct = window.orichiLimit.currentProduct;
  const quantityInCart = await orichiLimitGetQuantityProductInCart(currentProduct.id);
  let currentQuantity = parseInt($(SELECTOR_ELEMENT.QUANTITY_INPUT).val()) || 1;
  if (getValue("PRODUCT_CHECK_QUANTITY_AND_ADJUST")) {
    currentQuantity = checkAndAdjustValueByValidationRules(currentLimit, currentQuantity);
  }
  const totalQuantity = currentQuantity + parseInt(quantityInCart) + step;
  return Validation({ currentLimit, totalQuantity });
};
const ValidationVariant = async (currentLimit, step = 0) => {
  const { getValue } = parameter();
  let variantElement = $(SELECTOR_ELEMENT.ORICHI_VARIANT_SELECTOR);
  if (Shopify.shop === "urth-yarns.myshopify.com") {
    variantElement = $("[name='product-id']");
  }
  const currentVariant = variantElement.val();
  const quantityInCart = await orichiLimitGetQuantityVariantInCart(currentVariant);
  let currentQuantity = parseInt($(SELECTOR_ELEMENT.QUANTITY_INPUT).val()) || 1;
  if (getValue("PRODUCT_CHECK_QUANTITY_AND_ADJUST")) {
    currentQuantity = checkAndAdjustValueByValidationRules(currentLimit, currentQuantity);
  }
  const totalQuantity = currentQuantity + parseInt(quantityInCart) + step;
  return Validation({ currentLimit, totalQuantity });
};
const firstRender = (currentLimit) => {
  const { getValue } = parameter();
  if (!currentLimit) {
    $(SELECTOR_ELEMENT.ORICHI_BUTTON_IN_FORM_CART).not(SELECTOR_ELEMENT.ORICHI_BUTTON_PLUS_MINUS).attr("disabled", false);
    $(".orichi-limit-error").remove();
    return;
  }
  const multiplesRule = currentLimit.ValidationRules.find(
    (rule) => rule.Type === ValidationRuleEnum.MULTIPLES
  );
  const minimumRule = currentLimit.ValidationRules.find(
    (rule) => rule.Type === ValidationRuleEnum.MINIMUM_QUANTITY
  );
  const specificRule = currentLimit.ValidationRules.find(
    (rule) => rule.Type === ValidationRuleEnum.SPECIFIC_QUANTITY
  );
  if (multiplesRule && minimumRule && getValue("PRODUCT_SET_STEP_AND_MINIMUM_QUANTITY")) {
    const multiplesValue = parseInt(multiplesRule.Value);
    const minimumValue = parseInt(minimumRule.Value);
    const initialValue = Math.ceil(minimumValue / multiplesValue) * multiplesValue;
    $(SELECTOR_ELEMENT.QUANTITY_INPUT).val(initialValue);
    $(SELECTOR_ELEMENT.QUANTITY_INPUT).attr("step", multiplesValue);
    $(SELECTOR_ELEMENT.QUANTITY_INPUT).attr("min", initialValue);
    return;
  }
  if (minimumRule && specificRule && getValue("PRODUCT_SET_VALUE_QUANTITY")) {
    const minimumValue = parseInt(minimumRule.Value);
    const specificValue = parseInt(specificRule.Value);
    const value = Math.max(minimumValue, specificValue);
    $(SELECTOR_ELEMENT.QUANTITY_INPUT).val(value);
    return;
  }
  currentLimit.ValidationRules.forEach((rule) => {
    const numericValue = parseInt(rule.Value);
    if (rule.Type === ValidationRuleEnum.MULTIPLES) {
      $(SELECTOR_ELEMENT.QUANTITY_INPUT).val(numericValue);
      $(SELECTOR_ELEMENT.QUANTITY_INPUT).attr("step", numericValue);
      $(SELECTOR_ELEMENT.QUANTITY_INPUT).attr("min", 0);
      return;
    }
    if (rule.Type === ValidationRuleEnum.MINIMUM_QUANTITY) {
      $(SELECTOR_ELEMENT.QUANTITY_INPUT).val(numericValue || 1);
      return;
    }
    if (rule.Type === ValidationRuleEnum.SPECIFIC_QUANTITY) {
      $(SELECTOR_ELEMENT.QUANTITY_INPUT).val(numericValue);
      return;
    }
  });
};
const ProductPage = async () => {
  var _a, _b;
  if (__st.p !== "product") return;
  if (!((_b = (_a = window == null ? void 0 : window.orichiLimit) == null ? void 0 : _a.currentProduct) == null ? void 0 : _b.available)) return;
  let variantElement = $(SELECTOR_ELEMENT.ORICHI_VARIANT_SELECTOR);
  if (Shopify.shop === "urth-yarns.myshopify.com") {
    variantElement = $("[name='product-id']");
  }
  const currentProduct = window.orichiLimit.currentProduct;
  window.orichiLimit.collectionsTemp;
  const currentLimitProduct = findProductInLimit(currentProduct.id, currentProduct);
  const currentVariant = $(SELECTOR_ELEMENT.ORICHI_VARIANT_SELECTOR).val();
  const currentLimitVariant = findProductInLimit(currentVariant, currentProduct);
  await initializeLimit(currentLimitProduct, currentLimitVariant);
  const handleVariantChange = async () => {
    const newVariant = variantElement.val();
    const updatedLimitVariant = findProductInLimit(newVariant);
    await initializeLimit(currentLimitProduct, updatedLimitVariant);
    if (Shopify.shop == "pu-ding-ding-dev.myshopify.com" || Shopify.shop == "super-magnet-man-2.myshopify.com") {
      $(SELECTOR_ELEMENT.ORICHI_BUTTON_PLUS_MINUS).attr("disabled", false);
    }
  };
  let previousVariantValue = variantElement.val();
  variantElement.on("change", function() {
    const currentVariantValue = variantElement.val();
    if (currentVariantValue !== previousVariantValue) {
      previousVariantValue = currentVariantValue;
      handleVariantChange();
    }
  });
  $(SELECTOR_ELEMENT.ORICHI_BUTTON_PLUS_MINUS).on("click", async (event) => {
    let cartElement = $(SELECTOR_ELEMENT.ORICHI_BUTTON_IN_FORM_CART);
    cartElement.not(SELECTOR_ELEMENT.ORICHI_BUTTON_PLUS_MINUS).attr("disabled", true);
    const newVariant = variantElement.val();
    const updatedLimitVariant = findProductInLimit(newVariant);
    if (!updatedLimitVariant) {
      cartElement.not(SELECTOR_ELEMENT.ORICHI_BUTTON_PLUS_MINUS).attr("disabled", false);
      return;
    }
    overrideApi(async () => {
      await handleFormSubmit(currentLimitProduct, updatedLimitVariant);
    });
  });
};
const initializeLimit = async (productLimitItem, variantLimitItem) => {
  let cartElement = $(SELECTOR_ELEMENT.ORICHI_BUTTON_IN_FORM_CART);
  $(SELECTOR_ELEMENT.ORICHI_VARIANT_SELECTOR);
  if (Shopify.shop === "urth-yarns.myshopify.com") {
    $("[name='product-id']");
  }
  if (Shopify.shop == "hobiukraite.myshopify.com") {
    cartElement = $(
      '.shopify-payment-button__button, .product-info__add-button button[type="submit"]'
    );
  }
  if (Shopify.shop == "petandgarden.myshopify.com") {
    cartElement = $(".shopify-payment-button__button, .btn--add-to-cart");
  }
  cartElement.not(SELECTOR_ELEMENT.ORICHI_BUTTON_PLUS_MINUS).attr("disabled", true);
  await wait(500);
  firstRender(productLimitItem || variantLimitItem);
  let errors = [];
  if (productLimitItem) {
    let currentProduct = productLimitItem.ShopifyObjects.find(
      (p) => p.Id == window.orichiLimit.currentProduct.id
    );
    if (currentProduct && productLimitItem.ValidationRules && productLimitItem.AlertProductPageMessage != null) {
      productLimitItem.AlertProductPageMessage = productLimitItem.AlertProductPageMessage.replaceAll(
        "{product_name}",
        currentProduct.Title
      ).replaceAll("{quantity}", productLimitItem.ValidationRules[0].Value);
    }
    const { errors: productErrors, currentLimit: productLimit } = await ValidationProduct(productLimitItem);
    errors = [...errors, ...productErrors];
  }
  if (variantLimitItem) {
    let currentVariant = variantLimitItem.ShopifyObjects.find(
      (p) => p.Id == $(SELECTOR_ELEMENT.ORICHI_VARIANT_SELECTOR).val()
    );
    if (currentVariant && variantLimitItem.ValidationRules && variantLimitItem.AlertProductPageMessage != null) {
      variantLimitItem.AlertProductPageMessage = variantLimitItem.AlertProductPageMessage.replaceAll(
        "{product_name}",
        currentVariant.ParentName
      ).replaceAll("{variant_name}", currentVariant.Title).replaceAll("{quantity}", variantLimitItem.ValidationRules[0].Value);
    }
    const { errors: variantErrors, currentLimit: variantLimit } = await ValidationVariant(variantLimitItem);
    errors = [...errors, ...variantErrors];
  }
  errors = removeDuplicateErrors(errors);
  $(SELECTOR_ELEMENT.QUANTITY_INPUT).off("change").on("change", async () => {
    let newErrors = [];
    if (productLimitItem) {
      const { errors: productErrors } = await ValidationProduct(productLimitItem);
      newErrors = [...newErrors, ...productErrors];
    }
    if (variantLimitItem) {
      const { errors: variantErrors } = await ValidationVariant(variantLimitItem);
      newErrors = [...newErrors, ...variantErrors];
    }
    errors = removeDuplicateErrors(newErrors);
    updateErrorDisplay(errors, productLimitItem || variantLimitItem);
  });
  $(SELECTOR_ELEMENT.ORICHI_BUTTON_PLUS_MINUS).off("click").on("click", async (e) => {
    if (Shopify.shop == "wegouda.myshopify.com") {
      e.preventDefault();
      e.stopPropagation();
    }
    let newErrors = [];
    let step = 0;
    if (Shopify.shop == "petandgarden.myshopify.com" || Shopify.shop == "super-magnet-man-2.myshopify.com") {
      if ($(e.target).hasClass("vela-qty__adjust--plus") || $(e.target).attr("data-action") == "increase-picker-quantity") {
        step = 1;
      } else {
        step = -1;
      }
    }
    if (productLimitItem) {
      const { errors: productErrors } = await ValidationProduct(productLimitItem, step);
      newErrors = [...newErrors, ...productErrors];
    }
    if (variantLimitItem) {
      const { errors: variantErrors } = await ValidationVariant(variantLimitItem, step);
      newErrors = [...newErrors, ...variantErrors];
    }
    errors = removeDuplicateErrors(newErrors);
    updateErrorDisplay(errors, productLimitItem || variantLimitItem);
    if (Shopify.shop == "pu-ding-ding-dev.myshopify.com" || Shopify.shop == "super-magnet-man-2.myshopify.com") {
      let currentValue = parseInt($(SELECTOR_ELEMENT.QUANTITY_INPUT).val()) + step;
      if (variantLimitItem) {
        for (let i = 0; i < variantLimitItem.ValidationRules.length; i++) {
          let element = variantLimitItem.ValidationRules[i];
          switch (element.Type) {
            case "maximum_quantity":
              if (currentValue == element.Value) {
                $("button.js-qty__adjust--plus, [data-action='increase-picker-quantity']").attr(
                  "disabled",
                  true
                );
              } else {
                $("button.js-qty__adjust--plus, [data-action='increase-picker-quantity']").attr(
                  "disabled",
                  false
                );
              }
              break;
            case "minimum_quantity":
              if (currentValue == element.Value) {
                $("button.js-qty__adjust--minus, [data-action='decrease-picker-quantity']").attr(
                  "disabled",
                  true
                );
              } else {
                $("button.js-qty__adjust--minus, [data-action='decrease-picker-quantity']").attr(
                  "disabled",
                  false
                );
              }
              break;
          }
        }
      }
      if (productLimitItem) {
        for (let i = 0; i < productLimitItem.ValidationRules.length; i++) {
          let element = productLimitItem.ValidationRules[i];
          switch (element.Type) {
            case "maximum_quantity":
              if (currentValue == element.Value) {
                $("button.js-qty__adjust--plus, [data-action='increase-picker-quantity']").attr(
                  "disabled",
                  true
                );
              } else {
                $("button.js-qty__adjust--plus, [data-action='increase-picker-quantity']").attr(
                  "disabled",
                  false
                );
              }
              break;
            case "minimum_quantity":
              if (currentValue == element.Value) {
                $("button.js-qty__adjust--minus, [data-action='decrease-picker-quantity']").attr(
                  "disabled",
                  true
                );
              } else {
                $("button.js-qty__adjust--minus, [data-action='decrease-picker-quantity']").attr(
                  "disabled",
                  false
                );
              }
              break;
          }
        }
      }
    }
  });
  updateErrorDisplay(errors, productLimitItem || variantLimitItem);
  if (Shopify.shop == "super-magnet-man-2.myshopify.com") {
    let currentValue = $(SELECTOR_ELEMENT.QUANTITY_INPUT).val();
    if (variantLimitItem) {
      for (let i = 0; i < variantLimitItem.ValidationRules.length; i++) {
        let element = variantLimitItem.ValidationRules[i];
        switch (element.Type) {
          case "maximum_quantity":
            if (currentValue == element.Value) {
              $("button.js-qty__adjust--plus, [data-action='increase-picker-quantity']").attr(
                "disabled",
                true
              );
            } else {
              $("button.js-qty__adjust--plus, [data-action='increase-picker-quantity']").attr(
                "disabled",
                false
              );
            }
            break;
          case "minimum_quantity":
            if (currentValue == element.Value) {
              $("button.js-qty__adjust--minus, [data-action='decrease-picker-quantity']").attr(
                "disabled",
                true
              );
            } else {
              $("button.js-qty__adjust--minus, [data-action='decrease-picker-quantity']").attr(
                "disabled",
                false
              );
            }
            break;
        }
      }
    }
    if (productLimitItem) {
      for (let i = 0; i < productLimitItem.ValidationRules.length; i++) {
        let element = productLimitItem.ValidationRules[i];
        switch (element.Type) {
          case "maximum_quantity":
            if (currentValue == element.Value) {
              $("button.js-qty__adjust--plus, [data-action='increase-picker-quantity']").attr(
                "disabled",
                true
              );
            } else {
              $("button.js-qty__adjust--plus, [data-action='increase-picker-quantity']").attr(
                "disabled",
                false
              );
            }
            break;
          case "minimum_quantity":
            if (currentValue == element.Value) {
              $("button.js-qty__adjust--minus, [data-action='decrease-picker-quantity']").attr(
                "disabled",
                true
              );
            } else {
              $("button.js-qty__adjust--minus, [data-action='decrease-picker-quantity']").attr(
                "disabled",
                false
              );
            }
            break;
        }
      }
    }
  }
};
const updateErrorDisplay = (errors, currentLimit) => {
  const quantityInputElement = $(SELECTOR_ELEMENT.QUANTITY_INPUT);
  const cartElement = $(SELECTOR_ELEMENT.ORICHI_BUTTON_IN_FORM_CART);
  const { getValue } = parameter();
  const targetErrorMessageContainer = getValue("Product-Message-Error-Append-To");
  if (errors.length > 0 && currentLimit.AlertInProductPage) {
    const errorElement = `<div class="orichi-limit-error">${currentLimit.AlertProductPageMessage}</div>`;
    if ($(".orichi-limit-error").length === 0) {
      if (targetErrorMessageContainer) {
        $(targetErrorMessageContainer).append(errorElement);
        return;
      }
      if (quantityInputElement.length) {
        quantityInputElement.parent().parent().append(errorElement);
      } else {
        if ((cartElement == null ? void 0 : cartElement.length) === 1 || !cartElement.length) {
          $(errorElement).insertBefore(cartElement);
        } else {
          $(errorElement).insertBefore(cartElement[0]);
        }
      }
    } else {
      $(".orichi-limit-error").html(currentLimit.AlertProductPageMessage);
    }
    cartElement.not(SELECTOR_ELEMENT.ORICHI_BUTTON_PLUS_MINUS).attr("disabled", true);
  } else {
    $(".orichi-limit-error").remove();
    cartElement.attr("disabled", false);
  }
};
const handleFormSubmit = async (productLimitItem, variantLimitItem) => {
  let errors = [];
  if (productLimitItem) {
    const { errors: productErrors } = await ValidationProduct(productLimitItem);
    errors = [...errors, ...productErrors];
  }
  if (variantLimitItem) {
    const { errors: variantErrors } = await ValidationVariant(variantLimitItem);
    errors = [...errors, ...variantErrors];
  }
  errors = removeDuplicateErrors(errors);
  updateErrorDisplay(errors, productLimitItem || variantLimitItem);
};
const Run = async () => {
  console.log(
    "%c Madgic Order Limit js is working. Version 1.1.73",
    "background: #FFFF00; color: #000000; padding: 5px 10px; border-radius: 4px;"
  );
  const cartItems = await orichiLimitGetVariants();
  window.orichiLimit.cartItems = cartItems;
  overrideSelector();
  initParameter();
  CartPopup();
  ProductPage();
  CartPage();
  if (Shopify.shop == "hobiukraite.myshopify.com" || Shopify.shop == "discountpaintball-com.myshopify.com") {
    let styleElement = document.createElement("style");
    styleElement.textContent = html`.product-info__add-to-cart:has(button[disabled]) quantity-input
    { opacity: 1 !important; cursor: default !important; pointer-events: unset !important; }`;
    let headElement = document.querySelector("head");
    headElement.appendChild(styleElement);
  }
  if (Shopify.shop === "doopfragrance.myshopify.com") {
    $("head").append(
      html`<style>
        .checkout__button + .checkout__button {
          display: none !important;
        }
      </style>`
    );
  }
  if (Shopify.shop === "0b5n0j-zv.myshopify.com") {
    $("head").append(
      html`<style>
        .cart__footer .cart__blocks:has(.orichi-limit-modal-error) .additional-checkout-buttons {
          pointer-events: none !important;
        }
      </style>`
    );
  }
  if (Shopify.shop == "98a125-a7.myshopify.com") {
    if (window.orichiLimit && window.orichiLimit.limits) {
      setInterval(() => {
        if ($(".orichi-limit-input-cart").length == 0) {
          window.orichiLimit.limits.forEach((element) => {
            let maxQuantity = element.ValidationRules.find((p) => p.Type == "maximum_quantity");
            let minQuantity = element.ValidationRules.find((p) => p.Type == "minimum_quantity");
            element.ShopifyObjects.forEach((e) => {
              if (maxQuantity) {
                $(".hdt-mini-cart__item:has(a[href*=" + e.Handle + "]) .hdt-quantity-input").attr(
                  "max",
                  maxQuantity.Value
                );
                $(
                  ".hdt-mini-cart__item:has(a[href*=" + e.Handle + "]) .hdt-quantity-input"
                ).addClass("orichi-limit-input-cart");
              }
              if (minQuantity) {
                $(".hdt-mini-cart__item:has(a[href*=" + e.Handle + "]) .hdt-quantity-input").attr(
                  "min",
                  minQuantity.Value
                );
                $(
                  ".hdt-mini-cart__item:has(a[href*=" + e.Handle + "]) .hdt-quantity-input"
                ).addClass("orichi-limit-input-cart");
              }
            });
          });
        }
      }, 500);
    }
  }
};
const SELECTOR_ELEMENT_CONSTANT = {
  QUANTITY_INPUT: "[name='quantity']:first",
  ORICHI_BUTTON_IN_FORM_CART: "form[action='/cart/add'] button, form[action='/cart/add'] input[type='submit'], form[action*='/cart/add']:first button",
  ORICHI_VARIANT_SELECTOR: "[name='id']",
  ORICHI_BUTTON_CHECKOUT: '.juice-cart__totals__checkout, .cart__checkout-button, .js-cart-btn-checkout,#wof_checkout_btn,.button-checkout,.icart-checkout-btn,.rebuy-cart__checkout-button, .cart-button-checkout,form[action="/checkout"] button[type="submit"],[name="checkout"],.cart__checkout,.shopify-payment-button__button .cart__checkout,form[action^="/checkout"] button[name^="checkout"],form[action^="/checkout"] .checkout-button,form[action^="/cart"] button[name^="checkout"],form[action^="/cart"] .checkout-button, form[action^="/checkout"] button[name^="update"], form[action^="/checkout"] button[name^="checkout"], a[href="/checkout"], input[name="checkout"], .checkout, button[name="checkout"], #checkout2,#checkout,.Cart__Checkout, .Orichi-checkout-button, .Orichi-dynamic-checkout-button, .Orichi-dynamic-checkout-button2, .cart__checkout, .cart__submit, .orichiCheckout,.cart-drawer__checkout,.cart__checkout,.btn-checkout,#slidecarthq .footer-sticky .footer-buttons button,.cart_button_secure, form[action^="/checkout"] input[value^="Checkout"], .btn-checkout, .actions .checkout-cart,.site-header-cart__dropdown-cart-footer-btn--checkout, #shopify-section-gocart .l-cart__purchase-button, #CartDrawer-Checkout, button.checkout__button, button#CartDrawer-Checkout',
  ORICHI_BUTTON_PLUS_MINUS: "form[action='/cart/add'] .minus,form[action='/cart/add'] .plus,form[action='/cart/add'] .wpbQtyAdjustMinus,form[action='/cart/add'] .wpbQtyAdjustPlus,form[action='/cart/add'] .qtyplus,form[action='/cart/add'] .qtyminus, button[data-action='decrease-quantity'], button[data-action='increase-quantity'], button[name='minus'], button[name='plus'], .js-qty__adjust--minus, .js-qty__adjust--plus, .vela-qty__adjust--plus, .vela-qty__adjust--minus, .quantity__button--plus, .quantity__button--minus, [data-action='decrease-picker-quantity'], [data-action='increase-picker-quantity']",
  CART_REMOVE_BUTTON: "cart-remove-button",
  ORICHI_CART_POPUP_SELECTOR: ".t4s-tab-minicart, #CartDrawer, #cartform, .minicart, .juice-cart__content, .t4s-drawer__wrap, .cart__drawer-form, .mini-cart-content, .cart, #cart-drawer, .minicart-content, .cart-order, .cart-form, #cart__drawer, #CartDrawerForm, #js_cart_popup, .icart-content, #rebuy-cart, .ajaxcart-draw, #shopify-section-mini-cart, .cart-mini-content, .halo-cart-sidebar,.w-commerce-commercecartwrapper, .m_cart-group .cart-info,.hs-site-cart-popup-layout,form[action='/cart'],form[action='/cart'],form[action='/checkout'],#cart,.ch_customer_cart,#cartformpargo,#cart-summary,.wrapper-top-cart, #shopify-section-cart-template form, .cart-wrapper,form[action='/fr/cart'],#shopify-section-cart-template .cart-wrapper, .ajaxcart, .js-popup-cart-ajax, .cart .popup-tab, .grid__item .cart, #dropdown-cart,#slidecarthq,.cart-preview,.cart-popup-content,.mini-cart-inner-desktop,.site-cart,.cart--form,#buy-form,#CartPopup,.site-header-cart__dropdown-cart-footer-checkout, #shopify-section-gocart",
  ORICHI_DISABLE_BUTTON_APP_IF_LIMITED: ".orichi-order__shippingDetails--submit"
};
class SelectorManager {
  constructor() {
    this._selectors = Object.fromEntries(
      Object.entries(SELECTOR_ELEMENT_CONSTANT).map(([key, value]) => [
        key,
        {
          value,
          subscribers: /* @__PURE__ */ new Set()
        }
      ])
    );
    Object.keys(this._selectors).forEach((selectorName) => {
      Object.defineProperty(this, selectorName, {
        get: () => this.getSelector(selectorName),
        set: (newValue) => this.setSelector(selectorName, newValue)
      });
    });
  }
  /**
   * Get the value and subscribers for a specific selector
   * @param {SelectorName} selectorName - The name of the selector (e.g. 'QUANTITY_INPUT', 'ORICHI_BUTTON_IN_FORM_CART')
   * @returns {string|undefined|null} The selector value and its subscribers
   */
  getSelector(selectorName) {
    var _a;
    return (_a = this._selectors[selectorName]) == null ? void 0 : _a.value;
  }
  /**
   * Set a new value for a specific selector
   * @param {SelectorName} selectorName - The name of the selector (e.g. 'QUANTITY_INPUT', 'ORICHI_BUTTON_IN_FORM_CART')
   * @param {string} newValue - The new value to set
   * @returns {void}
   */
  setSelector(selectorName, newValue) {
    if (this._selectors[selectorName]) {
      this._selectors[selectorName].value = newValue;
      this._notifySubscribers(selectorName, newValue);
    }
  }
  /**
   * Subscribe to changes in a specific selector
   * @param {SelectorName} selectorName - The name of the selector (e.g. 'QUANTITY_INPUT', 'ORICHI_BUTTON_IN_FORM_CART')
   * @param {Function} callback - The callback function to be called when the selector changes
   */
  subscribe(selectorName, callback) {
    if (this._selectors[selectorName]) {
      this._selectors[selectorName].subscribers.add(callback);
    }
    return () => this.unsubscribe(selectorName, callback);
  }
  /**
   * Unsubscribe from changes in a specific selector
   * @param {SelectorName} selectorName - The name of the selector (e.g. 'QUANTITY_INPUT', 'ORICHI_BUTTON_IN_FORM_CART')
   * @param {Function} callback - The callback function to remove
   * @returns {void}
   */
  unsubscribe(selectorName, callback) {
    if (this._selectors[selectorName]) {
      this._selectors[selectorName].subscribers.delete(callback);
    }
  }
  _notifySubscribers(selectorName, newValue) {
    if (this._selectors[selectorName]) {
      this._selectors[selectorName].subscribers.forEach((callback) => {
        callback(newValue, selectorName);
      });
    }
  }
  /**
   * Append a new value to an existing selector. If the selector already has a value,
   * the new value will be appended with a comma separator
   * @param {SelectorName} selectorName - The name of the selector (e.g. 'QUANTITY_INPUT', 'ORICHI_BUTTON_IN_FORM_CART')
   * @param {string} newValue - The new selector value to append
   * @throws {Error} If the selector does not exist
   * @returns {string} The updated selector value
   */
  appendSelector(selectorName, newValue) {
    if (!this._selectors[selectorName]) {
      throw new Error(`Selector "${selectorName}" does not exist`);
    }
    const currentValue = this._selectors[selectorName].value;
    if (!currentValue) {
      this._selectors[selectorName].value = newValue;
    } else {
      this._selectors[selectorName].value = `${currentValue}, ${newValue}`;
    }
    this._notifySubscribers(selectorName, this._selectors[selectorName].value);
    return this._selectors[selectorName].value;
  }
}
const SELECTOR_ELEMENT = new SelectorManager();
console.log("Starting to run");
if (!window.jQuery || !window.$) {
  const scriptJquery = document.createElement("script");
  scriptJquery.src = "https://cdnjs.cloudflare.com/ajax/libs/jquery/3.7.1/jquery.min.js";
  document.head.appendChild(scriptJquery);
  scriptJquery.onload = () => {
    if (window.jQuery || window.$) {
      Run();
    } else {
      console.error("jQuery failed to load");
    }
  };
} else {
  Run();
}