// cache-related helpers/values

// Some information from cache is stored on the variables as objects to make editing easier and simpler

// Each time something is changed in the variables, update* must also be called to save the changes to the cache

static config = _Store.get(Cached.Configuration.key) ?? { default: {} };

static categories = _Store.get(Cached.FlagCategories) ?? [];

static flagTypes = _Store.get(Cached.FlagTypes) ?? [];

static updateConfiguration = () => _Store.set(Cached.Configuration.key, this.config);

static updateFlagTypes = () => _Store.set(Cached.FlagTypes, this.flagTypes);

static dryRun = this.config[Cached.Configuration.debug];

// export const updateCategories = (): void => GreaseMonkeyCache.storeInCache(FlagCategoriesKey, cachedCategories);

static async getAndCache(cacheKey, getterPromise, expiresAt) {

const cachedItem = _Store.get(cacheKey);

if (cachedItem) return cachedItem;

const result = await getterPromise();

_Store.set(cacheKey, result, expiresAt);

return result;

}

// There are two kinds of objects that are stored in the cache:

// - those that expire (only fkey currently)

// - those that are not

//

// The type of those that are expirable is ExpiryingCacheItem.

// The others are strings or objects.

// To make TS happy and avoid runtime errors, we need to take into account both cases.

static get(cacheKey) {

const cachedItem = GM_getValue(cacheKey);

if (!cachedItem) return null;

const isItemExpired = typeof cachedItem === "object" && "Data" in cachedItem && new Date(cachedItem.Expires) < /* @__PURE__ */ new Date();

if (isItemExpired) return null;

return typeof cachedItem === "object" && "Data" in cachedItem ? cachedItem.Data : cachedItem;

}

static set(cacheKey, item, expiresAt) {

const jsonObject = expiresAt ? { Expires: expiresAt.getTime(), Data: item } : item;

GM_setValue(cacheKey, jsonObject);

}

static unset(cacheKey) {

GM_deleteValue(cacheKey);

}

var _a;

const { value = "", classes = [], placeholder = "", title, isSearch } = inputOptions;

const inputParent = document.createElement("div");

inputParent.classList.add("d-flex", "ps-relative");

const input = document.createElement("input");

input.classList.add("s-input", ...classes);

input.type = "text";

input.id = input.name = id;

input.placeholder = placeholder;

input.value = value;

if (title)

input.title = title;

if (isSearch) {

input.classList.add("s-input__search");

const [searchIcon] = icons_exports.makeStacksIcon("iconSearch", "m18 16.5-5.14-5.18h-.35a7 7 0 10-1.19 1.19v.35L16.5 18l1.5-1.5zM12 7A5 5 0 112 7a5 5 0 0110 0z", {

classes: ["s-input-icon", "s-input-icon__search"],

width: 18

});

inputParent.append(searchIcon);

}

inputParent.prepend(input);

if (labelOptions) {

(_a = labelOptions.parentClasses || (labelOptions.parentClasses = [])) === null || _a === void 0 ? void 0 : _a.push("flex--item");

const label = label_exports.makeStacksLabel(id, labelOptions);

const container = document.createElement("div");

container.classList.add("d-flex", "gy4", "fd-column");

container.append(label, inputParent);

return container;

}

return inputParent;

const fieldset = document.createElement("fieldset");

fieldset.classList.add("s-check-group");

if (options) {

const { legendText = "", legendDescription = "", horizontal, classes = [] } = options;

if (horizontal) {

fieldset.classList.add("s-check-group__horizontal");

}

fieldset.classList.add(...classes);

const legend = document.createElement("legend");

legend.classList.add("flex--item", "s-label");

legend.innerText = legendText;

if (legendDescription) {

const span = document.createElement("span");

span.classList.add("ml4", "fw-normal", "fc-light");

span.innerText = legendDescription;

legend.append(" ", span);

}

fieldset.append(legend);

}

const items = inputs.map((inputType) => makeFormContainer(inputType, type));

if (withoutFieldset) {

return items;

} else {

fieldset.append(...items);

return [fieldset, ...items];

}

const { id, labelConfig, selected = false, disabled = false, name } = radioCheckbox;

const container = document.createElement("div");

container.classList.add("s-check-control");

const input = document.createElement("input");

input.classList.add(`s-${type}`);

