7264 lines
235 KiB
JavaScript
7264 lines
235 KiB
JavaScript
/**
|
|
* @name PermissionsViewer
|
|
* @description Allows you to view all the permissions for users, servers, and channels!
|
|
* @version 1.0.0
|
|
* @author Zerebos
|
|
* @authorId 249746236008169473
|
|
* @website https://github.com/zerebos/BetterDiscordAddons/tree/master/Plugins/PermissionsViewer
|
|
* @source https://raw.githubusercontent.com/zerebos/BetterDiscordAddons/master/Plugins/PermissionsViewer/PermissionsViewer.plugin.js
|
|
*/
|
|
|
|
/*@cc_on
|
|
@if (@_jscript)
|
|
|
|
// Offer to self-install for clueless users that try to run this directly.
|
|
var shell = WScript.CreateObject("WScript.Shell");
|
|
var fs = new ActiveXObject("Scripting.FileSystemObject");
|
|
var pathPlugins = shell.ExpandEnvironmentStrings("%APPDATA%\\BetterDiscord\\plugins");
|
|
var pathSelf = WScript.ScriptFullName;
|
|
// Put the user at ease by addressing them in the first person
|
|
shell.Popup("It looks like you've mistakenly tried to run me directly. \n(Don't do that!)", 0, "I'm a plugin for BetterDiscord", 0x30);
|
|
if (fs.GetParentFolderName(pathSelf) === fs.GetAbsolutePathName(pathPlugins)) {
|
|
shell.Popup("I'm in the correct folder already.", 0, "I'm already installed", 0x40);
|
|
} else if (!fs.FolderExists(pathPlugins)) {
|
|
shell.Popup("I can't find the BetterDiscord plugins folder.\nAre you sure it's even installed?", 0, "Can't install myself", 0x10);
|
|
} else if (shell.Popup("Should I copy myself to BetterDiscord's plugins folder for you?", 0, "Do you need some help?", 0x34) === 6) {
|
|
fs.CopyFile(pathSelf, fs.BuildPath(pathPlugins, fs.GetFileName(pathSelf)), true);
|
|
// Show the user where to put plugins in the future
|
|
shell.Exec("explorer " + pathPlugins);
|
|
shell.Popup("I'm installed!", 0, "Successfully installed", 0x40);
|
|
}
|
|
WScript.Quit();
|
|
|
|
@else@*/
|
|
|
|
var __defProp = Object.defineProperty;
|
|
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
var __export = (target, all) => {
|
|
for (var name in all)
|
|
__defProp(target, name, { get: all[name], enumerable: true });
|
|
};
|
|
var __copyProps = (to, from, except, desc) => {
|
|
if (from && typeof from === "object" || typeof from === "function") {
|
|
for (let key2 of __getOwnPropNames(from))
|
|
if (!__hasOwnProp.call(to, key2) && key2 !== except)
|
|
__defProp(to, key2, { get: () => from[key2], enumerable: !(desc = __getOwnPropDesc(from, key2)) || desc.enumerable });
|
|
}
|
|
return to;
|
|
};
|
|
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
|
|
|
// src/plugins/PermissionsViewer/index.ts
|
|
var index_exports = {};
|
|
__export(index_exports, {
|
|
default: () => PermissionsViewer
|
|
});
|
|
module.exports = __toCommonJS(index_exports);
|
|
|
|
// src/common/plugin.ts
|
|
var Plugin = class {
|
|
meta;
|
|
manifest;
|
|
settings;
|
|
defaultSettings;
|
|
LocaleManager;
|
|
get strings() {
|
|
if (!this.manifest.strings) return {};
|
|
const locale = this.LocaleManager?.locale.split("-")[0] ?? "en";
|
|
if (this.manifest.strings.hasOwnProperty(locale)) return this.manifest.strings[locale];
|
|
if (this.manifest.strings.hasOwnProperty("en")) return this.manifest.strings.en;
|
|
return this.manifest.strings;
|
|
}
|
|
constructor(meta, zplConfig) {
|
|
this.meta = meta;
|
|
this.manifest = zplConfig;
|
|
if (typeof this.manifest.config !== "undefined") {
|
|
this.defaultSettings = {};
|
|
for (let s = 0; s < this.manifest.config.length; s++) {
|
|
const current = this.manifest.config[s];
|
|
if (current.type != "category") {
|
|
this.defaultSettings[current.id] = current.value;
|
|
} else {
|
|
for (let si = 0; si < current.settings.length; si++) {
|
|
const subCurrent = current.settings[si];
|
|
this.defaultSettings[subCurrent.id] = subCurrent.value;
|
|
}
|
|
}
|
|
}
|
|
this.settings = BdApi.Utils.extend({}, this.defaultSettings);
|
|
}
|
|
const currentVersionInfo = BdApi.Data.load(this.meta.name, "version");
|
|
if (currentVersionInfo !== this.meta.version) {
|
|
this.#showChangelog();
|
|
BdApi.Data.save(this.meta.name, "version", this.meta.version);
|
|
}
|
|
if (this.manifest.strings) this.LocaleManager = BdApi.Webpack.getByKeys("locale", "initialize");
|
|
if (this.manifest.config && !this.getSettingsPanel) {
|
|
this.getSettingsPanel = () => {
|
|
this.#updateConfig();
|
|
return BdApi.UI.buildSettingsPanel({
|
|
onChange: (_, id, value) => {
|
|
this.settings[id] = value;
|
|
this.saveSettings();
|
|
},
|
|
settings: this.manifest.config
|
|
});
|
|
};
|
|
}
|
|
}
|
|
async start() {
|
|
BdApi.Logger.info(this.meta.name, `version ${this.meta.version} has started.`);
|
|
if (this.defaultSettings) this.settings = this.loadSettings();
|
|
if (typeof this.onStart == "function") this.onStart();
|
|
}
|
|
stop() {
|
|
BdApi.Logger.info(this.meta.name, `version ${this.meta.version} has stopped.`);
|
|
if (typeof this.onStop == "function") this.onStop();
|
|
}
|
|
#showChangelog() {
|
|
if (typeof this.manifest.changelog == "undefined") return;
|
|
const changelog = {
|
|
title: this.meta.name + " Changelog",
|
|
subtitle: `v${this.meta.version}`,
|
|
changes: []
|
|
};
|
|
if (!Array.isArray(this.manifest.changelog)) Object.assign(changelog, this.manifest.changelog);
|
|
else changelog.changes = this.manifest.changelog;
|
|
BdApi.UI.showChangelogModal(changelog);
|
|
}
|
|
saveSettings() {
|
|
BdApi.Data.save(this.meta.name, "settings", this.settings);
|
|
}
|
|
loadSettings() {
|
|
return BdApi.Utils.extend({}, this.defaultSettings ?? {}, BdApi.Data.load(this.meta.name, "settings"));
|
|
}
|
|
#updateConfig() {
|
|
if (!this.manifest.config) return;
|
|
for (const setting of this.manifest.config) {
|
|
if (setting.type !== "category") {
|
|
setting.value = this.settings[setting.id] ?? setting.value;
|
|
} else {
|
|
for (const subsetting of setting.settings) {
|
|
subsetting.value = this.settings[subsetting.id] ?? subsetting.value;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
buildSettingsPanel(onChange) {
|
|
this.#updateConfig();
|
|
return BdApi.UI.buildSettingsPanel({
|
|
onChange: (groupId, id, value) => {
|
|
this.settings[id] = value;
|
|
onChange?.(groupId, id, value);
|
|
this.saveSettings();
|
|
},
|
|
settings: this.manifest.config
|
|
});
|
|
}
|
|
};
|
|
|
|
// src/common/formatstring.ts
|
|
function formatString(stringToFormat, ...replacements) {
|
|
for (let v = 0; v < replacements.length; v++) {
|
|
const values = replacements[v];
|
|
for (const val in values) {
|
|
let replacement = values[val];
|
|
if (Array.isArray(replacement)) replacement = JSON.stringify(replacement);
|
|
if (typeof replacement === "object" && replacement !== null) replacement = replacement.toString();
|
|
stringToFormat = stringToFormat.replace(new RegExp(`{{${val}}}`, "g"), replacement.toString());
|
|
}
|
|
}
|
|
return stringToFormat;
|
|
}
|
|
|
|
// src/plugins/PermissionsViewer/config.ts
|
|
var manifest = {
|
|
info: {
|
|
name: "PermissionsViewer",
|
|
authors: [{
|
|
name: "Zerebos",
|
|
discord_id: "249746236008169473",
|
|
github_username: "zerebos",
|
|
twitter_username: "IAmZerebos"
|
|
}],
|
|
version: "1.0.0",
|
|
description: "Allows you to view all the permissions for users, servers, and channels!",
|
|
github: "https://github.com/zerebos/BetterDiscordAddons/tree/master/Plugins/PermissionsViewer",
|
|
github_raw: "https://raw.githubusercontent.com/zerebos/BetterDiscordAddons/master/Plugins/PermissionsViewer/PermissionsViewer.plugin.js"
|
|
},
|
|
changelog: {
|
|
banner: "https://github.com/user-attachments/assets/a9cd5ef8-35fa-446e-8839-1b9cb1dc8962",
|
|
blurb: "It took me a long time but I finally sat down and rewrote the entire plugin to be more efficient, better looking, and more accurate. If you had issues with the old version, please give this one a try!",
|
|
changes: [
|
|
{
|
|
type: "added",
|
|
title: "Total Rewrite!",
|
|
items: [
|
|
"Switched from using stinky virgin React to based chad Svelte.",
|
|
"Completely revamped the UI to be more user friendly and look better.",
|
|
"Improved performance and reduced memory usage.",
|
|
'Users now have an "Effective Permissions" section that shows their overall permissions.',
|
|
"Roles and permissions are now searchable to make finding specific permissions easier.",
|
|
"Channel overwrites now make user and role overwrites more clear and easier to understand.",
|
|
"Added support for role icons and emojis.",
|
|
"Neutral permissions can now be toggled either in settings or in the modal itself."
|
|
]
|
|
},
|
|
{
|
|
title: "Also Some Fixes",
|
|
type: "fixed",
|
|
items: [
|
|
"Permission badges in popouts now show up properly.",
|
|
"Improved accuracy of permission calculations.",
|
|
"Fixed an issue where some permissions would show up as denied when they were actually neutral.",
|
|
"Roles and permissions are now sorted by position instead of alphabetically."
|
|
]
|
|
}
|
|
]
|
|
},
|
|
config: [
|
|
{
|
|
type: "switch",
|
|
id: "contextMenus",
|
|
name: "Context Menus",
|
|
value: true
|
|
},
|
|
{
|
|
type: "switch",
|
|
id: "popouts",
|
|
name: "Popouts",
|
|
value: true
|
|
},
|
|
{
|
|
type: "switch",
|
|
id: "showNeutral",
|
|
name: "Show Neutral Permissions",
|
|
value: false
|
|
}
|
|
],
|
|
strings: {
|
|
es: {
|
|
contextMenuLabel: "Permisos",
|
|
popoutLabel: "Permisos",
|
|
modal: {
|
|
header: "Permisos de {{name}}",
|
|
rolesLabel: "Roles",
|
|
permissionsLabel: "Permisos",
|
|
owner: "@propietario"
|
|
},
|
|
settings: {
|
|
popouts: {
|
|
name: "Mostrar en Popouts",
|
|
note: "Mostrar los permisos de usuario en popouts como los roles."
|
|
},
|
|
contextMenus: {
|
|
name: "Bot\xF3n de men\xFA contextual",
|
|
note: "A\xF1adir un bot\xF3n para ver permisos en los men\xFAs contextuales."
|
|
}
|
|
}
|
|
},
|
|
pt: {
|
|
contextMenuLabel: "Permiss\xF5es",
|
|
popoutLabel: "Permiss\xF5es",
|
|
modal: {
|
|
header: "Permiss\xF5es de {{name}}",
|
|
rolesLabel: "Cargos",
|
|
permissionsLabel: "Permiss\xF5es",
|
|
owner: "@dono"
|
|
},
|
|
settings: {
|
|
popouts: {
|
|
name: "Mostrar em Popouts",
|
|
note: "Mostrar as permiss\xF5es em popouts como os cargos."
|
|
},
|
|
contextMenus: {
|
|
name: "Bot\xE3o do menu de contexto",
|
|
note: "Adicionar um bot\xE3o parar ver permiss\xF5es ao menu de contexto."
|
|
}
|
|
}
|
|
},
|
|
de: {
|
|
contextMenuLabel: "Berechtigungen",
|
|
popoutLabel: "Berechtigungen",
|
|
modal: {
|
|
header: "{{name}}s Berechtigungen",
|
|
rolesLabel: "Rollen",
|
|
permissionsLabel: "Berechtigungen",
|
|
owner: "@eigent\xFCmer"
|
|
},
|
|
settings: {
|
|
popouts: {
|
|
name: "In Popouts anzeigen",
|
|
note: "Zeigt die Gesamtberechtigungen eines Benutzers in seinem Popup \xE4hnlich den Rollen an."
|
|
},
|
|
contextMenus: {
|
|
name: "Kontextmen\xFC-Schaltfl\xE4che",
|
|
note: "F\xFCgt eine Schaltfl\xE4che hinzu, um die Berechtigungen mithilfe von Kontextmen\xFCs anzuzeigen."
|
|
}
|
|
}
|
|
},
|
|
en: {
|
|
contextMenuLabel: "Permissions",
|
|
popoutLabel: "Permissions",
|
|
modal: {
|
|
header: "{{name}}'s Permissions",
|
|
rolesLabel: "Roles",
|
|
permissionsLabel: "Permissions",
|
|
owner: "@owner"
|
|
},
|
|
settings: {
|
|
popouts: {
|
|
name: "Show In Popouts",
|
|
note: "Shows a user's total permissions in their popout similar to roles."
|
|
},
|
|
contextMenus: {
|
|
name: "Context Menu Button",
|
|
note: "Adds a button to view the permissions modal to select context menus."
|
|
},
|
|
showNeutral: {
|
|
name: "Show Neutral Permissions",
|
|
note: "Whether to show permissions that are neither allowed nor denied."
|
|
}
|
|
}
|
|
},
|
|
ru: {
|
|
contextMenuLabel: "\u041F\u043E\u043B\u043D\u043E\u043C\u043E\u0447\u0438\u044F",
|
|
popoutLabel: "\u041F\u043E\u043B\u043D\u043E\u043C\u043E\u0447\u0438\u044F",
|
|
modal: {
|
|
header: "\u041F\u043E\u043B\u043D\u043E\u043C\u043E\u0447\u0438\u044F {{name}}",
|
|
rolesLabel: "\u0420\u043E\u043B\u0438",
|
|
permissionsLabel: "\u041F\u043E\u043B\u043D\u043E\u043C\u043E\u0447\u0438\u044F",
|
|
owner: "\u0412\u043B\u0430\u0434\u0435\u043B\u0435\u0446"
|
|
},
|
|
settings: {
|
|
popouts: {
|
|
name: "\u041F\u043E\u043A\u0430\u0437\u0430\u0442\u044C \u0432\u043E \u0432\u0441\u043F\u043B\u044B\u0432\u0430\u044E\u0449\u0438\u0445 \u043E\u043A\u043D\u0430\u0445",
|
|
note: "\u041E\u0442\u043E\u0431\u0440\u0430\u0436\u0430\u0435\u0442 \u043F\u043E\u043B\u043D\u043E\u043C\u043E\u0447\u0438\u044F \u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u0442\u0435\u043B\u044F \u0432 \u0438\u0445 \u0432\u0441\u043F\u043B\u044B\u0432\u0430\u044E\u0449\u0435\u043C \u043E\u043A\u043D\u0435, \u0430\u043D\u0430\u043B\u043E\u0433\u0438\u0447\u043D\u043E\u043C \u0440\u043E\u043B\u044F\u043C."
|
|
},
|
|
contextMenus: {
|
|
name: "\u041A\u043D\u043E\u043F\u043A\u0430 \u043A\u043E\u043D\u0442\u0435\u043A\u0441\u0442\u043D\u043E\u0433\u043E \u043C\u0435\u043D\u044E",
|
|
note: "\u0414\u043E\u0431\u0430\u0432\u0438\u0442\u044C \u043A\u043D\u043E\u043F\u043A\u0443 \u0434\u043B\u044F \u043E\u0442\u043E\u0431\u0440\u0430\u0436\u0435\u043D\u0438\u044F \u043F\u043E\u043B\u043D\u043E\u043C\u043E\u0447\u0438\u0439 \u0441 \u043F\u043E\u043C\u043E\u0449\u044C\u044E \u043A\u043E\u043D\u0442\u0435\u043A\u0441\u0442\u043D\u044B\u0445 \u043C\u0435\u043D\u044E."
|
|
}
|
|
}
|
|
},
|
|
nl: {
|
|
contextMenuLabel: "Permissies",
|
|
popoutLabel: "Permissies",
|
|
modal: {
|
|
header: "{{name}}'s Permissies",
|
|
rolesLabel: "Rollen",
|
|
permissionsLabel: "Permissies",
|
|
owner: "@eigenaar"
|
|
},
|
|
settings: {
|
|
popouts: {
|
|
name: "Toon in Popouts",
|
|
note: "Toont de totale rechten van een gebruiker in zijn pop-out, vergelijkbaar met rollen."
|
|
},
|
|
contextMenus: {
|
|
name: "Contextmenuknop",
|
|
note: "Voegt een knop toe om de machtigingsmodaliteit voor het selecteren van contextmenu's te bekijken."
|
|
}
|
|
}
|
|
}
|
|
},
|
|
main: "index.ts"
|
|
};
|
|
var config_default = manifest;
|
|
|
|
// src/plugins/PermissionsViewer/styles.css
|
|
var styles_default = ".perm-user-avatar {\n border-radius: 50%;\n width: 16px;\n height: 16px;\n margin-right: 3px;\n}\n\n.member-perms-header {\n display: flex;\n justify-content: space-between;\n}\n\n.member-perms {\n display: flex;\n flex-wrap: wrap;\n margin-top: 2px;\n max-height: 160px;\n overflow-y: auto;\n overflow-x: hidden;\n}\n\n.member-perms .member-perm .perm-circle {\n border-radius: 50%;\n height: 12px;\n margin: 0 8px 0 5px;\n width: 12px;\n}\n\n.member-perms .member-perm .name {\n margin-right: 4px;\n max-width: 200px;\n overflow: hidden;\n text-overflow: ellipsis;\n white-space: nowrap;\n}\n\n.perm-details-button {\n cursor: pointer;\n height: 12px;\n}\n\n.perm-details {\n display: flex;\n justify-content: flex-end;\n}\n\n.member-perm-details {\n cursor: pointer;\n}\n\n.member-perm-details-button {\n fill: #72767d;\n height: 10px;\n}\n\n.member-perms::-webkit-scrollbar-thumb,\n.member-perms::-webkit-scrollbar-track {\n background-clip: padding-box;\n border-radius: 7.5px;\n border-style: solid;\n border-width: 3px;\n visibility: hidden;\n}\n\n.member-perms:hover::-webkit-scrollbar-thumb,\n.member-perms:hover::-webkit-scrollbar-track {\n visibility: visible;\n}\n\n.member-perms::-webkit-scrollbar-track {\n border-width: initial;\n background-color: transparent;\n border: 2px solid transparent;\n}\n\n.member-perms::-webkit-scrollbar-thumb {\n border: 2px solid transparent;\n border-radius: 4px;\n cursor: move;\n background-color: rgba(32,34,37,.6);\n}\n\n.member-perms::-webkit-scrollbar {\n height: 8px;\n width: 8px;\n}";
|
|
|
|
// src/plugins/PermissionsViewer/item.html
|
|
var item_default = '<div class="{{roleTag}}">\n <div class="member-perm {{role}}" style="max-width: 268px;">\n <span class="perm-circle {{roleCircle}} {{desaturateUserColors}}"></span>\n <div class="name {{text-xs/normal}} {{roleName}}" style="color: var(--text-default);"></div>\n </div>\n</div>';
|
|
|
|
// src/plugins/PermissionsViewer/list.html
|
|
var list_default = '<div class="{{section}}" id="permissions-popout">\n <h1 class="member-perms-header {{text-xs/semibold}} {{defaultColor}} {{heading}}">\n <div class="member-perms-title">{{sectionTitle}}</div>\n <span class="perm-details">\n <svg name="Details" viewBox="0 0 24 24" class="perm-details-button" fill="currentColor">\n <path d="M0 0h24v24H0z" fill="none"/>\n <path d="M12 8c1.1 0 2-.9 2-2s-.9-2-2-2-2 .9-2 2 .9 2 2 2zm0 2c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm0 6c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2z"/>\n </svg>\n </span>\n </h1>\n <div class="member-perms {{root}}"></div>\n</div>';
|
|
|
|
// src/common/colors.ts
|
|
function getRGB(color) {
|
|
let result = /rgb\(\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*\)/.exec(color);
|
|
if (result) return [parseInt(result[1]), parseInt(result[2]), parseInt(result[3])];
|
|
result = /rgb\(\s*([0-9]+(?:\.[0-9]+)?)%\s*,\s*([0-9]+(?:\.[0-9]+)?)%\s*,\s*([0-9]+(?:\.[0-9]+)?)%\s*\)/.exec(color);
|
|
if (result) return [parseFloat(result[1]) * 2.55, parseFloat(result[2]) * 2.55, parseFloat(result[3]) * 2.55];
|
|
result = /#([a-fA-F0-9]{2})([a-fA-F0-9]{2})([a-fA-F0-9]{2})/.exec(color);
|
|
if (result) return [parseInt(result[1], 16), parseInt(result[2], 16), parseInt(result[3], 16)];
|
|
result = /#([a-fA-F0-9])([a-fA-F0-9])([a-fA-F0-9])/.exec(color);
|
|
if (result) return [parseInt(result[1] + result[1], 16), parseInt(result[2] + result[2], 16), parseInt(result[3] + result[3], 16)];
|
|
}
|
|
function rgbToAlpha(color, alpha) {
|
|
const rgb = getRGB(color);
|
|
if (!rgb) return color;
|
|
return "rgba(" + rgb[0] + "," + rgb[1] + "," + rgb[2] + "," + alpha + ")";
|
|
}
|
|
|
|
// node_modules/svelte/src/version.js
|
|
var PUBLIC_VERSION = "5";
|
|
|
|
// node_modules/svelte/src/internal/disclose-version.js
|
|
if (typeof window !== "undefined") {
|
|
((window.__svelte ??= {}).v ??= /* @__PURE__ */ new Set()).add(PUBLIC_VERSION);
|
|
}
|
|
|
|
// node_modules/svelte/src/constants.js
|
|
var EACH_ITEM_REACTIVE = 1;
|
|
var EACH_INDEX_REACTIVE = 1 << 1;
|
|
var EACH_IS_CONTROLLED = 1 << 2;
|
|
var EACH_IS_ANIMATED = 1 << 3;
|
|
var EACH_ITEM_IMMUTABLE = 1 << 4;
|
|
var PROPS_IS_IMMUTABLE = 1;
|
|
var PROPS_IS_RUNES = 1 << 1;
|
|
var PROPS_IS_UPDATED = 1 << 2;
|
|
var PROPS_IS_BINDABLE = 1 << 3;
|
|
var PROPS_IS_LAZY_INITIAL = 1 << 4;
|
|
var TRANSITION_IN = 1;
|
|
var TRANSITION_OUT = 1 << 1;
|
|
var TRANSITION_GLOBAL = 1 << 2;
|
|
var TEMPLATE_FRAGMENT = 1;
|
|
var TEMPLATE_USE_IMPORT_NODE = 1 << 1;
|
|
var TEMPLATE_USE_SVG = 1 << 2;
|
|
var TEMPLATE_USE_MATHML = 1 << 3;
|
|
var HYDRATION_START = "[";
|
|
var HYDRATION_START_ELSE = "[!";
|
|
var HYDRATION_START_FAILED = "[?";
|
|
var HYDRATION_END = "]";
|
|
var HYDRATION_ERROR = {};
|
|
var ELEMENT_PRESERVE_ATTRIBUTE_CASE = 1 << 1;
|
|
var ELEMENT_IS_INPUT = 1 << 2;
|
|
var UNINITIALIZED = /* @__PURE__ */ Symbol();
|
|
var FILENAME = /* @__PURE__ */ Symbol("filename");
|
|
var NAMESPACE_HTML = "http://www.w3.org/1999/xhtml";
|
|
|
|
// node_modules/esm-env/true.js
|
|
var true_default = true;
|
|
|
|
// node_modules/esm-env/dev-fallback.js
|
|
var node_env = globalThis.process?.env?.NODE_ENV;
|
|
var dev_fallback_default = node_env && !node_env.toLowerCase().startsWith("prod");
|
|
|
|
// node_modules/svelte/src/internal/shared/utils.js
|
|
var is_array = Array.isArray;
|
|
var index_of = Array.prototype.indexOf;
|
|
var includes = Array.prototype.includes;
|
|
var array_from = Array.from;
|
|
var object_keys = Object.keys;
|
|
var define_property = Object.defineProperty;
|
|
var get_descriptor = Object.getOwnPropertyDescriptor;
|
|
var get_descriptors = Object.getOwnPropertyDescriptors;
|
|
var object_prototype = Object.prototype;
|
|
var array_prototype = Array.prototype;
|
|
var get_prototype_of = Object.getPrototypeOf;
|
|
var is_extensible = Object.isExtensible;
|
|
function is_function(thing) {
|
|
return typeof thing === "function";
|
|
}
|
|
var noop = () => {
|
|
};
|
|
function run_all(arr) {
|
|
for (var i = 0; i < arr.length; i++) {
|
|
arr[i]();
|
|
}
|
|
}
|
|
function deferred() {
|
|
var resolve;
|
|
var reject;
|
|
var promise = new Promise((res, rej) => {
|
|
resolve = res;
|
|
reject = rej;
|
|
});
|
|
return { promise, resolve, reject };
|
|
}
|
|
|
|
// node_modules/svelte/src/internal/client/constants.js
|
|
var DERIVED = 1 << 1;
|
|
var EFFECT = 1 << 2;
|
|
var RENDER_EFFECT = 1 << 3;
|
|
var MANAGED_EFFECT = 1 << 24;
|
|
var BLOCK_EFFECT = 1 << 4;
|
|
var BRANCH_EFFECT = 1 << 5;
|
|
var ROOT_EFFECT = 1 << 6;
|
|
var BOUNDARY_EFFECT = 1 << 7;
|
|
var CONNECTED = 1 << 9;
|
|
var CLEAN = 1 << 10;
|
|
var DIRTY = 1 << 11;
|
|
var MAYBE_DIRTY = 1 << 12;
|
|
var INERT = 1 << 13;
|
|
var DESTROYED = 1 << 14;
|
|
var REACTION_RAN = 1 << 15;
|
|
var EFFECT_TRANSPARENT = 1 << 16;
|
|
var EAGER_EFFECT = 1 << 17;
|
|
var HEAD_EFFECT = 1 << 18;
|
|
var EFFECT_PRESERVED = 1 << 19;
|
|
var USER_EFFECT = 1 << 20;
|
|
var EFFECT_OFFSCREEN = 1 << 25;
|
|
var WAS_MARKED = 1 << 16;
|
|
var REACTION_IS_UPDATING = 1 << 21;
|
|
var ASYNC = 1 << 22;
|
|
var ERROR_VALUE = 1 << 23;
|
|
var STATE_SYMBOL = /* @__PURE__ */ Symbol("$state");
|
|
var LEGACY_PROPS = /* @__PURE__ */ Symbol("legacy props");
|
|
var LOADING_ATTR_SYMBOL = /* @__PURE__ */ Symbol("");
|
|
var PROXY_PATH_SYMBOL = /* @__PURE__ */ Symbol("proxy path");
|
|
var STALE_REACTION = new class StaleReactionError extends Error {
|
|
name = "StaleReactionError";
|
|
message = "The reaction that called `getAbortSignal()` was re-run or destroyed";
|
|
}();
|
|
var IS_XHTML = (
|
|
// We gotta write it like this because after downleveling the pure comment may end up in the wrong location
|
|
!!globalThis.document?.contentType && /* @__PURE__ */ globalThis.document.contentType.includes("xml")
|
|
);
|
|
var TEXT_NODE = 3;
|
|
var COMMENT_NODE = 8;
|
|
|
|
// node_modules/svelte/src/internal/client/errors.js
|
|
function async_derived_orphan() {
|
|
if (dev_fallback_default) {
|
|
const error = new Error(`async_derived_orphan
|
|
Cannot create a \`$derived(...)\` with an \`await\` expression outside of an effect tree
|
|
https://svelte.dev/e/async_derived_orphan`);
|
|
error.name = "Svelte error";
|
|
throw error;
|
|
} else {
|
|
throw new Error(`https://svelte.dev/e/async_derived_orphan`);
|
|
}
|
|
}
|
|
function derived_references_self() {
|
|
if (dev_fallback_default) {
|
|
const error = new Error(`derived_references_self
|
|
A derived value cannot reference itself recursively
|
|
https://svelte.dev/e/derived_references_self`);
|
|
error.name = "Svelte error";
|
|
throw error;
|
|
} else {
|
|
throw new Error(`https://svelte.dev/e/derived_references_self`);
|
|
}
|
|
}
|
|
function each_key_duplicate(a, b, value) {
|
|
if (dev_fallback_default) {
|
|
const error = new Error(`each_key_duplicate
|
|
${value ? `Keyed each block has duplicate key \`${value}\` at indexes ${a} and ${b}` : `Keyed each block has duplicate key at indexes ${a} and ${b}`}
|
|
https://svelte.dev/e/each_key_duplicate`);
|
|
error.name = "Svelte error";
|
|
throw error;
|
|
} else {
|
|
throw new Error(`https://svelte.dev/e/each_key_duplicate`);
|
|
}
|
|
}
|
|
function each_key_volatile(index2, a, b) {
|
|
if (dev_fallback_default) {
|
|
const error = new Error(`each_key_volatile
|
|
Keyed each block has key that is not idempotent \u2014 the key for item at index ${index2} was \`${a}\` but is now \`${b}\`. Keys must be the same each time for a given item
|
|
https://svelte.dev/e/each_key_volatile`);
|
|
error.name = "Svelte error";
|
|
throw error;
|
|
} else {
|
|
throw new Error(`https://svelte.dev/e/each_key_volatile`);
|
|
}
|
|
}
|
|
function effect_in_teardown(rune) {
|
|
if (dev_fallback_default) {
|
|
const error = new Error(`effect_in_teardown
|
|
\`${rune}\` cannot be used inside an effect cleanup function
|
|
https://svelte.dev/e/effect_in_teardown`);
|
|
error.name = "Svelte error";
|
|
throw error;
|
|
} else {
|
|
throw new Error(`https://svelte.dev/e/effect_in_teardown`);
|
|
}
|
|
}
|
|
function effect_in_unowned_derived() {
|
|
if (dev_fallback_default) {
|
|
const error = new Error(`effect_in_unowned_derived
|
|
Effect cannot be created inside a \`$derived\` value that was not itself created inside an effect
|
|
https://svelte.dev/e/effect_in_unowned_derived`);
|
|
error.name = "Svelte error";
|
|
throw error;
|
|
} else {
|
|
throw new Error(`https://svelte.dev/e/effect_in_unowned_derived`);
|
|
}
|
|
}
|
|
function effect_orphan(rune) {
|
|
if (dev_fallback_default) {
|
|
const error = new Error(`effect_orphan
|
|
\`${rune}\` can only be used inside an effect (e.g. during component initialisation)
|
|
https://svelte.dev/e/effect_orphan`);
|
|
error.name = "Svelte error";
|
|
throw error;
|
|
} else {
|
|
throw new Error(`https://svelte.dev/e/effect_orphan`);
|
|
}
|
|
}
|
|
function effect_update_depth_exceeded() {
|
|
if (dev_fallback_default) {
|
|
const error = new Error(`effect_update_depth_exceeded
|
|
Maximum update depth exceeded. This typically indicates that an effect reads and writes the same piece of state
|
|
https://svelte.dev/e/effect_update_depth_exceeded`);
|
|
error.name = "Svelte error";
|
|
throw error;
|
|
} else {
|
|
throw new Error(`https://svelte.dev/e/effect_update_depth_exceeded`);
|
|
}
|
|
}
|
|
function hydration_failed() {
|
|
if (dev_fallback_default) {
|
|
const error = new Error(`hydration_failed
|
|
Failed to hydrate the application
|
|
https://svelte.dev/e/hydration_failed`);
|
|
error.name = "Svelte error";
|
|
throw error;
|
|
} else {
|
|
throw new Error(`https://svelte.dev/e/hydration_failed`);
|
|
}
|
|
}
|
|
function invalid_snippet() {
|
|
if (dev_fallback_default) {
|
|
const error = new Error(`invalid_snippet
|
|
Could not \`{@render}\` snippet due to the expression being \`null\` or \`undefined\`. Consider using optional chaining \`{@render snippet?.()}\`
|
|
https://svelte.dev/e/invalid_snippet`);
|
|
error.name = "Svelte error";
|
|
throw error;
|
|
} else {
|
|
throw new Error(`https://svelte.dev/e/invalid_snippet`);
|
|
}
|
|
}
|
|
function props_invalid_value(key2) {
|
|
if (dev_fallback_default) {
|
|
const error = new Error(`props_invalid_value
|
|
Cannot do \`bind:${key2}={undefined}\` when \`${key2}\` has a fallback value
|
|
https://svelte.dev/e/props_invalid_value`);
|
|
error.name = "Svelte error";
|
|
throw error;
|
|
} else {
|
|
throw new Error(`https://svelte.dev/e/props_invalid_value`);
|
|
}
|
|
}
|
|
function rune_outside_svelte(rune) {
|
|
if (dev_fallback_default) {
|
|
const error = new Error(`rune_outside_svelte
|
|
The \`${rune}\` rune is only available inside \`.svelte\` and \`.svelte.js/ts\` files
|
|
https://svelte.dev/e/rune_outside_svelte`);
|
|
error.name = "Svelte error";
|
|
throw error;
|
|
} else {
|
|
throw new Error(`https://svelte.dev/e/rune_outside_svelte`);
|
|
}
|
|
}
|
|
function state_descriptors_fixed() {
|
|
if (dev_fallback_default) {
|
|
const error = new Error(`state_descriptors_fixed
|
|
Property descriptors defined on \`$state\` objects must contain \`value\` and always be \`enumerable\`, \`configurable\` and \`writable\`.
|
|
https://svelte.dev/e/state_descriptors_fixed`);
|
|
error.name = "Svelte error";
|
|
throw error;
|
|
} else {
|
|
throw new Error(`https://svelte.dev/e/state_descriptors_fixed`);
|
|
}
|
|
}
|
|
function state_prototype_fixed() {
|
|
if (dev_fallback_default) {
|
|
const error = new Error(`state_prototype_fixed
|
|
Cannot set prototype of \`$state\` object
|
|
https://svelte.dev/e/state_prototype_fixed`);
|
|
error.name = "Svelte error";
|
|
throw error;
|
|
} else {
|
|
throw new Error(`https://svelte.dev/e/state_prototype_fixed`);
|
|
}
|
|
}
|
|
function state_unsafe_mutation() {
|
|
if (dev_fallback_default) {
|
|
const error = new Error(`state_unsafe_mutation
|
|
Updating state inside \`$derived(...)\`, \`$inspect(...)\` or a template expression is forbidden. If the value should not be reactive, declare it without \`$state\`
|
|
https://svelte.dev/e/state_unsafe_mutation`);
|
|
error.name = "Svelte error";
|
|
throw error;
|
|
} else {
|
|
throw new Error(`https://svelte.dev/e/state_unsafe_mutation`);
|
|
}
|
|
}
|
|
function svelte_boundary_reset_onerror() {
|
|
if (dev_fallback_default) {
|
|
const error = new Error(`svelte_boundary_reset_onerror
|
|
A \`<svelte:boundary>\` \`reset\` function cannot be called while an error is still being handled
|
|
https://svelte.dev/e/svelte_boundary_reset_onerror`);
|
|
error.name = "Svelte error";
|
|
throw error;
|
|
} else {
|
|
throw new Error(`https://svelte.dev/e/svelte_boundary_reset_onerror`);
|
|
}
|
|
}
|
|
|
|
// node_modules/svelte/src/internal/client/warnings.js
|
|
var bold = "font-weight: bold";
|
|
var normal = "font-weight: normal";
|
|
function await_waterfall(name, location) {
|
|
if (dev_fallback_default) {
|
|
console.warn(`%c[svelte] await_waterfall
|
|
%cAn async derived, \`${name}\` (${location}) was not read immediately after it resolved. This often indicates an unnecessary waterfall, which can slow down your app
|
|
https://svelte.dev/e/await_waterfall`, bold, normal);
|
|
} else {
|
|
console.warn(`https://svelte.dev/e/await_waterfall`);
|
|
}
|
|
}
|
|
function hydration_attribute_changed(attribute, html2, value) {
|
|
if (dev_fallback_default) {
|
|
console.warn(`%c[svelte] hydration_attribute_changed
|
|
%cThe \`${attribute}\` attribute on \`${html2}\` changed its value between server and client renders. The client value, \`${value}\`, will be ignored in favour of the server value
|
|
https://svelte.dev/e/hydration_attribute_changed`, bold, normal);
|
|
} else {
|
|
console.warn(`https://svelte.dev/e/hydration_attribute_changed`);
|
|
}
|
|
}
|
|
function hydration_mismatch(location) {
|
|
if (dev_fallback_default) {
|
|
console.warn(
|
|
`%c[svelte] hydration_mismatch
|
|
%c${location ? `Hydration failed because the initial UI does not match what was rendered on the server. The error occurred near ${location}` : "Hydration failed because the initial UI does not match what was rendered on the server"}
|
|
https://svelte.dev/e/hydration_mismatch`,
|
|
bold,
|
|
normal
|
|
);
|
|
} else {
|
|
console.warn(`https://svelte.dev/e/hydration_mismatch`);
|
|
}
|
|
}
|
|
function lifecycle_double_unmount() {
|
|
if (dev_fallback_default) {
|
|
console.warn(`%c[svelte] lifecycle_double_unmount
|
|
%cTried to unmount a component that was not mounted
|
|
https://svelte.dev/e/lifecycle_double_unmount`, bold, normal);
|
|
} else {
|
|
console.warn(`https://svelte.dev/e/lifecycle_double_unmount`);
|
|
}
|
|
}
|
|
function state_proxy_equality_mismatch(operator) {
|
|
if (dev_fallback_default) {
|
|
console.warn(`%c[svelte] state_proxy_equality_mismatch
|
|
%cReactive \`$state(...)\` proxies and the values they proxy have different identities. Because of this, comparisons with \`${operator}\` will produce unexpected results
|
|
https://svelte.dev/e/state_proxy_equality_mismatch`, bold, normal);
|
|
} else {
|
|
console.warn(`https://svelte.dev/e/state_proxy_equality_mismatch`);
|
|
}
|
|
}
|
|
function state_proxy_unmount() {
|
|
if (dev_fallback_default) {
|
|
console.warn(`%c[svelte] state_proxy_unmount
|
|
%cTried to unmount a state proxy, rather than a component
|
|
https://svelte.dev/e/state_proxy_unmount`, bold, normal);
|
|
} else {
|
|
console.warn(`https://svelte.dev/e/state_proxy_unmount`);
|
|
}
|
|
}
|
|
function svelte_boundary_reset_noop() {
|
|
if (dev_fallback_default) {
|
|
console.warn(`%c[svelte] svelte_boundary_reset_noop
|
|
%cA \`<svelte:boundary>\` \`reset\` function only resets the boundary the first time it is called
|
|
https://svelte.dev/e/svelte_boundary_reset_noop`, bold, normal);
|
|
} else {
|
|
console.warn(`https://svelte.dev/e/svelte_boundary_reset_noop`);
|
|
}
|
|
}
|
|
|
|
// node_modules/svelte/src/internal/client/dom/hydration.js
|
|
var hydrating = false;
|
|
function set_hydrating(value) {
|
|
hydrating = value;
|
|
}
|
|
var hydrate_node;
|
|
function set_hydrate_node(node) {
|
|
if (node === null) {
|
|
hydration_mismatch();
|
|
throw HYDRATION_ERROR;
|
|
}
|
|
return hydrate_node = node;
|
|
}
|
|
function hydrate_next() {
|
|
return set_hydrate_node(get_next_sibling(hydrate_node));
|
|
}
|
|
function reset(node) {
|
|
if (!hydrating) return;
|
|
if (get_next_sibling(hydrate_node) !== null) {
|
|
hydration_mismatch();
|
|
throw HYDRATION_ERROR;
|
|
}
|
|
hydrate_node = node;
|
|
}
|
|
function next(count = 1) {
|
|
if (hydrating) {
|
|
var i = count;
|
|
var node = hydrate_node;
|
|
while (i--) {
|
|
node = /** @type {TemplateNode} */
|
|
get_next_sibling(node);
|
|
}
|
|
hydrate_node = node;
|
|
}
|
|
}
|
|
function skip_nodes(remove = true) {
|
|
var depth = 0;
|
|
var node = hydrate_node;
|
|
while (true) {
|
|
if (node.nodeType === COMMENT_NODE) {
|
|
var data = (
|
|
/** @type {Comment} */
|
|
node.data
|
|
);
|
|
if (data === HYDRATION_END) {
|
|
if (depth === 0) return node;
|
|
depth -= 1;
|
|
} else if (data === HYDRATION_START || data === HYDRATION_START_ELSE || // "[1", "[2", etc. for if blocks
|
|
data[0] === "[" && !isNaN(Number(data.slice(1)))) {
|
|
depth += 1;
|
|
}
|
|
}
|
|
var next2 = (
|
|
/** @type {TemplateNode} */
|
|
get_next_sibling(node)
|
|
);
|
|
if (remove) node.remove();
|
|
node = next2;
|
|
}
|
|
}
|
|
function read_hydration_instruction(node) {
|
|
if (!node || node.nodeType !== COMMENT_NODE) {
|
|
hydration_mismatch();
|
|
throw HYDRATION_ERROR;
|
|
}
|
|
return (
|
|
/** @type {Comment} */
|
|
node.data
|
|
);
|
|
}
|
|
|
|
// node_modules/svelte/src/internal/client/reactivity/equality.js
|
|
function equals(value) {
|
|
return value === this.v;
|
|
}
|
|
function safe_not_equal(a, b) {
|
|
return a != a ? b == b : a !== b || a !== null && typeof a === "object" || typeof a === "function";
|
|
}
|
|
function safe_equals(value) {
|
|
return !safe_not_equal(value, this.v);
|
|
}
|
|
|
|
// node_modules/svelte/src/internal/flags/index.js
|
|
var async_mode_flag = false;
|
|
var legacy_mode_flag = false;
|
|
var tracing_mode_flag = false;
|
|
|
|
// node_modules/svelte/src/internal/client/dev/tracing.js
|
|
var tracing_expressions = null;
|
|
function tag(source2, label) {
|
|
source2.label = label;
|
|
tag_proxy(source2.v, label);
|
|
return source2;
|
|
}
|
|
function tag_proxy(value, label) {
|
|
value?.[PROXY_PATH_SYMBOL]?.(label);
|
|
return value;
|
|
}
|
|
|
|
// node_modules/svelte/src/internal/shared/dev.js
|
|
function get_error(label) {
|
|
const error = new Error();
|
|
const stack2 = get_stack();
|
|
if (stack2.length === 0) {
|
|
return null;
|
|
}
|
|
stack2.unshift("\n");
|
|
define_property(error, "stack", {
|
|
value: stack2.join("\n")
|
|
});
|
|
define_property(error, "name", {
|
|
value: label
|
|
});
|
|
return (
|
|
/** @type {Error & { stack: string }} */
|
|
error
|
|
);
|
|
}
|
|
function get_stack() {
|
|
const limit = Error.stackTraceLimit;
|
|
Error.stackTraceLimit = Infinity;
|
|
const stack2 = new Error().stack;
|
|
Error.stackTraceLimit = limit;
|
|
if (!stack2) return [];
|
|
const lines = stack2.split("\n");
|
|
const new_lines = [];
|
|
for (let i = 0; i < lines.length; i++) {
|
|
const line = lines[i];
|
|
const posixified = line.replaceAll("\\", "/");
|
|
if (line.trim() === "Error") {
|
|
continue;
|
|
}
|
|
if (line.includes("validate_each_keys")) {
|
|
return [];
|
|
}
|
|
if (posixified.includes("svelte/src/internal") || posixified.includes("node_modules/.vite")) {
|
|
continue;
|
|
}
|
|
new_lines.push(line);
|
|
}
|
|
return new_lines;
|
|
}
|
|
|
|
// node_modules/svelte/src/internal/client/context.js
|
|
var component_context = null;
|
|
function set_component_context(context) {
|
|
component_context = context;
|
|
}
|
|
var dev_stack = null;
|
|
function set_dev_stack(stack2) {
|
|
dev_stack = stack2;
|
|
}
|
|
var dev_current_component_function = null;
|
|
function set_dev_current_component_function(fn) {
|
|
dev_current_component_function = fn;
|
|
}
|
|
function push(props, runes = false, fn) {
|
|
component_context = {
|
|
p: component_context,
|
|
i: false,
|
|
c: null,
|
|
e: null,
|
|
s: props,
|
|
x: null,
|
|
l: legacy_mode_flag && !runes ? { s: null, u: null, $: [] } : null
|
|
};
|
|
if (dev_fallback_default) {
|
|
component_context.function = fn;
|
|
dev_current_component_function = fn;
|
|
}
|
|
}
|
|
function pop(component2) {
|
|
var context = (
|
|
/** @type {ComponentContext} */
|
|
component_context
|
|
);
|
|
var effects = context.e;
|
|
if (effects !== null) {
|
|
context.e = null;
|
|
for (var fn of effects) {
|
|
create_user_effect(fn);
|
|
}
|
|
}
|
|
if (component2 !== void 0) {
|
|
context.x = component2;
|
|
}
|
|
context.i = true;
|
|
component_context = context.p;
|
|
if (dev_fallback_default) {
|
|
dev_current_component_function = component_context?.function ?? null;
|
|
}
|
|
return component2 ?? /** @type {T} */
|
|
{};
|
|
}
|
|
function is_runes() {
|
|
return !legacy_mode_flag || component_context !== null && component_context.l === null;
|
|
}
|
|
|
|
// node_modules/svelte/src/internal/client/dom/task.js
|
|
var micro_tasks = [];
|
|
function run_micro_tasks() {
|
|
var tasks = micro_tasks;
|
|
micro_tasks = [];
|
|
run_all(tasks);
|
|
}
|
|
function queue_micro_task(fn) {
|
|
if (micro_tasks.length === 0 && !is_flushing_sync) {
|
|
var tasks = micro_tasks;
|
|
queueMicrotask(() => {
|
|
if (tasks === micro_tasks) run_micro_tasks();
|
|
});
|
|
}
|
|
micro_tasks.push(fn);
|
|
}
|
|
function flush_tasks() {
|
|
while (micro_tasks.length > 0) {
|
|
run_micro_tasks();
|
|
}
|
|
}
|
|
|
|
// node_modules/svelte/src/internal/client/error-handling.js
|
|
var adjustments = /* @__PURE__ */ new WeakMap();
|
|
function handle_error(error) {
|
|
var effect2 = active_effect;
|
|
if (effect2 === null) {
|
|
active_reaction.f |= ERROR_VALUE;
|
|
return error;
|
|
}
|
|
if (dev_fallback_default && error instanceof Error && !adjustments.has(error)) {
|
|
adjustments.set(error, get_adjustments(error, effect2));
|
|
}
|
|
if ((effect2.f & REACTION_RAN) === 0 && (effect2.f & EFFECT) === 0) {
|
|
if (dev_fallback_default && !effect2.parent && error instanceof Error) {
|
|
apply_adjustments(error);
|
|
}
|
|
throw error;
|
|
}
|
|
invoke_error_boundary(error, effect2);
|
|
}
|
|
function invoke_error_boundary(error, effect2) {
|
|
while (effect2 !== null) {
|
|
if ((effect2.f & BOUNDARY_EFFECT) !== 0) {
|
|
if ((effect2.f & REACTION_RAN) === 0) {
|
|
throw error;
|
|
}
|
|
try {
|
|
effect2.b.error(error);
|
|
return;
|
|
} catch (e) {
|
|
error = e;
|
|
}
|
|
}
|
|
effect2 = effect2.parent;
|
|
}
|
|
if (dev_fallback_default && error instanceof Error) {
|
|
apply_adjustments(error);
|
|
}
|
|
throw error;
|
|
}
|
|
function get_adjustments(error, effect2) {
|
|
const message_descriptor = get_descriptor(error, "message");
|
|
if (message_descriptor && !message_descriptor.configurable) return;
|
|
var indent = is_firefox ? " " : " ";
|
|
var component_stack = `
|
|
${indent}in ${effect2.fn?.name || "<unknown>"}`;
|
|
var context = effect2.ctx;
|
|
while (context !== null) {
|
|
component_stack += `
|
|
${indent}in ${context.function?.[FILENAME].split("/").pop()}`;
|
|
context = context.p;
|
|
}
|
|
return {
|
|
message: error.message + `
|
|
${component_stack}
|
|
`,
|
|
stack: error.stack?.split("\n").filter((line) => !line.includes("svelte/src/internal")).join("\n")
|
|
};
|
|
}
|
|
function apply_adjustments(error) {
|
|
const adjusted = adjustments.get(error);
|
|
if (adjusted) {
|
|
define_property(error, "message", {
|
|
value: adjusted.message
|
|
});
|
|
define_property(error, "stack", {
|
|
value: adjusted.stack
|
|
});
|
|
}
|
|
}
|
|
|
|
// node_modules/svelte/src/internal/client/reactivity/status.js
|
|
var STATUS_MASK = ~(DIRTY | MAYBE_DIRTY | CLEAN);
|
|
function set_signal_status(signal, status) {
|
|
signal.f = signal.f & STATUS_MASK | status;
|
|
}
|
|
function update_derived_status(derived2) {
|
|
if ((derived2.f & CONNECTED) !== 0 || derived2.deps === null) {
|
|
set_signal_status(derived2, CLEAN);
|
|
} else {
|
|
set_signal_status(derived2, MAYBE_DIRTY);
|
|
}
|
|
}
|
|
|
|
// node_modules/svelte/src/internal/client/reactivity/utils.js
|
|
function clear_marked(deps) {
|
|
if (deps === null) return;
|
|
for (const dep of deps) {
|
|
if ((dep.f & DERIVED) === 0 || (dep.f & WAS_MARKED) === 0) {
|
|
continue;
|
|
}
|
|
dep.f ^= WAS_MARKED;
|
|
clear_marked(
|
|
/** @type {Derived} */
|
|
dep.deps
|
|
);
|
|
}
|
|
}
|
|
function defer_effect(effect2, dirty_effects, maybe_dirty_effects) {
|
|
if ((effect2.f & DIRTY) !== 0) {
|
|
dirty_effects.add(effect2);
|
|
} else if ((effect2.f & MAYBE_DIRTY) !== 0) {
|
|
maybe_dirty_effects.add(effect2);
|
|
}
|
|
clear_marked(effect2.deps);
|
|
set_signal_status(effect2, CLEAN);
|
|
}
|
|
|
|
// node_modules/svelte/src/internal/client/reactivity/batch.js
|
|
var batches = /* @__PURE__ */ new Set();
|
|
var current_batch = null;
|
|
var previous_batch = null;
|
|
var batch_values = null;
|
|
var queued_root_effects = [];
|
|
var last_scheduled_effect = null;
|
|
var is_flushing_sync = false;
|
|
var collected_effects = null;
|
|
var Batch = class _Batch {
|
|
/**
|
|
* The current values of any sources that are updated in this batch
|
|
* They keys of this map are identical to `this.#previous`
|
|
* @type {Map<Source, any>}
|
|
*/
|
|
current = /* @__PURE__ */ new Map();
|
|
/**
|
|
* The values of any sources that are updated in this batch _before_ those updates took place.
|
|
* They keys of this map are identical to `this.#current`
|
|
* @type {Map<Source, any>}
|
|
*/
|
|
previous = /* @__PURE__ */ new Map();
|
|
/**
|
|
* When the batch is committed (and the DOM is updated), we need to remove old branches
|
|
* and append new ones by calling the functions added inside (if/each/key/etc) blocks
|
|
* @type {Set<(batch: Batch) => void>}
|
|
*/
|
|
#commit_callbacks = /* @__PURE__ */ new Set();
|
|
/**
|
|
* If a fork is discarded, we need to destroy any effects that are no longer needed
|
|
* @type {Set<(batch: Batch) => void>}
|
|
*/
|
|
#discard_callbacks = /* @__PURE__ */ new Set();
|
|
/**
|
|
* The number of async effects that are currently in flight
|
|
*/
|
|
#pending = 0;
|
|
/**
|
|
* The number of async effects that are currently in flight, _not_ inside a pending boundary
|
|
*/
|
|
#blocking_pending = 0;
|
|
/**
|
|
* A deferred that resolves when the batch is committed, used with `settled()`
|
|
* TODO replace with Promise.withResolvers once supported widely enough
|
|
* @type {{ promise: Promise<void>, resolve: (value?: any) => void, reject: (reason: unknown) => void } | null}
|
|
*/
|
|
#deferred = null;
|
|
/**
|
|
* Deferred effects (which run after async work has completed) that are DIRTY
|
|
* @type {Set<Effect>}
|
|
*/
|
|
#dirty_effects = /* @__PURE__ */ new Set();
|
|
/**
|
|
* Deferred effects that are MAYBE_DIRTY
|
|
* @type {Set<Effect>}
|
|
*/
|
|
#maybe_dirty_effects = /* @__PURE__ */ new Set();
|
|
/**
|
|
* A map of branches that still exist, but will be destroyed when this batch
|
|
* is committed — we skip over these during `process`.
|
|
* The value contains child effects that were dirty/maybe_dirty before being reset,
|
|
* so they can be rescheduled if the branch survives.
|
|
* @type {Map<Effect, { d: Effect[], m: Effect[] }>}
|
|
*/
|
|
#skipped_branches = /* @__PURE__ */ new Map();
|
|
is_fork = false;
|
|
#decrement_queued = false;
|
|
#is_deferred() {
|
|
return this.is_fork || this.#blocking_pending > 0;
|
|
}
|
|
/**
|
|
* Add an effect to the #skipped_branches map and reset its children
|
|
* @param {Effect} effect
|
|
*/
|
|
skip_effect(effect2) {
|
|
if (!this.#skipped_branches.has(effect2)) {
|
|
this.#skipped_branches.set(effect2, { d: [], m: [] });
|
|
}
|
|
}
|
|
/**
|
|
* Remove an effect from the #skipped_branches map and reschedule
|
|
* any tracked dirty/maybe_dirty child effects
|
|
* @param {Effect} effect
|
|
*/
|
|
unskip_effect(effect2) {
|
|
var tracked = this.#skipped_branches.get(effect2);
|
|
if (tracked) {
|
|
this.#skipped_branches.delete(effect2);
|
|
for (var e of tracked.d) {
|
|
set_signal_status(e, DIRTY);
|
|
schedule_effect(e);
|
|
}
|
|
for (e of tracked.m) {
|
|
set_signal_status(e, MAYBE_DIRTY);
|
|
schedule_effect(e);
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
*
|
|
* @param {Effect[]} root_effects
|
|
*/
|
|
process(root_effects) {
|
|
queued_root_effects = [];
|
|
this.apply();
|
|
var effects = collected_effects = [];
|
|
var render_effects = [];
|
|
for (const root7 of root_effects) {
|
|
this.#traverse_effect_tree(root7, effects, render_effects);
|
|
}
|
|
collected_effects = null;
|
|
if (this.#is_deferred()) {
|
|
this.#defer_effects(render_effects);
|
|
this.#defer_effects(effects);
|
|
for (const [e, t] of this.#skipped_branches) {
|
|
reset_branch(e, t);
|
|
}
|
|
} else {
|
|
previous_batch = this;
|
|
current_batch = null;
|
|
for (const fn of this.#commit_callbacks) fn(this);
|
|
this.#commit_callbacks.clear();
|
|
if (this.#pending === 0) {
|
|
this.#commit();
|
|
}
|
|
flush_queued_effects(render_effects);
|
|
flush_queued_effects(effects);
|
|
this.#dirty_effects.clear();
|
|
this.#maybe_dirty_effects.clear();
|
|
previous_batch = null;
|
|
this.#deferred?.resolve();
|
|
}
|
|
batch_values = null;
|
|
}
|
|
/**
|
|
* Traverse the effect tree, executing effects or stashing
|
|
* them for later execution as appropriate
|
|
* @param {Effect} root
|
|
* @param {Effect[]} effects
|
|
* @param {Effect[]} render_effects
|
|
*/
|
|
#traverse_effect_tree(root7, effects, render_effects) {
|
|
root7.f ^= CLEAN;
|
|
var effect2 = root7.first;
|
|
while (effect2 !== null) {
|
|
var flags2 = effect2.f;
|
|
var is_branch = (flags2 & (BRANCH_EFFECT | ROOT_EFFECT)) !== 0;
|
|
var is_skippable_branch = is_branch && (flags2 & CLEAN) !== 0;
|
|
var skip = is_skippable_branch || (flags2 & INERT) !== 0 || this.#skipped_branches.has(effect2);
|
|
if (!skip && effect2.fn !== null) {
|
|
if (is_branch) {
|
|
effect2.f ^= CLEAN;
|
|
} else if ((flags2 & EFFECT) !== 0) {
|
|
effects.push(effect2);
|
|
} else if (async_mode_flag && (flags2 & (RENDER_EFFECT | MANAGED_EFFECT)) !== 0) {
|
|
render_effects.push(effect2);
|
|
} else if (is_dirty(effect2)) {
|
|
if ((flags2 & BLOCK_EFFECT) !== 0) this.#maybe_dirty_effects.add(effect2);
|
|
update_effect(effect2);
|
|
}
|
|
var child2 = effect2.first;
|
|
if (child2 !== null) {
|
|
effect2 = child2;
|
|
continue;
|
|
}
|
|
}
|
|
while (effect2 !== null) {
|
|
var next2 = effect2.next;
|
|
if (next2 !== null) {
|
|
effect2 = next2;
|
|
break;
|
|
}
|
|
effect2 = effect2.parent;
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* @param {Effect[]} effects
|
|
*/
|
|
#defer_effects(effects) {
|
|
for (var i = 0; i < effects.length; i += 1) {
|
|
defer_effect(effects[i], this.#dirty_effects, this.#maybe_dirty_effects);
|
|
}
|
|
}
|
|
/**
|
|
* Associate a change to a given source with the current
|
|
* batch, noting its previous and current values
|
|
* @param {Source} source
|
|
* @param {any} value
|
|
*/
|
|
capture(source2, value) {
|
|
if (value !== UNINITIALIZED && !this.previous.has(source2)) {
|
|
this.previous.set(source2, value);
|
|
}
|
|
if ((source2.f & ERROR_VALUE) === 0) {
|
|
this.current.set(source2, source2.v);
|
|
batch_values?.set(source2, source2.v);
|
|
}
|
|
}
|
|
activate() {
|
|
current_batch = this;
|
|
this.apply();
|
|
}
|
|
deactivate() {
|
|
if (current_batch !== this) return;
|
|
current_batch = null;
|
|
batch_values = null;
|
|
}
|
|
flush() {
|
|
if (queued_root_effects.length > 0) {
|
|
current_batch = this;
|
|
flush_effects();
|
|
} else if (this.#pending === 0 && !this.is_fork) {
|
|
for (const fn of this.#commit_callbacks) fn(this);
|
|
this.#commit_callbacks.clear();
|
|
this.#commit();
|
|
this.#deferred?.resolve();
|
|
}
|
|
this.deactivate();
|
|
}
|
|
discard() {
|
|
for (const fn of this.#discard_callbacks) fn(this);
|
|
this.#discard_callbacks.clear();
|
|
}
|
|
#commit() {
|
|
if (batches.size > 1) {
|
|
this.previous.clear();
|
|
var previous_batch2 = current_batch;
|
|
var previous_batch_values = batch_values;
|
|
var is_earlier = true;
|
|
for (const batch of batches) {
|
|
if (batch === this) {
|
|
is_earlier = false;
|
|
continue;
|
|
}
|
|
const sources = [];
|
|
for (const [source2, value] of this.current) {
|
|
if (batch.current.has(source2)) {
|
|
if (is_earlier && value !== batch.current.get(source2)) {
|
|
batch.current.set(source2, value);
|
|
} else {
|
|
continue;
|
|
}
|
|
}
|
|
sources.push(source2);
|
|
}
|
|
if (sources.length === 0) {
|
|
continue;
|
|
}
|
|
const others = [...batch.current.keys()].filter((s) => !this.current.has(s));
|
|
if (others.length > 0) {
|
|
var prev_queued_root_effects = queued_root_effects;
|
|
queued_root_effects = [];
|
|
const marked = /* @__PURE__ */ new Set();
|
|
const checked = /* @__PURE__ */ new Map();
|
|
for (const source2 of sources) {
|
|
mark_effects(source2, others, marked, checked);
|
|
}
|
|
if (queued_root_effects.length > 0) {
|
|
current_batch = batch;
|
|
batch.apply();
|
|
for (const root7 of queued_root_effects) {
|
|
batch.#traverse_effect_tree(root7, [], []);
|
|
}
|
|
batch.deactivate();
|
|
}
|
|
queued_root_effects = prev_queued_root_effects;
|
|
}
|
|
}
|
|
current_batch = previous_batch2;
|
|
batch_values = previous_batch_values;
|
|
}
|
|
this.#skipped_branches.clear();
|
|
batches.delete(this);
|
|
}
|
|
/**
|
|
*
|
|
* @param {boolean} blocking
|
|
*/
|
|
increment(blocking) {
|
|
this.#pending += 1;
|
|
if (blocking) this.#blocking_pending += 1;
|
|
}
|
|
/**
|
|
*
|
|
* @param {boolean} blocking
|
|
*/
|
|
decrement(blocking) {
|
|
this.#pending -= 1;
|
|
if (blocking) this.#blocking_pending -= 1;
|
|
if (this.#decrement_queued) return;
|
|
this.#decrement_queued = true;
|
|
queue_micro_task(() => {
|
|
this.#decrement_queued = false;
|
|
if (!this.#is_deferred()) {
|
|
this.revive();
|
|
} else if (queued_root_effects.length > 0) {
|
|
this.flush();
|
|
}
|
|
});
|
|
}
|
|
revive() {
|
|
for (const e of this.#dirty_effects) {
|
|
this.#maybe_dirty_effects.delete(e);
|
|
set_signal_status(e, DIRTY);
|
|
schedule_effect(e);
|
|
}
|
|
for (const e of this.#maybe_dirty_effects) {
|
|
set_signal_status(e, MAYBE_DIRTY);
|
|
schedule_effect(e);
|
|
}
|
|
this.flush();
|
|
}
|
|
/** @param {(batch: Batch) => void} fn */
|
|
oncommit(fn) {
|
|
this.#commit_callbacks.add(fn);
|
|
}
|
|
/** @param {(batch: Batch) => void} fn */
|
|
ondiscard(fn) {
|
|
this.#discard_callbacks.add(fn);
|
|
}
|
|
settled() {
|
|
return (this.#deferred ??= deferred()).promise;
|
|
}
|
|
static ensure() {
|
|
if (current_batch === null) {
|
|
const batch = current_batch = new _Batch();
|
|
batches.add(current_batch);
|
|
if (!is_flushing_sync) {
|
|
queue_micro_task(() => {
|
|
if (current_batch !== batch) {
|
|
return;
|
|
}
|
|
batch.flush();
|
|
});
|
|
}
|
|
}
|
|
return current_batch;
|
|
}
|
|
apply() {
|
|
if (!async_mode_flag || !this.is_fork && batches.size === 1) return;
|
|
batch_values = new Map(this.current);
|
|
for (const batch of batches) {
|
|
if (batch === this) continue;
|
|
for (const [source2, previous] of batch.previous) {
|
|
if (!batch_values.has(source2)) {
|
|
batch_values.set(source2, previous);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
function flushSync(fn) {
|
|
var was_flushing_sync = is_flushing_sync;
|
|
is_flushing_sync = true;
|
|
try {
|
|
var result;
|
|
if (fn) {
|
|
if (current_batch !== null) {
|
|
flush_effects();
|
|
}
|
|
result = fn();
|
|
}
|
|
while (true) {
|
|
flush_tasks();
|
|
if (queued_root_effects.length === 0) {
|
|
current_batch?.flush();
|
|
if (queued_root_effects.length === 0) {
|
|
last_scheduled_effect = null;
|
|
return (
|
|
/** @type {T} */
|
|
result
|
|
);
|
|
}
|
|
}
|
|
flush_effects();
|
|
}
|
|
} finally {
|
|
is_flushing_sync = was_flushing_sync;
|
|
}
|
|
}
|
|
function flush_effects() {
|
|
var source_stacks = dev_fallback_default ? /* @__PURE__ */ new Set() : null;
|
|
try {
|
|
var flush_count = 0;
|
|
while (queued_root_effects.length > 0) {
|
|
var batch = Batch.ensure();
|
|
if (flush_count++ > 1e3) {
|
|
if (dev_fallback_default) {
|
|
var updates = /* @__PURE__ */ new Map();
|
|
for (const source2 of batch.current.keys()) {
|
|
for (const [stack2, update2] of source2.updated ?? []) {
|
|
var entry = updates.get(stack2);
|
|
if (!entry) {
|
|
entry = { error: update2.error, count: 0 };
|
|
updates.set(stack2, entry);
|
|
}
|
|
entry.count += update2.count;
|
|
}
|
|
}
|
|
for (const update2 of updates.values()) {
|
|
if (update2.error) {
|
|
console.error(update2.error);
|
|
}
|
|
}
|
|
}
|
|
infinite_loop_guard();
|
|
}
|
|
batch.process(queued_root_effects);
|
|
old_values.clear();
|
|
if (dev_fallback_default) {
|
|
for (const source2 of batch.current.keys()) {
|
|
source_stacks.add(source2);
|
|
}
|
|
}
|
|
}
|
|
} finally {
|
|
queued_root_effects = [];
|
|
last_scheduled_effect = null;
|
|
collected_effects = null;
|
|
if (dev_fallback_default) {
|
|
for (
|
|
const source2 of
|
|
/** @type {Set<Source>} */
|
|
source_stacks
|
|
) {
|
|
source2.updated = null;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function infinite_loop_guard() {
|
|
try {
|
|
effect_update_depth_exceeded();
|
|
} catch (error) {
|
|
if (dev_fallback_default) {
|
|
define_property(error, "stack", { value: "" });
|
|
}
|
|
invoke_error_boundary(error, last_scheduled_effect);
|
|
}
|
|
}
|
|
var eager_block_effects = null;
|
|
function flush_queued_effects(effects) {
|
|
var length = effects.length;
|
|
if (length === 0) return;
|
|
var i = 0;
|
|
while (i < length) {
|
|
var effect2 = effects[i++];
|
|
if ((effect2.f & (DESTROYED | INERT)) === 0 && is_dirty(effect2)) {
|
|
eager_block_effects = /* @__PURE__ */ new Set();
|
|
update_effect(effect2);
|
|
if (effect2.deps === null && effect2.first === null && effect2.nodes === null && effect2.teardown === null && effect2.ac === null) {
|
|
unlink_effect(effect2);
|
|
}
|
|
if (eager_block_effects?.size > 0) {
|
|
old_values.clear();
|
|
for (const e of eager_block_effects) {
|
|
if ((e.f & (DESTROYED | INERT)) !== 0) continue;
|
|
const ordered_effects = [e];
|
|
let ancestor = e.parent;
|
|
while (ancestor !== null) {
|
|
if (eager_block_effects.has(ancestor)) {
|
|
eager_block_effects.delete(ancestor);
|
|
ordered_effects.push(ancestor);
|
|
}
|
|
ancestor = ancestor.parent;
|
|
}
|
|
for (let j = ordered_effects.length - 1; j >= 0; j--) {
|
|
const e2 = ordered_effects[j];
|
|
if ((e2.f & (DESTROYED | INERT)) !== 0) continue;
|
|
update_effect(e2);
|
|
}
|
|
}
|
|
eager_block_effects.clear();
|
|
}
|
|
}
|
|
}
|
|
eager_block_effects = null;
|
|
}
|
|
function mark_effects(value, sources, marked, checked) {
|
|
if (marked.has(value)) return;
|
|
marked.add(value);
|
|
if (value.reactions !== null) {
|
|
for (const reaction of value.reactions) {
|
|
const flags2 = reaction.f;
|
|
if ((flags2 & DERIVED) !== 0) {
|
|
mark_effects(
|
|
/** @type {Derived} */
|
|
reaction,
|
|
sources,
|
|
marked,
|
|
checked
|
|
);
|
|
} else if ((flags2 & (ASYNC | BLOCK_EFFECT)) !== 0 && (flags2 & DIRTY) === 0 && depends_on(reaction, sources, checked)) {
|
|
set_signal_status(reaction, DIRTY);
|
|
schedule_effect(
|
|
/** @type {Effect} */
|
|
reaction
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function depends_on(reaction, sources, checked) {
|
|
const depends = checked.get(reaction);
|
|
if (depends !== void 0) return depends;
|
|
if (reaction.deps !== null) {
|
|
for (const dep of reaction.deps) {
|
|
if (includes.call(sources, dep)) {
|
|
return true;
|
|
}
|
|
if ((dep.f & DERIVED) !== 0 && depends_on(
|
|
/** @type {Derived} */
|
|
dep,
|
|
sources,
|
|
checked
|
|
)) {
|
|
checked.set(
|
|
/** @type {Derived} */
|
|
dep,
|
|
true
|
|
);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
checked.set(reaction, false);
|
|
return false;
|
|
}
|
|
function schedule_effect(signal) {
|
|
var effect2 = last_scheduled_effect = signal;
|
|
var boundary2 = effect2.b;
|
|
if (boundary2?.is_pending && (signal.f & (EFFECT | RENDER_EFFECT | MANAGED_EFFECT)) !== 0 && (signal.f & REACTION_RAN) === 0) {
|
|
boundary2.defer_effect(signal);
|
|
return;
|
|
}
|
|
while (effect2.parent !== null) {
|
|
effect2 = effect2.parent;
|
|
var flags2 = effect2.f;
|
|
if (collected_effects !== null && effect2 === active_effect) {
|
|
if (async_mode_flag || (signal.f & RENDER_EFFECT) === 0) {
|
|
return;
|
|
}
|
|
}
|
|
if ((flags2 & (ROOT_EFFECT | BRANCH_EFFECT)) !== 0) {
|
|
if ((flags2 & CLEAN) === 0) {
|
|
return;
|
|
}
|
|
effect2.f ^= CLEAN;
|
|
}
|
|
}
|
|
queued_root_effects.push(effect2);
|
|
}
|
|
function reset_branch(effect2, tracked) {
|
|
if ((effect2.f & BRANCH_EFFECT) !== 0 && (effect2.f & CLEAN) !== 0) {
|
|
return;
|
|
}
|
|
if ((effect2.f & DIRTY) !== 0) {
|
|
tracked.d.push(effect2);
|
|
} else if ((effect2.f & MAYBE_DIRTY) !== 0) {
|
|
tracked.m.push(effect2);
|
|
}
|
|
set_signal_status(effect2, CLEAN);
|
|
var e = effect2.first;
|
|
while (e !== null) {
|
|
reset_branch(e, tracked);
|
|
e = e.next;
|
|
}
|
|
}
|
|
|
|
// node_modules/svelte/src/reactivity/create-subscriber.js
|
|
function createSubscriber(start) {
|
|
let subscribers = 0;
|
|
let version = source(0);
|
|
let stop;
|
|
if (dev_fallback_default) {
|
|
tag(version, "createSubscriber version");
|
|
}
|
|
return () => {
|
|
if (effect_tracking()) {
|
|
get(version);
|
|
render_effect(() => {
|
|
if (subscribers === 0) {
|
|
stop = untrack(() => start(() => increment(version)));
|
|
}
|
|
subscribers += 1;
|
|
return () => {
|
|
queue_micro_task(() => {
|
|
subscribers -= 1;
|
|
if (subscribers === 0) {
|
|
stop?.();
|
|
stop = void 0;
|
|
increment(version);
|
|
}
|
|
});
|
|
};
|
|
});
|
|
}
|
|
};
|
|
}
|
|
|
|
// node_modules/svelte/src/internal/client/dom/blocks/boundary.js
|
|
var flags = EFFECT_TRANSPARENT | EFFECT_PRESERVED;
|
|
function boundary(node, props, children, transform_error) {
|
|
new Boundary(node, props, children, transform_error);
|
|
}
|
|
var Boundary = class {
|
|
/** @type {Boundary | null} */
|
|
parent;
|
|
is_pending = false;
|
|
/**
|
|
* API-level transformError transform function. Transforms errors before they reach the `failed` snippet.
|
|
* Inherited from parent boundary, or defaults to identity.
|
|
* @type {(error: unknown) => unknown}
|
|
*/
|
|
transform_error;
|
|
/** @type {TemplateNode} */
|
|
#anchor;
|
|
/** @type {TemplateNode | null} */
|
|
#hydrate_open = hydrating ? hydrate_node : null;
|
|
/** @type {BoundaryProps} */
|
|
#props;
|
|
/** @type {((anchor: Node) => void)} */
|
|
#children;
|
|
/** @type {Effect} */
|
|
#effect;
|
|
/** @type {Effect | null} */
|
|
#main_effect = null;
|
|
/** @type {Effect | null} */
|
|
#pending_effect = null;
|
|
/** @type {Effect | null} */
|
|
#failed_effect = null;
|
|
/** @type {DocumentFragment | null} */
|
|
#offscreen_fragment = null;
|
|
#local_pending_count = 0;
|
|
#pending_count = 0;
|
|
#pending_count_update_queued = false;
|
|
/** @type {Set<Effect>} */
|
|
#dirty_effects = /* @__PURE__ */ new Set();
|
|
/** @type {Set<Effect>} */
|
|
#maybe_dirty_effects = /* @__PURE__ */ new Set();
|
|
/**
|
|
* A source containing the number of pending async deriveds/expressions.
|
|
* Only created if `$effect.pending()` is used inside the boundary,
|
|
* otherwise updating the source results in needless `Batch.ensure()`
|
|
* calls followed by no-op flushes
|
|
* @type {Source<number> | null}
|
|
*/
|
|
#effect_pending = null;
|
|
#effect_pending_subscriber = createSubscriber(() => {
|
|
this.#effect_pending = source(this.#local_pending_count);
|
|
if (dev_fallback_default) {
|
|
tag(this.#effect_pending, "$effect.pending()");
|
|
}
|
|
return () => {
|
|
this.#effect_pending = null;
|
|
};
|
|
});
|
|
/**
|
|
* @param {TemplateNode} node
|
|
* @param {BoundaryProps} props
|
|
* @param {((anchor: Node) => void)} children
|
|
* @param {((error: unknown) => unknown) | undefined} [transform_error]
|
|
*/
|
|
constructor(node, props, children, transform_error) {
|
|
this.#anchor = node;
|
|
this.#props = props;
|
|
this.#children = (anchor) => {
|
|
var effect2 = (
|
|
/** @type {Effect} */
|
|
active_effect
|
|
);
|
|
effect2.b = this;
|
|
effect2.f |= BOUNDARY_EFFECT;
|
|
children(anchor);
|
|
};
|
|
this.parent = /** @type {Effect} */
|
|
active_effect.b;
|
|
this.transform_error = transform_error ?? this.parent?.transform_error ?? ((e) => e);
|
|
this.#effect = block(() => {
|
|
if (hydrating) {
|
|
const comment2 = (
|
|
/** @type {Comment} */
|
|
this.#hydrate_open
|
|
);
|
|
hydrate_next();
|
|
const server_rendered_pending = comment2.data === HYDRATION_START_ELSE;
|
|
const server_rendered_failed = comment2.data.startsWith(HYDRATION_START_FAILED);
|
|
if (server_rendered_failed) {
|
|
const serialized_error = JSON.parse(comment2.data.slice(HYDRATION_START_FAILED.length));
|
|
this.#hydrate_failed_content(serialized_error);
|
|
} else if (server_rendered_pending) {
|
|
this.#hydrate_pending_content();
|
|
} else {
|
|
this.#hydrate_resolved_content();
|
|
}
|
|
} else {
|
|
this.#render();
|
|
}
|
|
}, flags);
|
|
if (hydrating) {
|
|
this.#anchor = hydrate_node;
|
|
}
|
|
}
|
|
#hydrate_resolved_content() {
|
|
try {
|
|
this.#main_effect = branch(() => this.#children(this.#anchor));
|
|
} catch (error) {
|
|
this.error(error);
|
|
}
|
|
}
|
|
/**
|
|
* @param {unknown} error The deserialized error from the server's hydration comment
|
|
*/
|
|
#hydrate_failed_content(error) {
|
|
const failed = this.#props.failed;
|
|
if (!failed) return;
|
|
this.#failed_effect = branch(() => {
|
|
failed(
|
|
this.#anchor,
|
|
() => error,
|
|
() => () => {
|
|
}
|
|
);
|
|
});
|
|
}
|
|
#hydrate_pending_content() {
|
|
const pending2 = this.#props.pending;
|
|
if (!pending2) return;
|
|
this.is_pending = true;
|
|
this.#pending_effect = branch(() => pending2(this.#anchor));
|
|
queue_micro_task(() => {
|
|
var fragment = this.#offscreen_fragment = document.createDocumentFragment();
|
|
var anchor = create_text();
|
|
fragment.append(anchor);
|
|
this.#main_effect = this.#run(() => {
|
|
Batch.ensure();
|
|
return branch(() => this.#children(anchor));
|
|
});
|
|
if (this.#pending_count === 0) {
|
|
this.#anchor.before(fragment);
|
|
this.#offscreen_fragment = null;
|
|
pause_effect(
|
|
/** @type {Effect} */
|
|
this.#pending_effect,
|
|
() => {
|
|
this.#pending_effect = null;
|
|
}
|
|
);
|
|
this.#resolve();
|
|
}
|
|
});
|
|
}
|
|
#render() {
|
|
try {
|
|
this.is_pending = this.has_pending_snippet();
|
|
this.#pending_count = 0;
|
|
this.#local_pending_count = 0;
|
|
this.#main_effect = branch(() => {
|
|
this.#children(this.#anchor);
|
|
});
|
|
if (this.#pending_count > 0) {
|
|
var fragment = this.#offscreen_fragment = document.createDocumentFragment();
|
|
move_effect(this.#main_effect, fragment);
|
|
const pending2 = (
|
|
/** @type {(anchor: Node) => void} */
|
|
this.#props.pending
|
|
);
|
|
this.#pending_effect = branch(() => pending2(this.#anchor));
|
|
} else {
|
|
this.#resolve();
|
|
}
|
|
} catch (error) {
|
|
this.error(error);
|
|
}
|
|
}
|
|
#resolve() {
|
|
this.is_pending = false;
|
|
for (const e of this.#dirty_effects) {
|
|
set_signal_status(e, DIRTY);
|
|
schedule_effect(e);
|
|
}
|
|
for (const e of this.#maybe_dirty_effects) {
|
|
set_signal_status(e, MAYBE_DIRTY);
|
|
schedule_effect(e);
|
|
}
|
|
this.#dirty_effects.clear();
|
|
this.#maybe_dirty_effects.clear();
|
|
}
|
|
/**
|
|
* Defer an effect inside a pending boundary until the boundary resolves
|
|
* @param {Effect} effect
|
|
*/
|
|
defer_effect(effect2) {
|
|
defer_effect(effect2, this.#dirty_effects, this.#maybe_dirty_effects);
|
|
}
|
|
/**
|
|
* Returns `false` if the effect exists inside a boundary whose pending snippet is shown
|
|
* @returns {boolean}
|
|
*/
|
|
is_rendered() {
|
|
return !this.is_pending && (!this.parent || this.parent.is_rendered());
|
|
}
|
|
has_pending_snippet() {
|
|
return !!this.#props.pending;
|
|
}
|
|
/**
|
|
* @template T
|
|
* @param {() => T} fn
|
|
*/
|
|
#run(fn) {
|
|
var previous_effect = active_effect;
|
|
var previous_reaction = active_reaction;
|
|
var previous_ctx = component_context;
|
|
set_active_effect(this.#effect);
|
|
set_active_reaction(this.#effect);
|
|
set_component_context(this.#effect.ctx);
|
|
try {
|
|
return fn();
|
|
} catch (e) {
|
|
handle_error(e);
|
|
return null;
|
|
} finally {
|
|
set_active_effect(previous_effect);
|
|
set_active_reaction(previous_reaction);
|
|
set_component_context(previous_ctx);
|
|
}
|
|
}
|
|
/**
|
|
* Updates the pending count associated with the currently visible pending snippet,
|
|
* if any, such that we can replace the snippet with content once work is done
|
|
* @param {1 | -1} d
|
|
*/
|
|
#update_pending_count(d) {
|
|
if (!this.has_pending_snippet()) {
|
|
if (this.parent) {
|
|
this.parent.#update_pending_count(d);
|
|
}
|
|
return;
|
|
}
|
|
this.#pending_count += d;
|
|
if (this.#pending_count === 0) {
|
|
this.#resolve();
|
|
if (this.#pending_effect) {
|
|
pause_effect(this.#pending_effect, () => {
|
|
this.#pending_effect = null;
|
|
});
|
|
}
|
|
if (this.#offscreen_fragment) {
|
|
this.#anchor.before(this.#offscreen_fragment);
|
|
this.#offscreen_fragment = null;
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Update the source that powers `$effect.pending()` inside this boundary,
|
|
* and controls when the current `pending` snippet (if any) is removed.
|
|
* Do not call from inside the class
|
|
* @param {1 | -1} d
|
|
*/
|
|
update_pending_count(d) {
|
|
this.#update_pending_count(d);
|
|
this.#local_pending_count += d;
|
|
if (!this.#effect_pending || this.#pending_count_update_queued) return;
|
|
this.#pending_count_update_queued = true;
|
|
queue_micro_task(() => {
|
|
this.#pending_count_update_queued = false;
|
|
if (this.#effect_pending) {
|
|
internal_set(this.#effect_pending, this.#local_pending_count);
|
|
}
|
|
});
|
|
}
|
|
get_effect_pending() {
|
|
this.#effect_pending_subscriber();
|
|
return get(
|
|
/** @type {Source<number>} */
|
|
this.#effect_pending
|
|
);
|
|
}
|
|
/** @param {unknown} error */
|
|
error(error) {
|
|
var onerror = this.#props.onerror;
|
|
let failed = this.#props.failed;
|
|
if (!onerror && !failed) {
|
|
throw error;
|
|
}
|
|
if (this.#main_effect) {
|
|
destroy_effect(this.#main_effect);
|
|
this.#main_effect = null;
|
|
}
|
|
if (this.#pending_effect) {
|
|
destroy_effect(this.#pending_effect);
|
|
this.#pending_effect = null;
|
|
}
|
|
if (this.#failed_effect) {
|
|
destroy_effect(this.#failed_effect);
|
|
this.#failed_effect = null;
|
|
}
|
|
if (hydrating) {
|
|
set_hydrate_node(
|
|
/** @type {TemplateNode} */
|
|
this.#hydrate_open
|
|
);
|
|
next();
|
|
set_hydrate_node(skip_nodes());
|
|
}
|
|
var did_reset = false;
|
|
var calling_on_error = false;
|
|
const reset2 = () => {
|
|
if (did_reset) {
|
|
svelte_boundary_reset_noop();
|
|
return;
|
|
}
|
|
did_reset = true;
|
|
if (calling_on_error) {
|
|
svelte_boundary_reset_onerror();
|
|
}
|
|
if (this.#failed_effect !== null) {
|
|
pause_effect(this.#failed_effect, () => {
|
|
this.#failed_effect = null;
|
|
});
|
|
}
|
|
this.#run(() => {
|
|
Batch.ensure();
|
|
this.#render();
|
|
});
|
|
};
|
|
const handle_error_result = (transformed_error) => {
|
|
try {
|
|
calling_on_error = true;
|
|
onerror?.(transformed_error, reset2);
|
|
calling_on_error = false;
|
|
} catch (error2) {
|
|
invoke_error_boundary(error2, this.#effect && this.#effect.parent);
|
|
}
|
|
if (failed) {
|
|
this.#failed_effect = this.#run(() => {
|
|
Batch.ensure();
|
|
try {
|
|
return branch(() => {
|
|
var effect2 = (
|
|
/** @type {Effect} */
|
|
active_effect
|
|
);
|
|
effect2.b = this;
|
|
effect2.f |= BOUNDARY_EFFECT;
|
|
failed(
|
|
this.#anchor,
|
|
() => transformed_error,
|
|
() => reset2
|
|
);
|
|
});
|
|
} catch (error2) {
|
|
invoke_error_boundary(
|
|
error2,
|
|
/** @type {Effect} */
|
|
this.#effect.parent
|
|
);
|
|
return null;
|
|
}
|
|
});
|
|
}
|
|
};
|
|
queue_micro_task(() => {
|
|
var result;
|
|
try {
|
|
result = this.transform_error(error);
|
|
} catch (e) {
|
|
invoke_error_boundary(e, this.#effect && this.#effect.parent);
|
|
return;
|
|
}
|
|
if (result !== null && typeof result === "object" && typeof /** @type {any} */
|
|
result.then === "function") {
|
|
result.then(
|
|
handle_error_result,
|
|
/** @param {unknown} e */
|
|
(e) => invoke_error_boundary(e, this.#effect && this.#effect.parent)
|
|
);
|
|
} else {
|
|
handle_error_result(result);
|
|
}
|
|
});
|
|
}
|
|
};
|
|
|
|
// node_modules/svelte/src/internal/client/reactivity/async.js
|
|
function flatten(blockers, sync, async2, fn) {
|
|
const d = is_runes() ? derived : derived_safe_equal;
|
|
var pending2 = blockers.filter((b) => !b.settled);
|
|
if (async2.length === 0 && pending2.length === 0) {
|
|
fn(sync.map(d));
|
|
return;
|
|
}
|
|
var batch = current_batch;
|
|
var parent = (
|
|
/** @type {Effect} */
|
|
active_effect
|
|
);
|
|
var restore = capture();
|
|
var blocker_promise = pending2.length === 1 ? pending2[0].promise : pending2.length > 1 ? Promise.all(pending2.map((b) => b.promise)) : null;
|
|
function finish(values) {
|
|
restore();
|
|
try {
|
|
fn(values);
|
|
} catch (error) {
|
|
if ((parent.f & DESTROYED) === 0) {
|
|
invoke_error_boundary(error, parent);
|
|
}
|
|
}
|
|
unset_context();
|
|
}
|
|
if (async2.length === 0) {
|
|
blocker_promise.then(() => finish(sync.map(d)));
|
|
return;
|
|
}
|
|
function run3() {
|
|
restore();
|
|
Promise.all(async2.map((expression) => async_derived(expression))).then((result) => finish([...sync.map(d), ...result])).catch((error) => invoke_error_boundary(error, parent));
|
|
}
|
|
if (blocker_promise) {
|
|
blocker_promise.then(run3);
|
|
} else {
|
|
run3();
|
|
}
|
|
}
|
|
function capture() {
|
|
var previous_effect = active_effect;
|
|
var previous_reaction = active_reaction;
|
|
var previous_component_context = component_context;
|
|
var previous_batch2 = current_batch;
|
|
if (dev_fallback_default) {
|
|
var previous_dev_stack = dev_stack;
|
|
}
|
|
return function restore(activate_batch = true) {
|
|
set_active_effect(previous_effect);
|
|
set_active_reaction(previous_reaction);
|
|
set_component_context(previous_component_context);
|
|
if (activate_batch) previous_batch2?.activate();
|
|
if (dev_fallback_default) {
|
|
set_from_async_derived(null);
|
|
set_dev_stack(previous_dev_stack);
|
|
}
|
|
};
|
|
}
|
|
function unset_context(deactivate_batch = true) {
|
|
set_active_effect(null);
|
|
set_active_reaction(null);
|
|
set_component_context(null);
|
|
if (deactivate_batch) current_batch?.deactivate();
|
|
if (dev_fallback_default) {
|
|
set_from_async_derived(null);
|
|
set_dev_stack(null);
|
|
}
|
|
}
|
|
function increment_pending() {
|
|
var boundary2 = (
|
|
/** @type {Boundary} */
|
|
/** @type {Effect} */
|
|
active_effect.b
|
|
);
|
|
var batch = (
|
|
/** @type {Batch} */
|
|
current_batch
|
|
);
|
|
var blocking = boundary2.is_rendered();
|
|
boundary2.update_pending_count(1);
|
|
batch.increment(blocking);
|
|
return () => {
|
|
boundary2.update_pending_count(-1);
|
|
batch.decrement(blocking);
|
|
};
|
|
}
|
|
|
|
// node_modules/svelte/src/internal/client/reactivity/deriveds.js
|
|
var current_async_effect = null;
|
|
function set_from_async_derived(v) {
|
|
current_async_effect = v;
|
|
}
|
|
var recent_async_deriveds = /* @__PURE__ */ new Set();
|
|
// @__NO_SIDE_EFFECTS__
|
|
function derived(fn) {
|
|
var flags2 = DERIVED | DIRTY;
|
|
var parent_derived = active_reaction !== null && (active_reaction.f & DERIVED) !== 0 ? (
|
|
/** @type {Derived} */
|
|
active_reaction
|
|
) : null;
|
|
if (active_effect !== null) {
|
|
active_effect.f |= EFFECT_PRESERVED;
|
|
}
|
|
const signal = {
|
|
ctx: component_context,
|
|
deps: null,
|
|
effects: null,
|
|
equals,
|
|
f: flags2,
|
|
fn,
|
|
reactions: null,
|
|
rv: 0,
|
|
v: (
|
|
/** @type {V} */
|
|
UNINITIALIZED
|
|
),
|
|
wv: 0,
|
|
parent: parent_derived ?? active_effect,
|
|
ac: null
|
|
};
|
|
if (dev_fallback_default && tracing_mode_flag) {
|
|
signal.created = get_error("created at");
|
|
}
|
|
return signal;
|
|
}
|
|
// @__NO_SIDE_EFFECTS__
|
|
function async_derived(fn, label, location) {
|
|
let parent = (
|
|
/** @type {Effect | null} */
|
|
active_effect
|
|
);
|
|
if (parent === null) {
|
|
async_derived_orphan();
|
|
}
|
|
var promise = (
|
|
/** @type {Promise<V>} */
|
|
/** @type {unknown} */
|
|
void 0
|
|
);
|
|
var signal = source(
|
|
/** @type {V} */
|
|
UNINITIALIZED
|
|
);
|
|
if (dev_fallback_default) signal.label = label;
|
|
var should_suspend = !active_reaction;
|
|
var deferreds = /* @__PURE__ */ new Map();
|
|
async_effect(() => {
|
|
if (dev_fallback_default) current_async_effect = active_effect;
|
|
var d = deferred();
|
|
promise = d.promise;
|
|
try {
|
|
Promise.resolve(fn()).then(d.resolve, d.reject).finally(unset_context);
|
|
} catch (error) {
|
|
d.reject(error);
|
|
unset_context();
|
|
}
|
|
if (dev_fallback_default) current_async_effect = null;
|
|
var batch = (
|
|
/** @type {Batch} */
|
|
current_batch
|
|
);
|
|
if (should_suspend) {
|
|
var decrement_pending = increment_pending();
|
|
deferreds.get(batch)?.reject(STALE_REACTION);
|
|
deferreds.delete(batch);
|
|
deferreds.set(batch, d);
|
|
}
|
|
const handler = (value, error = void 0) => {
|
|
current_async_effect = null;
|
|
batch.activate();
|
|
if (error) {
|
|
if (error !== STALE_REACTION) {
|
|
signal.f |= ERROR_VALUE;
|
|
internal_set(signal, error);
|
|
}
|
|
} else {
|
|
if ((signal.f & ERROR_VALUE) !== 0) {
|
|
signal.f ^= ERROR_VALUE;
|
|
}
|
|
internal_set(signal, value);
|
|
for (const [b, d2] of deferreds) {
|
|
deferreds.delete(b);
|
|
if (b === batch) break;
|
|
d2.reject(STALE_REACTION);
|
|
}
|
|
if (dev_fallback_default && location !== void 0) {
|
|
recent_async_deriveds.add(signal);
|
|
setTimeout(() => {
|
|
if (recent_async_deriveds.has(signal)) {
|
|
await_waterfall(
|
|
/** @type {string} */
|
|
signal.label,
|
|
location
|
|
);
|
|
recent_async_deriveds.delete(signal);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
if (decrement_pending) {
|
|
decrement_pending();
|
|
}
|
|
};
|
|
d.promise.then(handler, (e) => handler(null, e || "unknown"));
|
|
});
|
|
teardown(() => {
|
|
for (const d of deferreds.values()) {
|
|
d.reject(STALE_REACTION);
|
|
}
|
|
});
|
|
if (dev_fallback_default) {
|
|
signal.f |= ASYNC;
|
|
}
|
|
return new Promise((fulfil) => {
|
|
function next2(p) {
|
|
function go() {
|
|
if (p === promise) {
|
|
fulfil(signal);
|
|
} else {
|
|
next2(promise);
|
|
}
|
|
}
|
|
p.then(go, go);
|
|
}
|
|
next2(promise);
|
|
});
|
|
}
|
|
// @__NO_SIDE_EFFECTS__
|
|
function user_derived(fn) {
|
|
const d = /* @__PURE__ */ derived(fn);
|
|
if (!async_mode_flag) push_reaction_value(d);
|
|
return d;
|
|
}
|
|
// @__NO_SIDE_EFFECTS__
|
|
function derived_safe_equal(fn) {
|
|
const signal = /* @__PURE__ */ derived(fn);
|
|
signal.equals = safe_equals;
|
|
return signal;
|
|
}
|
|
function destroy_derived_effects(derived2) {
|
|
var effects = derived2.effects;
|
|
if (effects !== null) {
|
|
derived2.effects = null;
|
|
for (var i = 0; i < effects.length; i += 1) {
|
|
destroy_effect(
|
|
/** @type {Effect} */
|
|
effects[i]
|
|
);
|
|
}
|
|
}
|
|
}
|
|
var stack = [];
|
|
function get_derived_parent_effect(derived2) {
|
|
var parent = derived2.parent;
|
|
while (parent !== null) {
|
|
if ((parent.f & DERIVED) === 0) {
|
|
return (parent.f & DESTROYED) === 0 ? (
|
|
/** @type {Effect} */
|
|
parent
|
|
) : null;
|
|
}
|
|
parent = parent.parent;
|
|
}
|
|
return null;
|
|
}
|
|
function execute_derived(derived2) {
|
|
var value;
|
|
var prev_active_effect = active_effect;
|
|
set_active_effect(get_derived_parent_effect(derived2));
|
|
if (dev_fallback_default) {
|
|
let prev_eager_effects = eager_effects;
|
|
set_eager_effects(/* @__PURE__ */ new Set());
|
|
try {
|
|
if (includes.call(stack, derived2)) {
|
|
derived_references_self();
|
|
}
|
|
stack.push(derived2);
|
|
derived2.f &= ~WAS_MARKED;
|
|
destroy_derived_effects(derived2);
|
|
value = update_reaction(derived2);
|
|
} finally {
|
|
set_active_effect(prev_active_effect);
|
|
set_eager_effects(prev_eager_effects);
|
|
stack.pop();
|
|
}
|
|
} else {
|
|
try {
|
|
derived2.f &= ~WAS_MARKED;
|
|
destroy_derived_effects(derived2);
|
|
value = update_reaction(derived2);
|
|
} finally {
|
|
set_active_effect(prev_active_effect);
|
|
}
|
|
}
|
|
return value;
|
|
}
|
|
function update_derived(derived2) {
|
|
var value = execute_derived(derived2);
|
|
if (!derived2.equals(value)) {
|
|
derived2.wv = increment_write_version();
|
|
if (!current_batch?.is_fork || derived2.deps === null) {
|
|
derived2.v = value;
|
|
if (derived2.deps === null) {
|
|
set_signal_status(derived2, CLEAN);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
if (is_destroying_effect) {
|
|
return;
|
|
}
|
|
if (batch_values !== null) {
|
|
if (effect_tracking() || current_batch?.is_fork) {
|
|
batch_values.set(derived2, value);
|
|
}
|
|
} else {
|
|
update_derived_status(derived2);
|
|
}
|
|
}
|
|
function freeze_derived_effects(derived2) {
|
|
if (derived2.effects === null) return;
|
|
for (const e of derived2.effects) {
|
|
if (e.teardown || e.ac) {
|
|
e.teardown?.();
|
|
e.ac?.abort(STALE_REACTION);
|
|
e.teardown = noop;
|
|
e.ac = null;
|
|
remove_reactions(e, 0);
|
|
destroy_effect_children(e);
|
|
}
|
|
}
|
|
}
|
|
function unfreeze_derived_effects(derived2) {
|
|
if (derived2.effects === null) return;
|
|
for (const e of derived2.effects) {
|
|
if (e.teardown) {
|
|
update_effect(e);
|
|
}
|
|
}
|
|
}
|
|
|
|
// node_modules/svelte/src/internal/client/reactivity/sources.js
|
|
var eager_effects = /* @__PURE__ */ new Set();
|
|
var old_values = /* @__PURE__ */ new Map();
|
|
function set_eager_effects(v) {
|
|
eager_effects = v;
|
|
}
|
|
var eager_effects_deferred = false;
|
|
function set_eager_effects_deferred() {
|
|
eager_effects_deferred = true;
|
|
}
|
|
function source(v, stack2) {
|
|
var signal = {
|
|
f: 0,
|
|
// TODO ideally we could skip this altogether, but it causes type errors
|
|
v,
|
|
reactions: null,
|
|
equals,
|
|
rv: 0,
|
|
wv: 0
|
|
};
|
|
if (dev_fallback_default && tracing_mode_flag) {
|
|
signal.created = stack2 ?? get_error("created at");
|
|
signal.updated = null;
|
|
signal.set_during_effect = false;
|
|
signal.trace = null;
|
|
}
|
|
return signal;
|
|
}
|
|
// @__NO_SIDE_EFFECTS__
|
|
function state(v, stack2) {
|
|
const s = source(v, stack2);
|
|
push_reaction_value(s);
|
|
return s;
|
|
}
|
|
// @__NO_SIDE_EFFECTS__
|
|
function mutable_source(initial_value, immutable = false, trackable = true) {
|
|
const s = source(initial_value);
|
|
if (!immutable) {
|
|
s.equals = safe_equals;
|
|
}
|
|
if (legacy_mode_flag && trackable && component_context !== null && component_context.l !== null) {
|
|
(component_context.l.s ??= []).push(s);
|
|
}
|
|
return s;
|
|
}
|
|
function set(source2, value, should_proxy = false) {
|
|
if (active_reaction !== null && // since we are untracking the function inside `$inspect.with` we need to add this check
|
|
// to ensure we error if state is set inside an inspect effect
|
|
(!untracking || (active_reaction.f & EAGER_EFFECT) !== 0) && is_runes() && (active_reaction.f & (DERIVED | BLOCK_EFFECT | ASYNC | EAGER_EFFECT)) !== 0 && (current_sources === null || !includes.call(current_sources, source2))) {
|
|
state_unsafe_mutation();
|
|
}
|
|
let new_value = should_proxy ? proxy(value) : value;
|
|
if (dev_fallback_default) {
|
|
tag_proxy(
|
|
new_value,
|
|
/** @type {string} */
|
|
source2.label
|
|
);
|
|
}
|
|
return internal_set(source2, new_value);
|
|
}
|
|
function internal_set(source2, value) {
|
|
if (!source2.equals(value)) {
|
|
var old_value = source2.v;
|
|
if (is_destroying_effect) {
|
|
old_values.set(source2, value);
|
|
} else {
|
|
old_values.set(source2, old_value);
|
|
}
|
|
source2.v = value;
|
|
var batch = Batch.ensure();
|
|
batch.capture(source2, old_value);
|
|
if (dev_fallback_default) {
|
|
if (tracing_mode_flag || active_effect !== null) {
|
|
source2.updated ??= /* @__PURE__ */ new Map();
|
|
const count = (source2.updated.get("")?.count ?? 0) + 1;
|
|
source2.updated.set("", { error: (
|
|
/** @type {any} */
|
|
null
|
|
), count });
|
|
if (tracing_mode_flag || count > 5) {
|
|
const error = get_error("updated at");
|
|
if (error !== null) {
|
|
let entry = source2.updated.get(error.stack);
|
|
if (!entry) {
|
|
entry = { error, count: 0 };
|
|
source2.updated.set(error.stack, entry);
|
|
}
|
|
entry.count++;
|
|
}
|
|
}
|
|
}
|
|
if (active_effect !== null) {
|
|
source2.set_during_effect = true;
|
|
}
|
|
}
|
|
if ((source2.f & DERIVED) !== 0) {
|
|
const derived2 = (
|
|
/** @type {Derived} */
|
|
source2
|
|
);
|
|
if ((source2.f & DIRTY) !== 0) {
|
|
execute_derived(derived2);
|
|
}
|
|
update_derived_status(derived2);
|
|
}
|
|
source2.wv = increment_write_version();
|
|
mark_reactions(source2, DIRTY);
|
|
if (is_runes() && active_effect !== null && (active_effect.f & CLEAN) !== 0 && (active_effect.f & (BRANCH_EFFECT | ROOT_EFFECT)) === 0) {
|
|
if (untracked_writes === null) {
|
|
set_untracked_writes([source2]);
|
|
} else {
|
|
untracked_writes.push(source2);
|
|
}
|
|
}
|
|
if (!batch.is_fork && eager_effects.size > 0 && !eager_effects_deferred) {
|
|
flush_eager_effects();
|
|
}
|
|
}
|
|
return value;
|
|
}
|
|
function flush_eager_effects() {
|
|
eager_effects_deferred = false;
|
|
for (const effect2 of eager_effects) {
|
|
if ((effect2.f & CLEAN) !== 0) {
|
|
set_signal_status(effect2, MAYBE_DIRTY);
|
|
}
|
|
if (is_dirty(effect2)) {
|
|
update_effect(effect2);
|
|
}
|
|
}
|
|
eager_effects.clear();
|
|
}
|
|
function increment(source2) {
|
|
set(source2, source2.v + 1);
|
|
}
|
|
function mark_reactions(signal, status) {
|
|
var reactions = signal.reactions;
|
|
if (reactions === null) return;
|
|
var runes = is_runes();
|
|
var length = reactions.length;
|
|
for (var i = 0; i < length; i++) {
|
|
var reaction = reactions[i];
|
|
var flags2 = reaction.f;
|
|
if (!runes && reaction === active_effect) continue;
|
|
if (dev_fallback_default && (flags2 & EAGER_EFFECT) !== 0) {
|
|
eager_effects.add(reaction);
|
|
continue;
|
|
}
|
|
var not_dirty = (flags2 & DIRTY) === 0;
|
|
if (not_dirty) {
|
|
set_signal_status(reaction, status);
|
|
}
|
|
if ((flags2 & DERIVED) !== 0) {
|
|
var derived2 = (
|
|
/** @type {Derived} */
|
|
reaction
|
|
);
|
|
batch_values?.delete(derived2);
|
|
if ((flags2 & WAS_MARKED) === 0) {
|
|
if (flags2 & CONNECTED) {
|
|
reaction.f |= WAS_MARKED;
|
|
}
|
|
mark_reactions(derived2, MAYBE_DIRTY);
|
|
}
|
|
} else if (not_dirty) {
|
|
if ((flags2 & BLOCK_EFFECT) !== 0 && eager_block_effects !== null) {
|
|
eager_block_effects.add(
|
|
/** @type {Effect} */
|
|
reaction
|
|
);
|
|
}
|
|
schedule_effect(
|
|
/** @type {Effect} */
|
|
reaction
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
// node_modules/svelte/src/internal/client/proxy.js
|
|
var regex_is_valid_identifier = /^[a-zA-Z_$][a-zA-Z_$0-9]*$/;
|
|
function proxy(value) {
|
|
if (typeof value !== "object" || value === null || STATE_SYMBOL in value) {
|
|
return value;
|
|
}
|
|
const prototype = get_prototype_of(value);
|
|
if (prototype !== object_prototype && prototype !== array_prototype) {
|
|
return value;
|
|
}
|
|
var sources = /* @__PURE__ */ new Map();
|
|
var is_proxied_array = is_array(value);
|
|
var version = state(0);
|
|
var stack2 = dev_fallback_default && tracing_mode_flag ? get_error("created at") : null;
|
|
var parent_version = update_version;
|
|
var with_parent = (fn) => {
|
|
if (update_version === parent_version) {
|
|
return fn();
|
|
}
|
|
var reaction = active_reaction;
|
|
var version2 = update_version;
|
|
set_active_reaction(null);
|
|
set_update_version(parent_version);
|
|
var result = fn();
|
|
set_active_reaction(reaction);
|
|
set_update_version(version2);
|
|
return result;
|
|
};
|
|
if (is_proxied_array) {
|
|
sources.set("length", state(
|
|
/** @type {any[]} */
|
|
value.length,
|
|
stack2
|
|
));
|
|
if (dev_fallback_default) {
|
|
value = /** @type {any} */
|
|
inspectable_array(
|
|
/** @type {any[]} */
|
|
value
|
|
);
|
|
}
|
|
}
|
|
var path = "";
|
|
let updating = false;
|
|
function update_path(new_path) {
|
|
if (updating) return;
|
|
updating = true;
|
|
path = new_path;
|
|
tag(version, `${path} version`);
|
|
for (const [prop2, source2] of sources) {
|
|
tag(source2, get_label(path, prop2));
|
|
}
|
|
updating = false;
|
|
}
|
|
return new Proxy(
|
|
/** @type {any} */
|
|
value,
|
|
{
|
|
defineProperty(_, prop2, descriptor) {
|
|
if (!("value" in descriptor) || descriptor.configurable === false || descriptor.enumerable === false || descriptor.writable === false) {
|
|
state_descriptors_fixed();
|
|
}
|
|
var s = sources.get(prop2);
|
|
if (s === void 0) {
|
|
with_parent(() => {
|
|
var s2 = state(descriptor.value, stack2);
|
|
sources.set(prop2, s2);
|
|
if (dev_fallback_default && typeof prop2 === "string") {
|
|
tag(s2, get_label(path, prop2));
|
|
}
|
|
return s2;
|
|
});
|
|
} else {
|
|
set(s, descriptor.value, true);
|
|
}
|
|
return true;
|
|
},
|
|
deleteProperty(target, prop2) {
|
|
var s = sources.get(prop2);
|
|
if (s === void 0) {
|
|
if (prop2 in target) {
|
|
const s2 = with_parent(() => state(UNINITIALIZED, stack2));
|
|
sources.set(prop2, s2);
|
|
increment(version);
|
|
if (dev_fallback_default) {
|
|
tag(s2, get_label(path, prop2));
|
|
}
|
|
}
|
|
} else {
|
|
set(s, UNINITIALIZED);
|
|
increment(version);
|
|
}
|
|
return true;
|
|
},
|
|
get(target, prop2, receiver) {
|
|
if (prop2 === STATE_SYMBOL) {
|
|
return value;
|
|
}
|
|
if (dev_fallback_default && prop2 === PROXY_PATH_SYMBOL) {
|
|
return update_path;
|
|
}
|
|
var s = sources.get(prop2);
|
|
var exists = prop2 in target;
|
|
if (s === void 0 && (!exists || get_descriptor(target, prop2)?.writable)) {
|
|
s = with_parent(() => {
|
|
var p = proxy(exists ? target[prop2] : UNINITIALIZED);
|
|
var s2 = state(p, stack2);
|
|
if (dev_fallback_default) {
|
|
tag(s2, get_label(path, prop2));
|
|
}
|
|
return s2;
|
|
});
|
|
sources.set(prop2, s);
|
|
}
|
|
if (s !== void 0) {
|
|
var v = get(s);
|
|
return v === UNINITIALIZED ? void 0 : v;
|
|
}
|
|
return Reflect.get(target, prop2, receiver);
|
|
},
|
|
getOwnPropertyDescriptor(target, prop2) {
|
|
var descriptor = Reflect.getOwnPropertyDescriptor(target, prop2);
|
|
if (descriptor && "value" in descriptor) {
|
|
var s = sources.get(prop2);
|
|
if (s) descriptor.value = get(s);
|
|
} else if (descriptor === void 0) {
|
|
var source2 = sources.get(prop2);
|
|
var value2 = source2?.v;
|
|
if (source2 !== void 0 && value2 !== UNINITIALIZED) {
|
|
return {
|
|
enumerable: true,
|
|
configurable: true,
|
|
value: value2,
|
|
writable: true
|
|
};
|
|
}
|
|
}
|
|
return descriptor;
|
|
},
|
|
has(target, prop2) {
|
|
if (prop2 === STATE_SYMBOL) {
|
|
return true;
|
|
}
|
|
var s = sources.get(prop2);
|
|
var has = s !== void 0 && s.v !== UNINITIALIZED || Reflect.has(target, prop2);
|
|
if (s !== void 0 || active_effect !== null && (!has || get_descriptor(target, prop2)?.writable)) {
|
|
if (s === void 0) {
|
|
s = with_parent(() => {
|
|
var p = has ? proxy(target[prop2]) : UNINITIALIZED;
|
|
var s2 = state(p, stack2);
|
|
if (dev_fallback_default) {
|
|
tag(s2, get_label(path, prop2));
|
|
}
|
|
return s2;
|
|
});
|
|
sources.set(prop2, s);
|
|
}
|
|
var value2 = get(s);
|
|
if (value2 === UNINITIALIZED) {
|
|
return false;
|
|
}
|
|
}
|
|
return has;
|
|
},
|
|
set(target, prop2, value2, receiver) {
|
|
var s = sources.get(prop2);
|
|
var has = prop2 in target;
|
|
if (is_proxied_array && prop2 === "length") {
|
|
for (var i = value2; i < /** @type {Source<number>} */
|
|
s.v; i += 1) {
|
|
var other_s = sources.get(i + "");
|
|
if (other_s !== void 0) {
|
|
set(other_s, UNINITIALIZED);
|
|
} else if (i in target) {
|
|
other_s = with_parent(() => state(UNINITIALIZED, stack2));
|
|
sources.set(i + "", other_s);
|
|
if (dev_fallback_default) {
|
|
tag(other_s, get_label(path, i));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (s === void 0) {
|
|
if (!has || get_descriptor(target, prop2)?.writable) {
|
|
s = with_parent(() => state(void 0, stack2));
|
|
if (dev_fallback_default) {
|
|
tag(s, get_label(path, prop2));
|
|
}
|
|
set(s, proxy(value2));
|
|
sources.set(prop2, s);
|
|
}
|
|
} else {
|
|
has = s.v !== UNINITIALIZED;
|
|
var p = with_parent(() => proxy(value2));
|
|
set(s, p);
|
|
}
|
|
var descriptor = Reflect.getOwnPropertyDescriptor(target, prop2);
|
|
if (descriptor?.set) {
|
|
descriptor.set.call(receiver, value2);
|
|
}
|
|
if (!has) {
|
|
if (is_proxied_array && typeof prop2 === "string") {
|
|
var ls = (
|
|
/** @type {Source<number>} */
|
|
sources.get("length")
|
|
);
|
|
var n = Number(prop2);
|
|
if (Number.isInteger(n) && n >= ls.v) {
|
|
set(ls, n + 1);
|
|
}
|
|
}
|
|
increment(version);
|
|
}
|
|
return true;
|
|
},
|
|
ownKeys(target) {
|
|
get(version);
|
|
var own_keys = Reflect.ownKeys(target).filter((key3) => {
|
|
var source3 = sources.get(key3);
|
|
return source3 === void 0 || source3.v !== UNINITIALIZED;
|
|
});
|
|
for (var [key2, source2] of sources) {
|
|
if (source2.v !== UNINITIALIZED && !(key2 in target)) {
|
|
own_keys.push(key2);
|
|
}
|
|
}
|
|
return own_keys;
|
|
},
|
|
setPrototypeOf() {
|
|
state_prototype_fixed();
|
|
}
|
|
}
|
|
);
|
|
}
|
|
function get_label(path, prop2) {
|
|
if (typeof prop2 === "symbol") return `${path}[Symbol(${prop2.description ?? ""})]`;
|
|
if (regex_is_valid_identifier.test(prop2)) return `${path}.${prop2}`;
|
|
return /^\d+$/.test(prop2) ? `${path}[${prop2}]` : `${path}['${prop2}']`;
|
|
}
|
|
function get_proxied_value(value) {
|
|
try {
|
|
if (value !== null && typeof value === "object" && STATE_SYMBOL in value) {
|
|
return value[STATE_SYMBOL];
|
|
}
|
|
} catch {
|
|
}
|
|
return value;
|
|
}
|
|
var ARRAY_MUTATING_METHODS = /* @__PURE__ */ new Set([
|
|
"copyWithin",
|
|
"fill",
|
|
"pop",
|
|
"push",
|
|
"reverse",
|
|
"shift",
|
|
"sort",
|
|
"splice",
|
|
"unshift"
|
|
]);
|
|
function inspectable_array(array) {
|
|
return new Proxy(array, {
|
|
get(target, prop2, receiver) {
|
|
var value = Reflect.get(target, prop2, receiver);
|
|
if (!ARRAY_MUTATING_METHODS.has(
|
|
/** @type {string} */
|
|
prop2
|
|
)) {
|
|
return value;
|
|
}
|
|
return function(...args) {
|
|
set_eager_effects_deferred();
|
|
var result = value.apply(this, args);
|
|
flush_eager_effects();
|
|
return result;
|
|
};
|
|
}
|
|
});
|
|
}
|
|
|
|
// node_modules/svelte/src/internal/client/dev/equality.js
|
|
function init_array_prototype_warnings() {
|
|
const array_prototype2 = Array.prototype;
|
|
const cleanup = Array.__svelte_cleanup;
|
|
if (cleanup) {
|
|
cleanup();
|
|
}
|
|
const { indexOf, lastIndexOf, includes: includes2 } = array_prototype2;
|
|
array_prototype2.indexOf = function(item, from_index) {
|
|
const index2 = indexOf.call(this, item, from_index);
|
|
if (index2 === -1) {
|
|
for (let i = from_index ?? 0; i < this.length; i += 1) {
|
|
if (get_proxied_value(this[i]) === item) {
|
|
state_proxy_equality_mismatch("array.indexOf(...)");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return index2;
|
|
};
|
|
array_prototype2.lastIndexOf = function(item, from_index) {
|
|
const index2 = lastIndexOf.call(this, item, from_index ?? this.length - 1);
|
|
if (index2 === -1) {
|
|
for (let i = 0; i <= (from_index ?? this.length - 1); i += 1) {
|
|
if (get_proxied_value(this[i]) === item) {
|
|
state_proxy_equality_mismatch("array.lastIndexOf(...)");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return index2;
|
|
};
|
|
array_prototype2.includes = function(item, from_index) {
|
|
const has = includes2.call(this, item, from_index);
|
|
if (!has) {
|
|
for (let i = 0; i < this.length; i += 1) {
|
|
if (get_proxied_value(this[i]) === item) {
|
|
state_proxy_equality_mismatch("array.includes(...)");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return has;
|
|
};
|
|
Array.__svelte_cleanup = () => {
|
|
array_prototype2.indexOf = indexOf;
|
|
array_prototype2.lastIndexOf = lastIndexOf;
|
|
array_prototype2.includes = includes2;
|
|
};
|
|
}
|
|
|
|
// node_modules/svelte/src/internal/client/dom/operations.js
|
|
var $window;
|
|
var $document;
|
|
var is_firefox;
|
|
var first_child_getter;
|
|
var next_sibling_getter;
|
|
function init_operations() {
|
|
if ($window !== void 0) {
|
|
return;
|
|
}
|
|
$window = window;
|
|
$document = document;
|
|
is_firefox = /Firefox/.test(navigator.userAgent);
|
|
var element_prototype = Element.prototype;
|
|
var node_prototype = Node.prototype;
|
|
var text_prototype = Text.prototype;
|
|
first_child_getter = get_descriptor(node_prototype, "firstChild").get;
|
|
next_sibling_getter = get_descriptor(node_prototype, "nextSibling").get;
|
|
if (is_extensible(element_prototype)) {
|
|
element_prototype.__click = void 0;
|
|
element_prototype.__className = void 0;
|
|
element_prototype.__attributes = null;
|
|
element_prototype.__style = void 0;
|
|
element_prototype.__e = void 0;
|
|
}
|
|
if (is_extensible(text_prototype)) {
|
|
text_prototype.__t = void 0;
|
|
}
|
|
if (dev_fallback_default) {
|
|
element_prototype.__svelte_meta = null;
|
|
init_array_prototype_warnings();
|
|
}
|
|
}
|
|
function create_text(value = "") {
|
|
return document.createTextNode(value);
|
|
}
|
|
// @__NO_SIDE_EFFECTS__
|
|
function get_first_child(node) {
|
|
return (
|
|
/** @type {TemplateNode | null} */
|
|
first_child_getter.call(node)
|
|
);
|
|
}
|
|
// @__NO_SIDE_EFFECTS__
|
|
function get_next_sibling(node) {
|
|
return (
|
|
/** @type {TemplateNode | null} */
|
|
next_sibling_getter.call(node)
|
|
);
|
|
}
|
|
function child(node, is_text) {
|
|
if (!hydrating) {
|
|
return /* @__PURE__ */ get_first_child(node);
|
|
}
|
|
var child2 = /* @__PURE__ */ get_first_child(hydrate_node);
|
|
if (child2 === null) {
|
|
child2 = hydrate_node.appendChild(create_text());
|
|
} else if (is_text && child2.nodeType !== TEXT_NODE) {
|
|
var text2 = create_text();
|
|
child2?.before(text2);
|
|
set_hydrate_node(text2);
|
|
return text2;
|
|
}
|
|
if (is_text) {
|
|
merge_text_nodes(
|
|
/** @type {Text} */
|
|
child2
|
|
);
|
|
}
|
|
set_hydrate_node(child2);
|
|
return child2;
|
|
}
|
|
function first_child(node, is_text = false) {
|
|
if (!hydrating) {
|
|
var first = /* @__PURE__ */ get_first_child(node);
|
|
if (first instanceof Comment && first.data === "") return /* @__PURE__ */ get_next_sibling(first);
|
|
return first;
|
|
}
|
|
if (is_text) {
|
|
if (hydrate_node?.nodeType !== TEXT_NODE) {
|
|
var text2 = create_text();
|
|
hydrate_node?.before(text2);
|
|
set_hydrate_node(text2);
|
|
return text2;
|
|
}
|
|
merge_text_nodes(
|
|
/** @type {Text} */
|
|
hydrate_node
|
|
);
|
|
}
|
|
return hydrate_node;
|
|
}
|
|
function sibling(node, count = 1, is_text = false) {
|
|
let next_sibling = hydrating ? hydrate_node : node;
|
|
var last_sibling;
|
|
while (count--) {
|
|
last_sibling = next_sibling;
|
|
next_sibling = /** @type {TemplateNode} */
|
|
/* @__PURE__ */ get_next_sibling(next_sibling);
|
|
}
|
|
if (!hydrating) {
|
|
return next_sibling;
|
|
}
|
|
if (is_text) {
|
|
if (next_sibling?.nodeType !== TEXT_NODE) {
|
|
var text2 = create_text();
|
|
if (next_sibling === null) {
|
|
last_sibling?.after(text2);
|
|
} else {
|
|
next_sibling.before(text2);
|
|
}
|
|
set_hydrate_node(text2);
|
|
return text2;
|
|
}
|
|
merge_text_nodes(
|
|
/** @type {Text} */
|
|
next_sibling
|
|
);
|
|
}
|
|
set_hydrate_node(next_sibling);
|
|
return next_sibling;
|
|
}
|
|
function clear_text_content(node) {
|
|
node.textContent = "";
|
|
}
|
|
function should_defer_append() {
|
|
if (!async_mode_flag) return false;
|
|
if (eager_block_effects !== null) return false;
|
|
var flags2 = (
|
|
/** @type {Effect} */
|
|
active_effect.f
|
|
);
|
|
return (flags2 & REACTION_RAN) !== 0;
|
|
}
|
|
function create_element(tag2, namespace, is2) {
|
|
let options = is2 ? { is: is2 } : void 0;
|
|
return (
|
|
/** @type {T extends keyof HTMLElementTagNameMap ? HTMLElementTagNameMap[T] : Element} */
|
|
document.createElementNS(namespace ?? NAMESPACE_HTML, tag2, options)
|
|
);
|
|
}
|
|
function merge_text_nodes(text2) {
|
|
if (
|
|
/** @type {string} */
|
|
text2.nodeValue.length < 65536
|
|
) {
|
|
return;
|
|
}
|
|
let next2 = text2.nextSibling;
|
|
while (next2 !== null && next2.nodeType === TEXT_NODE) {
|
|
next2.remove();
|
|
text2.nodeValue += /** @type {string} */
|
|
next2.nodeValue;
|
|
next2 = text2.nextSibling;
|
|
}
|
|
}
|
|
|
|
// node_modules/svelte/src/internal/client/dom/elements/misc.js
|
|
var listening_to_form_reset = false;
|
|
function add_form_reset_listener() {
|
|
if (!listening_to_form_reset) {
|
|
listening_to_form_reset = true;
|
|
document.addEventListener(
|
|
"reset",
|
|
(evt) => {
|
|
Promise.resolve().then(() => {
|
|
if (!evt.defaultPrevented) {
|
|
for (
|
|
const e of
|
|
/**@type {HTMLFormElement} */
|
|
evt.target.elements
|
|
) {
|
|
e.__on_r?.();
|
|
}
|
|
}
|
|
});
|
|
},
|
|
// In the capture phase to guarantee we get noticed of it (no possibility of stopPropagation)
|
|
{ capture: true }
|
|
);
|
|
}
|
|
}
|
|
|
|
// node_modules/svelte/src/internal/client/dom/elements/bindings/shared.js
|
|
function without_reactive_context(fn) {
|
|
var previous_reaction = active_reaction;
|
|
var previous_effect = active_effect;
|
|
set_active_reaction(null);
|
|
set_active_effect(null);
|
|
try {
|
|
return fn();
|
|
} finally {
|
|
set_active_reaction(previous_reaction);
|
|
set_active_effect(previous_effect);
|
|
}
|
|
}
|
|
|
|
// node_modules/svelte/src/internal/client/reactivity/effects.js
|
|
function validate_effect(rune) {
|
|
if (active_effect === null) {
|
|
if (active_reaction === null) {
|
|
effect_orphan(rune);
|
|
}
|
|
effect_in_unowned_derived();
|
|
}
|
|
if (is_destroying_effect) {
|
|
effect_in_teardown(rune);
|
|
}
|
|
}
|
|
function push_effect(effect2, parent_effect) {
|
|
var parent_last = parent_effect.last;
|
|
if (parent_last === null) {
|
|
parent_effect.last = parent_effect.first = effect2;
|
|
} else {
|
|
parent_last.next = effect2;
|
|
effect2.prev = parent_last;
|
|
parent_effect.last = effect2;
|
|
}
|
|
}
|
|
function create_effect(type, fn) {
|
|
var parent = active_effect;
|
|
if (dev_fallback_default) {
|
|
while (parent !== null && (parent.f & EAGER_EFFECT) !== 0) {
|
|
parent = parent.parent;
|
|
}
|
|
}
|
|
if (parent !== null && (parent.f & INERT) !== 0) {
|
|
type |= INERT;
|
|
}
|
|
var effect2 = {
|
|
ctx: component_context,
|
|
deps: null,
|
|
nodes: null,
|
|
f: type | DIRTY | CONNECTED,
|
|
first: null,
|
|
fn,
|
|
last: null,
|
|
next: null,
|
|
parent,
|
|
b: parent && parent.b,
|
|
prev: null,
|
|
teardown: null,
|
|
wv: 0,
|
|
ac: null
|
|
};
|
|
if (dev_fallback_default) {
|
|
effect2.component_function = dev_current_component_function;
|
|
}
|
|
var e = effect2;
|
|
if ((type & EFFECT) !== 0) {
|
|
if (collected_effects !== null) {
|
|
collected_effects.push(effect2);
|
|
} else {
|
|
schedule_effect(effect2);
|
|
}
|
|
} else if (fn !== null) {
|
|
try {
|
|
update_effect(effect2);
|
|
} catch (e2) {
|
|
destroy_effect(effect2);
|
|
throw e2;
|
|
}
|
|
if (e.deps === null && e.teardown === null && e.nodes === null && e.first === e.last && // either `null`, or a singular child
|
|
(e.f & EFFECT_PRESERVED) === 0) {
|
|
e = e.first;
|
|
if ((type & BLOCK_EFFECT) !== 0 && (type & EFFECT_TRANSPARENT) !== 0 && e !== null) {
|
|
e.f |= EFFECT_TRANSPARENT;
|
|
}
|
|
}
|
|
}
|
|
if (e !== null) {
|
|
e.parent = parent;
|
|
if (parent !== null) {
|
|
push_effect(e, parent);
|
|
}
|
|
if (active_reaction !== null && (active_reaction.f & DERIVED) !== 0 && (type & ROOT_EFFECT) === 0) {
|
|
var derived2 = (
|
|
/** @type {Derived} */
|
|
active_reaction
|
|
);
|
|
(derived2.effects ??= []).push(e);
|
|
}
|
|
}
|
|
return effect2;
|
|
}
|
|
function effect_tracking() {
|
|
return active_reaction !== null && !untracking;
|
|
}
|
|
function teardown(fn) {
|
|
const effect2 = create_effect(RENDER_EFFECT, null);
|
|
set_signal_status(effect2, CLEAN);
|
|
effect2.teardown = fn;
|
|
return effect2;
|
|
}
|
|
function user_effect(fn) {
|
|
validate_effect("$effect");
|
|
if (dev_fallback_default) {
|
|
define_property(fn, "name", {
|
|
value: "$effect"
|
|
});
|
|
}
|
|
var flags2 = (
|
|
/** @type {Effect} */
|
|
active_effect.f
|
|
);
|
|
var defer = !active_reaction && (flags2 & BRANCH_EFFECT) !== 0 && (flags2 & REACTION_RAN) === 0;
|
|
if (defer) {
|
|
var context = (
|
|
/** @type {ComponentContext} */
|
|
component_context
|
|
);
|
|
(context.e ??= []).push(fn);
|
|
} else {
|
|
return create_user_effect(fn);
|
|
}
|
|
}
|
|
function create_user_effect(fn) {
|
|
return create_effect(EFFECT | USER_EFFECT, fn);
|
|
}
|
|
function effect_root(fn) {
|
|
Batch.ensure();
|
|
const effect2 = create_effect(ROOT_EFFECT | EFFECT_PRESERVED, fn);
|
|
return () => {
|
|
destroy_effect(effect2);
|
|
};
|
|
}
|
|
function component_root(fn) {
|
|
Batch.ensure();
|
|
const effect2 = create_effect(ROOT_EFFECT | EFFECT_PRESERVED, fn);
|
|
return (options = {}) => {
|
|
return new Promise((fulfil) => {
|
|
if (options.outro) {
|
|
pause_effect(effect2, () => {
|
|
destroy_effect(effect2);
|
|
fulfil(void 0);
|
|
});
|
|
} else {
|
|
destroy_effect(effect2);
|
|
fulfil(void 0);
|
|
}
|
|
});
|
|
};
|
|
}
|
|
function effect(fn) {
|
|
return create_effect(EFFECT, fn);
|
|
}
|
|
function async_effect(fn) {
|
|
return create_effect(ASYNC | EFFECT_PRESERVED, fn);
|
|
}
|
|
function render_effect(fn, flags2 = 0) {
|
|
return create_effect(RENDER_EFFECT | flags2, fn);
|
|
}
|
|
function template_effect(fn, sync = [], async2 = [], blockers = []) {
|
|
flatten(blockers, sync, async2, (values) => {
|
|
create_effect(RENDER_EFFECT, () => fn(...values.map(get)));
|
|
});
|
|
}
|
|
function block(fn, flags2 = 0) {
|
|
var effect2 = create_effect(BLOCK_EFFECT | flags2, fn);
|
|
if (dev_fallback_default) {
|
|
effect2.dev_stack = dev_stack;
|
|
}
|
|
return effect2;
|
|
}
|
|
function branch(fn) {
|
|
return create_effect(BRANCH_EFFECT | EFFECT_PRESERVED, fn);
|
|
}
|
|
function execute_effect_teardown(effect2) {
|
|
var teardown2 = effect2.teardown;
|
|
if (teardown2 !== null) {
|
|
const previously_destroying_effect = is_destroying_effect;
|
|
const previous_reaction = active_reaction;
|
|
set_is_destroying_effect(true);
|
|
set_active_reaction(null);
|
|
try {
|
|
teardown2.call(null);
|
|
} finally {
|
|
set_is_destroying_effect(previously_destroying_effect);
|
|
set_active_reaction(previous_reaction);
|
|
}
|
|
}
|
|
}
|
|
function destroy_effect_children(signal, remove_dom = false) {
|
|
var effect2 = signal.first;
|
|
signal.first = signal.last = null;
|
|
while (effect2 !== null) {
|
|
const controller = effect2.ac;
|
|
if (controller !== null) {
|
|
without_reactive_context(() => {
|
|
controller.abort(STALE_REACTION);
|
|
});
|
|
}
|
|
var next2 = effect2.next;
|
|
if ((effect2.f & ROOT_EFFECT) !== 0) {
|
|
effect2.parent = null;
|
|
} else {
|
|
destroy_effect(effect2, remove_dom);
|
|
}
|
|
effect2 = next2;
|
|
}
|
|
}
|
|
function destroy_block_effect_children(signal) {
|
|
var effect2 = signal.first;
|
|
while (effect2 !== null) {
|
|
var next2 = effect2.next;
|
|
if ((effect2.f & BRANCH_EFFECT) === 0) {
|
|
destroy_effect(effect2);
|
|
}
|
|
effect2 = next2;
|
|
}
|
|
}
|
|
function destroy_effect(effect2, remove_dom = true) {
|
|
var removed = false;
|
|
if ((remove_dom || (effect2.f & HEAD_EFFECT) !== 0) && effect2.nodes !== null && effect2.nodes.end !== null) {
|
|
remove_effect_dom(
|
|
effect2.nodes.start,
|
|
/** @type {TemplateNode} */
|
|
effect2.nodes.end
|
|
);
|
|
removed = true;
|
|
}
|
|
destroy_effect_children(effect2, remove_dom && !removed);
|
|
remove_reactions(effect2, 0);
|
|
set_signal_status(effect2, DESTROYED);
|
|
var transitions = effect2.nodes && effect2.nodes.t;
|
|
if (transitions !== null) {
|
|
for (const transition2 of transitions) {
|
|
transition2.stop();
|
|
}
|
|
}
|
|
execute_effect_teardown(effect2);
|
|
var parent = effect2.parent;
|
|
if (parent !== null && parent.first !== null) {
|
|
unlink_effect(effect2);
|
|
}
|
|
if (dev_fallback_default) {
|
|
effect2.component_function = null;
|
|
}
|
|
effect2.next = effect2.prev = effect2.teardown = effect2.ctx = effect2.deps = effect2.fn = effect2.nodes = effect2.ac = null;
|
|
}
|
|
function remove_effect_dom(node, end) {
|
|
while (node !== null) {
|
|
var next2 = node === end ? null : get_next_sibling(node);
|
|
node.remove();
|
|
node = next2;
|
|
}
|
|
}
|
|
function unlink_effect(effect2) {
|
|
var parent = effect2.parent;
|
|
var prev = effect2.prev;
|
|
var next2 = effect2.next;
|
|
if (prev !== null) prev.next = next2;
|
|
if (next2 !== null) next2.prev = prev;
|
|
if (parent !== null) {
|
|
if (parent.first === effect2) parent.first = next2;
|
|
if (parent.last === effect2) parent.last = prev;
|
|
}
|
|
}
|
|
function pause_effect(effect2, callback, destroy = true) {
|
|
var transitions = [];
|
|
pause_children(effect2, transitions, true);
|
|
var fn = () => {
|
|
if (destroy) destroy_effect(effect2);
|
|
if (callback) callback();
|
|
};
|
|
var remaining = transitions.length;
|
|
if (remaining > 0) {
|
|
var check = () => --remaining || fn();
|
|
for (var transition2 of transitions) {
|
|
transition2.out(check);
|
|
}
|
|
} else {
|
|
fn();
|
|
}
|
|
}
|
|
function pause_children(effect2, transitions, local) {
|
|
if ((effect2.f & INERT) !== 0) return;
|
|
effect2.f ^= INERT;
|
|
var t = effect2.nodes && effect2.nodes.t;
|
|
if (t !== null) {
|
|
for (const transition2 of t) {
|
|
if (transition2.is_global || local) {
|
|
transitions.push(transition2);
|
|
}
|
|
}
|
|
}
|
|
var child2 = effect2.first;
|
|
while (child2 !== null) {
|
|
var sibling2 = child2.next;
|
|
var transparent = (child2.f & EFFECT_TRANSPARENT) !== 0 || // If this is a branch effect without a block effect parent,
|
|
// it means the parent block effect was pruned. In that case,
|
|
// transparency information was transferred to the branch effect.
|
|
(child2.f & BRANCH_EFFECT) !== 0 && (effect2.f & BLOCK_EFFECT) !== 0;
|
|
pause_children(child2, transitions, transparent ? local : false);
|
|
child2 = sibling2;
|
|
}
|
|
}
|
|
function resume_effect(effect2) {
|
|
resume_children(effect2, true);
|
|
}
|
|
function resume_children(effect2, local) {
|
|
if ((effect2.f & INERT) === 0) return;
|
|
effect2.f ^= INERT;
|
|
if ((effect2.f & CLEAN) === 0) {
|
|
set_signal_status(effect2, DIRTY);
|
|
schedule_effect(effect2);
|
|
}
|
|
var child2 = effect2.first;
|
|
while (child2 !== null) {
|
|
var sibling2 = child2.next;
|
|
var transparent = (child2.f & EFFECT_TRANSPARENT) !== 0 || (child2.f & BRANCH_EFFECT) !== 0;
|
|
resume_children(child2, transparent ? local : false);
|
|
child2 = sibling2;
|
|
}
|
|
var t = effect2.nodes && effect2.nodes.t;
|
|
if (t !== null) {
|
|
for (const transition2 of t) {
|
|
if (transition2.is_global || local) {
|
|
transition2.in();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function move_effect(effect2, fragment) {
|
|
if (!effect2.nodes) return;
|
|
var node = effect2.nodes.start;
|
|
var end = effect2.nodes.end;
|
|
while (node !== null) {
|
|
var next2 = node === end ? null : get_next_sibling(node);
|
|
fragment.append(node);
|
|
node = next2;
|
|
}
|
|
}
|
|
|
|
// node_modules/svelte/src/internal/client/legacy.js
|
|
var captured_signals = null;
|
|
|
|
// node_modules/svelte/src/internal/client/runtime.js
|
|
var is_updating_effect = false;
|
|
var is_destroying_effect = false;
|
|
function set_is_destroying_effect(value) {
|
|
is_destroying_effect = value;
|
|
}
|
|
var active_reaction = null;
|
|
var untracking = false;
|
|
function set_active_reaction(reaction) {
|
|
active_reaction = reaction;
|
|
}
|
|
var active_effect = null;
|
|
function set_active_effect(effect2) {
|
|
active_effect = effect2;
|
|
}
|
|
var current_sources = null;
|
|
function push_reaction_value(value) {
|
|
if (active_reaction !== null && (!async_mode_flag || (active_reaction.f & DERIVED) !== 0)) {
|
|
if (current_sources === null) {
|
|
current_sources = [value];
|
|
} else {
|
|
current_sources.push(value);
|
|
}
|
|
}
|
|
}
|
|
var new_deps = null;
|
|
var skipped_deps = 0;
|
|
var untracked_writes = null;
|
|
function set_untracked_writes(value) {
|
|
untracked_writes = value;
|
|
}
|
|
var write_version = 1;
|
|
var read_version = 0;
|
|
var update_version = read_version;
|
|
function set_update_version(value) {
|
|
update_version = value;
|
|
}
|
|
function increment_write_version() {
|
|
return ++write_version;
|
|
}
|
|
function is_dirty(reaction) {
|
|
var flags2 = reaction.f;
|
|
if ((flags2 & DIRTY) !== 0) {
|
|
return true;
|
|
}
|
|
if (flags2 & DERIVED) {
|
|
reaction.f &= ~WAS_MARKED;
|
|
}
|
|
if ((flags2 & MAYBE_DIRTY) !== 0) {
|
|
var dependencies = (
|
|
/** @type {Value[]} */
|
|
reaction.deps
|
|
);
|
|
var length = dependencies.length;
|
|
for (var i = 0; i < length; i++) {
|
|
var dependency = dependencies[i];
|
|
if (is_dirty(
|
|
/** @type {Derived} */
|
|
dependency
|
|
)) {
|
|
update_derived(
|
|
/** @type {Derived} */
|
|
dependency
|
|
);
|
|
}
|
|
if (dependency.wv > reaction.wv) {
|
|
return true;
|
|
}
|
|
}
|
|
if ((flags2 & CONNECTED) !== 0 && // During time traveling we don't want to reset the status so that
|
|
// traversal of the graph in the other batches still happens
|
|
batch_values === null) {
|
|
set_signal_status(reaction, CLEAN);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function schedule_possible_effect_self_invalidation(signal, effect2, root7 = true) {
|
|
var reactions = signal.reactions;
|
|
if (reactions === null) return;
|
|
if (!async_mode_flag && current_sources !== null && includes.call(current_sources, signal)) {
|
|
return;
|
|
}
|
|
for (var i = 0; i < reactions.length; i++) {
|
|
var reaction = reactions[i];
|
|
if ((reaction.f & DERIVED) !== 0) {
|
|
schedule_possible_effect_self_invalidation(
|
|
/** @type {Derived} */
|
|
reaction,
|
|
effect2,
|
|
false
|
|
);
|
|
} else if (effect2 === reaction) {
|
|
if (root7) {
|
|
set_signal_status(reaction, DIRTY);
|
|
} else if ((reaction.f & CLEAN) !== 0) {
|
|
set_signal_status(reaction, MAYBE_DIRTY);
|
|
}
|
|
schedule_effect(
|
|
/** @type {Effect} */
|
|
reaction
|
|
);
|
|
}
|
|
}
|
|
}
|
|
function update_reaction(reaction) {
|
|
var previous_deps = new_deps;
|
|
var previous_skipped_deps = skipped_deps;
|
|
var previous_untracked_writes = untracked_writes;
|
|
var previous_reaction = active_reaction;
|
|
var previous_sources = current_sources;
|
|
var previous_component_context = component_context;
|
|
var previous_untracking = untracking;
|
|
var previous_update_version = update_version;
|
|
var flags2 = reaction.f;
|
|
new_deps = /** @type {null | Value[]} */
|
|
null;
|
|
skipped_deps = 0;
|
|
untracked_writes = null;
|
|
active_reaction = (flags2 & (BRANCH_EFFECT | ROOT_EFFECT)) === 0 ? reaction : null;
|
|
current_sources = null;
|
|
set_component_context(reaction.ctx);
|
|
untracking = false;
|
|
update_version = ++read_version;
|
|
if (reaction.ac !== null) {
|
|
without_reactive_context(() => {
|
|
reaction.ac.abort(STALE_REACTION);
|
|
});
|
|
reaction.ac = null;
|
|
}
|
|
try {
|
|
reaction.f |= REACTION_IS_UPDATING;
|
|
var fn = (
|
|
/** @type {Function} */
|
|
reaction.fn
|
|
);
|
|
var result = fn();
|
|
reaction.f |= REACTION_RAN;
|
|
var deps = reaction.deps;
|
|
var is_fork = current_batch?.is_fork;
|
|
if (new_deps !== null) {
|
|
var i;
|
|
if (!is_fork) {
|
|
remove_reactions(reaction, skipped_deps);
|
|
}
|
|
if (deps !== null && skipped_deps > 0) {
|
|
deps.length = skipped_deps + new_deps.length;
|
|
for (i = 0; i < new_deps.length; i++) {
|
|
deps[skipped_deps + i] = new_deps[i];
|
|
}
|
|
} else {
|
|
reaction.deps = deps = new_deps;
|
|
}
|
|
if (effect_tracking() && (reaction.f & CONNECTED) !== 0) {
|
|
for (i = skipped_deps; i < deps.length; i++) {
|
|
(deps[i].reactions ??= []).push(reaction);
|
|
}
|
|
}
|
|
} else if (!is_fork && deps !== null && skipped_deps < deps.length) {
|
|
remove_reactions(reaction, skipped_deps);
|
|
deps.length = skipped_deps;
|
|
}
|
|
if (is_runes() && untracked_writes !== null && !untracking && deps !== null && (reaction.f & (DERIVED | MAYBE_DIRTY | DIRTY)) === 0) {
|
|
for (i = 0; i < /** @type {Source[]} */
|
|
untracked_writes.length; i++) {
|
|
schedule_possible_effect_self_invalidation(
|
|
untracked_writes[i],
|
|
/** @type {Effect} */
|
|
reaction
|
|
);
|
|
}
|
|
}
|
|
if (previous_reaction !== null && previous_reaction !== reaction) {
|
|
read_version++;
|
|
if (previous_reaction.deps !== null) {
|
|
for (let i2 = 0; i2 < previous_skipped_deps; i2 += 1) {
|
|
previous_reaction.deps[i2].rv = read_version;
|
|
}
|
|
}
|
|
if (previous_deps !== null) {
|
|
for (const dep of previous_deps) {
|
|
dep.rv = read_version;
|
|
}
|
|
}
|
|
if (untracked_writes !== null) {
|
|
if (previous_untracked_writes === null) {
|
|
previous_untracked_writes = untracked_writes;
|
|
} else {
|
|
previous_untracked_writes.push(.../** @type {Source[]} */
|
|
untracked_writes);
|
|
}
|
|
}
|
|
}
|
|
if ((reaction.f & ERROR_VALUE) !== 0) {
|
|
reaction.f ^= ERROR_VALUE;
|
|
}
|
|
return result;
|
|
} catch (error) {
|
|
return handle_error(error);
|
|
} finally {
|
|
reaction.f ^= REACTION_IS_UPDATING;
|
|
new_deps = previous_deps;
|
|
skipped_deps = previous_skipped_deps;
|
|
untracked_writes = previous_untracked_writes;
|
|
active_reaction = previous_reaction;
|
|
current_sources = previous_sources;
|
|
set_component_context(previous_component_context);
|
|
untracking = previous_untracking;
|
|
update_version = previous_update_version;
|
|
}
|
|
}
|
|
function remove_reaction(signal, dependency) {
|
|
let reactions = dependency.reactions;
|
|
if (reactions !== null) {
|
|
var index2 = index_of.call(reactions, signal);
|
|
if (index2 !== -1) {
|
|
var new_length = reactions.length - 1;
|
|
if (new_length === 0) {
|
|
reactions = dependency.reactions = null;
|
|
} else {
|
|
reactions[index2] = reactions[new_length];
|
|
reactions.pop();
|
|
}
|
|
}
|
|
}
|
|
if (reactions === null && (dependency.f & DERIVED) !== 0 && // Destroying a child effect while updating a parent effect can cause a dependency to appear
|
|
// to be unused, when in fact it is used by the currently-updating parent. Checking `new_deps`
|
|
// allows us to skip the expensive work of disconnecting and immediately reconnecting it
|
|
(new_deps === null || !includes.call(new_deps, dependency))) {
|
|
var derived2 = (
|
|
/** @type {Derived} */
|
|
dependency
|
|
);
|
|
if ((derived2.f & CONNECTED) !== 0) {
|
|
derived2.f ^= CONNECTED;
|
|
derived2.f &= ~WAS_MARKED;
|
|
}
|
|
update_derived_status(derived2);
|
|
freeze_derived_effects(derived2);
|
|
remove_reactions(derived2, 0);
|
|
}
|
|
}
|
|
function remove_reactions(signal, start_index) {
|
|
var dependencies = signal.deps;
|
|
if (dependencies === null) return;
|
|
for (var i = start_index; i < dependencies.length; i++) {
|
|
remove_reaction(signal, dependencies[i]);
|
|
}
|
|
}
|
|
function update_effect(effect2) {
|
|
var flags2 = effect2.f;
|
|
if ((flags2 & DESTROYED) !== 0) {
|
|
return;
|
|
}
|
|
set_signal_status(effect2, CLEAN);
|
|
var previous_effect = active_effect;
|
|
var was_updating_effect = is_updating_effect;
|
|
active_effect = effect2;
|
|
is_updating_effect = true;
|
|
if (dev_fallback_default) {
|
|
var previous_component_fn = dev_current_component_function;
|
|
set_dev_current_component_function(effect2.component_function);
|
|
var previous_stack = (
|
|
/** @type {any} */
|
|
dev_stack
|
|
);
|
|
set_dev_stack(effect2.dev_stack ?? dev_stack);
|
|
}
|
|
try {
|
|
if ((flags2 & (BLOCK_EFFECT | MANAGED_EFFECT)) !== 0) {
|
|
destroy_block_effect_children(effect2);
|
|
} else {
|
|
destroy_effect_children(effect2);
|
|
}
|
|
execute_effect_teardown(effect2);
|
|
var teardown2 = update_reaction(effect2);
|
|
effect2.teardown = typeof teardown2 === "function" ? teardown2 : null;
|
|
effect2.wv = write_version;
|
|
if (dev_fallback_default && tracing_mode_flag && (effect2.f & DIRTY) !== 0 && effect2.deps !== null) {
|
|
for (var dep of effect2.deps) {
|
|
if (dep.set_during_effect) {
|
|
dep.wv = increment_write_version();
|
|
dep.set_during_effect = false;
|
|
}
|
|
}
|
|
}
|
|
} finally {
|
|
is_updating_effect = was_updating_effect;
|
|
active_effect = previous_effect;
|
|
if (dev_fallback_default) {
|
|
set_dev_current_component_function(previous_component_fn);
|
|
set_dev_stack(previous_stack);
|
|
}
|
|
}
|
|
}
|
|
function get(signal) {
|
|
var flags2 = signal.f;
|
|
var is_derived = (flags2 & DERIVED) !== 0;
|
|
captured_signals?.add(signal);
|
|
if (active_reaction !== null && !untracking) {
|
|
var destroyed = active_effect !== null && (active_effect.f & DESTROYED) !== 0;
|
|
if (!destroyed && (current_sources === null || !includes.call(current_sources, signal))) {
|
|
var deps = active_reaction.deps;
|
|
if ((active_reaction.f & REACTION_IS_UPDATING) !== 0) {
|
|
if (signal.rv < read_version) {
|
|
signal.rv = read_version;
|
|
if (new_deps === null && deps !== null && deps[skipped_deps] === signal) {
|
|
skipped_deps++;
|
|
} else if (new_deps === null) {
|
|
new_deps = [signal];
|
|
} else {
|
|
new_deps.push(signal);
|
|
}
|
|
}
|
|
} else {
|
|
(active_reaction.deps ??= []).push(signal);
|
|
var reactions = signal.reactions;
|
|
if (reactions === null) {
|
|
signal.reactions = [active_reaction];
|
|
} else if (!includes.call(reactions, active_reaction)) {
|
|
reactions.push(active_reaction);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (dev_fallback_default) {
|
|
recent_async_deriveds.delete(signal);
|
|
if (tracing_mode_flag && !untracking && tracing_expressions !== null && active_reaction !== null && tracing_expressions.reaction === active_reaction) {
|
|
if (signal.trace) {
|
|
signal.trace();
|
|
} else {
|
|
var trace2 = get_error("traced at");
|
|
if (trace2) {
|
|
var entry = tracing_expressions.entries.get(signal);
|
|
if (entry === void 0) {
|
|
entry = { traces: [] };
|
|
tracing_expressions.entries.set(signal, entry);
|
|
}
|
|
var last = entry.traces[entry.traces.length - 1];
|
|
if (trace2.stack !== last?.stack) {
|
|
entry.traces.push(trace2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (is_destroying_effect && old_values.has(signal)) {
|
|
return old_values.get(signal);
|
|
}
|
|
if (is_derived) {
|
|
var derived2 = (
|
|
/** @type {Derived} */
|
|
signal
|
|
);
|
|
if (is_destroying_effect) {
|
|
var value = derived2.v;
|
|
if ((derived2.f & CLEAN) === 0 && derived2.reactions !== null || depends_on_old_values(derived2)) {
|
|
value = execute_derived(derived2);
|
|
}
|
|
old_values.set(derived2, value);
|
|
return value;
|
|
}
|
|
var should_connect = (derived2.f & CONNECTED) === 0 && !untracking && active_reaction !== null && (is_updating_effect || (active_reaction.f & CONNECTED) !== 0);
|
|
var is_new = (derived2.f & REACTION_RAN) === 0;
|
|
if (is_dirty(derived2)) {
|
|
if (should_connect) {
|
|
derived2.f |= CONNECTED;
|
|
}
|
|
update_derived(derived2);
|
|
}
|
|
if (should_connect && !is_new) {
|
|
unfreeze_derived_effects(derived2);
|
|
reconnect(derived2);
|
|
}
|
|
}
|
|
if (batch_values?.has(signal)) {
|
|
return batch_values.get(signal);
|
|
}
|
|
if ((signal.f & ERROR_VALUE) !== 0) {
|
|
throw signal.v;
|
|
}
|
|
return signal.v;
|
|
}
|
|
function reconnect(derived2) {
|
|
derived2.f |= CONNECTED;
|
|
if (derived2.deps === null) return;
|
|
for (const dep of derived2.deps) {
|
|
(dep.reactions ??= []).push(derived2);
|
|
if ((dep.f & DERIVED) !== 0 && (dep.f & CONNECTED) === 0) {
|
|
unfreeze_derived_effects(
|
|
/** @type {Derived} */
|
|
dep
|
|
);
|
|
reconnect(
|
|
/** @type {Derived} */
|
|
dep
|
|
);
|
|
}
|
|
}
|
|
}
|
|
function depends_on_old_values(derived2) {
|
|
if (derived2.v === UNINITIALIZED) return true;
|
|
if (derived2.deps === null) return false;
|
|
for (const dep of derived2.deps) {
|
|
if (old_values.has(dep)) {
|
|
return true;
|
|
}
|
|
if ((dep.f & DERIVED) !== 0 && depends_on_old_values(
|
|
/** @type {Derived} */
|
|
dep
|
|
)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function untrack(fn) {
|
|
var previous_untracking = untracking;
|
|
try {
|
|
untracking = true;
|
|
return fn();
|
|
} finally {
|
|
untracking = previous_untracking;
|
|
}
|
|
}
|
|
|
|
// node_modules/svelte/src/internal/client/dom/elements/events.js
|
|
var event_symbol = /* @__PURE__ */ Symbol("events");
|
|
var all_registered_events = /* @__PURE__ */ new Set();
|
|
var root_event_handles = /* @__PURE__ */ new Set();
|
|
function delegated(event_name, element2, handler) {
|
|
(element2[event_symbol] ??= {})[event_name] = handler;
|
|
}
|
|
function delegate(events) {
|
|
for (var i = 0; i < events.length; i++) {
|
|
all_registered_events.add(events[i]);
|
|
}
|
|
for (var fn of root_event_handles) {
|
|
fn(events);
|
|
}
|
|
}
|
|
var last_propagated_event = null;
|
|
function handle_event_propagation(event2) {
|
|
var handler_element = this;
|
|
var owner_document = (
|
|
/** @type {Node} */
|
|
handler_element.ownerDocument
|
|
);
|
|
var event_name = event2.type;
|
|
var path = event2.composedPath?.() || [];
|
|
var current_target = (
|
|
/** @type {null | Element} */
|
|
path[0] || event2.target
|
|
);
|
|
last_propagated_event = event2;
|
|
var path_idx = 0;
|
|
var handled_at = last_propagated_event === event2 && event2[event_symbol];
|
|
if (handled_at) {
|
|
var at_idx = path.indexOf(handled_at);
|
|
if (at_idx !== -1 && (handler_element === document || handler_element === /** @type {any} */
|
|
window)) {
|
|
event2[event_symbol] = handler_element;
|
|
return;
|
|
}
|
|
var handler_idx = path.indexOf(handler_element);
|
|
if (handler_idx === -1) {
|
|
return;
|
|
}
|
|
if (at_idx <= handler_idx) {
|
|
path_idx = at_idx;
|
|
}
|
|
}
|
|
current_target = /** @type {Element} */
|
|
path[path_idx] || event2.target;
|
|
if (current_target === handler_element) return;
|
|
define_property(event2, "currentTarget", {
|
|
configurable: true,
|
|
get() {
|
|
return current_target || owner_document;
|
|
}
|
|
});
|
|
var previous_reaction = active_reaction;
|
|
var previous_effect = active_effect;
|
|
set_active_reaction(null);
|
|
set_active_effect(null);
|
|
try {
|
|
var throw_error;
|
|
var other_errors = [];
|
|
while (current_target !== null) {
|
|
var parent_element = current_target.assignedSlot || current_target.parentNode || /** @type {any} */
|
|
current_target.host || null;
|
|
try {
|
|
var delegated2 = current_target[event_symbol]?.[event_name];
|
|
if (delegated2 != null && (!/** @type {any} */
|
|
current_target.disabled || // DOM could've been updated already by the time this is reached, so we check this as well
|
|
// -> the target could not have been disabled because it emits the event in the first place
|
|
event2.target === current_target)) {
|
|
delegated2.call(current_target, event2);
|
|
}
|
|
} catch (error) {
|
|
if (throw_error) {
|
|
other_errors.push(error);
|
|
} else {
|
|
throw_error = error;
|
|
}
|
|
}
|
|
if (event2.cancelBubble || parent_element === handler_element || parent_element === null) {
|
|
break;
|
|
}
|
|
current_target = parent_element;
|
|
}
|
|
if (throw_error) {
|
|
for (let error of other_errors) {
|
|
queueMicrotask(() => {
|
|
throw error;
|
|
});
|
|
}
|
|
throw throw_error;
|
|
}
|
|
} finally {
|
|
event2[event_symbol] = handler_element;
|
|
delete event2.currentTarget;
|
|
set_active_reaction(previous_reaction);
|
|
set_active_effect(previous_effect);
|
|
}
|
|
}
|
|
|
|
// node_modules/svelte/src/internal/client/dom/reconciler.js
|
|
var policy = (
|
|
// We gotta write it like this because after downleveling the pure comment may end up in the wrong location
|
|
globalThis?.window?.trustedTypes && /* @__PURE__ */ globalThis.window.trustedTypes.createPolicy("svelte-trusted-html", {
|
|
/** @param {string} html */
|
|
createHTML: (html2) => {
|
|
return html2;
|
|
}
|
|
})
|
|
);
|
|
function create_trusted_html(html2) {
|
|
return (
|
|
/** @type {string} */
|
|
policy?.createHTML(html2) ?? html2
|
|
);
|
|
}
|
|
function create_fragment_from_html(html2) {
|
|
var elem = create_element("template");
|
|
elem.innerHTML = create_trusted_html(html2.replaceAll("<!>", "<!---->"));
|
|
return elem.content;
|
|
}
|
|
|
|
// node_modules/svelte/src/internal/client/dom/template.js
|
|
function assign_nodes(start, end) {
|
|
var effect2 = (
|
|
/** @type {Effect} */
|
|
active_effect
|
|
);
|
|
if (effect2.nodes === null) {
|
|
effect2.nodes = { start, end, a: null, t: null };
|
|
}
|
|
}
|
|
// @__NO_SIDE_EFFECTS__
|
|
function from_html(content, flags2) {
|
|
var is_fragment = (flags2 & TEMPLATE_FRAGMENT) !== 0;
|
|
var use_import_node = (flags2 & TEMPLATE_USE_IMPORT_NODE) !== 0;
|
|
var node;
|
|
var has_start = !content.startsWith("<!>");
|
|
return () => {
|
|
if (hydrating) {
|
|
assign_nodes(hydrate_node, null);
|
|
return hydrate_node;
|
|
}
|
|
if (node === void 0) {
|
|
node = create_fragment_from_html(has_start ? content : "<!>" + content);
|
|
if (!is_fragment) node = /** @type {TemplateNode} */
|
|
get_first_child(node);
|
|
}
|
|
var clone = (
|
|
/** @type {TemplateNode} */
|
|
use_import_node || is_firefox ? document.importNode(node, true) : node.cloneNode(true)
|
|
);
|
|
if (is_fragment) {
|
|
var start = (
|
|
/** @type {TemplateNode} */
|
|
get_first_child(clone)
|
|
);
|
|
var end = (
|
|
/** @type {TemplateNode} */
|
|
clone.lastChild
|
|
);
|
|
assign_nodes(start, end);
|
|
} else {
|
|
assign_nodes(clone, clone);
|
|
}
|
|
return clone;
|
|
};
|
|
}
|
|
// @__NO_SIDE_EFFECTS__
|
|
function from_namespace(content, flags2, ns = "svg") {
|
|
var has_start = !content.startsWith("<!>");
|
|
var is_fragment = (flags2 & TEMPLATE_FRAGMENT) !== 0;
|
|
var wrapped = `<${ns}>${has_start ? content : "<!>" + content}</${ns}>`;
|
|
var node;
|
|
return () => {
|
|
if (hydrating) {
|
|
assign_nodes(hydrate_node, null);
|
|
return hydrate_node;
|
|
}
|
|
if (!node) {
|
|
var fragment = (
|
|
/** @type {DocumentFragment} */
|
|
create_fragment_from_html(wrapped)
|
|
);
|
|
var root7 = (
|
|
/** @type {Element} */
|
|
get_first_child(fragment)
|
|
);
|
|
if (is_fragment) {
|
|
node = document.createDocumentFragment();
|
|
while (get_first_child(root7)) {
|
|
node.appendChild(
|
|
/** @type {TemplateNode} */
|
|
get_first_child(root7)
|
|
);
|
|
}
|
|
} else {
|
|
node = /** @type {Element} */
|
|
get_first_child(root7);
|
|
}
|
|
}
|
|
var clone = (
|
|
/** @type {TemplateNode} */
|
|
node.cloneNode(true)
|
|
);
|
|
if (is_fragment) {
|
|
var start = (
|
|
/** @type {TemplateNode} */
|
|
get_first_child(clone)
|
|
);
|
|
var end = (
|
|
/** @type {TemplateNode} */
|
|
clone.lastChild
|
|
);
|
|
assign_nodes(start, end);
|
|
} else {
|
|
assign_nodes(clone, clone);
|
|
}
|
|
return clone;
|
|
};
|
|
}
|
|
// @__NO_SIDE_EFFECTS__
|
|
function from_svg(content, flags2) {
|
|
return /* @__PURE__ */ from_namespace(content, flags2, "svg");
|
|
}
|
|
function comment() {
|
|
if (hydrating) {
|
|
assign_nodes(hydrate_node, null);
|
|
return hydrate_node;
|
|
}
|
|
var frag = document.createDocumentFragment();
|
|
var start = document.createComment("");
|
|
var anchor = create_text();
|
|
frag.append(start, anchor);
|
|
assign_nodes(start, anchor);
|
|
return frag;
|
|
}
|
|
function append(anchor, dom) {
|
|
if (hydrating) {
|
|
var effect2 = (
|
|
/** @type {Effect & { nodes: EffectNodes }} */
|
|
active_effect
|
|
);
|
|
if ((effect2.f & REACTION_RAN) === 0 || effect2.nodes.end === null) {
|
|
effect2.nodes.end = hydrate_node;
|
|
}
|
|
hydrate_next();
|
|
return;
|
|
}
|
|
if (anchor === null) {
|
|
return;
|
|
}
|
|
anchor.before(
|
|
/** @type {Node} */
|
|
dom
|
|
);
|
|
}
|
|
|
|
// node_modules/svelte/src/utils.js
|
|
var DOM_BOOLEAN_ATTRIBUTES = [
|
|
"allowfullscreen",
|
|
"async",
|
|
"autofocus",
|
|
"autoplay",
|
|
"checked",
|
|
"controls",
|
|
"default",
|
|
"disabled",
|
|
"formnovalidate",
|
|
"indeterminate",
|
|
"inert",
|
|
"ismap",
|
|
"loop",
|
|
"multiple",
|
|
"muted",
|
|
"nomodule",
|
|
"novalidate",
|
|
"open",
|
|
"playsinline",
|
|
"readonly",
|
|
"required",
|
|
"reversed",
|
|
"seamless",
|
|
"selected",
|
|
"webkitdirectory",
|
|
"defer",
|
|
"disablepictureinpicture",
|
|
"disableremoteplayback"
|
|
];
|
|
var DOM_PROPERTIES = [
|
|
...DOM_BOOLEAN_ATTRIBUTES,
|
|
"formNoValidate",
|
|
"isMap",
|
|
"noModule",
|
|
"playsInline",
|
|
"readOnly",
|
|
"value",
|
|
"volume",
|
|
"defaultValue",
|
|
"defaultChecked",
|
|
"srcObject",
|
|
"noValidate",
|
|
"allowFullscreen",
|
|
"disablePictureInPicture",
|
|
"disableRemotePlayback"
|
|
];
|
|
var PASSIVE_EVENTS = ["touchstart", "touchmove"];
|
|
function is_passive_event(name) {
|
|
return PASSIVE_EVENTS.includes(name);
|
|
}
|
|
var STATE_CREATION_RUNES = (
|
|
/** @type {const} */
|
|
[
|
|
"$state",
|
|
"$state.raw",
|
|
"$derived",
|
|
"$derived.by"
|
|
]
|
|
);
|
|
var RUNES = (
|
|
/** @type {const} */
|
|
[
|
|
...STATE_CREATION_RUNES,
|
|
"$state.eager",
|
|
"$state.snapshot",
|
|
"$props",
|
|
"$props.id",
|
|
"$bindable",
|
|
"$effect",
|
|
"$effect.pre",
|
|
"$effect.tracking",
|
|
"$effect.root",
|
|
"$effect.pending",
|
|
"$inspect",
|
|
"$inspect().with",
|
|
"$inspect.trace",
|
|
"$host"
|
|
]
|
|
);
|
|
|
|
// node_modules/svelte/src/internal/client/render.js
|
|
var should_intro = true;
|
|
function set_text(text2, value) {
|
|
var str = value == null ? "" : typeof value === "object" ? `${value}` : value;
|
|
if (str !== (text2.__t ??= text2.nodeValue)) {
|
|
text2.__t = str;
|
|
text2.nodeValue = `${str}`;
|
|
}
|
|
}
|
|
function mount(component2, options) {
|
|
return _mount(component2, options);
|
|
}
|
|
function hydrate(component2, options) {
|
|
init_operations();
|
|
options.intro = options.intro ?? false;
|
|
const target = options.target;
|
|
const was_hydrating = hydrating;
|
|
const previous_hydrate_node = hydrate_node;
|
|
try {
|
|
var anchor = get_first_child(target);
|
|
while (anchor && (anchor.nodeType !== COMMENT_NODE || /** @type {Comment} */
|
|
anchor.data !== HYDRATION_START)) {
|
|
anchor = get_next_sibling(anchor);
|
|
}
|
|
if (!anchor) {
|
|
throw HYDRATION_ERROR;
|
|
}
|
|
set_hydrating(true);
|
|
set_hydrate_node(
|
|
/** @type {Comment} */
|
|
anchor
|
|
);
|
|
const instance = _mount(component2, { ...options, anchor });
|
|
set_hydrating(false);
|
|
return (
|
|
/** @type {Exports} */
|
|
instance
|
|
);
|
|
} catch (error) {
|
|
if (error instanceof Error && error.message.split("\n").some((line) => line.startsWith("https://svelte.dev/e/"))) {
|
|
throw error;
|
|
}
|
|
if (error !== HYDRATION_ERROR) {
|
|
console.warn("Failed to hydrate: ", error);
|
|
}
|
|
if (options.recover === false) {
|
|
hydration_failed();
|
|
}
|
|
init_operations();
|
|
clear_text_content(target);
|
|
set_hydrating(false);
|
|
return mount(component2, options);
|
|
} finally {
|
|
set_hydrating(was_hydrating);
|
|
set_hydrate_node(previous_hydrate_node);
|
|
}
|
|
}
|
|
var listeners = /* @__PURE__ */ new Map();
|
|
function _mount(Component, { target, anchor, props = {}, events, context, intro = true, transformError }) {
|
|
init_operations();
|
|
var component2 = void 0;
|
|
var unmount2 = component_root(() => {
|
|
var anchor_node = anchor ?? target.appendChild(create_text());
|
|
boundary(
|
|
/** @type {TemplateNode} */
|
|
anchor_node,
|
|
{
|
|
pending: () => {
|
|
}
|
|
},
|
|
(anchor_node2) => {
|
|
push({});
|
|
var ctx = (
|
|
/** @type {ComponentContext} */
|
|
component_context
|
|
);
|
|
if (context) ctx.c = context;
|
|
if (events) {
|
|
props.$$events = events;
|
|
}
|
|
if (hydrating) {
|
|
assign_nodes(
|
|
/** @type {TemplateNode} */
|
|
anchor_node2,
|
|
null
|
|
);
|
|
}
|
|
should_intro = intro;
|
|
component2 = Component(anchor_node2, props) || {};
|
|
should_intro = true;
|
|
if (hydrating) {
|
|
active_effect.nodes.end = hydrate_node;
|
|
if (hydrate_node === null || hydrate_node.nodeType !== COMMENT_NODE || /** @type {Comment} */
|
|
hydrate_node.data !== HYDRATION_END) {
|
|
hydration_mismatch();
|
|
throw HYDRATION_ERROR;
|
|
}
|
|
}
|
|
pop();
|
|
},
|
|
transformError
|
|
);
|
|
var registered_events = /* @__PURE__ */ new Set();
|
|
var event_handle = (events2) => {
|
|
for (var i = 0; i < events2.length; i++) {
|
|
var event_name = events2[i];
|
|
if (registered_events.has(event_name)) continue;
|
|
registered_events.add(event_name);
|
|
var passive2 = is_passive_event(event_name);
|
|
for (const node of [target, document]) {
|
|
var counts = listeners.get(node);
|
|
if (counts === void 0) {
|
|
counts = /* @__PURE__ */ new Map();
|
|
listeners.set(node, counts);
|
|
}
|
|
var count = counts.get(event_name);
|
|
if (count === void 0) {
|
|
node.addEventListener(event_name, handle_event_propagation, { passive: passive2 });
|
|
counts.set(event_name, 1);
|
|
} else {
|
|
counts.set(event_name, count + 1);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
event_handle(array_from(all_registered_events));
|
|
root_event_handles.add(event_handle);
|
|
return () => {
|
|
for (var event_name of registered_events) {
|
|
for (const node of [target, document]) {
|
|
var counts = (
|
|
/** @type {Map<string, number>} */
|
|
listeners.get(node)
|
|
);
|
|
var count = (
|
|
/** @type {number} */
|
|
counts.get(event_name)
|
|
);
|
|
if (--count == 0) {
|
|
node.removeEventListener(event_name, handle_event_propagation);
|
|
counts.delete(event_name);
|
|
if (counts.size === 0) {
|
|
listeners.delete(node);
|
|
}
|
|
} else {
|
|
counts.set(event_name, count);
|
|
}
|
|
}
|
|
}
|
|
root_event_handles.delete(event_handle);
|
|
if (anchor_node !== anchor) {
|
|
anchor_node.parentNode?.removeChild(anchor_node);
|
|
}
|
|
};
|
|
});
|
|
mounted_components.set(component2, unmount2);
|
|
return component2;
|
|
}
|
|
var mounted_components = /* @__PURE__ */ new WeakMap();
|
|
function unmount(component2, options) {
|
|
const fn = mounted_components.get(component2);
|
|
if (fn) {
|
|
mounted_components.delete(component2);
|
|
return fn(options);
|
|
}
|
|
if (dev_fallback_default) {
|
|
if (STATE_SYMBOL in component2) {
|
|
state_proxy_unmount();
|
|
} else {
|
|
lifecycle_double_unmount();
|
|
}
|
|
}
|
|
return Promise.resolve();
|
|
}
|
|
|
|
// node_modules/svelte/src/internal/client/dom/blocks/branches.js
|
|
var BranchManager = class {
|
|
/** @type {TemplateNode} */
|
|
anchor;
|
|
/** @type {Map<Batch, Key>} */
|
|
#batches = /* @__PURE__ */ new Map();
|
|
/**
|
|
* Map of keys to effects that are currently rendered in the DOM.
|
|
* These effects are visible and actively part of the document tree.
|
|
* Example:
|
|
* ```
|
|
* {#if condition}
|
|
* foo
|
|
* {:else}
|
|
* bar
|
|
* {/if}
|
|
* ```
|
|
* Can result in the entries `true->Effect` and `false->Effect`
|
|
* @type {Map<Key, Effect>}
|
|
*/
|
|
#onscreen = /* @__PURE__ */ new Map();
|
|
/**
|
|
* Similar to #onscreen with respect to the keys, but contains branches that are not yet
|
|
* in the DOM, because their insertion is deferred.
|
|
* @type {Map<Key, Branch>}
|
|
*/
|
|
#offscreen = /* @__PURE__ */ new Map();
|
|
/**
|
|
* Keys of effects that are currently outroing
|
|
* @type {Set<Key>}
|
|
*/
|
|
#outroing = /* @__PURE__ */ new Set();
|
|
/**
|
|
* Whether to pause (i.e. outro) on change, or destroy immediately.
|
|
* This is necessary for `<svelte:element>`
|
|
*/
|
|
#transition = true;
|
|
/**
|
|
* @param {TemplateNode} anchor
|
|
* @param {boolean} transition
|
|
*/
|
|
constructor(anchor, transition2 = true) {
|
|
this.anchor = anchor;
|
|
this.#transition = transition2;
|
|
}
|
|
/**
|
|
* @param {Batch} batch
|
|
*/
|
|
#commit = (batch) => {
|
|
if (!this.#batches.has(batch)) return;
|
|
var key2 = (
|
|
/** @type {Key} */
|
|
this.#batches.get(batch)
|
|
);
|
|
var onscreen = this.#onscreen.get(key2);
|
|
if (onscreen) {
|
|
resume_effect(onscreen);
|
|
this.#outroing.delete(key2);
|
|
} else {
|
|
var offscreen = this.#offscreen.get(key2);
|
|
if (offscreen) {
|
|
this.#onscreen.set(key2, offscreen.effect);
|
|
this.#offscreen.delete(key2);
|
|
offscreen.fragment.lastChild.remove();
|
|
this.anchor.before(offscreen.fragment);
|
|
onscreen = offscreen.effect;
|
|
}
|
|
}
|
|
for (const [b, k] of this.#batches) {
|
|
this.#batches.delete(b);
|
|
if (b === batch) {
|
|
break;
|
|
}
|
|
const offscreen2 = this.#offscreen.get(k);
|
|
if (offscreen2) {
|
|
destroy_effect(offscreen2.effect);
|
|
this.#offscreen.delete(k);
|
|
}
|
|
}
|
|
for (const [k, effect2] of this.#onscreen) {
|
|
if (k === key2 || this.#outroing.has(k)) continue;
|
|
const on_destroy = () => {
|
|
const keys = Array.from(this.#batches.values());
|
|
if (keys.includes(k)) {
|
|
var fragment = document.createDocumentFragment();
|
|
move_effect(effect2, fragment);
|
|
fragment.append(create_text());
|
|
this.#offscreen.set(k, { effect: effect2, fragment });
|
|
} else {
|
|
destroy_effect(effect2);
|
|
}
|
|
this.#outroing.delete(k);
|
|
this.#onscreen.delete(k);
|
|
};
|
|
if (this.#transition || !onscreen) {
|
|
this.#outroing.add(k);
|
|
pause_effect(effect2, on_destroy, false);
|
|
} else {
|
|
on_destroy();
|
|
}
|
|
}
|
|
};
|
|
/**
|
|
* @param {Batch} batch
|
|
*/
|
|
#discard = (batch) => {
|
|
this.#batches.delete(batch);
|
|
const keys = Array.from(this.#batches.values());
|
|
for (const [k, branch2] of this.#offscreen) {
|
|
if (!keys.includes(k)) {
|
|
destroy_effect(branch2.effect);
|
|
this.#offscreen.delete(k);
|
|
}
|
|
}
|
|
};
|
|
/**
|
|
*
|
|
* @param {any} key
|
|
* @param {null | ((target: TemplateNode) => void)} fn
|
|
*/
|
|
ensure(key2, fn) {
|
|
var batch = (
|
|
/** @type {Batch} */
|
|
current_batch
|
|
);
|
|
var defer = should_defer_append();
|
|
if (fn && !this.#onscreen.has(key2) && !this.#offscreen.has(key2)) {
|
|
if (defer) {
|
|
var fragment = document.createDocumentFragment();
|
|
var target = create_text();
|
|
fragment.append(target);
|
|
this.#offscreen.set(key2, {
|
|
effect: branch(() => fn(target)),
|
|
fragment
|
|
});
|
|
} else {
|
|
this.#onscreen.set(
|
|
key2,
|
|
branch(() => fn(this.anchor))
|
|
);
|
|
}
|
|
}
|
|
this.#batches.set(batch, key2);
|
|
if (defer) {
|
|
for (const [k, effect2] of this.#onscreen) {
|
|
if (k === key2) {
|
|
batch.unskip_effect(effect2);
|
|
} else {
|
|
batch.skip_effect(effect2);
|
|
}
|
|
}
|
|
for (const [k, branch2] of this.#offscreen) {
|
|
if (k === key2) {
|
|
batch.unskip_effect(branch2.effect);
|
|
} else {
|
|
batch.skip_effect(branch2.effect);
|
|
}
|
|
}
|
|
batch.oncommit(this.#commit);
|
|
batch.ondiscard(this.#discard);
|
|
} else {
|
|
if (hydrating) {
|
|
this.anchor = hydrate_node;
|
|
}
|
|
this.#commit(batch);
|
|
}
|
|
}
|
|
};
|
|
|
|
// node_modules/svelte/src/internal/client/dom/blocks/snippet.js
|
|
function snippet(node, get_snippet, ...args) {
|
|
var branches = new BranchManager(node);
|
|
block(() => {
|
|
const snippet2 = get_snippet() ?? null;
|
|
if (dev_fallback_default && snippet2 == null) {
|
|
invalid_snippet();
|
|
}
|
|
branches.ensure(snippet2, snippet2 && ((anchor) => snippet2(anchor, ...args)));
|
|
}, EFFECT_TRANSPARENT);
|
|
}
|
|
|
|
// node_modules/svelte/src/index-client.js
|
|
if (dev_fallback_default) {
|
|
let throw_rune_error = function(rune) {
|
|
if (!(rune in globalThis)) {
|
|
let value;
|
|
Object.defineProperty(globalThis, rune, {
|
|
configurable: true,
|
|
// eslint-disable-next-line getter-return
|
|
get: () => {
|
|
if (value !== void 0) {
|
|
return value;
|
|
}
|
|
rune_outside_svelte(rune);
|
|
},
|
|
set: (v) => {
|
|
value = v;
|
|
}
|
|
});
|
|
}
|
|
};
|
|
throw_rune_error("$state");
|
|
throw_rune_error("$effect");
|
|
throw_rune_error("$derived");
|
|
throw_rune_error("$inspect");
|
|
throw_rune_error("$props");
|
|
throw_rune_error("$bindable");
|
|
}
|
|
|
|
// node_modules/svelte/src/internal/client/dev/css.js
|
|
var all_styles = /* @__PURE__ */ new Map();
|
|
function register_style(hash2, style) {
|
|
var styles = all_styles.get(hash2);
|
|
if (!styles) {
|
|
styles = /* @__PURE__ */ new Set();
|
|
all_styles.set(hash2, styles);
|
|
}
|
|
styles.add(style);
|
|
}
|
|
|
|
// node_modules/svelte/src/internal/client/dom/blocks/if.js
|
|
function if_block(node, fn, elseif = false) {
|
|
var marker;
|
|
if (hydrating) {
|
|
marker = hydrate_node;
|
|
hydrate_next();
|
|
}
|
|
var branches = new BranchManager(node);
|
|
var flags2 = elseif ? EFFECT_TRANSPARENT : 0;
|
|
function update_branch(key2, fn2) {
|
|
if (hydrating) {
|
|
var data = read_hydration_instruction(
|
|
/** @type {TemplateNode} */
|
|
marker
|
|
);
|
|
var hydrated_key;
|
|
if (data === HYDRATION_START) {
|
|
hydrated_key = 0;
|
|
} else if (data === HYDRATION_START_ELSE) {
|
|
hydrated_key = false;
|
|
} else {
|
|
hydrated_key = parseInt(data.substring(1));
|
|
}
|
|
if (key2 !== hydrated_key) {
|
|
var anchor = skip_nodes();
|
|
set_hydrate_node(anchor);
|
|
branches.anchor = anchor;
|
|
set_hydrating(false);
|
|
branches.ensure(key2, fn2);
|
|
set_hydrating(true);
|
|
return;
|
|
}
|
|
}
|
|
branches.ensure(key2, fn2);
|
|
}
|
|
block(() => {
|
|
var has_branch = false;
|
|
fn((fn2, key2 = 0) => {
|
|
has_branch = true;
|
|
update_branch(key2, fn2);
|
|
});
|
|
if (!has_branch) {
|
|
update_branch(false, null);
|
|
}
|
|
}, flags2);
|
|
}
|
|
|
|
// node_modules/svelte/src/internal/client/dom/blocks/each.js
|
|
function pause_effects(state2, to_destroy, controlled_anchor) {
|
|
var transitions = [];
|
|
var length = to_destroy.length;
|
|
var group;
|
|
var remaining = to_destroy.length;
|
|
for (var i = 0; i < length; i++) {
|
|
let effect2 = to_destroy[i];
|
|
pause_effect(
|
|
effect2,
|
|
() => {
|
|
if (group) {
|
|
group.pending.delete(effect2);
|
|
group.done.add(effect2);
|
|
if (group.pending.size === 0) {
|
|
var groups = (
|
|
/** @type {Set<EachOutroGroup>} */
|
|
state2.outrogroups
|
|
);
|
|
destroy_effects(array_from(group.done));
|
|
groups.delete(group);
|
|
if (groups.size === 0) {
|
|
state2.outrogroups = null;
|
|
}
|
|
}
|
|
} else {
|
|
remaining -= 1;
|
|
}
|
|
},
|
|
false
|
|
);
|
|
}
|
|
if (remaining === 0) {
|
|
var fast_path = transitions.length === 0 && controlled_anchor !== null;
|
|
if (fast_path) {
|
|
var anchor = (
|
|
/** @type {Element} */
|
|
controlled_anchor
|
|
);
|
|
var parent_node = (
|
|
/** @type {Element} */
|
|
anchor.parentNode
|
|
);
|
|
clear_text_content(parent_node);
|
|
parent_node.append(anchor);
|
|
state2.items.clear();
|
|
}
|
|
destroy_effects(to_destroy, !fast_path);
|
|
} else {
|
|
group = {
|
|
pending: new Set(to_destroy),
|
|
done: /* @__PURE__ */ new Set()
|
|
};
|
|
(state2.outrogroups ??= /* @__PURE__ */ new Set()).add(group);
|
|
}
|
|
}
|
|
function destroy_effects(to_destroy, remove_dom = true) {
|
|
for (var i = 0; i < to_destroy.length; i++) {
|
|
destroy_effect(to_destroy[i], remove_dom);
|
|
}
|
|
}
|
|
var offscreen_anchor;
|
|
function each(node, flags2, get_collection, get_key, render_fn, fallback_fn = null) {
|
|
var anchor = node;
|
|
var items = /* @__PURE__ */ new Map();
|
|
var is_controlled = (flags2 & EACH_IS_CONTROLLED) !== 0;
|
|
if (is_controlled) {
|
|
var parent_node = (
|
|
/** @type {Element} */
|
|
node
|
|
);
|
|
anchor = hydrating ? set_hydrate_node(get_first_child(parent_node)) : parent_node.appendChild(create_text());
|
|
}
|
|
if (hydrating) {
|
|
hydrate_next();
|
|
}
|
|
var fallback2 = null;
|
|
var each_array = derived_safe_equal(() => {
|
|
var collection = get_collection();
|
|
return is_array(collection) ? collection : collection == null ? [] : array_from(collection);
|
|
});
|
|
var array;
|
|
var first_run = true;
|
|
function commit() {
|
|
state2.fallback = fallback2;
|
|
reconcile(state2, array, anchor, flags2, get_key);
|
|
if (fallback2 !== null) {
|
|
if (array.length === 0) {
|
|
if ((fallback2.f & EFFECT_OFFSCREEN) === 0) {
|
|
resume_effect(fallback2);
|
|
} else {
|
|
fallback2.f ^= EFFECT_OFFSCREEN;
|
|
move(fallback2, null, anchor);
|
|
}
|
|
} else {
|
|
pause_effect(fallback2, () => {
|
|
fallback2 = null;
|
|
});
|
|
}
|
|
}
|
|
}
|
|
var effect2 = block(() => {
|
|
array = /** @type {V[]} */
|
|
get(each_array);
|
|
var length = array.length;
|
|
let mismatch = false;
|
|
if (hydrating) {
|
|
var is_else = read_hydration_instruction(anchor) === HYDRATION_START_ELSE;
|
|
if (is_else !== (length === 0)) {
|
|
anchor = skip_nodes();
|
|
set_hydrate_node(anchor);
|
|
set_hydrating(false);
|
|
mismatch = true;
|
|
}
|
|
}
|
|
var keys = /* @__PURE__ */ new Set();
|
|
var batch = (
|
|
/** @type {Batch} */
|
|
current_batch
|
|
);
|
|
var defer = should_defer_append();
|
|
for (var index2 = 0; index2 < length; index2 += 1) {
|
|
if (hydrating && hydrate_node.nodeType === COMMENT_NODE && /** @type {Comment} */
|
|
hydrate_node.data === HYDRATION_END) {
|
|
anchor = /** @type {Comment} */
|
|
hydrate_node;
|
|
mismatch = true;
|
|
set_hydrating(false);
|
|
}
|
|
var value = array[index2];
|
|
var key2 = get_key(value, index2);
|
|
if (dev_fallback_default) {
|
|
var key_again = get_key(value, index2);
|
|
if (key2 !== key_again) {
|
|
each_key_volatile(String(index2), String(key2), String(key_again));
|
|
}
|
|
}
|
|
var item = first_run ? null : items.get(key2);
|
|
if (item) {
|
|
if (item.v) internal_set(item.v, value);
|
|
if (item.i) internal_set(item.i, index2);
|
|
if (defer) {
|
|
batch.unskip_effect(item.e);
|
|
}
|
|
} else {
|
|
item = create_item(
|
|
items,
|
|
first_run ? anchor : offscreen_anchor ??= create_text(),
|
|
value,
|
|
key2,
|
|
index2,
|
|
render_fn,
|
|
flags2,
|
|
get_collection
|
|
);
|
|
if (!first_run) {
|
|
item.e.f |= EFFECT_OFFSCREEN;
|
|
}
|
|
items.set(key2, item);
|
|
}
|
|
keys.add(key2);
|
|
}
|
|
if (length === 0 && fallback_fn && !fallback2) {
|
|
if (first_run) {
|
|
fallback2 = branch(() => fallback_fn(anchor));
|
|
} else {
|
|
fallback2 = branch(() => fallback_fn(offscreen_anchor ??= create_text()));
|
|
fallback2.f |= EFFECT_OFFSCREEN;
|
|
}
|
|
}
|
|
if (length > keys.size) {
|
|
if (dev_fallback_default) {
|
|
validate_each_keys(array, get_key);
|
|
} else {
|
|
each_key_duplicate("", "", "");
|
|
}
|
|
}
|
|
if (hydrating && length > 0) {
|
|
set_hydrate_node(skip_nodes());
|
|
}
|
|
if (!first_run) {
|
|
if (defer) {
|
|
for (const [key3, item2] of items) {
|
|
if (!keys.has(key3)) {
|
|
batch.skip_effect(item2.e);
|
|
}
|
|
}
|
|
batch.oncommit(commit);
|
|
batch.ondiscard(() => {
|
|
});
|
|
} else {
|
|
commit();
|
|
}
|
|
}
|
|
if (mismatch) {
|
|
set_hydrating(true);
|
|
}
|
|
get(each_array);
|
|
});
|
|
var state2 = { effect: effect2, flags: flags2, items, outrogroups: null, fallback: fallback2 };
|
|
first_run = false;
|
|
if (hydrating) {
|
|
anchor = hydrate_node;
|
|
}
|
|
}
|
|
function skip_to_branch(effect2) {
|
|
while (effect2 !== null && (effect2.f & BRANCH_EFFECT) === 0) {
|
|
effect2 = effect2.next;
|
|
}
|
|
return effect2;
|
|
}
|
|
function reconcile(state2, array, anchor, flags2, get_key) {
|
|
var is_animated = (flags2 & EACH_IS_ANIMATED) !== 0;
|
|
var length = array.length;
|
|
var items = state2.items;
|
|
var current = skip_to_branch(state2.effect.first);
|
|
var seen;
|
|
var prev = null;
|
|
var to_animate;
|
|
var matched = [];
|
|
var stashed = [];
|
|
var value;
|
|
var key2;
|
|
var effect2;
|
|
var i;
|
|
if (is_animated) {
|
|
for (i = 0; i < length; i += 1) {
|
|
value = array[i];
|
|
key2 = get_key(value, i);
|
|
effect2 = /** @type {EachItem} */
|
|
items.get(key2).e;
|
|
if ((effect2.f & EFFECT_OFFSCREEN) === 0) {
|
|
effect2.nodes?.a?.measure();
|
|
(to_animate ??= /* @__PURE__ */ new Set()).add(effect2);
|
|
}
|
|
}
|
|
}
|
|
for (i = 0; i < length; i += 1) {
|
|
value = array[i];
|
|
key2 = get_key(value, i);
|
|
effect2 = /** @type {EachItem} */
|
|
items.get(key2).e;
|
|
if (state2.outrogroups !== null) {
|
|
for (const group of state2.outrogroups) {
|
|
group.pending.delete(effect2);
|
|
group.done.delete(effect2);
|
|
}
|
|
}
|
|
if ((effect2.f & EFFECT_OFFSCREEN) !== 0) {
|
|
effect2.f ^= EFFECT_OFFSCREEN;
|
|
if (effect2 === current) {
|
|
move(effect2, null, anchor);
|
|
} else {
|
|
var next2 = prev ? prev.next : current;
|
|
if (effect2 === state2.effect.last) {
|
|
state2.effect.last = effect2.prev;
|
|
}
|
|
if (effect2.prev) effect2.prev.next = effect2.next;
|
|
if (effect2.next) effect2.next.prev = effect2.prev;
|
|
link(state2, prev, effect2);
|
|
link(state2, effect2, next2);
|
|
move(effect2, next2, anchor);
|
|
prev = effect2;
|
|
matched = [];
|
|
stashed = [];
|
|
current = skip_to_branch(prev.next);
|
|
continue;
|
|
}
|
|
}
|
|
if ((effect2.f & INERT) !== 0) {
|
|
resume_effect(effect2);
|
|
if (is_animated) {
|
|
effect2.nodes?.a?.unfix();
|
|
(to_animate ??= /* @__PURE__ */ new Set()).delete(effect2);
|
|
}
|
|
}
|
|
if (effect2 !== current) {
|
|
if (seen !== void 0 && seen.has(effect2)) {
|
|
if (matched.length < stashed.length) {
|
|
var start = stashed[0];
|
|
var j;
|
|
prev = start.prev;
|
|
var a = matched[0];
|
|
var b = matched[matched.length - 1];
|
|
for (j = 0; j < matched.length; j += 1) {
|
|
move(matched[j], start, anchor);
|
|
}
|
|
for (j = 0; j < stashed.length; j += 1) {
|
|
seen.delete(stashed[j]);
|
|
}
|
|
link(state2, a.prev, b.next);
|
|
link(state2, prev, a);
|
|
link(state2, b, start);
|
|
current = start;
|
|
prev = b;
|
|
i -= 1;
|
|
matched = [];
|
|
stashed = [];
|
|
} else {
|
|
seen.delete(effect2);
|
|
move(effect2, current, anchor);
|
|
link(state2, effect2.prev, effect2.next);
|
|
link(state2, effect2, prev === null ? state2.effect.first : prev.next);
|
|
link(state2, prev, effect2);
|
|
prev = effect2;
|
|
}
|
|
continue;
|
|
}
|
|
matched = [];
|
|
stashed = [];
|
|
while (current !== null && current !== effect2) {
|
|
(seen ??= /* @__PURE__ */ new Set()).add(current);
|
|
stashed.push(current);
|
|
current = skip_to_branch(current.next);
|
|
}
|
|
if (current === null) {
|
|
continue;
|
|
}
|
|
}
|
|
if ((effect2.f & EFFECT_OFFSCREEN) === 0) {
|
|
matched.push(effect2);
|
|
}
|
|
prev = effect2;
|
|
current = skip_to_branch(effect2.next);
|
|
}
|
|
if (state2.outrogroups !== null) {
|
|
for (const group of state2.outrogroups) {
|
|
if (group.pending.size === 0) {
|
|
destroy_effects(array_from(group.done));
|
|
state2.outrogroups?.delete(group);
|
|
}
|
|
}
|
|
if (state2.outrogroups.size === 0) {
|
|
state2.outrogroups = null;
|
|
}
|
|
}
|
|
if (current !== null || seen !== void 0) {
|
|
var to_destroy = [];
|
|
if (seen !== void 0) {
|
|
for (effect2 of seen) {
|
|
if ((effect2.f & INERT) === 0) {
|
|
to_destroy.push(effect2);
|
|
}
|
|
}
|
|
}
|
|
while (current !== null) {
|
|
if ((current.f & INERT) === 0 && current !== state2.fallback) {
|
|
to_destroy.push(current);
|
|
}
|
|
current = skip_to_branch(current.next);
|
|
}
|
|
var destroy_length = to_destroy.length;
|
|
if (destroy_length > 0) {
|
|
var controlled_anchor = (flags2 & EACH_IS_CONTROLLED) !== 0 && length === 0 ? anchor : null;
|
|
if (is_animated) {
|
|
for (i = 0; i < destroy_length; i += 1) {
|
|
to_destroy[i].nodes?.a?.measure();
|
|
}
|
|
for (i = 0; i < destroy_length; i += 1) {
|
|
to_destroy[i].nodes?.a?.fix();
|
|
}
|
|
}
|
|
pause_effects(state2, to_destroy, controlled_anchor);
|
|
}
|
|
}
|
|
if (is_animated) {
|
|
queue_micro_task(() => {
|
|
if (to_animate === void 0) return;
|
|
for (effect2 of to_animate) {
|
|
effect2.nodes?.a?.apply();
|
|
}
|
|
});
|
|
}
|
|
}
|
|
function create_item(items, anchor, value, key2, index2, render_fn, flags2, get_collection) {
|
|
var v = (flags2 & EACH_ITEM_REACTIVE) !== 0 ? (flags2 & EACH_ITEM_IMMUTABLE) === 0 ? mutable_source(value, false, false) : source(value) : null;
|
|
var i = (flags2 & EACH_INDEX_REACTIVE) !== 0 ? source(index2) : null;
|
|
if (dev_fallback_default && v) {
|
|
v.trace = () => {
|
|
get_collection()[i?.v ?? index2];
|
|
};
|
|
}
|
|
return {
|
|
v,
|
|
i,
|
|
e: branch(() => {
|
|
render_fn(anchor, v ?? value, i ?? index2, get_collection);
|
|
return () => {
|
|
items.delete(key2);
|
|
};
|
|
})
|
|
};
|
|
}
|
|
function move(effect2, next2, anchor) {
|
|
if (!effect2.nodes) return;
|
|
var node = effect2.nodes.start;
|
|
var end = effect2.nodes.end;
|
|
var dest = next2 && (next2.f & EFFECT_OFFSCREEN) === 0 ? (
|
|
/** @type {EffectNodes} */
|
|
next2.nodes.start
|
|
) : anchor;
|
|
while (node !== null) {
|
|
var next_node = (
|
|
/** @type {TemplateNode} */
|
|
get_next_sibling(node)
|
|
);
|
|
dest.before(node);
|
|
if (node === end) {
|
|
return;
|
|
}
|
|
node = next_node;
|
|
}
|
|
}
|
|
function link(state2, prev, next2) {
|
|
if (prev === null) {
|
|
state2.effect.first = next2;
|
|
} else {
|
|
prev.next = next2;
|
|
}
|
|
if (next2 === null) {
|
|
state2.effect.last = prev;
|
|
} else {
|
|
next2.prev = prev;
|
|
}
|
|
}
|
|
function validate_each_keys(array, key_fn) {
|
|
const keys = /* @__PURE__ */ new Map();
|
|
const length = array.length;
|
|
for (let i = 0; i < length; i++) {
|
|
const key2 = key_fn(array[i], i);
|
|
if (keys.has(key2)) {
|
|
const a = String(keys.get(key2));
|
|
const b = String(i);
|
|
let k = String(key2);
|
|
if (k.startsWith("[object ")) k = null;
|
|
each_key_duplicate(a, b, k);
|
|
}
|
|
keys.set(key2, i);
|
|
}
|
|
}
|
|
|
|
// node_modules/svelte/src/internal/client/timing.js
|
|
var now = true_default ? () => performance.now() : () => Date.now();
|
|
var raf = {
|
|
// don't access requestAnimationFrame eagerly outside method
|
|
// this allows basic testing of user code without JSDOM
|
|
// bunder will eval and remove ternary when the user's app is built
|
|
tick: (
|
|
/** @param {any} _ */
|
|
(_) => (true_default ? requestAnimationFrame : noop)(_)
|
|
),
|
|
now: () => now(),
|
|
tasks: /* @__PURE__ */ new Set()
|
|
};
|
|
|
|
// node_modules/svelte/src/internal/client/loop.js
|
|
function run_tasks() {
|
|
const now2 = raf.now();
|
|
raf.tasks.forEach((task) => {
|
|
if (!task.c(now2)) {
|
|
raf.tasks.delete(task);
|
|
task.f();
|
|
}
|
|
});
|
|
if (raf.tasks.size !== 0) {
|
|
raf.tick(run_tasks);
|
|
}
|
|
}
|
|
function loop(callback) {
|
|
let task;
|
|
if (raf.tasks.size === 0) {
|
|
raf.tick(run_tasks);
|
|
}
|
|
return {
|
|
promise: new Promise((fulfill) => {
|
|
raf.tasks.add(task = { c: callback, f: fulfill });
|
|
}),
|
|
abort() {
|
|
raf.tasks.delete(task);
|
|
}
|
|
};
|
|
}
|
|
|
|
// node_modules/svelte/src/internal/client/dom/elements/transitions.js
|
|
function dispatch_event(element2, type) {
|
|
without_reactive_context(() => {
|
|
element2.dispatchEvent(new CustomEvent(type));
|
|
});
|
|
}
|
|
function css_property_to_camelcase(style) {
|
|
if (style === "float") return "cssFloat";
|
|
if (style === "offset") return "cssOffset";
|
|
if (style.startsWith("--")) return style;
|
|
const parts = style.split("-");
|
|
if (parts.length === 1) return parts[0];
|
|
return parts[0] + parts.slice(1).map(
|
|
/** @param {any} word */
|
|
(word) => word[0].toUpperCase() + word.slice(1)
|
|
).join("");
|
|
}
|
|
function css_to_keyframe(css) {
|
|
const keyframe = {};
|
|
const parts = css.split(";");
|
|
for (const part of parts) {
|
|
const [property, value] = part.split(":");
|
|
if (!property || value === void 0) break;
|
|
const formatted_property = css_property_to_camelcase(property.trim());
|
|
keyframe[formatted_property] = value.trim();
|
|
}
|
|
return keyframe;
|
|
}
|
|
var linear = (t) => t;
|
|
function transition(flags2, element2, get_fn, get_params) {
|
|
var is_intro = (flags2 & TRANSITION_IN) !== 0;
|
|
var is_outro = (flags2 & TRANSITION_OUT) !== 0;
|
|
var is_both = is_intro && is_outro;
|
|
var is_global = (flags2 & TRANSITION_GLOBAL) !== 0;
|
|
var direction = is_both ? "both" : is_intro ? "in" : "out";
|
|
var current_options;
|
|
var inert = element2.inert;
|
|
var overflow = element2.style.overflow;
|
|
var intro;
|
|
var outro;
|
|
function get_options() {
|
|
return without_reactive_context(() => {
|
|
return current_options ??= get_fn()(element2, get_params?.() ?? /** @type {P} */
|
|
{}, {
|
|
direction
|
|
});
|
|
});
|
|
}
|
|
var transition2 = {
|
|
is_global,
|
|
in() {
|
|
element2.inert = inert;
|
|
if (!is_intro) {
|
|
outro?.abort();
|
|
outro?.reset?.();
|
|
return;
|
|
}
|
|
if (!is_outro) {
|
|
intro?.abort();
|
|
}
|
|
intro = animate(element2, get_options(), outro, 1, () => {
|
|
dispatch_event(element2, "introend");
|
|
intro?.abort();
|
|
intro = current_options = void 0;
|
|
element2.style.overflow = overflow;
|
|
});
|
|
},
|
|
out(fn) {
|
|
if (!is_outro) {
|
|
fn?.();
|
|
current_options = void 0;
|
|
return;
|
|
}
|
|
element2.inert = true;
|
|
outro = animate(element2, get_options(), intro, 0, () => {
|
|
dispatch_event(element2, "outroend");
|
|
fn?.();
|
|
});
|
|
},
|
|
stop: () => {
|
|
intro?.abort();
|
|
outro?.abort();
|
|
}
|
|
};
|
|
var e = (
|
|
/** @type {Effect & { nodes: EffectNodes }} */
|
|
active_effect
|
|
);
|
|
(e.nodes.t ??= []).push(transition2);
|
|
if (is_intro && should_intro) {
|
|
var run3 = is_global;
|
|
if (!run3) {
|
|
var block2 = (
|
|
/** @type {Effect | null} */
|
|
e.parent
|
|
);
|
|
while (block2 && (block2.f & EFFECT_TRANSPARENT) !== 0) {
|
|
while (block2 = block2.parent) {
|
|
if ((block2.f & BLOCK_EFFECT) !== 0) break;
|
|
}
|
|
}
|
|
run3 = !block2 || (block2.f & REACTION_RAN) !== 0;
|
|
}
|
|
if (run3) {
|
|
effect(() => {
|
|
untrack(() => transition2.in());
|
|
});
|
|
}
|
|
}
|
|
}
|
|
function animate(element2, options, counterpart, t2, on_finish) {
|
|
var is_intro = t2 === 1;
|
|
if (is_function(options)) {
|
|
var a;
|
|
var aborted2 = false;
|
|
queue_micro_task(() => {
|
|
if (aborted2) return;
|
|
var o = options({ direction: is_intro ? "in" : "out" });
|
|
a = animate(element2, o, counterpart, t2, on_finish);
|
|
});
|
|
return {
|
|
abort: () => {
|
|
aborted2 = true;
|
|
a?.abort();
|
|
},
|
|
deactivate: () => a.deactivate(),
|
|
reset: () => a.reset(),
|
|
t: () => a.t()
|
|
};
|
|
}
|
|
counterpart?.deactivate();
|
|
if (!options?.duration && !options?.delay) {
|
|
dispatch_event(element2, is_intro ? "introstart" : "outrostart");
|
|
on_finish();
|
|
return {
|
|
abort: noop,
|
|
deactivate: noop,
|
|
reset: noop,
|
|
t: () => t2
|
|
};
|
|
}
|
|
const { delay = 0, css, tick: tick2, easing = linear } = options;
|
|
var keyframes = [];
|
|
if (is_intro && counterpart === void 0) {
|
|
if (tick2) {
|
|
tick2(0, 1);
|
|
}
|
|
if (css) {
|
|
var styles = css_to_keyframe(css(0, 1));
|
|
keyframes.push(styles, styles);
|
|
}
|
|
}
|
|
var get_t = () => 1 - t2;
|
|
var animation2 = element2.animate(keyframes, { duration: delay, fill: "forwards" });
|
|
animation2.onfinish = () => {
|
|
animation2.cancel();
|
|
dispatch_event(element2, is_intro ? "introstart" : "outrostart");
|
|
var t1 = counterpart?.t() ?? 1 - t2;
|
|
counterpart?.abort();
|
|
var delta = t2 - t1;
|
|
var duration = (
|
|
/** @type {number} */
|
|
options.duration * Math.abs(delta)
|
|
);
|
|
var keyframes2 = [];
|
|
if (duration > 0) {
|
|
var needs_overflow_hidden = false;
|
|
if (css) {
|
|
var n = Math.ceil(duration / (1e3 / 60));
|
|
for (var i = 0; i <= n; i += 1) {
|
|
var t = t1 + delta * easing(i / n);
|
|
var styles2 = css_to_keyframe(css(t, 1 - t));
|
|
keyframes2.push(styles2);
|
|
needs_overflow_hidden ||= styles2.overflow === "hidden";
|
|
}
|
|
}
|
|
if (needs_overflow_hidden) {
|
|
element2.style.overflow = "hidden";
|
|
}
|
|
get_t = () => {
|
|
var time = (
|
|
/** @type {number} */
|
|
/** @type {globalThis.Animation} */
|
|
animation2.currentTime
|
|
);
|
|
return t1 + delta * easing(time / duration);
|
|
};
|
|
if (tick2) {
|
|
loop(() => {
|
|
if (animation2.playState !== "running") return false;
|
|
var t3 = get_t();
|
|
tick2(t3, 1 - t3);
|
|
return true;
|
|
});
|
|
}
|
|
}
|
|
animation2 = element2.animate(keyframes2, { duration, fill: "forwards" });
|
|
animation2.onfinish = () => {
|
|
get_t = () => t2;
|
|
tick2?.(t2, 1 - t2);
|
|
on_finish();
|
|
};
|
|
};
|
|
return {
|
|
abort: () => {
|
|
if (animation2) {
|
|
animation2.cancel();
|
|
animation2.effect = null;
|
|
animation2.onfinish = noop;
|
|
}
|
|
},
|
|
deactivate: () => {
|
|
on_finish = noop;
|
|
},
|
|
reset: () => {
|
|
if (t2 === 0) {
|
|
tick2?.(1, 0);
|
|
}
|
|
},
|
|
t: () => get_t()
|
|
};
|
|
}
|
|
|
|
// node_modules/svelte/src/internal/client/dom/css.js
|
|
function append_styles(anchor, css) {
|
|
effect(() => {
|
|
var root7 = anchor.getRootNode();
|
|
var target = (
|
|
/** @type {ShadowRoot} */
|
|
root7.host ? (
|
|
/** @type {ShadowRoot} */
|
|
root7
|
|
) : (
|
|
/** @type {Document} */
|
|
root7.head ?? /** @type {Document} */
|
|
root7.ownerDocument.head
|
|
)
|
|
);
|
|
if (!target.querySelector("#" + css.hash)) {
|
|
const style = create_element("style");
|
|
style.id = css.hash;
|
|
style.textContent = css.code;
|
|
target.appendChild(style);
|
|
if (dev_fallback_default) {
|
|
register_style(css.hash, style);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
// node_modules/svelte/src/internal/shared/attributes.js
|
|
var whitespace = [..." \n\r\f\xA0\v\uFEFF"];
|
|
function to_class(value, hash2, directives) {
|
|
var classname = value == null ? "" : "" + value;
|
|
if (hash2) {
|
|
classname = classname ? classname + " " + hash2 : hash2;
|
|
}
|
|
if (directives) {
|
|
for (var key2 of Object.keys(directives)) {
|
|
if (directives[key2]) {
|
|
classname = classname ? classname + " " + key2 : key2;
|
|
} else if (classname.length) {
|
|
var len = key2.length;
|
|
var a = 0;
|
|
while ((a = classname.indexOf(key2, a)) >= 0) {
|
|
var b = a + len;
|
|
if ((a === 0 || whitespace.includes(classname[a - 1])) && (b === classname.length || whitespace.includes(classname[b]))) {
|
|
classname = (a === 0 ? "" : classname.substring(0, a)) + classname.substring(b + 1);
|
|
} else {
|
|
a = b;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return classname === "" ? null : classname;
|
|
}
|
|
function append_styles2(styles, important = false) {
|
|
var separator = important ? " !important;" : ";";
|
|
var css = "";
|
|
for (var key2 of Object.keys(styles)) {
|
|
var value = styles[key2];
|
|
if (value != null && value !== "") {
|
|
css += " " + key2 + ": " + value + separator;
|
|
}
|
|
}
|
|
return css;
|
|
}
|
|
function to_css_name(name) {
|
|
if (name[0] !== "-" || name[1] !== "-") {
|
|
return name.toLowerCase();
|
|
}
|
|
return name;
|
|
}
|
|
function to_style(value, styles) {
|
|
if (styles) {
|
|
var new_style = "";
|
|
var normal_styles;
|
|
var important_styles;
|
|
if (Array.isArray(styles)) {
|
|
normal_styles = styles[0];
|
|
important_styles = styles[1];
|
|
} else {
|
|
normal_styles = styles;
|
|
}
|
|
if (value) {
|
|
value = String(value).replaceAll(/\s*\/\*.*?\*\/\s*/g, "").trim();
|
|
var in_str = false;
|
|
var in_apo = 0;
|
|
var in_comment = false;
|
|
var reserved_names = [];
|
|
if (normal_styles) {
|
|
reserved_names.push(...Object.keys(normal_styles).map(to_css_name));
|
|
}
|
|
if (important_styles) {
|
|
reserved_names.push(...Object.keys(important_styles).map(to_css_name));
|
|
}
|
|
var start_index = 0;
|
|
var name_index = -1;
|
|
const len = value.length;
|
|
for (var i = 0; i < len; i++) {
|
|
var c = value[i];
|
|
if (in_comment) {
|
|
if (c === "/" && value[i - 1] === "*") {
|
|
in_comment = false;
|
|
}
|
|
} else if (in_str) {
|
|
if (in_str === c) {
|
|
in_str = false;
|
|
}
|
|
} else if (c === "/" && value[i + 1] === "*") {
|
|
in_comment = true;
|
|
} else if (c === '"' || c === "'") {
|
|
in_str = c;
|
|
} else if (c === "(") {
|
|
in_apo++;
|
|
} else if (c === ")") {
|
|
in_apo--;
|
|
}
|
|
if (!in_comment && in_str === false && in_apo === 0) {
|
|
if (c === ":" && name_index === -1) {
|
|
name_index = i;
|
|
} else if (c === ";" || i === len - 1) {
|
|
if (name_index !== -1) {
|
|
var name = to_css_name(value.substring(start_index, name_index).trim());
|
|
if (!reserved_names.includes(name)) {
|
|
if (c !== ";") {
|
|
i++;
|
|
}
|
|
var property = value.substring(start_index, i).trim();
|
|
new_style += " " + property + ";";
|
|
}
|
|
}
|
|
start_index = i + 1;
|
|
name_index = -1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (normal_styles) {
|
|
new_style += append_styles2(normal_styles);
|
|
}
|
|
if (important_styles) {
|
|
new_style += append_styles2(important_styles, true);
|
|
}
|
|
new_style = new_style.trim();
|
|
return new_style === "" ? null : new_style;
|
|
}
|
|
return value == null ? null : String(value);
|
|
}
|
|
|
|
// node_modules/svelte/src/internal/client/dom/elements/class.js
|
|
function set_class(dom, is_html, value, hash2, prev_classes, next_classes) {
|
|
var prev = dom.__className;
|
|
if (hydrating || prev !== value || prev === void 0) {
|
|
var next_class_name = to_class(value, hash2, next_classes);
|
|
if (!hydrating || next_class_name !== dom.getAttribute("class")) {
|
|
if (next_class_name == null) {
|
|
dom.removeAttribute("class");
|
|
} else if (is_html) {
|
|
dom.className = next_class_name;
|
|
} else {
|
|
dom.setAttribute("class", next_class_name);
|
|
}
|
|
}
|
|
dom.__className = value;
|
|
} else if (next_classes && prev_classes !== next_classes) {
|
|
for (var key2 in next_classes) {
|
|
var is_present = !!next_classes[key2];
|
|
if (prev_classes == null || is_present !== !!prev_classes[key2]) {
|
|
dom.classList.toggle(key2, is_present);
|
|
}
|
|
}
|
|
}
|
|
return next_classes;
|
|
}
|
|
|
|
// node_modules/svelte/src/internal/client/dom/elements/style.js
|
|
function update_styles(dom, prev = {}, next2, priority) {
|
|
for (var key2 in next2) {
|
|
var value = next2[key2];
|
|
if (prev[key2] !== value) {
|
|
if (next2[key2] == null) {
|
|
dom.style.removeProperty(key2);
|
|
} else {
|
|
dom.style.setProperty(key2, value, priority);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function set_style(dom, value, prev_styles, next_styles) {
|
|
var prev = dom.__style;
|
|
if (hydrating || prev !== value) {
|
|
var next_style_attr = to_style(value, next_styles);
|
|
if (!hydrating || next_style_attr !== dom.getAttribute("style")) {
|
|
if (next_style_attr == null) {
|
|
dom.removeAttribute("style");
|
|
} else {
|
|
dom.style.cssText = next_style_attr;
|
|
}
|
|
}
|
|
dom.__style = value;
|
|
} else if (next_styles) {
|
|
if (Array.isArray(next_styles)) {
|
|
update_styles(dom, prev_styles?.[0], next_styles[0]);
|
|
update_styles(dom, prev_styles?.[1], next_styles[1], "important");
|
|
} else {
|
|
update_styles(dom, prev_styles, next_styles);
|
|
}
|
|
}
|
|
return next_styles;
|
|
}
|
|
|
|
// node_modules/svelte/src/internal/client/dom/elements/attributes.js
|
|
var IS_CUSTOM_ELEMENT = /* @__PURE__ */ Symbol("is custom element");
|
|
var IS_HTML = /* @__PURE__ */ Symbol("is html");
|
|
var LINK_TAG = IS_XHTML ? "link" : "LINK";
|
|
var PROGRESS_TAG = IS_XHTML ? "progress" : "PROGRESS";
|
|
function remove_input_defaults(input) {
|
|
if (!hydrating) return;
|
|
var already_removed = false;
|
|
var remove_defaults = () => {
|
|
if (already_removed) return;
|
|
already_removed = true;
|
|
if (input.hasAttribute("value")) {
|
|
var value = input.value;
|
|
set_attribute2(input, "value", null);
|
|
input.value = value;
|
|
}
|
|
if (input.hasAttribute("checked")) {
|
|
var checked = input.checked;
|
|
set_attribute2(input, "checked", null);
|
|
input.checked = checked;
|
|
}
|
|
};
|
|
input.__on_r = remove_defaults;
|
|
queue_micro_task(remove_defaults);
|
|
add_form_reset_listener();
|
|
}
|
|
function set_value(element2, value) {
|
|
var attributes = get_attributes(element2);
|
|
if (attributes.value === (attributes.value = // treat null and undefined the same for the initial value
|
|
value ?? void 0) || // @ts-expect-error
|
|
// `progress` elements always need their value set when it's `0`
|
|
element2.value === value && (value !== 0 || element2.nodeName !== PROGRESS_TAG)) {
|
|
return;
|
|
}
|
|
element2.value = value ?? "";
|
|
}
|
|
function set_attribute2(element2, attribute, value, skip_warning) {
|
|
var attributes = get_attributes(element2);
|
|
if (hydrating) {
|
|
attributes[attribute] = element2.getAttribute(attribute);
|
|
if (attribute === "src" || attribute === "srcset" || attribute === "href" && element2.nodeName === LINK_TAG) {
|
|
if (!skip_warning) {
|
|
check_src_in_dev_hydration(element2, attribute, value ?? "");
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
if (attributes[attribute] === (attributes[attribute] = value)) return;
|
|
if (attribute === "loading") {
|
|
element2[LOADING_ATTR_SYMBOL] = value;
|
|
}
|
|
if (value == null) {
|
|
element2.removeAttribute(attribute);
|
|
} else if (typeof value !== "string" && get_setters(element2).includes(attribute)) {
|
|
element2[attribute] = value;
|
|
} else {
|
|
element2.setAttribute(attribute, value);
|
|
}
|
|
}
|
|
function get_attributes(element2) {
|
|
return (
|
|
/** @type {Record<string | symbol, unknown>} **/
|
|
// @ts-expect-error
|
|
element2.__attributes ??= {
|
|
[IS_CUSTOM_ELEMENT]: element2.nodeName.includes("-"),
|
|
[IS_HTML]: element2.namespaceURI === NAMESPACE_HTML
|
|
}
|
|
);
|
|
}
|
|
var setters_cache = /* @__PURE__ */ new Map();
|
|
function get_setters(element2) {
|
|
var cache_key = element2.getAttribute("is") || element2.nodeName;
|
|
var setters = setters_cache.get(cache_key);
|
|
if (setters) return setters;
|
|
setters_cache.set(cache_key, setters = []);
|
|
var descriptors;
|
|
var proto = element2;
|
|
var element_proto = Element.prototype;
|
|
while (element_proto !== proto) {
|
|
descriptors = get_descriptors(proto);
|
|
for (var key2 in descriptors) {
|
|
if (descriptors[key2].set) {
|
|
setters.push(key2);
|
|
}
|
|
}
|
|
proto = get_prototype_of(proto);
|
|
}
|
|
return setters;
|
|
}
|
|
function check_src_in_dev_hydration(element2, attribute, value) {
|
|
if (!dev_fallback_default) return;
|
|
if (attribute === "srcset" && srcset_url_equal(element2, value)) return;
|
|
if (src_url_equal(element2.getAttribute(attribute) ?? "", value)) return;
|
|
hydration_attribute_changed(
|
|
attribute,
|
|
element2.outerHTML.replace(element2.innerHTML, element2.innerHTML && "..."),
|
|
String(value)
|
|
);
|
|
}
|
|
function src_url_equal(element_src, url) {
|
|
if (element_src === url) return true;
|
|
return new URL(element_src, document.baseURI).href === new URL(url, document.baseURI).href;
|
|
}
|
|
function split_srcset(srcset) {
|
|
return srcset.split(",").map((src) => src.trim().split(" ").filter(Boolean));
|
|
}
|
|
function srcset_url_equal(element2, srcset) {
|
|
var element_urls = split_srcset(element2.srcset);
|
|
var urls = split_srcset(srcset);
|
|
return urls.length === element_urls.length && urls.every(
|
|
([url, width], i) => width === element_urls[i][1] && // We need to test both ways because Vite will create an a full URL with
|
|
// `new URL(asset, import.meta.url).href` for the client when `base: './'`, and the
|
|
// relative URLs inside srcset are not automatically resolved to absolute URLs by
|
|
// browsers (in contrast to img.src). This means both SSR and DOM code could
|
|
// contain relative or absolute URLs.
|
|
(src_url_equal(element_urls[i][0], url) || src_url_equal(url, element_urls[i][0]))
|
|
);
|
|
}
|
|
|
|
// node_modules/svelte/src/internal/client/reactivity/store.js
|
|
var is_store_binding = false;
|
|
function capture_store_binding(fn) {
|
|
var previous_is_store_binding = is_store_binding;
|
|
try {
|
|
is_store_binding = false;
|
|
return [fn(), is_store_binding];
|
|
} finally {
|
|
is_store_binding = previous_is_store_binding;
|
|
}
|
|
}
|
|
|
|
// node_modules/svelte/src/internal/client/reactivity/props.js
|
|
function prop(props, key2, flags2, fallback2) {
|
|
var runes = !legacy_mode_flag || (flags2 & PROPS_IS_RUNES) !== 0;
|
|
var bindable = (flags2 & PROPS_IS_BINDABLE) !== 0;
|
|
var lazy = (flags2 & PROPS_IS_LAZY_INITIAL) !== 0;
|
|
var fallback_value = (
|
|
/** @type {V} */
|
|
fallback2
|
|
);
|
|
var fallback_dirty = true;
|
|
var get_fallback = () => {
|
|
if (fallback_dirty) {
|
|
fallback_dirty = false;
|
|
fallback_value = lazy ? untrack(
|
|
/** @type {() => V} */
|
|
fallback2
|
|
) : (
|
|
/** @type {V} */
|
|
fallback2
|
|
);
|
|
}
|
|
return fallback_value;
|
|
};
|
|
var setter;
|
|
if (bindable) {
|
|
var is_entry_props = STATE_SYMBOL in props || LEGACY_PROPS in props;
|
|
setter = get_descriptor(props, key2)?.set ?? (is_entry_props && key2 in props ? (v) => props[key2] = v : void 0);
|
|
}
|
|
var initial_value;
|
|
var is_store_sub = false;
|
|
if (bindable) {
|
|
[initial_value, is_store_sub] = capture_store_binding(() => (
|
|
/** @type {V} */
|
|
props[key2]
|
|
));
|
|
} else {
|
|
initial_value = /** @type {V} */
|
|
props[key2];
|
|
}
|
|
if (initial_value === void 0 && fallback2 !== void 0) {
|
|
initial_value = get_fallback();
|
|
if (setter) {
|
|
if (runes) props_invalid_value(key2);
|
|
setter(initial_value);
|
|
}
|
|
}
|
|
var getter;
|
|
if (runes) {
|
|
getter = () => {
|
|
var value = (
|
|
/** @type {V} */
|
|
props[key2]
|
|
);
|
|
if (value === void 0) return get_fallback();
|
|
fallback_dirty = true;
|
|
return value;
|
|
};
|
|
} else {
|
|
getter = () => {
|
|
var value = (
|
|
/** @type {V} */
|
|
props[key2]
|
|
);
|
|
if (value !== void 0) {
|
|
fallback_value = /** @type {V} */
|
|
void 0;
|
|
}
|
|
return value === void 0 ? fallback_value : value;
|
|
};
|
|
}
|
|
if (runes && (flags2 & PROPS_IS_UPDATED) === 0) {
|
|
return getter;
|
|
}
|
|
if (setter) {
|
|
var legacy_parent = props.$$legacy;
|
|
return (
|
|
/** @type {() => V} */
|
|
(function(value, mutation) {
|
|
if (arguments.length > 0) {
|
|
if (!runes || !mutation || legacy_parent || is_store_sub) {
|
|
setter(mutation ? getter() : value);
|
|
}
|
|
return value;
|
|
}
|
|
return getter();
|
|
})
|
|
);
|
|
}
|
|
var overridden = false;
|
|
var d = ((flags2 & PROPS_IS_IMMUTABLE) !== 0 ? derived : derived_safe_equal)(() => {
|
|
overridden = false;
|
|
return getter();
|
|
});
|
|
if (dev_fallback_default) {
|
|
d.label = key2;
|
|
}
|
|
if (bindable) get(d);
|
|
var parent_effect = (
|
|
/** @type {Effect} */
|
|
active_effect
|
|
);
|
|
return (
|
|
/** @type {() => V} */
|
|
(function(value, mutation) {
|
|
if (arguments.length > 0) {
|
|
const new_value = mutation ? get(d) : runes && bindable ? proxy(value) : value;
|
|
set(d, new_value);
|
|
overridden = true;
|
|
if (fallback_value !== void 0) {
|
|
fallback_value = new_value;
|
|
}
|
|
return value;
|
|
}
|
|
if (is_destroying_effect && overridden || (parent_effect.f & DESTROYED) !== 0) {
|
|
return d.v;
|
|
}
|
|
return get(d);
|
|
})
|
|
);
|
|
}
|
|
|
|
// node_modules/svelte/src/legacy/legacy-client.js
|
|
function createClassComponent(options) {
|
|
return new Svelte4Component(options);
|
|
}
|
|
var Svelte4Component = class {
|
|
/** @type {any} */
|
|
#events;
|
|
/** @type {Record<string, any>} */
|
|
#instance;
|
|
/**
|
|
* @param {ComponentConstructorOptions & {
|
|
* component: any;
|
|
* }} options
|
|
*/
|
|
constructor(options) {
|
|
var sources = /* @__PURE__ */ new Map();
|
|
var add_source = (key2, value) => {
|
|
var s = mutable_source(value, false, false);
|
|
sources.set(key2, s);
|
|
return s;
|
|
};
|
|
const props = new Proxy(
|
|
{ ...options.props || {}, $$events: {} },
|
|
{
|
|
get(target, prop2) {
|
|
return get(sources.get(prop2) ?? add_source(prop2, Reflect.get(target, prop2)));
|
|
},
|
|
has(target, prop2) {
|
|
if (prop2 === LEGACY_PROPS) return true;
|
|
get(sources.get(prop2) ?? add_source(prop2, Reflect.get(target, prop2)));
|
|
return Reflect.has(target, prop2);
|
|
},
|
|
set(target, prop2, value) {
|
|
set(sources.get(prop2) ?? add_source(prop2, value), value);
|
|
return Reflect.set(target, prop2, value);
|
|
}
|
|
}
|
|
);
|
|
this.#instance = (options.hydrate ? hydrate : mount)(options.component, {
|
|
target: options.target,
|
|
anchor: options.anchor,
|
|
props,
|
|
context: options.context,
|
|
intro: options.intro ?? false,
|
|
recover: options.recover,
|
|
transformError: options.transformError
|
|
});
|
|
if (!async_mode_flag && (!options?.props?.$$host || options.sync === false)) {
|
|
flushSync();
|
|
}
|
|
this.#events = props.$$events;
|
|
for (const key2 of Object.keys(this.#instance)) {
|
|
if (key2 === "$set" || key2 === "$destroy" || key2 === "$on") continue;
|
|
define_property(this, key2, {
|
|
get() {
|
|
return this.#instance[key2];
|
|
},
|
|
/** @param {any} value */
|
|
set(value) {
|
|
this.#instance[key2] = value;
|
|
},
|
|
enumerable: true
|
|
});
|
|
}
|
|
this.#instance.$set = /** @param {Record<string, any>} next */
|
|
(next2) => {
|
|
Object.assign(props, next2);
|
|
};
|
|
this.#instance.$destroy = () => {
|
|
unmount(this.#instance);
|
|
};
|
|
}
|
|
/** @param {Record<string, any>} props */
|
|
$set(props) {
|
|
this.#instance.$set(props);
|
|
}
|
|
/**
|
|
* @param {string} event
|
|
* @param {(...args: any[]) => any} callback
|
|
* @returns {any}
|
|
*/
|
|
$on(event2, callback) {
|
|
this.#events[event2] = this.#events[event2] || [];
|
|
const cb = (...args) => callback.call(this, ...args);
|
|
this.#events[event2].push(cb);
|
|
return () => {
|
|
this.#events[event2] = this.#events[event2].filter(
|
|
/** @param {any} fn */
|
|
(fn) => fn !== cb
|
|
);
|
|
};
|
|
}
|
|
$destroy() {
|
|
this.#instance.$destroy();
|
|
}
|
|
};
|
|
|
|
// node_modules/svelte/src/internal/client/dom/elements/custom-element.js
|
|
var SvelteElement;
|
|
if (typeof HTMLElement === "function") {
|
|
SvelteElement = class extends HTMLElement {
|
|
/** The Svelte component constructor */
|
|
$$ctor;
|
|
/** Slots */
|
|
$$s;
|
|
/** @type {any} The Svelte component instance */
|
|
$$c;
|
|
/** Whether or not the custom element is connected */
|
|
$$cn = false;
|
|
/** @type {Record<string, any>} Component props data */
|
|
$$d = {};
|
|
/** `true` if currently in the process of reflecting component props back to attributes */
|
|
$$r = false;
|
|
/** @type {Record<string, CustomElementPropDefinition>} Props definition (name, reflected, type etc) */
|
|
$$p_d = {};
|
|
/** @type {Record<string, EventListenerOrEventListenerObject[]>} Event listeners */
|
|
$$l = {};
|
|
/** @type {Map<EventListenerOrEventListenerObject, Function>} Event listener unsubscribe functions */
|
|
$$l_u = /* @__PURE__ */ new Map();
|
|
/** @type {any} The managed render effect for reflecting attributes */
|
|
$$me;
|
|
/** @type {ShadowRoot | null} The ShadowRoot of the custom element */
|
|
$$shadowRoot = null;
|
|
/**
|
|
* @param {*} $$componentCtor
|
|
* @param {*} $$slots
|
|
* @param {ShadowRootInit | undefined} shadow_root_init
|
|
*/
|
|
constructor($$componentCtor, $$slots, shadow_root_init) {
|
|
super();
|
|
this.$$ctor = $$componentCtor;
|
|
this.$$s = $$slots;
|
|
if (shadow_root_init) {
|
|
this.$$shadowRoot = this.attachShadow(shadow_root_init);
|
|
}
|
|
}
|
|
/**
|
|
* @param {string} type
|
|
* @param {EventListenerOrEventListenerObject} listener
|
|
* @param {boolean | AddEventListenerOptions} [options]
|
|
*/
|
|
addEventListener(type, listener, options) {
|
|
this.$$l[type] = this.$$l[type] || [];
|
|
this.$$l[type].push(listener);
|
|
if (this.$$c) {
|
|
const unsub = this.$$c.$on(type, listener);
|
|
this.$$l_u.set(listener, unsub);
|
|
}
|
|
super.addEventListener(type, listener, options);
|
|
}
|
|
/**
|
|
* @param {string} type
|
|
* @param {EventListenerOrEventListenerObject} listener
|
|
* @param {boolean | AddEventListenerOptions} [options]
|
|
*/
|
|
removeEventListener(type, listener, options) {
|
|
super.removeEventListener(type, listener, options);
|
|
if (this.$$c) {
|
|
const unsub = this.$$l_u.get(listener);
|
|
if (unsub) {
|
|
unsub();
|
|
this.$$l_u.delete(listener);
|
|
}
|
|
}
|
|
}
|
|
async connectedCallback() {
|
|
this.$$cn = true;
|
|
if (!this.$$c) {
|
|
let create_slot = function(name) {
|
|
return (anchor) => {
|
|
const slot2 = create_element("slot");
|
|
if (name !== "default") slot2.name = name;
|
|
append(anchor, slot2);
|
|
};
|
|
};
|
|
await Promise.resolve();
|
|
if (!this.$$cn || this.$$c) {
|
|
return;
|
|
}
|
|
const $$slots = {};
|
|
const existing_slots = get_custom_elements_slots(this);
|
|
for (const name of this.$$s) {
|
|
if (name in existing_slots) {
|
|
if (name === "default" && !this.$$d.children) {
|
|
this.$$d.children = create_slot(name);
|
|
$$slots.default = true;
|
|
} else {
|
|
$$slots[name] = create_slot(name);
|
|
}
|
|
}
|
|
}
|
|
for (const attribute of this.attributes) {
|
|
const name = this.$$g_p(attribute.name);
|
|
if (!(name in this.$$d)) {
|
|
this.$$d[name] = get_custom_element_value(name, attribute.value, this.$$p_d, "toProp");
|
|
}
|
|
}
|
|
for (const key2 in this.$$p_d) {
|
|
if (!(key2 in this.$$d) && this[key2] !== void 0) {
|
|
this.$$d[key2] = this[key2];
|
|
delete this[key2];
|
|
}
|
|
}
|
|
this.$$c = createClassComponent({
|
|
component: this.$$ctor,
|
|
target: this.$$shadowRoot || this,
|
|
props: {
|
|
...this.$$d,
|
|
$$slots,
|
|
$$host: this
|
|
}
|
|
});
|
|
this.$$me = effect_root(() => {
|
|
render_effect(() => {
|
|
this.$$r = true;
|
|
for (const key2 of object_keys(this.$$c)) {
|
|
if (!this.$$p_d[key2]?.reflect) continue;
|
|
this.$$d[key2] = this.$$c[key2];
|
|
const attribute_value = get_custom_element_value(
|
|
key2,
|
|
this.$$d[key2],
|
|
this.$$p_d,
|
|
"toAttribute"
|
|
);
|
|
if (attribute_value == null) {
|
|
this.removeAttribute(this.$$p_d[key2].attribute || key2);
|
|
} else {
|
|
this.setAttribute(this.$$p_d[key2].attribute || key2, attribute_value);
|
|
}
|
|
}
|
|
this.$$r = false;
|
|
});
|
|
});
|
|
for (const type in this.$$l) {
|
|
for (const listener of this.$$l[type]) {
|
|
const unsub = this.$$c.$on(type, listener);
|
|
this.$$l_u.set(listener, unsub);
|
|
}
|
|
}
|
|
this.$$l = {};
|
|
}
|
|
}
|
|
// We don't need this when working within Svelte code, but for compatibility of people using this outside of Svelte
|
|
// and setting attributes through setAttribute etc, this is helpful
|
|
/**
|
|
* @param {string} attr
|
|
* @param {string} _oldValue
|
|
* @param {string} newValue
|
|
*/
|
|
attributeChangedCallback(attr2, _oldValue, newValue) {
|
|
if (this.$$r) return;
|
|
attr2 = this.$$g_p(attr2);
|
|
this.$$d[attr2] = get_custom_element_value(attr2, newValue, this.$$p_d, "toProp");
|
|
this.$$c?.$set({ [attr2]: this.$$d[attr2] });
|
|
}
|
|
disconnectedCallback() {
|
|
this.$$cn = false;
|
|
Promise.resolve().then(() => {
|
|
if (!this.$$cn && this.$$c) {
|
|
this.$$c.$destroy();
|
|
this.$$me();
|
|
this.$$c = void 0;
|
|
}
|
|
});
|
|
}
|
|
/**
|
|
* @param {string} attribute_name
|
|
*/
|
|
$$g_p(attribute_name) {
|
|
return object_keys(this.$$p_d).find(
|
|
(key2) => this.$$p_d[key2].attribute === attribute_name || !this.$$p_d[key2].attribute && key2.toLowerCase() === attribute_name
|
|
) || attribute_name;
|
|
}
|
|
};
|
|
}
|
|
function get_custom_element_value(prop2, value, props_definition, transform) {
|
|
const type = props_definition[prop2]?.type;
|
|
value = type === "Boolean" && typeof value !== "boolean" ? value != null : value;
|
|
if (!transform || !props_definition[prop2]) {
|
|
return value;
|
|
} else if (transform === "toAttribute") {
|
|
switch (type) {
|
|
case "Object":
|
|
case "Array":
|
|
return value == null ? null : JSON.stringify(value);
|
|
case "Boolean":
|
|
return value ? "" : null;
|
|
case "Number":
|
|
return value == null ? null : value;
|
|
default:
|
|
return value;
|
|
}
|
|
} else {
|
|
switch (type) {
|
|
case "Object":
|
|
case "Array":
|
|
return value && JSON.parse(value);
|
|
case "Boolean":
|
|
return value;
|
|
// conversion already handled above
|
|
case "Number":
|
|
return value != null ? +value : value;
|
|
default:
|
|
return value;
|
|
}
|
|
}
|
|
}
|
|
function get_custom_elements_slots(element2) {
|
|
const result = {};
|
|
element2.childNodes.forEach((node) => {
|
|
result[
|
|
/** @type {Element} node */
|
|
node.slot || "default"
|
|
] = true;
|
|
});
|
|
return result;
|
|
}
|
|
|
|
// node_modules/svelte/src/transition/index.js
|
|
var linear2 = (x) => x;
|
|
function cubic_out(t) {
|
|
const f = t - 1;
|
|
return f * f * f + 1;
|
|
}
|
|
function fade(node, { delay = 0, duration = 400, easing = linear2 } = {}) {
|
|
const o = +getComputedStyle(node).opacity;
|
|
return {
|
|
delay,
|
|
duration,
|
|
easing,
|
|
css: (t) => `opacity: ${t * o}`
|
|
};
|
|
}
|
|
function scale(node, { delay = 0, duration = 400, easing = cubic_out, start = 0, opacity = 0 } = {}) {
|
|
const style = getComputedStyle(node);
|
|
const target_opacity = +style.opacity;
|
|
const transform = style.transform === "none" ? "" : style.transform;
|
|
const sd = 1 - start;
|
|
const od = target_opacity * (1 - opacity);
|
|
return {
|
|
delay,
|
|
duration,
|
|
easing,
|
|
css: (_t, u) => `
|
|
transform: ${transform} scale(${1 - sd * u});
|
|
opacity: ${target_opacity - od * u}
|
|
`
|
|
};
|
|
}
|
|
|
|
// src/plugins/PermissionsViewer/components/ui/ModalFrame.svelte
|
|
var root = from_html(`<div class="ui-modal-backdrop PermissionsViewer-jvc0fb" role="presentation"><div class="ui-modal PermissionsViewer-jvc0fb" role="dialog" aria-modal="true"><!> <div class="ui-modal-content PermissionsViewer-jvc0fb"><!></div></div></div>`);
|
|
var $$css = {
|
|
hash: "PermissionsViewer-jvc0fb",
|
|
code: ".ui-modal-backdrop.PermissionsViewer-jvc0fb {position:fixed;inset:0;display:flex;align-items:center;justify-content:center;padding:20px;background:var(--ui-modal-backdrop, rgba(0, 0, 0, 0.85));}.ui-modal.PermissionsViewer-jvc0fb {display:flex;flex-direction:column;width:min(var(--ui-modal-max-width), 100%);height:var(--ui-modal-height);border-radius:8px;overflow:hidden;background:var(--ui-modal-surface, #313338);box-shadow:0 8px 16px rgba(0, 0, 0, 0.4);}.ui-modal-content.PermissionsViewer-jvc0fb {display:flex;flex:1;overflow:hidden;}\n\n @media (max-width: 768px) {.ui-modal.PermissionsViewer-jvc0fb {max-height:95vh;}.ui-modal-content.PermissionsViewer-jvc0fb {flex-direction:column;}\n }"
|
|
};
|
|
function ModalFrame($$anchor, $$props) {
|
|
push($$props, true);
|
|
append_styles($$anchor, $$css);
|
|
const maxWidth = prop($$props, "maxWidth", 3, "900px"), height = prop($$props, "height", 3, "60vh");
|
|
function handleBackdropClick(event2) {
|
|
if (event2.target === event2.currentTarget) {
|
|
$$props.onBackdropClick?.();
|
|
}
|
|
}
|
|
var div = root();
|
|
var div_1 = child(div);
|
|
let styles;
|
|
var node = child(div_1);
|
|
snippet(node, () => $$props.header ?? noop);
|
|
var div_2 = sibling(node, 2);
|
|
var node_1 = child(div_2);
|
|
snippet(node_1, () => $$props.children);
|
|
reset(div_2);
|
|
reset(div_1);
|
|
reset(div);
|
|
template_effect(() => {
|
|
set_attribute2(div_1, "aria-label", $$props.ariaLabel);
|
|
styles = set_style(div_1, "", styles, {
|
|
"--ui-modal-max-width": maxWidth(),
|
|
"--ui-modal-height": height()
|
|
});
|
|
});
|
|
delegated("click", div, handleBackdropClick);
|
|
transition(3, div_1, () => scale, () => ({ duration: 200 }));
|
|
transition(3, div, () => fade, () => ({ duration: 200 }));
|
|
append($$anchor, div);
|
|
pop();
|
|
}
|
|
delegate(["click"]);
|
|
|
|
// src/plugins/PermissionsViewer/components/ui/ModalHeader.svelte
|
|
var root_1 = from_html(`<img class="ui-header-avatar PermissionsViewer-1ltsp6t" alt=""/>`);
|
|
var root_2 = from_html(`<div class="ui-header-fallback PermissionsViewer-1ltsp6t" aria-hidden="true"> </div>`);
|
|
var root_3 = from_html(`<p class="PermissionsViewer-1ltsp6t"> </p>`);
|
|
var root2 = from_html(`<div class="ui-modal-header PermissionsViewer-1ltsp6t"><div class="ui-header-title PermissionsViewer-1ltsp6t"><!> <div class="ui-header-text PermissionsViewer-1ltsp6t"><h2 class="PermissionsViewer-1ltsp6t"> </h2> <!></div></div> <button type="button" class="ui-close-button PermissionsViewer-1ltsp6t"><svg width="24" height="24" viewBox="0 0 24 24" fill="currentColor" aria-hidden="true"><path d="M18.4 4L12 10.4L5.6 4L4 5.6L10.4 12L4 18.4L5.6 20L12 13.6L18.4 20L20 18.4L13.6 12L20 5.6L18.4 4Z"></path></svg></button></div>`);
|
|
var $$css2 = {
|
|
hash: "PermissionsViewer-1ltsp6t",
|
|
code: ".ui-modal-header.PermissionsViewer-1ltsp6t {display:flex;align-items:center;justify-content:space-between;padding:16px;background:var(--ui-panel-surface, #2b2d31);border-bottom:1px solid var(--ui-border, #1e1f22);}.ui-header-title.PermissionsViewer-1ltsp6t {display:flex;align-items:center;gap:12px;min-width:0;}.ui-header-avatar.PermissionsViewer-1ltsp6t,\n .ui-header-fallback.PermissionsViewer-1ltsp6t {width:40px;height:40px;border-radius:50%;flex-shrink:0;}.ui-header-avatar.PermissionsViewer-1ltsp6t {object-fit:cover;}.ui-header-fallback.PermissionsViewer-1ltsp6t {display:flex;align-items:center;justify-content:center;font-size:18px;font-weight:700;color:var(--ui-text-primary, #f2f3f5);background:var(--ui-header-fallback-bg, linear-gradient(135deg, #5865f2, #7289da));}.ui-header-text.PermissionsViewer-1ltsp6t {min-width:0;}.ui-header-text.PermissionsViewer-1ltsp6t h2:where(.PermissionsViewer-1ltsp6t) {font-size:20px;font-weight:600;line-height:1.2;color:var(--ui-text-primary, #f2f3f5);white-space:nowrap;overflow:hidden;text-overflow:ellipsis;}.ui-header-text.PermissionsViewer-1ltsp6t p:where(.PermissionsViewer-1ltsp6t) {margin:2px 0 0 0;font-size:13px;color:var(--ui-text-secondary, #b5bac1);}.ui-close-button.PermissionsViewer-1ltsp6t {display:flex;align-items:center;justify-content:center;padding:8px;border:none;border-radius:4px;background:transparent;color:var(--ui-text-secondary, #b5bac1);cursor:pointer;}.ui-close-button.PermissionsViewer-1ltsp6t:hover {color:var(--ui-text-body, #dbdee1);background:var(--ui-hover-soft, #3f4147);}"
|
|
};
|
|
function ModalHeader($$anchor, $$props) {
|
|
append_styles($$anchor, $$css2);
|
|
const subtitle = prop($$props, "subtitle", 3, ""), avatarFallback = prop($$props, "avatarFallback", 3, "#"), closeLabel = prop($$props, "closeLabel", 3, "Close");
|
|
var div = root2();
|
|
var div_1 = child(div);
|
|
var node = child(div_1);
|
|
{
|
|
var consequent = ($$anchor2) => {
|
|
var img = root_1();
|
|
template_effect(() => set_attribute2(img, "src", $$props.avatarUrl));
|
|
append($$anchor2, img);
|
|
};
|
|
var alternate = ($$anchor2) => {
|
|
var div_2 = root_2();
|
|
var text2 = child(div_2, true);
|
|
reset(div_2);
|
|
template_effect(() => set_text(text2, avatarFallback()));
|
|
append($$anchor2, div_2);
|
|
};
|
|
if_block(node, ($$render) => {
|
|
if ($$props.avatarUrl) $$render(consequent);
|
|
else $$render(alternate, false);
|
|
});
|
|
}
|
|
var div_3 = sibling(node, 2);
|
|
var h2 = child(div_3);
|
|
var text_1 = child(h2, true);
|
|
reset(h2);
|
|
var node_1 = sibling(h2, 2);
|
|
{
|
|
var consequent_1 = ($$anchor2) => {
|
|
var p = root_3();
|
|
var text_2 = child(p, true);
|
|
reset(p);
|
|
template_effect(() => set_text(text_2, subtitle()));
|
|
append($$anchor2, p);
|
|
};
|
|
if_block(node_1, ($$render) => {
|
|
if (subtitle()) $$render(consequent_1);
|
|
});
|
|
}
|
|
reset(div_3);
|
|
reset(div_1);
|
|
var button = sibling(div_1, 2);
|
|
reset(div);
|
|
template_effect(() => {
|
|
set_text(text_1, $$props.title);
|
|
set_attribute2(button, "aria-label", closeLabel());
|
|
});
|
|
delegated("click", button, function(...$$args) {
|
|
$$props.onClose?.apply(this, $$args);
|
|
});
|
|
append($$anchor, div);
|
|
}
|
|
delegate(["click"]);
|
|
|
|
// src/plugins/PermissionsViewer/components/PermissionViewerHeader.svelte
|
|
function PermissionViewerHeader($$anchor, $$props) {
|
|
const subtitle = prop($$props, "subtitle", 3, "");
|
|
ModalHeader($$anchor, {
|
|
get title() {
|
|
return $$props.title;
|
|
},
|
|
get subtitle() {
|
|
return subtitle();
|
|
},
|
|
get avatarUrl() {
|
|
return $$props.avatarUrl;
|
|
},
|
|
avatarFallback: "#",
|
|
closeLabel: "Close permission viewer",
|
|
get onClose() {
|
|
return $$props.onClose;
|
|
}
|
|
});
|
|
}
|
|
|
|
// src/plugins/PermissionsViewer/components/PermissionStatusIcon.svelte
|
|
var root_12 = from_svg(`<svg viewBox="0 0 24 24" fill="currentColor" aria-hidden="true" class="PermissionsViewer-1ra9ehi"><path d="M9 16.17L4.83 12l-1.42 1.41L9 19 21 7l-1.41-1.41L9 16.17z"></path></svg>`);
|
|
var root_22 = from_svg(`<svg viewBox="0 0 24 24" fill="currentColor" aria-hidden="true" class="PermissionsViewer-1ra9ehi"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.42 0-8-3.58-8-8 0-1.85.63-3.55 1.68-4.9L16.9 18.32C15.55 19.37 13.85 20 12 20zm6.32-3.1L7.1 5.68C8.45 4.63 10.15 4 12 4c4.42 0 8 3.58 8 8 0 1.85-.63 3.55-1.68 4.9z"></path></svg>`);
|
|
var root_32 = from_svg(`<svg viewBox="0 0 24 24" fill="currentColor" aria-hidden="true" class="PermissionsViewer-1ra9ehi"><path d="M19 13H5v-2h14v2z"></path></svg>`);
|
|
var $$css3 = {
|
|
hash: "PermissionsViewer-1ra9ehi",
|
|
code: "svg.PermissionsViewer-1ra9ehi {width:14px;height:14px;}"
|
|
};
|
|
function PermissionStatusIcon($$anchor, $$props) {
|
|
append_styles($$anchor, $$css3);
|
|
var fragment = comment();
|
|
var node = first_child(fragment);
|
|
{
|
|
var consequent = ($$anchor2) => {
|
|
var svg = root_12();
|
|
append($$anchor2, svg);
|
|
};
|
|
var consequent_1 = ($$anchor2) => {
|
|
var svg_1 = root_22();
|
|
append($$anchor2, svg_1);
|
|
};
|
|
var alternate = ($$anchor2) => {
|
|
var svg_2 = root_32();
|
|
append($$anchor2, svg_2);
|
|
};
|
|
if_block(node, ($$render) => {
|
|
if ($$props.status === "allowed") $$render(consequent);
|
|
else if ($$props.status === "denied") $$render(consequent_1, 1);
|
|
else $$render(alternate, false);
|
|
});
|
|
}
|
|
append($$anchor, fragment);
|
|
}
|
|
|
|
// src/plugins/PermissionsViewer/components/ui/SearchField.svelte
|
|
var root_13 = from_svg(`<svg class="ui-search-icon PermissionsViewer-9xbgz6" width="16" height="16" viewBox="0 0 24 24" fill="currentColor" aria-hidden="true"><path d="M21.707 20.293L16.314 14.9C17.403 13.504 18 11.799 18 10C18 7.863 17.167 5.854 15.656 4.344C14.146 2.832 12.137 2 10 2C7.863 2 5.854 2.832 4.344 4.344C2.833 5.854 2 7.863 2 10C2 12.137 2.833 14.146 4.344 15.656C5.854 17.168 7.863 18 10 18C11.799 18 13.504 17.404 14.9 16.314L20.293 21.706L21.707 20.293ZM10 16C8.397 16 6.891 15.376 5.758 14.243C4.624 13.11 4 11.603 4 10C4 8.398 4.624 6.891 5.758 5.758C6.891 4.624 8.397 4 10 4C11.603 4 13.109 4.624 14.242 5.758C15.376 6.891 16 8.398 16 10C16 11.603 15.376 13.11 14.242 14.243C13.109 15.376 11.603 16 10 16Z"></path></svg>`);
|
|
var root3 = from_html(`<div><!> <input type="text" class="PermissionsViewer-9xbgz6"/></div>`);
|
|
var $$css4 = {
|
|
hash: "PermissionsViewer-9xbgz6",
|
|
code: ".ui-search-field.PermissionsViewer-9xbgz6 {position:relative;flex:1;}.ui-search-field.PermissionsViewer-9xbgz6 input:where(.PermissionsViewer-9xbgz6) {width:100%;padding:9px 10px;border:none;border-radius:4px;font-size:14px;color:var(--ui-text-body, #dbdee1);background:var(--ui-input-bg, #1e1f22);outline:none;}.ui-search-field.PermissionsViewer-9xbgz6 input:where(.PermissionsViewer-9xbgz6)::placeholder {color:var(--ui-text-muted, #949ba4);}.ui-search-field.PermissionsViewer-9xbgz6 input:where(.PermissionsViewer-9xbgz6):focus {background:var(--ui-input-bg-focus, #1a1b1e);}.ui-search-field.with-icon.PermissionsViewer-9xbgz6 input:where(.PermissionsViewer-9xbgz6) {padding:9px 12px 9px 36px;}.ui-search-icon.PermissionsViewer-9xbgz6 {position:absolute;left:12px;top:50%;transform:translateY(-50%);color:var(--ui-text-muted, #949ba4);pointer-events:none;}"
|
|
};
|
|
function SearchField($$anchor, $$props) {
|
|
push($$props, true);
|
|
append_styles($$anchor, $$css4);
|
|
const placeholder = prop($$props, "placeholder", 3, "Search..."), ariaLabel = prop($$props, "ariaLabel", 19, placeholder), withSearchIcon = prop($$props, "withSearchIcon", 3, false);
|
|
var div = root3();
|
|
let classes;
|
|
var node = child(div);
|
|
{
|
|
var consequent = ($$anchor2) => {
|
|
var svg = root_13();
|
|
append($$anchor2, svg);
|
|
};
|
|
if_block(node, ($$render) => {
|
|
if (withSearchIcon()) $$render(consequent);
|
|
});
|
|
}
|
|
var input = sibling(node, 2);
|
|
remove_input_defaults(input);
|
|
reset(div);
|
|
template_effect(() => {
|
|
classes = set_class(div, 1, "ui-search-field PermissionsViewer-9xbgz6", null, classes, { "with-icon": withSearchIcon() });
|
|
set_attribute2(input, "placeholder", placeholder());
|
|
set_value(input, $$props.value);
|
|
set_attribute2(input, "aria-label", ariaLabel());
|
|
});
|
|
delegated("input", input, (event2) => $$props.onInput(event2.currentTarget.value));
|
|
append($$anchor, div);
|
|
pop();
|
|
}
|
|
delegate(["input"]);
|
|
|
|
// src/plugins/PermissionsViewer/components/PermissionViewerPermissions.svelte
|
|
var root_14 = from_svg(`<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M2.062 12.348a1 1 0 0 1 0-.696 10.75 10.75 0 0 1 19.876 0 1 1 0 0 1 0 .696 10.75 10.75 0 0 1-19.876 0"></path><circle cx="12" cy="12" r="3"></circle></svg>`);
|
|
var root_23 = from_svg(`<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M10.733 5.076a10.744 10.744 0 0 1 11.205 6.575 1 1 0 0 1 0 .696 10.747 10.747 0 0 1-1.444 2.49"></path><path d="M14.084 14.158a3 3 0 0 1-4.242-4.242"></path><path d="M17.479 17.499a10.75 10.75 0 0 1-15.417-5.151 1 1 0 0 1 0-.696 10.75 10.75 0 0 1 4.446-5.143"></path><path d="m2 2 20 20"></path></svg>`);
|
|
var root_33 = from_html(`<div class="empty-state PermissionsViewer-18b2fsv">No role data available</div>`);
|
|
var root_4 = from_html(`<div class="empty-state PermissionsViewer-18b2fsv">No permissions match this search</div>`);
|
|
var root_7 = from_html(`<div class="permission-item PermissionsViewer-18b2fsv"><div class="permission-info PermissionsViewer-18b2fsv"><div><!></div> <div class="permission-details PermissionsViewer-18b2fsv"><div class="permission-name PermissionsViewer-18b2fsv"> </div> <div class="permission-description PermissionsViewer-18b2fsv"> </div></div></div> <div><!> </div></div>`);
|
|
var root_6 = from_html(`<section class="permission-category PermissionsViewer-18b2fsv"><h3 class="category-header PermissionsViewer-18b2fsv"> </h3> <div class="permission-list PermissionsViewer-18b2fsv"></div></section>`);
|
|
var root4 = from_html(`<div class="main-content PermissionsViewer-18b2fsv"><div class="content-search PermissionsViewer-18b2fsv"><!> <button type="button" class="toggle-neutral PermissionsViewer-18b2fsv"><!></button></div> <div class="main-body PermissionsViewer-18b2fsv"><!></div></div>`);
|
|
var $$css5 = {
|
|
hash: "PermissionsViewer-18b2fsv",
|
|
code: '.main-content.PermissionsViewer-18b2fsv {display:flex;flex:1;flex-direction:column;overflow:hidden;}.content-search.PermissionsViewer-18b2fsv {display:flex;justify-content:center;align-items:center;padding:12px 20px;background:var(--pv-bg-panel);border-bottom:1px solid var(--pv-border);}.toggle-neutral.PermissionsViewer-18b2fsv {display:inline-flex;align-items:center;justify-content:center;margin-left:8px;border:none;border-radius:4px;background:transparent;color:var(--pv-text-muted);cursor:pointer;}.main-body.PermissionsViewer-18b2fsv {flex:1;overflow-y:auto;padding:20px;scrollbar-width:thin;scrollbar-color:var(--ui-border, #1e1f22) transparent;}.permission-category.PermissionsViewer-18b2fsv {margin-bottom:24px;}.permission-category.PermissionsViewer-18b2fsv:last-child {margin-bottom:0;}.category-header.PermissionsViewer-18b2fsv {display:flex;align-items:center;gap:8px;margin-bottom:12px;font-size:12px;font-weight:700;text-transform:uppercase;letter-spacing:0.5px;color:var(--pv-text-muted);}.category-header.PermissionsViewer-18b2fsv::after {content:"";flex:1;height:1px;background:linear-gradient(to right, #3f4147, transparent);}.permission-list.PermissionsViewer-18b2fsv {display:flex;flex-direction:column;gap:2px;}.permission-item.PermissionsViewer-18b2fsv {display:flex;align-items:center;justify-content:space-between;gap:16px;padding:12px 14px;border-radius:4px;background:var(--pv-bg-panel);}.permission-item.PermissionsViewer-18b2fsv:hover {background:var(--pv-bg-hover);}.permission-info.PermissionsViewer-18b2fsv {display:flex;align-items:flex-start;gap:12px;flex:1;}.permission-icon.PermissionsViewer-18b2fsv {display:flex;align-items:center;justify-content:center;width:20px;height:20px;margin-top:2px;}.permission-details.PermissionsViewer-18b2fsv {min-width:0;}.permission-name.PermissionsViewer-18b2fsv {font-size:14px;font-weight:500;color:var(--pv-text-primary);}.permission-description.PermissionsViewer-18b2fsv {font-size:12px;line-height:1.4;color:var(--pv-text-muted);}.permission-status.PermissionsViewer-18b2fsv {display:inline-flex;align-items:center;justify-content:space-between;gap:6px;padding:4px 10px;border-radius:3px;font-size:12px;font-weight:500;white-space:nowrap;}.permission-status.allowed.PermissionsViewer-18b2fsv {color:var(--pv-status-allowed);background:color-mix(in srgb, var(--pv-status-allowed) 12%, transparent);}.permission-status.denied.PermissionsViewer-18b2fsv {color:var(--pv-status-denied);background:color-mix(in srgb, var(--pv-status-denied) 12%, transparent);}.permission-status.neutral.PermissionsViewer-18b2fsv {color:var(--pv-status-neutral);background:color-mix(in srgb, var(--pv-status-neutral) 12%, transparent);}.permission-badge.PermissionsViewer-18b2fsv {width:82px;}.empty-state.PermissionsViewer-18b2fsv {padding:12px;font-size:13px;color:var(--pv-text-muted);}\n\n @media (max-width: 768px) {.permission-item.PermissionsViewer-18b2fsv {flex-direction:column;align-items:flex-start;}.permission-item.PermissionsViewer-18b2fsv .permission-status:where(.PermissionsViewer-18b2fsv) {width:100%;justify-content:center;}\n }'
|
|
};
|
|
function PermissionViewerPermissions($$anchor, $$props) {
|
|
push($$props, true);
|
|
append_styles($$anchor, $$css5);
|
|
const showNeutral = prop($$props, "showNeutral", 3, true);
|
|
let shouldShowNeutral = user_derived(showNeutral);
|
|
const visibleCategories = user_derived(() => {
|
|
const search = $$props.permissionSearch.trim().toLowerCase();
|
|
const permissions = $$props.activeEntity?.permissions ?? {};
|
|
return $$props.categories.map((category) => {
|
|
const categoryPermissions = category.permissions.filter((permission) => {
|
|
const status = permissions[permission.id] ?? "neutral";
|
|
if (!get(shouldShowNeutral) && status === "neutral") {
|
|
return false;
|
|
}
|
|
if (!search) {
|
|
return true;
|
|
}
|
|
const permissionName = permission.name.toLowerCase();
|
|
const permissionDescription = permission.description.toLowerCase();
|
|
return permissionName.includes(search) || permissionDescription.includes(search);
|
|
}).map((permission) => ({
|
|
...permission,
|
|
status: permissions[permission.id] ?? "neutral"
|
|
}));
|
|
return { name: category.name, permissions: categoryPermissions };
|
|
}).filter((category) => category.permissions.length > 0);
|
|
});
|
|
function getStatusLabel(status) {
|
|
if (status === "allowed") {
|
|
return "Allowed";
|
|
}
|
|
if (status === "denied") {
|
|
return "Denied";
|
|
}
|
|
return "Neutral";
|
|
}
|
|
function toggleShowNeutral() {
|
|
set(shouldShowNeutral, !get(shouldShowNeutral));
|
|
$$props.onToggleShowNeutral?.(get(shouldShowNeutral));
|
|
}
|
|
var div = root4();
|
|
var div_1 = child(div);
|
|
var node = child(div_1);
|
|
SearchField(node, {
|
|
get value() {
|
|
return $$props.permissionSearch;
|
|
},
|
|
placeholder: "Search permissions...",
|
|
ariaLabel: "Search permissions",
|
|
withSearchIcon: true,
|
|
get onInput() {
|
|
return $$props.onPermissionSearch;
|
|
}
|
|
});
|
|
var button = sibling(node, 2);
|
|
var node_1 = child(button);
|
|
{
|
|
var consequent = ($$anchor2) => {
|
|
var svg = root_14();
|
|
append($$anchor2, svg);
|
|
};
|
|
var alternate = ($$anchor2) => {
|
|
var svg_1 = root_23();
|
|
append($$anchor2, svg_1);
|
|
};
|
|
if_block(node_1, ($$render) => {
|
|
if (get(shouldShowNeutral)) $$render(consequent);
|
|
else $$render(alternate, false);
|
|
});
|
|
}
|
|
reset(button);
|
|
reset(div_1);
|
|
var div_2 = sibling(div_1, 2);
|
|
var node_2 = child(div_2);
|
|
{
|
|
var consequent_1 = ($$anchor2) => {
|
|
var div_3 = root_33();
|
|
append($$anchor2, div_3);
|
|
};
|
|
var consequent_2 = ($$anchor2) => {
|
|
var div_4 = root_4();
|
|
append($$anchor2, div_4);
|
|
};
|
|
var alternate_1 = ($$anchor2) => {
|
|
var fragment = comment();
|
|
var node_3 = first_child(fragment);
|
|
each(node_3, 17, () => get(visibleCategories), (category) => category.name, ($$anchor3, category) => {
|
|
var section = root_6();
|
|
var h3 = child(section);
|
|
var text2 = child(h3, true);
|
|
reset(h3);
|
|
var div_5 = sibling(h3, 2);
|
|
each(div_5, 21, () => get(category).permissions, (permission) => permission.id, ($$anchor4, permission) => {
|
|
var div_6 = root_7();
|
|
var div_7 = child(div_6);
|
|
var div_8 = child(div_7);
|
|
var node_4 = child(div_8);
|
|
PermissionStatusIcon(node_4, {
|
|
get status() {
|
|
return get(permission).status;
|
|
}
|
|
});
|
|
reset(div_8);
|
|
var div_9 = sibling(div_8, 2);
|
|
var div_10 = child(div_9);
|
|
var text_1 = child(div_10, true);
|
|
reset(div_10);
|
|
var div_11 = sibling(div_10, 2);
|
|
var text_2 = child(div_11, true);
|
|
reset(div_11);
|
|
reset(div_9);
|
|
reset(div_7);
|
|
var div_12 = sibling(div_7, 2);
|
|
var node_5 = child(div_12);
|
|
PermissionStatusIcon(node_5, {
|
|
get status() {
|
|
return get(permission).status;
|
|
}
|
|
});
|
|
var text_3 = sibling(node_5);
|
|
reset(div_12);
|
|
reset(div_6);
|
|
template_effect(
|
|
($0) => {
|
|
set_class(div_8, 1, `permission-icon permission-status ${get(permission).status ?? ""}`, "PermissionsViewer-18b2fsv");
|
|
set_text(text_1, get(permission).name);
|
|
set_text(text_2, get(permission).description);
|
|
set_class(div_12, 1, `permission-badge permission-status ${get(permission).status ?? ""}`, "PermissionsViewer-18b2fsv");
|
|
set_text(text_3, ` ${$0 ?? ""}`);
|
|
},
|
|
[() => getStatusLabel(get(permission).status)]
|
|
);
|
|
append($$anchor4, div_6);
|
|
});
|
|
reset(div_5);
|
|
reset(section);
|
|
template_effect(() => set_text(text2, get(category).name));
|
|
append($$anchor3, section);
|
|
});
|
|
append($$anchor2, fragment);
|
|
};
|
|
if_block(node_2, ($$render) => {
|
|
if (!$$props.activeEntity) $$render(consequent_1);
|
|
else if (get(visibleCategories).length === 0) $$render(consequent_2, 1);
|
|
else $$render(alternate_1, false);
|
|
});
|
|
}
|
|
reset(div_2);
|
|
reset(div);
|
|
template_effect(() => set_attribute2(button, "title", get(shouldShowNeutral) ? "Hide neutral permissions" : "Show neutral permissions"));
|
|
delegated("click", button, toggleShowNeutral);
|
|
append($$anchor, div);
|
|
pop();
|
|
}
|
|
delegate(["click"]);
|
|
|
|
// src/plugins/PermissionsViewer/components/ui/SidebarPanel.svelte
|
|
var root5 = from_html(`<aside class="ui-sidebar PermissionsViewer-15abvfz"><div class="ui-sidebar-search PermissionsViewer-15abvfz"><!></div> <div class="ui-sidebar-body PermissionsViewer-15abvfz"><!></div></aside>`);
|
|
var $$css6 = {
|
|
hash: "PermissionsViewer-15abvfz",
|
|
code: ".ui-sidebar.PermissionsViewer-15abvfz {display:flex;flex-direction:column;width:var(--ui-sidebar-width);background:var(--ui-panel-surface, #2b2d31);border-right:1px solid var(--ui-border, #1e1f22);}.ui-sidebar-search.PermissionsViewer-15abvfz {padding:12px;border-bottom:1px solid var(--ui-border, #1e1f22);}.ui-sidebar-body.PermissionsViewer-15abvfz {flex:1;overflow-y:auto;padding:8px;scrollbar-width:thin;scrollbar-color:var(--ui-border, #1e1f22) transparent;}\n\n @media (max-width: 768px) {.ui-sidebar.PermissionsViewer-15abvfz {width:100%;max-height:200px;border-right:none;border-bottom:1px solid var(--ui-border, #1e1f22);}.ui-sidebar-body.PermissionsViewer-15abvfz {display:flex;gap:4px;overflow-x:auto;overflow-y:hidden;}\n }"
|
|
};
|
|
function SidebarPanel($$anchor, $$props) {
|
|
append_styles($$anchor, $$css6);
|
|
const width = prop($$props, "width", 3, "240px"), ariaLabel = prop($$props, "ariaLabel", 3, "Sidebar");
|
|
var aside = root5();
|
|
let styles;
|
|
var div = child(aside);
|
|
var node = child(div);
|
|
snippet(node, () => $$props.search ?? noop);
|
|
reset(div);
|
|
var div_1 = sibling(div, 2);
|
|
var node_1 = child(div_1);
|
|
snippet(node_1, () => $$props.children);
|
|
reset(div_1);
|
|
reset(aside);
|
|
template_effect(() => {
|
|
set_attribute2(aside, "aria-label", ariaLabel());
|
|
styles = set_style(aside, "", styles, { "--ui-sidebar-width": width() });
|
|
});
|
|
append($$anchor, aside);
|
|
}
|
|
|
|
// src/plugins/PermissionsViewer/components/PermissionViewerSidebar.svelte
|
|
var root_34 = from_html(`<div class="empty-state PermissionsViewer-otwe8i">No roles found</div>`);
|
|
var root_72 = from_html(`<img class="role-avatar PermissionsViewer-otwe8i" alt=""/>`);
|
|
var root_8 = from_html(`<span class="role-indicator PermissionsViewer-otwe8i"></span>`);
|
|
var root_9 = from_html(`<img class="role-trailing-icon PermissionsViewer-otwe8i" alt=""/>`);
|
|
var root_62 = from_html(`<button type="button" role="tab"><!> <span class="role-name PermissionsViewer-otwe8i"> </span> <!></button>`);
|
|
var root_5 = from_html(`<div class="sidebar-section PermissionsViewer-otwe8i"><div class="sidebar-section-label PermissionsViewer-otwe8i"> </div> <!></div>`);
|
|
var root_24 = from_html(`<div class="sidebar-roles PermissionsViewer-otwe8i" role="tablist" aria-label="Roles and users"><!></div>`);
|
|
var $$css7 = {
|
|
hash: "PermissionsViewer-otwe8i",
|
|
code: ".sidebar-roles.PermissionsViewer-otwe8i {width:100%;}.sidebar-section.PermissionsViewer-otwe8i {margin-bottom:16px;}.sidebar-section.PermissionsViewer-otwe8i:last-child {margin-bottom:8px;}.sidebar-section-label.PermissionsViewer-otwe8i {color:var(--pv-text-muted);font-size:11px;font-weight:700;text-transform:uppercase;letter-spacing:0.5px;padding:8px 8px 4px;}.sidebar-role.PermissionsViewer-otwe8i {display:flex;align-items:center;gap:10px;width:100%;margin-bottom:2px;padding:8px 10px;border:none;border-radius:4px;text-align:left;cursor:pointer;color:var(--pv-text-body);background:transparent;}.sidebar-role.PermissionsViewer-otwe8i:hover {color:var(--pv-text-primary);background:var(--pv-bg-hover);}.sidebar-role.active.PermissionsViewer-otwe8i {color:var(--pv-text-primary);background:var(--pv-bg-active);}.role-indicator.PermissionsViewer-otwe8i,\n .role-avatar.PermissionsViewer-otwe8i,\n .role-trailing-icon.PermissionsViewer-otwe8i {display:inline-flex;align-items:center;justify-content:center;flex-shrink:0;width:14px;height:14px;border-radius:50%;}.role-avatar.PermissionsViewer-otwe8i {width:18px;height:18px;object-fit:cover;}.role-trailing-icon.PermissionsViewer-otwe8i {width:18px;height:18px;border-radius:4px;object-fit:cover;margin-left:auto;}.role-name.PermissionsViewer-otwe8i {overflow:hidden;white-space:nowrap;text-overflow:ellipsis;}.empty-state.PermissionsViewer-otwe8i {padding:12px;font-size:13px;color:var(--pv-text-muted);}\n\n @media (max-width: 768px) {.sidebar-section.PermissionsViewer-otwe8i {display:flex;gap:4px;margin-bottom:0;}.sidebar-section-label.PermissionsViewer-otwe8i {display:none;}.sidebar-role.PermissionsViewer-otwe8i {flex-shrink:0;width:auto;}\n }"
|
|
};
|
|
function PermissionViewerSidebar($$anchor, $$props) {
|
|
push($$props, true);
|
|
append_styles($$anchor, $$css7);
|
|
{
|
|
const search = ($$anchor2) => {
|
|
SearchField($$anchor2, {
|
|
get value() {
|
|
return $$props.roleSearch;
|
|
},
|
|
placeholder: "Search roles...",
|
|
ariaLabel: "Search roles and users",
|
|
get onInput() {
|
|
return $$props.onRoleSearch;
|
|
}
|
|
});
|
|
};
|
|
SidebarPanel($$anchor, {
|
|
width: "240px",
|
|
ariaLabel: "Roles and users",
|
|
search,
|
|
children: ($$anchor2, $$slotProps) => {
|
|
var div = root_24();
|
|
var node = child(div);
|
|
{
|
|
var consequent = ($$anchor3) => {
|
|
var div_1 = root_34();
|
|
append($$anchor3, div_1);
|
|
};
|
|
var alternate_1 = ($$anchor3) => {
|
|
var fragment_2 = comment();
|
|
var node_1 = first_child(fragment_2);
|
|
each(node_1, 17, () => $$props.sections, (section) => section.id, ($$anchor4, section) => {
|
|
var div_2 = root_5();
|
|
var div_3 = child(div_2);
|
|
var text2 = child(div_3, true);
|
|
reset(div_3);
|
|
var node_2 = sibling(div_3, 2);
|
|
each(node_2, 17, () => get(section).entities, (entity) => entity.id, ($$anchor5, entity) => {
|
|
var button = root_62();
|
|
let classes;
|
|
var node_3 = child(button);
|
|
{
|
|
var consequent_1 = ($$anchor6) => {
|
|
var img = root_72();
|
|
template_effect(() => set_attribute2(img, "src", get(entity).avatarUrl));
|
|
append($$anchor6, img);
|
|
};
|
|
var alternate = ($$anchor6) => {
|
|
var span = root_8();
|
|
let styles;
|
|
template_effect(() => styles = set_style(span, "", styles, {
|
|
"background-color": get(entity).color ?? "var(--pv-role-indicator-default)"
|
|
}));
|
|
append($$anchor6, span);
|
|
};
|
|
if_block(node_3, ($$render) => {
|
|
if (get(entity).avatarUrl) $$render(consequent_1);
|
|
else $$render(alternate, false);
|
|
});
|
|
}
|
|
var span_1 = sibling(node_3, 2);
|
|
var text_1 = child(span_1, true);
|
|
reset(span_1);
|
|
var node_4 = sibling(span_1, 2);
|
|
{
|
|
var consequent_2 = ($$anchor6) => {
|
|
var img_1 = root_9();
|
|
template_effect(() => set_attribute2(img_1, "src", get(entity).iconUrl));
|
|
append($$anchor6, img_1);
|
|
};
|
|
if_block(node_4, ($$render) => {
|
|
if (!get(entity).avatarUrl && get(entity).iconUrl) $$render(consequent_2);
|
|
});
|
|
}
|
|
reset(button);
|
|
template_effect(() => {
|
|
classes = set_class(button, 1, "sidebar-role PermissionsViewer-otwe8i", null, classes, { active: get(entity).id === $$props.activeTabId });
|
|
set_attribute2(button, "aria-selected", get(entity).id === $$props.activeTabId);
|
|
set_text(text_1, get(entity).name);
|
|
});
|
|
delegated("click", button, () => $$props.onSelectTab(get(entity).id));
|
|
append($$anchor5, button);
|
|
});
|
|
reset(div_2);
|
|
template_effect(() => set_text(text2, get(section).label));
|
|
append($$anchor4, div_2);
|
|
});
|
|
append($$anchor3, fragment_2);
|
|
};
|
|
if_block(node, ($$render) => {
|
|
if ($$props.sections.length === 0) $$render(consequent);
|
|
else $$render(alternate_1, false);
|
|
});
|
|
}
|
|
reset(div);
|
|
append($$anchor2, div);
|
|
},
|
|
$$slots: { search: true, default: true }
|
|
});
|
|
}
|
|
pop();
|
|
}
|
|
delegate(["click"]);
|
|
|
|
// src/plugins/PermissionsViewer/components/PermissionViewerModal.svelte
|
|
var root_25 = from_html(`<!> <!>`, 1);
|
|
var root6 = from_html(`<div class="permission-viewer PermissionsViewer-48gin"><!></div>`);
|
|
var $$css8 = {
|
|
hash: "PermissionsViewer-48gin",
|
|
code: ".permission-viewer.PermissionsViewer-48gin {--pv-bg-backdrop: rgba(0, 0, 0, 0.85);--pv-bg-modal: #313338;--pv-bg-panel: #2b2d31;--pv-bg-input: #1e1f22;--pv-bg-input-focus: #1a1b1e;--pv-bg-hover: #35373c;--pv-bg-active: #404249;--pv-border: #1e1f22;--pv-text-primary: #f2f3f5;--pv-text-body: #dbdee1;--pv-text-muted: #949ba4;--pv-status-allowed: #23a55a;--pv-status-denied: #f23f43;--pv-status-neutral: #949ba4;--pv-role-indicator-default: #949ba4;z-index:1000;}.permission-viewer.PermissionsViewer-48gin {--ui-modal-backdrop: var(--pv-bg-backdrop);--ui-modal-surface: var(--pv-bg-modal);--ui-panel-surface: var(--pv-bg-panel);--ui-border: var(--pv-border);--ui-text-primary: var(--pv-text-primary);--ui-text-secondary: #b5bac1;--ui-text-body: var(--pv-text-body);--ui-text-muted: var(--pv-text-muted);--ui-input-bg: var(--pv-bg-input);--ui-input-bg-focus: var(--pv-bg-input-focus);--ui-hover-soft: #3f4147;--ui-header-fallback-bg: linear-gradient(135deg, #5865f2, #7289da);}.permission-viewer * {box-sizing:border-box;}"
|
|
};
|
|
function PermissionViewerModal($$anchor, $$props) {
|
|
push($$props, true);
|
|
append_styles($$anchor, $$css8);
|
|
const subtitle = prop($$props, "subtitle", 3, ""), showNeutral = prop($$props, "showNeutral", 3, true);
|
|
let roleSearch = state("");
|
|
let permissionSearch = state("");
|
|
let activeTabId = state("");
|
|
const groupedSections = user_derived(() => {
|
|
const specialViews = $$props.tabs.filter((entity) => !entity.avatarUrl && entity.position == null);
|
|
const serverRoles = $$props.tabs.filter((entity) => !entity.avatarUrl && entity.position != null).slice().sort((a, b) => (b.position ?? -1) - (a.position ?? -1));
|
|
const users = $$props.tabs.filter((entity) => Boolean(entity.avatarUrl));
|
|
const sections = [];
|
|
if (specialViews.length > 0) {
|
|
sections.push({
|
|
id: "special",
|
|
label: "Special Views",
|
|
entities: specialViews
|
|
});
|
|
}
|
|
if (serverRoles.length > 0) {
|
|
sections.push({ id: "roles", label: "Server Roles", entities: serverRoles });
|
|
}
|
|
if (users.length > 0) {
|
|
sections.push({ id: "users", label: "Users", entities: users });
|
|
}
|
|
return sections;
|
|
});
|
|
const filteredSections = user_derived(() => {
|
|
const query = get(roleSearch).trim().toLowerCase();
|
|
if (!query) {
|
|
return get(groupedSections);
|
|
}
|
|
return get(groupedSections).map((section) => ({
|
|
...section,
|
|
entities: section.entities.filter((entity) => entity.name.toLowerCase().includes(query))
|
|
})).filter((section) => section.entities.length > 0);
|
|
});
|
|
const flatEntities = user_derived(() => get(groupedSections).flatMap((section) => section.entities));
|
|
const activeEntity = user_derived(() => get(flatEntities).find((entity) => entity.id === get(activeTabId)) ?? get(flatEntities)[0]);
|
|
user_effect(() => {
|
|
if (!get(activeTabId) && get(flatEntities).length > 0) {
|
|
set(activeTabId, get(flatEntities)[0].id, true);
|
|
return;
|
|
}
|
|
if (get(activeTabId) && !get(flatEntities).some((entity) => entity.id === get(activeTabId))) {
|
|
set(activeTabId, get(flatEntities)[0]?.id ?? "", true);
|
|
}
|
|
});
|
|
function selectTab(tabId) {
|
|
set(activeTabId, tabId, true);
|
|
}
|
|
var div = root6();
|
|
var node = child(div);
|
|
{
|
|
const header = ($$anchor2) => {
|
|
PermissionViewerHeader($$anchor2, {
|
|
get title() {
|
|
return $$props.title;
|
|
},
|
|
get subtitle() {
|
|
return subtitle();
|
|
},
|
|
get avatarUrl() {
|
|
return $$props.avatarUrl;
|
|
},
|
|
get onClose() {
|
|
return $$props.onClose;
|
|
}
|
|
});
|
|
};
|
|
ModalFrame(node, {
|
|
get ariaLabel() {
|
|
return $$props.title;
|
|
},
|
|
maxWidth: "900px",
|
|
height: "60vh",
|
|
get onBackdropClick() {
|
|
return $$props.onClose;
|
|
},
|
|
header,
|
|
children: ($$anchor2, $$slotProps) => {
|
|
var fragment_1 = root_25();
|
|
var node_1 = first_child(fragment_1);
|
|
PermissionViewerSidebar(node_1, {
|
|
get sections() {
|
|
return get(filteredSections);
|
|
},
|
|
get roleSearch() {
|
|
return get(roleSearch);
|
|
},
|
|
get activeTabId() {
|
|
return get(activeTabId);
|
|
},
|
|
onRoleSearch: (value) => {
|
|
set(roleSearch, value, true);
|
|
},
|
|
onSelectTab: selectTab
|
|
});
|
|
var node_2 = sibling(node_1, 2);
|
|
PermissionViewerPermissions(node_2, {
|
|
get categories() {
|
|
return $$props.categories;
|
|
},
|
|
get activeEntity() {
|
|
return get(activeEntity);
|
|
},
|
|
get permissionSearch() {
|
|
return get(permissionSearch);
|
|
},
|
|
get showNeutral() {
|
|
return showNeutral();
|
|
},
|
|
get onToggleShowNeutral() {
|
|
return $$props.onToggleShowNeutral;
|
|
},
|
|
onPermissionSearch: (value) => {
|
|
set(permissionSearch, value, true);
|
|
}
|
|
});
|
|
append($$anchor2, fragment_1);
|
|
},
|
|
$$slots: { header: true, default: true }
|
|
});
|
|
}
|
|
reset(div);
|
|
append($$anchor, div);
|
|
pop();
|
|
}
|
|
|
|
// src/plugins/PermissionsViewer/perms.ts
|
|
var GuildStore = BdApi.Webpack.Stores.GuildStore;
|
|
var UserStore = BdApi.Webpack.Stores.UserStore;
|
|
var DiscordPermissions = BdApi.Webpack.getModule((m) => m.ADD_REACTIONS, { searchExports: true });
|
|
var specManager = BdApi.Webpack.getByKeys("generateGuildPermissionSpec");
|
|
function getDefinitions(guildIdOrGuild) {
|
|
if (!specManager) throw new Error("Permission spec manager not found");
|
|
if (!guildIdOrGuild) guildIdOrGuild = BdApi.Webpack.Stores.SortedGuildStore.getFlattenedGuildIds()[0];
|
|
const guild = typeof guildIdOrGuild === "string" ? BdApi.Webpack.Stores.GuildStore.getGuild(guildIdOrGuild) : guildIdOrGuild;
|
|
if (!guild) throw new Error("Guild not found");
|
|
const guildSpecs = specManager.generateGuildPermissionSpec(guild);
|
|
return guildSpecs.map((category) => ({
|
|
name: category.title,
|
|
permissions: category.permissions.map((perm) => ({
|
|
id: Object.keys(DiscordPermissions).find((key2) => DiscordPermissions[key2] === perm.flag) ?? "",
|
|
name: perm.title,
|
|
description: typeof perm.description === "function" ? perm.description(BdApi.Webpack.Stores.LocaleStore.locale).ast[0] : perm.description[0]
|
|
}))
|
|
}));
|
|
}
|
|
function getAllowedDenied(roleOrOverwrite) {
|
|
const allowed = getAllowedPermissions(roleOrOverwrite);
|
|
const denied = getDeniedPermissions(roleOrOverwrite);
|
|
const result = {};
|
|
for (const perm in DiscordPermissions) {
|
|
const isAllowed = (allowed & DiscordPermissions[perm]) === DiscordPermissions[perm];
|
|
const isDenied = (denied & DiscordPermissions[perm]) === DiscordPermissions[perm];
|
|
result[perm] = isAllowed ? "allowed" : isDenied ? "denied" : "neutral";
|
|
}
|
|
return result;
|
|
}
|
|
function getRoles(guild) {
|
|
const roleStore = BdApi.Webpack.Stores.GuildRoleStore;
|
|
const roles = roleStore.getRolesSnapshot(guild.id);
|
|
return roles;
|
|
}
|
|
function getAllowedPermissions(roleOrOverwrite) {
|
|
if (typeof roleOrOverwrite === "object" && "allow" in roleOrOverwrite) {
|
|
return roleOrOverwrite.allow;
|
|
}
|
|
if (typeof roleOrOverwrite === "object" && "hoist" in roleOrOverwrite) {
|
|
return roleOrOverwrite.permissions;
|
|
}
|
|
if (typeof roleOrOverwrite === "object" && "permissions" in roleOrOverwrite && !("guildId" in roleOrOverwrite)) {
|
|
if (typeof roleOrOverwrite.permissions === "bigint") {
|
|
return roleOrOverwrite.permissions;
|
|
}
|
|
return roleOrOverwrite.permissions.allow;
|
|
}
|
|
return 0n;
|
|
}
|
|
function getDeniedPermissions(roleOrOverwrite) {
|
|
if (typeof roleOrOverwrite === "object" && "deny" in roleOrOverwrite) {
|
|
return roleOrOverwrite.deny;
|
|
}
|
|
if (typeof roleOrOverwrite === "object" && "permissions" in roleOrOverwrite && !("guildId" in roleOrOverwrite)) {
|
|
if (typeof roleOrOverwrite.permissions === "bigint") {
|
|
return 0n;
|
|
}
|
|
return roleOrOverwrite.permissions.deny;
|
|
}
|
|
return 0n;
|
|
}
|
|
function getEntityTargets(permTarget) {
|
|
if ("guild_id" in permTarget && permTarget.guild_id) {
|
|
return permTarget.permissionOverwrites;
|
|
}
|
|
if ("maxMembers" in permTarget) {
|
|
const roles = getRoles(permTarget);
|
|
return roles;
|
|
}
|
|
if ("userId" in permTarget) {
|
|
const guild = GuildStore.getGuild(permTarget.guildId);
|
|
if (!guild) return {};
|
|
const roles = getRoles(guild);
|
|
const memberRoleList = [...permTarget.roles];
|
|
const memberTargetMap = {};
|
|
for (const roleId of memberRoleList) {
|
|
if (roles[roleId]) memberTargetMap[roleId] = roles[roleId];
|
|
}
|
|
memberRoleList.push(guild.id);
|
|
const isOwner = permTarget.userId === guild.ownerId;
|
|
const ALL_PERMISSIONS = Object.values(DiscordPermissions).reduce((all, p) => all | p);
|
|
let userPerms = 0n;
|
|
for (const roleId of memberRoleList) {
|
|
const role = roles[roleId];
|
|
if (role) userPerms |= role.permissions;
|
|
}
|
|
memberTargetMap["@effective"] = {
|
|
id: "@effective",
|
|
name: "Effective Permissions",
|
|
permissions: {
|
|
allow: isOwner ? ALL_PERMISSIONS : userPerms,
|
|
deny: isOwner ? 0n : ~userPerms
|
|
}
|
|
};
|
|
if (isOwner) {
|
|
memberTargetMap["@owner"] = {
|
|
id: "@owner",
|
|
name: "Server Owner",
|
|
permissions: ALL_PERMISSIONS,
|
|
iconUrl: "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIyNCIgaGVpZ2h0PSIyNCIgZmlsbD0ibm9uZSIgdmlld0JveD0iMCAwIDI0IDI0Ij48cGF0aCBmaWxsPSJjb2xvci1taXgoaW4gb2tsYWIsIGhzbCgzOC40NTUgY2FsYygxKjEwMCUpIDQzLjEzNyUgLzEpIDEwMCUsICMwMDAgMCUpIiBkPSJNNSAxOGExIDEgMCAwIDAtMSAxIDMgMyAwIDAgMCAzIDNoMTBhMyAzIDAgMCAwIDMtMyAxIDEgMCAwIDAtMS0xSDVaTTMuMDQgNy43NmExIDEgMCAwIDAtMS41MiAxLjE1bDIuMjUgNi40MmExIDEgMCAwIDAgLjk0LjY3aDE0LjU1YTEgMSAwIDAgMCAuOTUtLjcxbDEuOTQtNi40NWExIDEgMCAwIDAtMS41NS0xLjFsLTQuMTEgMy0zLjU1LTUuMzMuODItLjgyYS44My44MyAwIDAgMCAwLTEuMThsLTEuMTctMS4xN2EuODMuODMgMCAwIDAtMS4xOCAwbC0xLjE3IDEuMTdhLjgzLjgzIDAgMCAwIDAgMS4xOGwuODIuODItMy42MSA1LjQyLTQuNDEtMy4wN1oiPjwvcGF0aD48L3N2Zz4=",
|
|
position: void 0
|
|
};
|
|
}
|
|
memberTargetMap[guild.id] = roles[guild.id];
|
|
return memberTargetMap;
|
|
}
|
|
return {};
|
|
}
|
|
function getPermissionableEntities(guildContext, permTarget) {
|
|
const roles = getRoles(guildContext);
|
|
const permEntries = [];
|
|
const permTargets = getEntityTargets(permTarget);
|
|
for (const key2 in permTargets) {
|
|
const entityPermissions = permTargets[key2];
|
|
const perms = getAllowedDenied(entityPermissions);
|
|
const role = roles?.[key2];
|
|
if (role) {
|
|
permEntries.push({
|
|
id: key2,
|
|
name: role.name,
|
|
permissions: perms,
|
|
color: role.colorStrings?.primaryColor,
|
|
iconUrl: role.icon ? `https://cdn.discordapp.com/role-icons/${role.id}/${role.icon}.webp` : void 0,
|
|
position: role.position || void 0
|
|
});
|
|
continue;
|
|
}
|
|
const user = UserStore.getUser(key2);
|
|
if (user) {
|
|
permEntries.push({
|
|
id: key2,
|
|
name: user.username,
|
|
permissions: perms,
|
|
avatarUrl: `https://cdn.discordapp.com/avatars/${user.id}/${user.avatar}.webp`
|
|
});
|
|
}
|
|
if ("permissions" in entityPermissions && !("guildId" in entityPermissions)) {
|
|
permEntries.push({
|
|
id: key2,
|
|
name: entityPermissions.name,
|
|
permissions: perms,
|
|
color: entityPermissions.color,
|
|
iconUrl: entityPermissions.iconUrl,
|
|
position: entityPermissions.position || void 0
|
|
});
|
|
}
|
|
}
|
|
return permEntries;
|
|
}
|
|
|
|
// src/plugins/PermissionsViewer/index.ts
|
|
var { ContextMenu, DOM, Utils, Webpack, UI, ReactUtils } = BdApi;
|
|
var GuildStore2 = Webpack.getStore("GuildStore");
|
|
var SelectedGuildStore = Webpack.getStore("SelectedGuildStore");
|
|
var GuildRoleStore = Webpack.getStore("GuildRoleStore");
|
|
var MemberStore = Webpack.getStore("GuildMemberStore");
|
|
var UserStore2 = Webpack.getStore("UserStore");
|
|
var DiscordPermissions2 = Webpack.getModule((m) => m.ADD_REACTIONS, { searchExports: true });
|
|
var intlModule = BdApi.Webpack.getByKeys("intl");
|
|
var getRoles2 = (guild) => guild?.roles ?? GuildRoleStore?.getRolesSnapshot(guild?.id);
|
|
var getPermString = (perm) => intlModule?.intl.string(intlModule.t[PermissionStringMap[perm]]) ?? perm.toString();
|
|
var PermissionStringMap = {
|
|
ADD_REACTIONS: "yEoJAr",
|
|
ADMINISTRATOR: "PGvZqX",
|
|
ATTACH_FILES: "3AS4UM",
|
|
BAN_MEMBERS: "oTBA7N",
|
|
BYPASS_SLOWMODE: "kqcjeV",
|
|
CHANGE_NICKNAME: "dilOF6",
|
|
CONNECT: "S0W8Z5",
|
|
CREATE_EVENTS: "qyjZua",
|
|
CREATE_GUILD_EXPRESSIONS: "HarVuP",
|
|
CREATE_INSTANT_INVITE: "zJrgTG",
|
|
CREATE_PRIVATE_THREADS: "QwbTSa",
|
|
CREATE_PUBLIC_THREADS: "25rKnX",
|
|
DEAFEN_MEMBERS: "9L47Fr",
|
|
EMBED_LINKS: "969dEL",
|
|
KICK_MEMBERS: "pBNv6i",
|
|
MANAGE_CHANNELS: "9qLtWs",
|
|
MANAGE_EVENTS: "HIgA5a",
|
|
MANAGE_GUILD_EXPRESSIONS: "bbuXIn",
|
|
MANAGE_MESSAGES: "6lU9xM",
|
|
MANAGE_NICKNAMES: "t+Ct5x",
|
|
MANAGE_ROLES: "C8d+oG",
|
|
MANAGE_GUILD: "QZRcfO",
|
|
MANAGE_THREADS: "kEqgr7",
|
|
MANAGE_WEBHOOKS: "/ADKmM",
|
|
MENTION_EVERYONE: "Y78KGC",
|
|
MODERATE_MEMBERS: "+RL6pz",
|
|
MOVE_MEMBERS: "YtjJPQ",
|
|
MUTE_MEMBERS: "8EI30/",
|
|
PIN_MESSAGES: "Y5BI39",
|
|
PRIORITY_SPEAKER: "BVK71i",
|
|
READ_MESSAGE_HISTORY: "l9ufaR",
|
|
REQUEST_TO_SPEAK: "5kicT2",
|
|
SEND_MESSAGES: "T32rkC",
|
|
SEND_MESSAGES_IN_THREADS: "fTE74g",
|
|
SEND_POLLS: "UMQ7Ww",
|
|
SEND_TTS_MESSAGES: "Mg7bku",
|
|
SEND_VOICE_MESSAGES: "WlWSBT",
|
|
SET_VOICE_CHANNEL_STATUS: "VBwkUf",
|
|
SPEAK: "8w1tIR",
|
|
STREAM: "FlNoSV",
|
|
USE_APPLICATION_COMMANDS: "shbR1a",
|
|
USE_EMBEDDED_ACTIVITIES: "rLSGeh",
|
|
USE_EXTERNAL_APPS: "3TzAk0",
|
|
USE_EXTERNAL_EMOJIS: "BpBGZU",
|
|
USE_EXTERNAL_SOUNDS: "pwaVJ6",
|
|
USE_EXTERNAL_STICKERS: "UeRs+b",
|
|
USE_SOUNDBOARD: "Bco7NG",
|
|
USE_VAD: "08zAV7",
|
|
VIEW_AUDIT_LOG: "fZgLpA",
|
|
VIEW_CHANNEL: "W/A4Qp",
|
|
VIEW_CREATOR_MONETIZATION_ANALYTICS: "0lTLTv",
|
|
VIEW_GUILD_ANALYTICS: "rQJBE/"
|
|
};
|
|
function isOverwriteEmpty(overwrite) {
|
|
return !overwrite.allow && !overwrite.deny && overwrite.type == 0;
|
|
}
|
|
function hasOverwrites(channel) {
|
|
const roleIds = Object.keys(channel.permissionOverwrites);
|
|
if (roleIds.length === 0) return false;
|
|
if (roleIds.length === 1 && isOverwriteEmpty(channel.permissionOverwrites[roleIds[0]])) return false;
|
|
return true;
|
|
}
|
|
function classModuleToMap(module2) {
|
|
if (!module2) return {};
|
|
const descriptors = Object.getOwnPropertyDescriptors(module2);
|
|
const classMap = {};
|
|
for (const key2 in descriptors) {
|
|
classMap[key2] = descriptors[key2].value;
|
|
}
|
|
return classMap;
|
|
}
|
|
var PermissionsViewer = class extends Plugin {
|
|
constructor(meta) {
|
|
super(meta, config_default);
|
|
}
|
|
sectionHTML;
|
|
itemHTML;
|
|
contextMenuPatches = [];
|
|
onStart() {
|
|
DOM.addStyle(this.meta.name, styles_default);
|
|
const PopoutRoleClasses = classModuleToMap(Webpack.getByKeys("roleCircle"));
|
|
const PopoutRoleClasses2 = classModuleToMap(Webpack.getByKeys("role", "roleTag"));
|
|
const EyebrowClasses = classModuleToMap(Webpack.getByKeys("defaultColor", "eyebrow"));
|
|
this.sectionHTML = formatString(list_default, PopoutRoleClasses, PopoutRoleClasses2, EyebrowClasses);
|
|
this.itemHTML = formatString(item_default, PopoutRoleClasses, PopoutRoleClasses2, EyebrowClasses);
|
|
if (this.settings.popouts) this.bindPopouts();
|
|
if (this.settings.contextMenus) this.bindContextMenus();
|
|
}
|
|
onStop() {
|
|
DOM.removeStyle(this.meta.name);
|
|
this.unbindPopouts();
|
|
this.unbindContextMenus();
|
|
}
|
|
patchPopouts(e) {
|
|
const popoutMount = (props2) => {
|
|
if (!props2 || !props2.displayProfile || !props2.user) return;
|
|
const popout2 = document.querySelector(`[class*="userPopout_"], [class*="outer_"]`);
|
|
if (!popout2 || popout2.querySelector("#permissions-popout")) return;
|
|
const user = MemberStore?.getMember(props2.displayProfile.guildId, props2.user.id);
|
|
const guild = GuildStore2?.getGuild(props2.displayProfile.guildId);
|
|
const name = MemberStore?.getNick(props2.displayProfile.guildId, props2.user.id) ?? props2.user.username;
|
|
if (!user || !guild || !name) return;
|
|
const userRoles = user.roles.slice(0);
|
|
userRoles.push(guild.id);
|
|
userRoles.reverse();
|
|
let perms = 0n;
|
|
const permBlock = DOM.parseHTML(formatString(this.sectionHTML, { sectionTitle: this.strings.popoutLabel }));
|
|
const memberPerms = permBlock.querySelector(".member-perms");
|
|
const referenceRoles = getRoles2(guild);
|
|
if (!referenceRoles) return;
|
|
for (let r = 0; r < userRoles.length; r++) {
|
|
const role = userRoles[r];
|
|
if (!referenceRoles[role]) continue;
|
|
perms = perms | referenceRoles[role].permissions;
|
|
for (const perm in DiscordPermissions2) {
|
|
const permName = getPermString(perm) || perm.split("_").map((n) => n[0].toUpperCase() + n.slice(1).toLowerCase()).join(" ");
|
|
const hasPerm = (perms & DiscordPermissions2[perm]) == DiscordPermissions2[perm];
|
|
if (hasPerm && !memberPerms.querySelector(`[data-name="${permName}"]`)) {
|
|
const element3 = DOM.parseHTML(this.itemHTML);
|
|
let roleColor = referenceRoles[role].colorStrings?.primaryColor;
|
|
element3.querySelector(".name").textContent = permName;
|
|
element3.setAttribute("data-name", permName);
|
|
if (!roleColor) roleColor = "#B9BBBE";
|
|
element3.querySelector(".perm-circle").style.backgroundColor = rgbToAlpha(roleColor, 1);
|
|
memberPerms.prepend(element3);
|
|
}
|
|
}
|
|
}
|
|
permBlock.querySelector(".perm-details")?.addEventListener("click", () => {
|
|
popoutInstance?.props?.targetRef?.current?.click();
|
|
document.querySelector(`[class*="backdrop__"]`)?.click();
|
|
this.createModalUser(name, user, guild);
|
|
});
|
|
let roleList = popout2.querySelector(`[class*="roleList"]`);
|
|
if (roleList?.parentElement?.className.includes("section")) roleList = roleList.parentElement;
|
|
roleList?.after(permBlock);
|
|
const popoutInstance = Utils.findInTree(
|
|
ReactUtils.getInternalInstance(popout2),
|
|
(m) => m && m.updatePosition,
|
|
{ walkable: ["stateNode", "return"] }
|
|
);
|
|
if (!popoutInstance || !popoutInstance.updatePosition) return;
|
|
popoutInstance.updatePosition();
|
|
};
|
|
if (!e.addedNodes.length || !(e.addedNodes[0] instanceof Element)) return;
|
|
const element2 = e.addedNodes[0];
|
|
const popout = element2.querySelector(`[class*="userPopout_"], [class*="outer_"]`) ?? element2;
|
|
if (!popout || !popout.matches(`[class*="userPopout_"], [class*="outer_"]`)) return;
|
|
const props = Utils.findInTree(ReactUtils.getInternalInstance(popout), (m) => m && m.user, { walkable: ["memoizedProps", "return"] });
|
|
popoutMount(props);
|
|
}
|
|
bindPopouts() {
|
|
this.observer = this.patchPopouts.bind(this);
|
|
}
|
|
unbindPopouts() {
|
|
this.observer = void 0;
|
|
}
|
|
async bindContextMenus() {
|
|
this.patchChannelContextMenu();
|
|
this.patchGuildContextMenu();
|
|
this.patchUserContextMenu();
|
|
}
|
|
unbindContextMenus() {
|
|
for (const cancel of this.contextMenuPatches) cancel();
|
|
}
|
|
patchGuildContextMenu() {
|
|
this.contextMenuPatches.push(ContextMenu.patch("guild-context", (retVal, props) => {
|
|
if (!props?.guild) return retVal;
|
|
const newItem = ContextMenu.buildItem({
|
|
label: this.strings.contextMenuLabel,
|
|
action: () => {
|
|
this.createModalGuild(props.guild.name, props.guild);
|
|
}
|
|
});
|
|
retVal.props.children?.splice(1, 0, newItem);
|
|
}));
|
|
}
|
|
patchChannelContextMenu() {
|
|
this.contextMenuPatches.push(ContextMenu.patch("channel-context", (retVal, props) => {
|
|
const newItem = ContextMenu.buildItem({
|
|
label: this.strings.contextMenuLabel,
|
|
action: () => {
|
|
if (!hasOverwrites(props.channel)) return UI.showToast(`#${props.channel.name} has no permission overrides`, { type: "info" });
|
|
this.createModalChannel(props.channel.name, props.channel, props.guild);
|
|
}
|
|
});
|
|
retVal.props.children?.splice(1, 0, newItem);
|
|
}));
|
|
}
|
|
patchUserContextMenu() {
|
|
this.contextMenuPatches.push(ContextMenu.patch("user-context", (retVal, props) => {
|
|
const guild = GuildStore2?.getGuild(props.guildId);
|
|
if (!guild) return;
|
|
const newItem = ContextMenu.buildItem({
|
|
label: this.strings.contextMenuLabel,
|
|
action: () => {
|
|
const user = MemberStore?.getMember(props.guildId, props.user.id);
|
|
if (!user) return;
|
|
const name = user.nick ? user.nick : props.user.globalName ?? props.user.username;
|
|
this.createModalUser(name, user, guild);
|
|
}
|
|
});
|
|
retVal?.props?.children?.[0]?.props?.children?.splice(2, 0, newItem);
|
|
}));
|
|
}
|
|
createModalChannel(name, channel, guild) {
|
|
return this.showModal({ title: `#${name}` }, getPermissionableEntities(guild, channel));
|
|
}
|
|
createModalUser(name, user, guild) {
|
|
const userInstance = UserStore2?.getUser(user.userId);
|
|
return this.showModal({
|
|
title: name,
|
|
avatarUrl: userInstance?.getAvatarURL(null, 128, true)
|
|
}, getPermissionableEntities(guild, user));
|
|
}
|
|
createModalGuild(name, guild) {
|
|
return this.showModal(
|
|
{
|
|
title: name,
|
|
avatarUrl: guild.icon ? `https://cdn.discordapp.com/icons/${guild.id}/${guild.icon}.webp?size=128&quality=lossless` : void 0
|
|
},
|
|
getPermissionableEntities(guild, guild)
|
|
);
|
|
}
|
|
showModal(title, entries) {
|
|
const svelteMountContainer = document.createElement("div");
|
|
svelteMountContainer.style.display = "contents";
|
|
const temp = mount(PermissionViewerModal, {
|
|
target: svelteMountContainer,
|
|
props: {
|
|
title: title.title,
|
|
avatarUrl: title.avatarUrl,
|
|
subtitle: title.subtitle ?? "View effective permissions and role breakdowns",
|
|
tabs: entries,
|
|
onClose: () => {
|
|
svelteMountContainer.remove();
|
|
},
|
|
categories: getDefinitions(SelectedGuildStore?.getGuildId() ?? ""),
|
|
showNeutral: this.settings.showNeutral,
|
|
onToggleShowNeutral: (value) => {
|
|
this.settings.showNeutral = value;
|
|
this.saveSettings();
|
|
}
|
|
}
|
|
});
|
|
document.querySelector("#app-mount")?.append(svelteMountContainer);
|
|
DOM.onRemoved(svelteMountContainer, () => unmount(temp));
|
|
}
|
|
getSettingsPanel() {
|
|
return this.buildSettingsPanel((_, id, checked) => {
|
|
if (id == "popouts") {
|
|
if (checked) this.bindPopouts();
|
|
else this.unbindPopouts();
|
|
}
|
|
if (id == "contextMenus") {
|
|
if (checked) this.bindContextMenus();
|
|
else this.unbindContextMenus();
|
|
}
|
|
});
|
|
}
|
|
};
|
|
|
|
/*@end@*/ |