input.type = type;

input.id = id;

input.checked = selected;

input.disabled = disabled;

if (name) {

input.name = name;

}

const label = label_exports.makeStacksLabel(id, labelConfig);

container.append(input, label);

return container;

const { classes = [], parentClasses = [], text, description, statusText, statusType } = labelOptions;

const labelParent = document.createElement("div");

labelParent.classList.add(...parentClasses);

const label = document.createElement("label");

label.classList.add("s-label", ...classes);

label.htmlFor = forId;

label.innerHTML = text;

if (statusText && statusType) {

const status = document.createElement("span");

status.innerHTML = statusText;

status.classList.add("s-label--status");

if (statusType !== "optional") {

status.classList.add(`s-label--status__${statusType}`);

}

label.append(" ", status);

}

if (description) {

const p = document.createElement("p");

p.classList.add("s-description", "mt2");

p.innerHTML = description;

label.classList.add("d-block");

label.append(p);

labelParent.append(label);

return labelParent;

} else {

label.classList.add("flex--item");

return label;

}

const { href = "", isButton = false, type = "", blockLink = null, text, click, classes = [] } = options;

const anchor = document.createElement(isButton ? "button" : "a");

anchor.classList.add("s-link", ...classes);

anchor.textContent = text;

if (type) {

anchor.classList.add(`s-link__${type}`);

}

if (blockLink) {

anchor.classList.add("s-block-link");

anchor.classList.remove("s-link");

if (blockLink.border) {

anchor.classList.add(`s-block-link__${blockLink.border}`);

}

if (blockLink.selected) {

anchor.classList.add("is-selected");

}

if (blockLink.danger) {

anchor.classList.add("s-block-link__danger");

}

}

if (href && anchor instanceof HTMLAnchorElement) {

anchor.href = href;

}

if (click) {

const { handler, options: options2 } = click;

anchor.addEventListener("click", handler, options2);

}

return anchor;

const { itemsType = "a", childrenClasses = [], navItems, classes = [] } = options;

const menu = document.createElement("ul");

menu.classList.add("s-menu", ...classes);

menu.setAttribute("role", "menu");

navItems.forEach((navItem) => {

var _a;

const li = document.createElement("li");

if ("popover" in navItem && navItem.popover) {

const { position = "auto", html } = navItem.popover;

Stacks.setTooltipHtml(li, html, {

placement: position

});

}

if ("separatorType" in navItem) {

const { separatorType, separatorText } = navItem;

li.setAttribute("role", "separator");

li.classList.add(`s-menu--${separatorType}`);

if (separatorText)

li.textContent = separatorText;

menu.append(li);

return;

} else if ("checkbox" in navItem) {

const { checkbox, checkboxOptions } = navItem;

const [, input] = checkbox_exports.makeStacksCheckboxes([checkbox], checkboxOptions);

li.append(input);

menu.append(li);

return;

}

(_a = navItem.classes) === null || _a === void 0 ? void 0 : _a.push(...childrenClasses);

li.setAttribute("role", "menuitem");

const item = links_exports.makeLink(Object.assign({

isButton: itemsType === "button" || navItem.isButton,

blockLink: {}

}, navItem));

li.append(item);

menu.append(li);

});

return menu;

const { type, important = false, icon, text, classes = [] } = options;

const notice = document.createElement("aside");

notice.classList.add("s-notice", ...classes);

notice.setAttribute("role", important ? "alert" : "status");

if (type) {

notice.classList.add(`s-notice__${type}`);

}

if (important) {

notice.classList.add("s-notice__important");

}

if (icon) {

notice.classList.add("d-flex");

const iconContainer = document.createElement("div");

iconContainer.classList.add("flex--item", "mr8");

const [name, path] = icon;

const [svgIcon] = icons_exports.makeStacksIcon(name, path, { width: 18 });

iconContainer.append(svgIcon);

const textContainer = document.createElement("div");

textContainer.classList.add("flex--item", "lh-lg");

textContainer.append(text);

notice.append(iconContainer, textContainer);

} else {

const p = document.createElement("p");

p.classList.add("m0");

p.append(text);

notice.append(p);

}

return notice;

radios.forEach((radio) => {

radio.name = groupName;

});

return input_exports.makeStacksRadiosOrCheckboxes(radios, "radio", options);

const { disabled = false, size, validation, classes = [] } = options;

const container = document.createElement("div");

container.classList.add("d-flex", "gy4", "fd-column");

if (labelOptions) {

(labelOptions.parentClasses || (labelOptions.parentClasses = [])).push("flex--item");

const label = label_exports.makeStacksLabel(id, labelOptions);

container.append(label);

}

const selectContainer = document.createElement("div");

selectContainer.classList.add("flex--item", "s-select");

if (size) {

selectContainer.classList.add(`s-select__${size}`);

}

const select = document.createElement("select");

select.id = id;

select.classList.add(...classes);

if (disabled) {

container.classList.add("is-disabled");

select.disabled = true;

}

items.forEach((item) => {

const { value, text, selected = false } = item;

const option = document.createElement("option");

option.value = value;

option.text = text;

option.selected = selected;

select.append(option);

});

selectContainer.append(select);

container.append(selectContainer);

if (validation) {

toggleValidation(container, validation);

}

return container;

var _a, _b;

container.classList.remove("has-success", "has-warning", "has-error");

(_a = container.querySelector(".s-input-icon")) === null || _a === void 0 ? void 0 : _a.remove();

if (!state)

return;

container.classList.add(`has-${state}`);

const [name, path] = icons_exports.validationIcons[state];

const [icon] = icons_exports.makeStacksIcon(name, path, {

classes: ["s-input-icon"],

width: 18

});

(_b = container.querySelector(".s-select")) === null || _b === void 0 ? void 0 : _b.append(icon);

const { size = "", hiddenText = "", classes = [] } = options;

const spinner = document.createElement("div");

spinner.classList.add("s-spinner", ...classes);

if (size) {

spinner.classList.add(`s-spinner__${size}`);

}

if (hiddenText) {

const hiddenElement = document.createElement("div");

hiddenElement.classList.add("v-visible-sr");

hiddenElement.innerText = hiddenText;

spinner.append(hiddenElement);

}

return spinner;

const { value = "", classes = [], placeholder = "", title = "", size, validation } = textareaOptions;

const textareaParent = document.createElement("div");

textareaParent.classList.add("d-flex", "fd-column", "gy4", ...classes);

if (labelOptions) {

const label = label_exports.makeStacksLabel(id, labelOptions);

textareaParent.append(label);

}

const textarea = document.createElement("textarea");

textarea.classList.add("flex--item", "s-textarea");

textarea.id = id;

textarea.placeholder = placeholder;

textarea.value = value;

textarea.title = title;

if (size) {

textarea.classList.add(`s-textarea__${size}`);

}

textareaParent.append(textarea);

if (validation) {

toggleValidation2(textareaParent, validation);

}

return textareaParent;

var _a, _b;

textareaParent.classList.remove("has-success", "has-warning", "has-error");

const oldTextarea = textareaParent.querySelector(".s-textarea");

if (!validation) {

(_a = textareaParent.querySelector(".s-input-icon")) === null || _a === void 0 ? void 0 : _a.remove();

(_b = textareaParent.querySelector(".s-input-message")) === null || _b === void 0 ? void 0 : _b.remove();

const validationContainer = oldTextarea.parentElement;

validationContainer === null || validationContainer === void 0 ? void 0 : validationContainer.replaceWith(oldTextarea);

return;

}

const { state, description } = validation;

textareaParent.classList.add(`has-${state}`);

const [iconName, iconPath] = icons_exports.validationIcons[state];

const [icon] = icons_exports.makeStacksIcon(iconName, iconPath, {

classes: ["s-input-icon"],

width: 18

});

if (oldTextarea.nextElementSibling) {

oldTextarea.nextElementSibling.replaceWith(icon);

const inputMessage = textareaParent.querySelector(".s-input-message");

if (description) {

if (inputMessage) {

inputMessage.innerHTML = description;

} else {

createAndAppendDescription(description, textareaParent);

}

} else if (!description && inputMessage) {

inputMessage.remove();

}

} else {

const validationContainer = document.createElement("div");

validationContainer.classList.add("d-flex", "ps-relative");

validationContainer.append(oldTextarea, icon);

textareaParent.append(validationContainer);

if (description) {

createAndAppendDescription(description, textareaParent);

}

}

const message = document.createElement("p");

message.classList.add("flex--item", "s-input-message");

message.innerHTML = description;

appendTo.append(message);

const container = document.createElement("div");

container.classList.add("d-flex", "g8", "ai-center", ...classes);

const label = label_exports.makeStacksLabel(id, labelOptions);

const toggle = document.createElement("input");

toggle.id = id;

toggle.classList.add("s-toggle-switch");

toggle.type = "checkbox";

toggle.checked = on;

container.append(label, toggle);

return container;

const { title, type = [], primary = false, loading = false, selected = false, disabled = false, badge, size, iconConfig, click, classes = [] } = options;

const btn = document.createElement("button");

if (id !== "") {

btn.id = id;

}

btn.classList.add("s-btn", ...type.map((name) => `s-btn__${name}`), ...classes);

btn.append(text);

btn.type = "button";

btn.setAttribute("role", "button");

const ariaLabel = title || (text instanceof HTMLElement ? text.textContent || "" : text);

btn.setAttribute("aria-label", ariaLabel);

if (primary) {

btn.classList.add("s-btn__filled");

}

if (loading) {

btn.classList.add("is-loading");

}

if (title) {

btn.title = title;

}

if (selected) {

btn.classList.add("is-selected");

}

if (disabled) {

btn.disabled = true;

}

if (badge) {

const badgeEl = document.createElement("span");

badgeEl.classList.add("s-btn--badge");

const badgeNumber = document.createElement("span");

badgeNumber.classList.add("s-btn--number");

badgeNumber.textContent = badge.toString();

badgeEl.append(badgeNumber);

btn.append(" ", badgeEl);

}

if (size) {

btn.classList.add(`s-btn__${size}`);

}

if (iconConfig) {

btn.classList.add("s-btn__icon");

const { name, path, width, height } = iconConfig;

const [icon] = icons_exports.makeStacksIcon(name, path, { width, height });

btn.prepend(icon, " ");

}

if (click) {

const { handler, options: options2 } = click;

btn.addEventListener("click", handler, options2);

}

return btn;

const ns = "http://www.w3.org/2000/svg";

const svg = document.createElementNS(ns, "svg");

svg.classList.add("svg-icon", name, ...classes);

svg.setAttribute("width", width.toString());

svg.setAttribute("height", height.toString());

svg.setAttribute("viewBox", `0 0 ${width} ${height}`);

svg.setAttribute("aria-hidden", "true");

if (typeof pathConfig === "string") {

const path = document.createElementNS(ns, "path");

path.setAttribute("d", pathConfig);

svg.append(path);

return [svg, path];

} else {

const paths = [];

pathConfig.forEach((svgPath) => {

const path = document.createElementNS(ns, "path");

path.setAttribute("d", svgPath);

svg.append(path);

paths.push(path);

});

return [svg, paths[0]];

}

const { classes = [], danger = false, fullscreen = false, celebratory = false, title: { text, id: titleId, classes: titleClasses = [] }, body: { bodyHtml, id: bodyId, classes: bodyClasses = [] }, footer: { buttons, classes: footerClasses = [] } } = options;

const modal = document.createElement("aside");

modal.id = id;

modal.classList.add("s-modal", ...classes);

modal.setAttribute("role", "dialog");

modal.setAttribute("data-controller", "s-modal");

modal.setAttribute("data-s-modal-target", "modal");

if (danger) {

modal.classList.add("s-modal__danger");

}

if (celebratory) {

modal.classList.add("s-modal__celebration");

}

const dialog = document.createElement("div");

dialog.classList.add("s-modal--dialog");

dialog.setAttribute("role", "document");

if (fullscreen) {

dialog.classList.add("s-modal__full");

}

const header = document.createElement("h1");

header.classList.add("s-modal--header", ...titleClasses);

header.append(text);

if (titleId) {

header.id = titleId;

modal.setAttribute("aria-labelledby", titleId);

}

const body = document.createElement("p");

body.classList.add("s-modal--body", ...bodyClasses);

body.append(bodyHtml);

if (bodyId) {

body.id = bodyId;

modal.setAttribute("aria-describedby", bodyId);

}

const footer = document.createElement("div");

footer.classList.add("d-flex", "gx8", "s-modal--footer", ...footerClasses);

buttons.forEach((button) => {

const { element, hideOnClick } = button;

element.classList.add("flex--item");