/** * List block tracker for UUID-aware list editing and serialization. * * Dependencies: wp.blocks, SFE.ElementPrep * Exposes: SFE.ListBlockTracker */ (function() { 'use strict'; window.MWP = window.MWP || {}; window.MWP.SFE = window.MWP.SFE || {}; const SFE = window.MWP.SFE; SFE.ManagerData = SFE.ManagerData || {}; const { createBlock, serialize: serializeBlocks } = window.wp?.blocks || {}; const UUID_ATTR_KEYS = ['mwpSfeUuid', 'mwpSfeUuidShadow']; const LIST_ITEM_TEXT_ATTR = 'data-mwp-sfe-list-item-text'; const LIST_ITEM_TEXT_CLASS = 'mwp-sfe-list-item-text'; const PLACEHOLDER_ATTR = 'data-rich-text-placeholder'; const LIST_ID_ATTR = 'data-list-id'; const LIST_ITEM_ID_ATTR = 'data-item-id'; const LIST_RUNTIME_UUID_ATTR = 'data-mwp-sfe-list-runtime-uuid'; const LIST_ITEM_RUNTIME_UUID_ATTR = 'data-mwp-sfe-list-item-runtime-uuid'; /** * Return whether one node is a nested list element. * * @param {Node|null} node Candidate DOM node. * @returns {boolean} True when the node is a nested list. */ function isNestedListNode(node) { return !!( node && node.nodeType === Node.ELEMENT_NODE && (node.tagName === 'UL' || node.tagName === 'OL') ); } /** * Return whether one node is ignorable formatting whitespace between list * structures. * * Pretty-printed block markup often leaves direct `\n` text nodes between a * list item's own text and its nested child list. Those nodes should not be * moved into the direct text surface because they become visible editing * artifacts once wrapped. * * @param {Node|null} node Candidate DOM node. * @returns {boolean} True when the node is ignorable whitespace. */ function isIgnorableListWhitespaceNode(node) { return !!( node && node.nodeType === Node.TEXT_NODE && String(node.textContent || '') .replace(/\uFEFF/g, '') .replace(/\u00A0/g, ' ') .trim() .length === 0 ); } /** * Return the direct inline text surface for one list item. * * @param {HTMLLIElement|null} liElement Candidate list item. * @returns {HTMLElement|null} Existing direct text surface, if any. */ function getDirectItemTextSurface(liElement) { if (!liElement || liElement.nodeType !== Node.ELEMENT_NODE || liElement.tagName !== 'LI') { return null; } return Array.from(liElement.children || []).find(child => ( child && child.nodeType === Node.ELEMENT_NODE && child.getAttribute(LIST_ITEM_TEXT_ATTR) === '1' )) || null; } /** * Return the DOM attribute name that stores one session-scoped runtime UUID. * * Runtime UUIDs are distinct from the existing serialization/attr UUIDs. They * exist only while the editor session is open so external callers can point at * the current live list cursor/target without having to manage shifting paths. * * @param {string} type Supported runtime identity type. * @returns {string} Attribute name, or an empty string for invalid types. */ function getRuntimeUuidAttributeName(type) { if (type === 'list') { return LIST_RUNTIME_UUID_ATTR; } if (type === 'item') { return LIST_ITEM_RUNTIME_UUID_ATTR; } return ''; } /** * Normalize one runtime UUID candidate. * * @param {*} value Candidate runtime UUID. * @returns {string} Trimmed runtime UUID, or an empty string. */ function normalizeRuntimeUuid(value) { return String(value || '').trim(); } /** * Return whether one element matches the requested runtime-identity type. * * @param {Element|null} element Candidate DOM element. * @param {string} type Supported runtime identity type. * @returns {boolean} True when the element matches the type. */ function isRuntimeIdentityElement(element, type) { if (!element || element.nodeType !== Node.ELEMENT_NODE) { return false; } if (type === 'list') { return element.tagName === 'UL' || element.tagName === 'OL'; } if (type === 'item') { return element.tagName === 'LI'; } return false; } /** * Return one tracked element by runtime UUID from the live DOM. * * This intentionally queries the current DOM first instead of trusting only a * cached map so history restores and other structural replacements can keep * runtime UUID resolution stable as long as the attributes remain present. * * @param {Object|null} tracker Active list tracker. * @param {string} runtimeUuid Session-scoped runtime UUID. * @param {string} type Supported runtime identity type. * @returns {Element|null} Matching live DOM element. */ function findElementByRuntimeUuid(tracker, runtimeUuid, type) { const normalizedRuntimeUuid = normalizeRuntimeUuid(runtimeUuid); const attrName = getRuntimeUuidAttributeName(type); if ( !tracker?.listElement || !normalizedRuntimeUuid || !attrName || !isRuntimeIdentityElement(tracker.listElement, 'list') ) { return null; } if ( type === 'list' && tracker.listElement.getAttribute(attrName) === normalizedRuntimeUuid ) { return tracker.listElement; } try { const selector = `[${attrName}="${CSS.escape(normalizedRuntimeUuid)}"]`; return tracker.listElement.querySelector(selector); } catch (error) { const escapedUuid = normalizedRuntimeUuid.replace(/"/g, '\\"'); return tracker.listElement.querySelector(`[${attrName}="${escapedUuid}"]`); } } /** * Return every direct text surface currently attached to one list item. * * Merge/delete flows can temporarily move multiple direct text surfaces into * the same list item. The shared list normalizer must collapse them back to * one canonical surface before placeholder syncing or serialization. * * @param {HTMLLIElement|null} liElement Candidate list item. * @returns {HTMLElement[]} Direct text surfaces in DOM order. */ function getAllDirectItemTextSurfaces(liElement) { if (!liElement || liElement.nodeType !== Node.ELEMENT_NODE || liElement.tagName !== 'LI') { return []; } return Array.from(liElement.children || []).filter(child => ( child && child.nodeType === Node.ELEMENT_NODE && child.getAttribute(LIST_ITEM_TEXT_ATTR) === '1' )); } /** * Return whether one node is only placeholder/caret scaffolding. * * Duplicate direct text surfaces may carry empty placeholder anchors or * caret `
` nodes. Those artifacts should be dropped when collapsing * duplicate surfaces instead of being concatenated into visible stacks. * * @param {Node|null} node Candidate DOM node. * @returns {boolean} True when the node is redundant placeholder UI. */ function isRedundantSurfaceArtifact(node) { if (!node) { return true; } if (isIgnorableListWhitespaceNode(node)) { return true; } if (node.nodeType === Node.TEXT_NODE) { return String(node.textContent || '') .replace(/\uFEFF/g, '') .replace(/\u00A0/g, ' ') .trim() .length === 0; } if (node.nodeType !== Node.ELEMENT_NODE) { return false; } if (node.tagName === 'BR') { return true; } return !!node.hasAttribute?.(PLACEHOLDER_ATTR); } /** * Ensure one list item owns one direct inline text surface. * * The root list remains the single live editor host, but this wrapper gives * schema/ABE flows one stable DOM surface per list item's own text content. * * @param {HTMLLIElement|null} liElement Candidate list item. * @returns {HTMLElement|null} Ensured direct text surface. */ function ensureDirectItemTextSurface(liElement) { if (!liElement || liElement.nodeType !== Node.ELEMENT_NODE || liElement.tagName !== 'LI') { return null; } let surface = getDirectItemTextSurface(liElement); if (!surface) { surface = document.createElement('span'); surface.setAttribute(LIST_ITEM_TEXT_ATTR, '1'); surface.classList.add(LIST_ITEM_TEXT_CLASS); liElement.insertBefore( surface, Array.from(liElement.childNodes || []).find(isNestedListNode) || null ); } getAllDirectItemTextSurfaces(liElement) .filter(candidate => candidate && candidate !== surface) .forEach(duplicateSurface => { Array.from(duplicateSurface.childNodes || []).forEach(node => { if (isRedundantSurfaceArtifact(node)) { node.remove(); return; } surface.appendChild(node); }); duplicateSurface.remove(); }); const childNodes = Array.from(liElement.childNodes || []); childNodes.forEach(node => { if ( node && node !== surface && !isNestedListNode(node) && isIgnorableListWhitespaceNode(node) ) { node.remove(); } }); const movableNodes = childNodes.filter(node => { if (!node || node === surface || isNestedListNode(node)) { return false; } if (isIgnorableListWhitespaceNode(node)) { return false; } return !( node.nodeType === Node.ELEMENT_NODE && node.getAttribute?.(LIST_ITEM_TEXT_ATTR) === '1' ); }); movableNodes.forEach(node => surface.appendChild(node)); return surface; } /** * Clone list attrs while optionally stripping plugin UUID ownership. * * The outermost core/list is the only persisted UUID owner for an entire * list tree. Nested core/list blocks are structural children of that root. * If we preserve a nested list UUID here, one accidental assignment can be * re-serialized forever and split a single logical list into multiple * history/edit targets. Keep this guard unless the ownership model changes * everywhere else in PHP and JS at the same time. * * @param {Object} attrs Parsed Gutenberg attrs. * @param {boolean} allowUuidOwnership True for the root list only. * @returns {Object} Safe cloned attrs. */ function cloneListAttrs(attrs, allowUuidOwnership = true) { const clonedAttrs = JSON.parse(JSON.stringify(attrs || {})); if (allowUuidOwnership) { return clonedAttrs; } UUID_ATTR_KEYS.forEach(key => delete clonedAttrs[key]); return clonedAttrs; } /** * Return the direct list-item children for one list element. * * @param {HTMLElement|null} listElement Candidate list element. * @returns {HTMLLIElement[]} Direct child list items. */ function getDirectListItems(listElement) { if (!listElement || listElement.nodeType !== Node.ELEMENT_NODE) { return []; } return Array.from(listElement.children || []).filter(child => child.tagName === 'LI'); } /** * Normalize one path-like value into zero-based list indexes. * * Supported inputs: * - `0_1_2` * - `1.2.3` * - arrays of integers * * @param {string|Array|null} pathValue Candidate path value. * @returns {number[]|null} Parsed zero-based indexes. */ function normalizePathIndexes(pathValue) { if (Array.isArray(pathValue)) { const indexes = pathValue.map(value => Number.parseInt(value, 10)); return indexes.every(Number.isInteger) && indexes.every(index => index >= 0) ? indexes : null; } const raw = typeof pathValue === 'string' ? pathValue.trim() : ''; if (!raw) { return []; } const separator = raw.includes('.') ? '.' : '_'; const parts = raw.split(separator).filter(Boolean); if (!parts.length) { return []; } const indexes = parts.map(part => Number.parseInt(part, 10)); if (!indexes.every(Number.isInteger)) { return null; } if (separator === '.') { return indexes.every(index => index > 0) ? indexes.map(index => index - 1) : null; } return indexes.every(index => index >= 0) ? indexes : null; } /** * Convert one zero-based path index list into public path metadata. * * @param {number[]} indexes Zero-based indexes. * @returns {{path: string, pathLabel: string, depth: number}} Path metadata. */ function buildPathMeta(indexes) { const safeIndexes = Array.isArray(indexes) ? indexes.filter(Number.isInteger) : []; return { path: safeIndexes.join('_'), pathLabel: safeIndexes.map(index => index + 1).join('.'), depth: Math.max(0, safeIndexes.length - 1), }; } /** * Return the direct child list element for one list item. * * @param {HTMLLIElement|null} listItem Candidate list item. * @returns {HTMLElement|null} Direct nested list, if present. */ function getDirectChildList(listItem) { if (!listItem || listItem.nodeType !== Node.ELEMENT_NODE || listItem.tagName !== 'LI') { return null; } return Array.from(listItem.children || []).find(child => ( child.tagName === 'UL' || child.tagName === 'OL' )) || null; } /** * Return the preferred nested list tag for one list item. * * @param {Object|null} tracker Active list tracker. * @param {HTMLLIElement} listItem Parent list item. * @returns {string} `UL` or `OL`. */ function getPreferredChildListTagName(tracker, listItem) { const directChildList = getDirectChildList(listItem); if (directChildList) { return directChildList.tagName; } const parentList = listItem?.parentElement; if (parentList && (parentList.tagName === 'UL' || parentList.tagName === 'OL')) { return parentList.tagName; } return tracker?.listElement?.tagName === 'OL' ? 'OL' : 'UL'; } /** * Return one direct child list for a list item, creating it only when needed. * * Outdent can promote one item and then re-home its trailing siblings beneath * that promoted item. When the promoted item already owns a child list, those * siblings must be appended into the existing list so the DOM mirrors native * editor behavior instead of creating duplicate sibling list wrappers. * * @param {Object|null} tracker Active list tracker. * @param {HTMLLIElement} listItem Parent list item. * @param {string} preferredTagName Fallback list tag name. * @returns {HTMLElement|null} Direct child list element. */ function ensureDirectChildList(tracker, listItem, preferredTagName = '') { if (!listItem || listItem.nodeType !== Node.ELEMENT_NODE || listItem.tagName !== 'LI') { return null; } let childList = getDirectChildList(listItem); if (childList) { return childList; } childList = document.createElement( preferredTagName || getPreferredChildListTagName(tracker, listItem) ); childList.classList.add('wp-block-list'); listItem.appendChild(childList); return childList; } /** * Remove empty nested list wrappers up the ancestry chain. * * The root list element is never removed, even when it becomes empty. * * @param {Object|null} tracker Active list tracker. * @param {HTMLElement|null} startList First candidate nested list. * @returns {void} */ function cleanupEmptyAncestorLists(tracker, startList) { let currentList = startList; while ( currentList && currentList !== tracker?.listElement && currentList.nodeType === Node.ELEMENT_NODE && (currentList.tagName === 'UL' || currentList.tagName === 'OL') && !getDirectListItems(currentList).length ) { const parentItem = currentList.parentElement?.tagName === 'LI' ? currentList.parentElement : null; currentList.remove(); currentList = parentItem ? parentItem.parentElement : null; } } /** * Build one new list item element from a structural operation payload. * * @param {Object|null} operation Candidate operation payload. * @returns {HTMLLIElement} New list item element. */ function buildListItemFromOperation(operation) { const li = document.createElement('li'); const directSurface = ensureDirectItemTextSurface(li); const runtimeUuid = normalizeRuntimeUuid( operation?.itemUuid ?? operation?.newItemUuid ); const html = typeof operation?.contentHtml === 'string' ? operation.contentHtml : (typeof operation?.html === 'string' ? operation.html : ''); const text = typeof operation?.contentText === 'string' ? operation.contentText : (typeof operation?.text === 'string' ? operation.text : ''); if (html) { directSurface.innerHTML = html; } else if (text) { directSurface.textContent = text; } if (runtimeUuid) { li.setAttribute(LIST_ITEM_RUNTIME_UUID_ATTR, runtimeUuid); } return li; } /** * Copy one donor item's structural/style attributes onto the destination list * item while preserving the destination runtime UUID. * * Native Enter list splitting happens inside the browser's contenteditable * engine, so the new sibling inherits the source `li` element's attributes * such as class and style automatically. API-driven insert/move operations * should mirror that behavior by cloning the donor item's `li` attributes, * except for the session-scoped runtime UUID which must stay unique. * * @param {HTMLLIElement|null} listItem Destination list item. * @param {HTMLLIElement|null} donorItem Style/structure donor item. * @returns {void} */ function copyDonorItemAttributes(listItem, donorItem) { if ( !listItem || listItem.nodeType !== Node.ELEMENT_NODE || listItem.tagName !== 'LI' || !donorItem || donorItem.nodeType !== Node.ELEMENT_NODE || donorItem.tagName !== 'LI' ) { return; } const destinationRuntimeUuid = normalizeRuntimeUuid( listItem.getAttribute(LIST_ITEM_RUNTIME_UUID_ATTR) ); Array.from(listItem.attributes || []).forEach(attr => { if (attr?.name === LIST_ITEM_RUNTIME_UUID_ATTR) { return; } listItem.removeAttribute(attr.name); }); Array.from(donorItem.attributes || []).forEach(attr => { if (attr?.name === LIST_ITEM_RUNTIME_UUID_ATTR) { return; } listItem.setAttribute(attr.name, attr.value); }); if (destinationRuntimeUuid) { listItem.setAttribute(LIST_ITEM_RUNTIME_UUID_ATTR, destinationRuntimeUuid); } } /** * Reassign one list item's structural ID from its destination styling * context. * * When an explicit target item is known, its structural `data-item-id` * becomes the style donor for insert-before, insert-after, move-before, and * move-after commands. This keeps the inheritance rule simple and matches the * public API's explicit `targetItemUuid` model. * * For internal list-path insert/move cases that do not resolve through one * target item, fall back to the local destination neighbors. If there is no * neighboring item at all, clear the structural ID so the next tracker rebuild * seeds a fresh item identity instead of accidentally preserving source attrs. * * @param {HTMLLIElement|null} listItem Destination list item. * @param {HTMLLIElement|null} targetItem Explicit style donor item. * @returns {string} Applied structural ID or an empty string. */ function inheritDestinationItemId(listItem, targetItem = null) { if (!listItem || listItem.nodeType !== Node.ELEMENT_NODE || listItem.tagName !== 'LI') { return ''; } const explicitTargetItem = targetItem && targetItem.nodeType === Node.ELEMENT_NODE && targetItem.tagName === 'LI' ? targetItem : null; const previousItem = listItem.previousElementSibling?.tagName === 'LI' ? listItem.previousElementSibling : null; const nextItem = listItem.nextElementSibling?.tagName === 'LI' ? listItem.nextElementSibling : null; const inheritedId = normalizeRuntimeUuid( explicitTargetItem?.getAttribute(LIST_ITEM_ID_ATTR) || previousItem?.getAttribute(LIST_ITEM_ID_ATTR) || nextItem?.getAttribute(LIST_ITEM_ID_ATTR) ); if (inheritedId) { listItem.setAttribute(LIST_ITEM_ID_ATTR, inheritedId); return inheritedId; } listItem.removeAttribute(LIST_ITEM_ID_ATTR); return ''; } /** * Apply one remove-list-item operation. * * @param {Object|null} tracker Active list tracker. * @param {HTMLLIElement} listItem Target list item. * @returns {boolean} True when the mutation applied. */ function applyRemoveListItemOperation(tracker, listItem) { if (!tracker?.listElement || !listItem) { return false; } const oldParentList = listItem.parentElement; listItem.remove(); cleanupEmptyAncestorLists(tracker, oldParentList); return true; } /** * Apply one indent-list-item operation. * * @param {Object|null} tracker Active list tracker. * @param {HTMLLIElement} listItem Target list item. * @returns {boolean} True when the mutation applied. */ function applyIndentListItemOperation(tracker, listItem) { if (!tracker?.listElement || !listItem) { return false; } const previousItem = listItem.previousElementSibling?.tagName === 'LI' ? listItem.previousElementSibling : null; if (!previousItem) { return false; } const nestedList = ensureDirectChildList(tracker, previousItem); nestedList.appendChild(listItem); return true; } /** * Apply one outdent-list-item operation. * * @param {Object|null} tracker Active list tracker. * @param {HTMLLIElement} listItem Target list item. * @returns {boolean} True when the mutation applied. */ function applyOutdentListItemOperation(tracker, listItem) { if (!tracker?.listElement || !listItem) { return false; } const parentList = listItem.parentElement; const parentItem = parentList?.parentElement?.tagName === 'LI' ? parentList.parentElement : null; if (!parentList || !parentItem) { return false; } const ancestorList = parentItem.parentElement; const followingSiblings = []; let next = listItem.nextElementSibling; while (next) { followingSiblings.push(next); next = next.nextElementSibling; } ancestorList.insertBefore(listItem, parentItem.nextElementSibling); if (followingSiblings.length) { const nestedList = ensureDirectChildList(tracker, listItem, parentList.tagName); followingSiblings.forEach(sibling => nestedList.appendChild(sibling)); } cleanupEmptyAncestorLists(tracker, parentList); return true; } /** * Apply one toggle-list-type operation. * * @param {Object|null} tracker Active list tracker. * @param {Object} rawOperation Structural operation payload. * @param {Object} options Apply-operation options. * @returns {boolean} True when the mutation applied. */ function applyToggleListTypeOperation(tracker, rawOperation, options = {}) { if (!tracker?.listElement) { return false; } const listPath = rawOperation.listPath ?? rawOperation.list_path ?? ''; const targetList = getListByPath(tracker, listPath); const editorHost = options?.editorHost && typeof options.editorHost.changeListType === 'function' ? options.editorHost : null; const requestedType = targetList ? ( normalizeListTypeTagName( rawOperation.value ?? rawOperation.listType ?? rawOperation.list_type ?? rawOperation.ordered ) || (targetList.tagName === 'OL' ? 'UL' : 'OL') ) : ''; if ( !targetList || !requestedType || targetList.tagName === requestedType || !editorHost ) { return false; } const nextList = editorHost.changeListType(targetList, requestedType.toLowerCase(), { saveHistory: options.saveHistory !== false, restoreCursor: options.restoreCursor !== false, }); return !!nextList; } /** * Apply one update-list-item-text operation. * * @param {HTMLLIElement} listItem Target list item. * @param {Object} rawOperation Structural operation payload. * @returns {boolean} True when the mutation applied. */ function applyUpdateListItemTextOperation(listItem, rawOperation) { if (!listItem) { return false; } const directSurface = ensureDirectItemTextSurface(listItem); const html = typeof rawOperation?.contentHtml === 'string' ? rawOperation.contentHtml : (typeof rawOperation?.html === 'string' ? rawOperation.html : ''); const text = typeof rawOperation?.contentText === 'string' ? rawOperation.contentText : (typeof rawOperation?.text === 'string' ? rawOperation.text : ''); if (!directSurface) { return false; } directSurface.innerHTML = ''; if (html) { directSurface.innerHTML = html; } else if (text) { directSurface.textContent = text; } return true; } /** * Insert one new list item relative to explicit before/after/list anchors. * * @param {Object|null} tracker Active list tracker. * @param {Object} rawOperation Structural operation payload. * @param {Object} trackerApi List tracker API surface. * @returns {boolean} True when the mutation applied. */ function applyInsertListItemOperation(tracker, rawOperation, trackerApi) { if (!tracker?.listElement || !trackerApi) { return false; } const beforePath = rawOperation.beforePath ?? rawOperation.before_path ?? ''; const afterPath = rawOperation.afterPath ?? rawOperation.after_path ?? ''; const listPath = rawOperation.listPath ?? rawOperation.list_path ?? ''; const beforeItem = trackerApi.getItemByPath(tracker, beforePath); const afterItem = trackerApi.getItemByPath(tracker, afterPath); const newListItem = buildListItemFromOperation(rawOperation); if (beforeItem?.parentElement) { beforeItem.parentElement.insertBefore(newListItem, beforeItem); copyDonorItemAttributes(newListItem, beforeItem); inheritDestinationItemId(newListItem, beforeItem); return true; } if (afterItem?.parentElement) { afterItem.parentElement.insertBefore(newListItem, afterItem.nextElementSibling); copyDonorItemAttributes(newListItem, afterItem); inheritDestinationItemId(newListItem, afterItem); return true; } const targetList = getListByPath(tracker, listPath); if (!targetList) { return false; } const position = typeof rawOperation.position === 'string' ? rawOperation.position.trim().toLowerCase() : 'append'; if (position === 'prepend' && targetList.firstElementChild) { targetList.insertBefore(newListItem, targetList.firstElementChild); } else { targetList.appendChild(newListItem); } inheritDestinationItemId(newListItem); return true; } /** * Move one existing list item relative to explicit before/after/list anchors. * * @param {Object|null} tracker Active list tracker. * @param {HTMLLIElement} listItem Target list item. * @param {Object} rawOperation Structural operation payload. * @param {Object} trackerApi List tracker API surface. * @returns {boolean} True when the mutation applied. */ function applyMoveListItemOperation(tracker, listItem, rawOperation, trackerApi) { if (!tracker?.listElement || !listItem || !trackerApi) { return false; } const beforePath = rawOperation.beforePath ?? rawOperation.before_path ?? ''; const afterPath = rawOperation.afterPath ?? rawOperation.after_path ?? ''; const listPath = rawOperation.listPath ?? rawOperation.list_path ?? ''; const beforeItem = trackerApi.getItemByPath(tracker, beforePath); const afterItem = trackerApi.getItemByPath(tracker, afterPath); const oldParentList = listItem.parentElement; let didApply = false; if (beforeItem && beforeItem !== listItem && !listItem.contains(beforeItem)) { beforeItem.parentElement.insertBefore(listItem, beforeItem); copyDonorItemAttributes(listItem, beforeItem); inheritDestinationItemId(listItem, beforeItem); didApply = true; } else if (afterItem && afterItem !== listItem && !listItem.contains(afterItem)) { afterItem.parentElement.insertBefore(listItem, afterItem.nextElementSibling); copyDonorItemAttributes(listItem, afterItem); inheritDestinationItemId(listItem, afterItem); didApply = true; } else if (typeof listPath === 'string') { const targetList = getListByPath(tracker, listPath); const ownerItem = targetList?.parentElement?.tagName === 'LI' ? targetList.parentElement : null; if (targetList && ownerItem !== listItem && !listItem.contains(ownerItem || null)) { const position = typeof rawOperation.position === 'string' ? rawOperation.position.trim().toLowerCase() : 'append'; if (position === 'prepend' && targetList.firstElementChild) { targetList.insertBefore(listItem, targetList.firstElementChild); } else { targetList.appendChild(listItem); } inheritDestinationItemId(listItem); didApply = true; } } if (didApply) { cleanupEmptyAncestorLists(tracker, oldParentList); } return didApply; } /** * Resolve one tracked list element from a list-path payload. * * The root list lives at the empty path. Nested lists are addressed by the * tree path of the parent item that owns that child list. * * @param {Object|null} tracker Active list tracker. * @param {string|Array} pathValue Root-empty list path or parent-item path. * @returns {HTMLElement|null} Matching list element. */ function getListByPath(tracker, pathValue) { if (!tracker?.listElement) { return null; } if ( pathValue === '' || pathValue === null || typeof pathValue === 'undefined' || (Array.isArray(pathValue) && !pathValue.length) || (typeof pathValue === 'string' && !pathValue.trim()) ) { return tracker.listElement; } const parentItem = ListBlockTracker.getItemByPath(tracker, pathValue); return parentItem ? getDirectChildList(parentItem) : null; } /** * Normalize one requested list-type value to a DOM tag name. * * @param {*} value Candidate list-type value. * @returns {string} `OL`, `UL`, or an empty string. */ function normalizeListTypeTagName(value) { if (value === true) { return 'OL'; } if (value === false) { return 'UL'; } const normalized = String(value || '').trim().toLowerCase(); if (normalized === 'ordered' || normalized === 'ol' || normalized === 'true') { return 'OL'; } if (normalized === 'unordered' || normalized === 'ul' || normalized === 'false') { return 'UL'; } return ''; } const ListBlockTracker = { active: null, /** * Initialize tracker for a list element * @param {HTMLElement} listElement - The UL or OL element * @param {Object} originalBlock - The complete WordPress block structure */ init(listElement, originalBlock = {}) { if (!createBlock || !serializeBlocks) { console.error('wp.blocks not available'); } const tracker = { listElement, originalBlock: JSON.parse(JSON.stringify(originalBlock)), uuidMap: new Map(), // uuid -> {type, attrs, element} domMap: new WeakMap(), // element -> uuid runtimeUuidMap: new Map(), // runtimeUuid -> {type, element} runtimeDomMap: new WeakMap() // element -> runtimeUuid }; // Attach tracker to element to avoid singleton issues listElement._mwpListTracker = tracker; // Build UUID tracking from DOM and original block structure this.buildFromDOM(tracker, listElement, originalBlock); this.active = tracker; return tracker; }, /** * Build UUID mappings from DOM and original block structure * Assigns UUIDs to all lists and list items, mapping to their original attrs */ buildFromDOM(tracker, listElement, originalBlock) { const previousEntries = tracker.uuidMap instanceof Map ? new Map(tracker.uuidMap) : new Map(); const previousRuntimeEntries = tracker.runtimeUuidMap instanceof Map ? new Map(tracker.runtimeUuidMap) : new Map(); tracker.uuidMap.clear(); tracker.domMap = new WeakMap(); tracker.runtimeUuidMap.clear(); tracker.runtimeDomMap = new WeakMap(); tracker.listElement = listElement; this.syncEditableTextSurfaces(listElement); this.registerRuntimeIdentity( tracker, listElement, 'list', previousRuntimeEntries ); // Assign UUID to root list and map to original attrs const rootUuid = this.getOrCreateUuid(listElement, 'list'); const previousRootEntry = previousEntries.get(rootUuid); tracker.uuidMap.set(rootUuid, { type: 'list', attrs: previousRootEntry?.attrs ? cloneListAttrs(previousRootEntry.attrs, true) : cloneListAttrs(originalBlock.attrs || {}, true), element: listElement }); tracker.domMap.set(listElement, rootUuid); // Recursively process list structure this.processListRecursive( tracker, listElement, originalBlock.innerBlocks || [], previousEntries, previousRuntimeEntries ); }, /** * Recursively process list items and nested lists, assigning UUIDs */ processListRecursive( tracker, listElement, originalItems, previousEntries = new Map(), previousRuntimeEntries = new Map() ) { const items = getDirectListItems(listElement); items.forEach((li, index) => { this.syncEditableTextSurfaces(li); const originalItem = originalItems[index] || {}; this.registerRuntimeIdentity( tracker, li, 'item', previousRuntimeEntries ); const itemUuid = this.getOrCreateUuid(li, 'item'); const previousItemEntry = previousEntries.get(itemUuid); // Map UUID to original item attrs tracker.uuidMap.set(itemUuid, { type: 'item', attrs: previousItemEntry?.attrs ? JSON.parse(JSON.stringify(previousItemEntry.attrs || {})) : JSON.parse(JSON.stringify(originalItem.attrs || {})), element: li }); tracker.domMap.set(li, itemUuid); // Handle nested lists const nestedList = getDirectChildList(li); if (nestedList) { const originalNested = originalItem.innerBlocks?.[0] || {}; this.registerRuntimeIdentity( tracker, nestedList, 'list', previousRuntimeEntries ); const nestedUuid = this.getOrCreateUuid(nestedList, 'list'); const previousNestedEntry = previousEntries.get(nestedUuid); // Map nested list attrs without plugin UUID ownership. // The tracker still needs a temporary DOM identity for list // editing, but persisting mwpSfeUuid* on nested lists would // fracture one logical list into multiple save/history roots. tracker.uuidMap.set(nestedUuid, { type: 'list', attrs: previousNestedEntry?.attrs ? cloneListAttrs(previousNestedEntry.attrs, false) : cloneListAttrs(originalNested.attrs || {}, false), element: nestedList }); tracker.domMap.set(nestedList, nestedUuid); // Recurse into nested list this.processListRecursive( tracker, nestedList, originalNested.innerBlocks || [], previousEntries, previousRuntimeEntries ); } }); }, /** * Register one list or list-item runtime identity on the tracker. * * @param {Object} tracker Active list tracker. * @param {Element} element Live list or list-item element. * @param {string} type Supported runtime identity type. * @param {Map} previousRuntimeEntries Previous runtime entry map. * @returns {string} Resolved runtime UUID. */ registerRuntimeIdentity( tracker, element, type, previousRuntimeEntries = new Map() ) { const runtimeUuid = this.getOrCreateRuntimeUuid( tracker, element, type, previousRuntimeEntries ); if (!runtimeUuid) { return ''; } tracker.runtimeUuidMap.set(runtimeUuid, { type, element, }); tracker.runtimeDomMap.set(element, runtimeUuid); return runtimeUuid; }, /** * Return whether one runtime UUID is already owned by a different element. * * Native contenteditable list splitting can clone DOM attributes from the * source item into the newly created sibling. When that happens, the new * runtime UUID must be reseeded so each live cursor target stays unique. * * @param {Object} tracker Active list tracker. * @param {string} runtimeUuid Candidate runtime UUID. * @param {Element|null} element Element requesting that UUID. * @returns {boolean} True when the UUID belongs elsewhere. */ isRuntimeUuidClaimedByDifferentElement(tracker, runtimeUuid, element) { const normalizedRuntimeUuid = normalizeRuntimeUuid(runtimeUuid); if (!tracker?.runtimeUuidMap || !normalizedRuntimeUuid) { return false; } const existingEntry = tracker.runtimeUuidMap.get(normalizedRuntimeUuid); return !!(existingEntry?.element && existingEntry.element !== element); }, /** * Get the inherited structural ID for an element or seed it from the * runtime UUID when it does not exist yet. * * Structural IDs may be intentionally copied by native list splitting so * related items can retain style inheritance. They are not treated as * unique runtime cursor identifiers. */ getOrCreateUuid(element, type) { const attrName = type === 'list' ? LIST_ID_ATTR : LIST_ITEM_ID_ATTR; let uuid = element.getAttribute(attrName); if (!uuid) { uuid = normalizeRuntimeUuid( element.getAttribute( type === 'list' ? LIST_RUNTIME_UUID_ATTR : LIST_ITEM_RUNTIME_UUID_ATTR ) ) || this.generateTempUuid(); element.setAttribute(attrName, uuid); } return uuid; }, /** * Return the existing runtime UUID for one element or create one. * * Caller-supplied runtime UUIDs win for newly created items/lists. When an * element already belongs to the previous tracker build, its existing * runtime UUID is preserved so API references remain stable across rebuilds. * * @param {Object} tracker Active list tracker. * @param {Element} element Live list or list-item element. * @param {string} type Supported runtime identity type. * @param {Map} previousRuntimeEntries Previous runtime entry map. * @returns {string} Session-scoped runtime UUID. */ getOrCreateRuntimeUuid( tracker, element, type, previousRuntimeEntries = new Map() ) { const attrName = getRuntimeUuidAttributeName(type); if (!attrName || !isRuntimeIdentityElement(element, type)) { return ''; } let runtimeUuid = normalizeRuntimeUuid(element.getAttribute(attrName)); if (!runtimeUuid) { for (const [candidateUuid, entry] of previousRuntimeEntries.entries()) { if (entry?.element === element && entry.type === type) { runtimeUuid = normalizeRuntimeUuid(candidateUuid); break; } } } if (this.isRuntimeUuidClaimedByDifferentElement(tracker, runtimeUuid, element)) { runtimeUuid = ''; } if (!runtimeUuid) { runtimeUuid = this.generateTempUuid(); } element.setAttribute(attrName, runtimeUuid); return runtimeUuid; }, /** * Generate a RFC4122 version 4 UUID */ generateTempUuid() { return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) { const r = Math.random() * 16 | 0; const v = c === 'x' ? r : (r & 0x3 | 0x8); return v.toString(16); }); }, /** * Return the zero-based tree path for one list item inside the tracked list. * * @param {Object} tracker Active list tracker. * @param {HTMLLIElement} listItem Candidate list item. * @returns {number[]|null} Zero-based indexes, or null on failure. */ getPathIndexesForItem(tracker, listItem) { if ( !tracker?.listElement || !listItem || listItem.nodeType !== Node.ELEMENT_NODE || listItem.tagName !== 'LI' || !tracker.listElement.contains(listItem) ) { return null; } const indexes = []; let currentItem = listItem; while (currentItem && tracker.listElement.contains(currentItem)) { const parentList = currentItem.parentElement; if (!parentList || (parentList.tagName !== 'UL' && parentList.tagName !== 'OL')) { return null; } const siblingItems = getDirectListItems(parentList); const itemIndex = siblingItems.indexOf(currentItem); if (itemIndex < 0) { return null; } indexes.unshift(itemIndex); const nextItem = parentList.closest('li'); if (!nextItem || !tracker.listElement.contains(nextItem)) { break; } currentItem = nextItem; } return indexes.length ? indexes : null; }, /** * Return the direct list item currently living at one tree path. * * @param {Object} tracker Active list tracker. * @param {string|Array} pathValue Zero-based path value. * @returns {HTMLLIElement|null} Matching list item. */ getItemByPath(tracker, pathValue) { const indexes = normalizePathIndexes(pathValue); if (!tracker?.listElement || !Array.isArray(indexes) || !indexes.length) { return null; } let currentList = tracker.listElement; let currentItem = null; for (let index = 0; index < indexes.length; index++) { const itemIndex = indexes[index]; const siblingItems = getDirectListItems(currentList); currentItem = siblingItems[itemIndex] || null; if (!currentItem) { return null; } if (index === indexes.length - 1) { return currentItem; } currentList = getDirectChildList(currentItem); if (!currentList) { return null; } } return currentItem; }, /** * Resolve one list element back to its public list path. * * The root list is addressed as an empty string. Nested child lists are * addressed by the path of the parent list item that owns them. * * @param {Object|null} tracker Active list tracker. * @param {HTMLElement|null} listElement Candidate list element. * @returns {string} Root-relative list path. */ getPathForList(tracker, listElement) { if (!tracker) tracker = this.active; if (!tracker?.listElement || !listElement || listElement.nodeType !== Node.ELEMENT_NODE) { return ''; } if (listElement === tracker.listElement) { return ''; } const parentItem = ( listElement.parentElement && listElement.parentElement.tagName === 'LI' ) ? listElement.parentElement : null; if (!parentItem) { return ''; } const indexes = this.getPathIndexesForItem(tracker, parentItem); return Array.isArray(indexes) ? indexes.join('_') : ''; }, /** * Return one tracked list item by runtime UUID. * * @param {Object|null} tracker Active list tracker. * @param {string} runtimeUuid Session-scoped item UUID. * @returns {HTMLLIElement|null} Matching list item. */ getItemByRuntimeUuid(tracker, runtimeUuid) { if (!tracker) tracker = this.active; const element = findElementByRuntimeUuid(tracker, runtimeUuid, 'item'); return element && element.tagName === 'LI' ? element : null; }, /** * Return one tracked list by runtime UUID. * * @param {Object|null} tracker Active list tracker. * @param {string} runtimeUuid Session-scoped list UUID. * @returns {HTMLElement|null} Matching list element. */ getListByRuntimeUuid(tracker, runtimeUuid) { if (!tracker) tracker = this.active; const element = findElementByRuntimeUuid(tracker, runtimeUuid, 'list'); return isListElementForRuntimeLookup(element) ? element : null; }, /** * Return the runtime UUID for one tracked list item. * * @param {Object|null} tracker Active list tracker. * @param {HTMLLIElement} listItem Live list item. * @returns {string} Session-scoped item UUID. */ getRuntimeUuidForItem(tracker, listItem) { if (!tracker) tracker = this.active; if (!tracker?.listElement || !listItem || listItem.tagName !== 'LI') { return ''; } return normalizeRuntimeUuid( listItem.getAttribute(LIST_ITEM_RUNTIME_UUID_ATTR) || tracker.runtimeDomMap?.get(listItem) ); }, /** * Return the runtime UUID for one tracked list. * * @param {Object|null} tracker Active list tracker. * @param {HTMLElement} listElement Live list element. * @returns {string} Session-scoped list UUID. */ getRuntimeUuidForList(tracker, listElement) { if (!tracker) tracker = this.active; if (!tracker?.listElement || !isListElementForRuntimeLookup(listElement)) { return ''; } return normalizeRuntimeUuid( listElement.getAttribute(LIST_RUNTIME_UUID_ATTR) || tracker.runtimeDomMap?.get(listElement) ); }, /** * Parse current DOM list structure to WordPress block format * Uses UUID to preserve original attrs, updates only content and ordered * * @param {HTMLElement} listElement Live UL/OL element. * @param {Object} tracker Active list tracker. * @param {boolean} allowUuidOwnership True only for the outermost * core/list. Nested lists must * serialize without persisted * plugin UUID attrs. */ parseListToBlock(listElement, tracker, allowUuidOwnership = true) { const isOrdered = listElement.tagName === 'OL'; const uuid = listElement.getAttribute(LIST_ID_ATTR); let attrs = { ordered: isOrdered }; if (uuid && tracker && tracker.uuidMap.has(uuid)) { const original = tracker.uuidMap.get(uuid); const originalAttrs = (Array.isArray(original.attrs) || !original.attrs) ? {} : cloneListAttrs(original.attrs, allowUuidOwnership); attrs = { ...originalAttrs, ordered: isOrdered }; } const listItems = Array.from(listElement.children).filter(el => el.tagName === 'LI'); const innerBlocks = listItems.map(li => this.parseListItemToBlock(li, tracker)); return createBlock('core/list', attrs, innerBlocks); }, /** * Parse a list item to WordPress block format * Preserves original attrs if UUID exists */ parseListItemToBlock(liElement, tracker) { const uuid = liElement.getAttribute(LIST_ITEM_ID_ATTR); let attrs = {}; if (uuid && tracker && tracker.uuidMap.has(uuid)) { const original = tracker.uuidMap.get(uuid); attrs = JSON.parse(JSON.stringify(original.attrs || {})); } // Recurse into nested list using the live element before cloning const innerBlocks = []; const nestedListEl = liElement.querySelector(':scope > ul, :scope > ol'); if (nestedListEl) { innerBlocks.push(this.parseListToBlock(nestedListEl, tracker, false)); } const clone = liElement.cloneNode(true); const directSurface = clone.querySelector(`:scope > [${LIST_ITEM_TEXT_ATTR}="1"]`); let content = ''; if (directSurface) { const cleanedSurface = this.cleanElement(directSurface); content = cleanedSurface.innerHTML.trim(); } else { const nestedInClone = clone.querySelector(':scope > ul, :scope > ol'); if (nestedInClone) nestedInClone.remove(); const cleaned = this.cleanElement(clone); content = cleaned.innerHTML.trim(); } return createBlock('core/list-item', { ...attrs, content }, innerBlocks); }, /** * Clean element using ElementPrep * Removes editing artifacts while preserving UUIDs and content */ cleanElement(element) { if (SFE.ElementPrep) { return SFE.ElementPrep.clean(element, { removeIdentity: true, removeControls: true, clone: false // Already working with a clone }); } console.error('ElementPrep not found'); return element; }, /** * Serialize the current list structure to WordPress block format * Preserves all original attrs, updates only content and ordered */ serialize(tracker) { if (!tracker) tracker = this.active; if (!tracker) return null; const block = this.parseListToBlock(tracker.listElement, tracker); return serializeBlocks([block]); }, /** * Update the tracker's element reference * Used when the list element is replaced (e.g., OL to UL conversion) */ updateElement(tracker, newElement) { if (!tracker) tracker = this.active; if (!tracker) return; // Ensure new element keeps the tracker reference newElement._mwpListTracker = tracker; this.syncEditableTextSurfaces(newElement); tracker.listElement = newElement; // Update element references in uuidMap tracker.uuidMap.forEach((value, key) => { if (value.type === 'list') { const newEl = newElement.querySelector(`[${LIST_ID_ATTR}="${key}"]`) || (newElement.getAttribute(LIST_ID_ATTR) === key ? newElement : null); if (newEl) { value.element = newEl; } } else if (value.type === 'item') { const newEl = newElement.querySelector(`[${LIST_ITEM_ID_ATTR}="${key}"]`); if (newEl) { value.element = newEl; } } }); tracker.runtimeUuidMap.forEach((value, key) => { if (value.type === 'list') { const newEl = this.getListByRuntimeUuid(tracker, key); if (newEl) { value.element = newEl; tracker.runtimeDomMap.set(newEl, key); } } else if (value.type === 'item') { const newEl = this.getItemByRuntimeUuid(tracker, key); if (newEl) { value.element = newEl; tracker.runtimeDomMap.set(newEl, key); } } }); }, /** * Return one tree-aware structural snapshot for the active list. * * @param {Object|null} tracker Active list tracker. * @returns {Object|null} Lightweight structure snapshot. */ getStructure(tracker) { if (!tracker) tracker = this.active; if (!tracker?.listElement) { return null; } const buildListNode = (listElement, listPath = '', parentIndexes = []) => ({ listUuid: this.getRuntimeUuidForList(tracker, listElement), listPath, ordered: listElement.tagName === 'OL', items: getDirectListItems(listElement).map((listItem, index) => { const indexes = [ ...parentIndexes, index ]; const pathMeta = buildPathMeta(indexes); const directSurface = ensureDirectItemTextSurface(listItem); const nestedList = getDirectChildList(listItem); return { itemUuid: this.getRuntimeUuidForItem(tracker, listItem), path: pathMeta.path, pathLabel: pathMeta.pathLabel, depth: pathMeta.depth, contentHtml: directSurface ? directSurface.innerHTML.trim() : '', childList: nestedList ? buildListNode(nestedList, pathMeta.path, indexes) : null, }; }), }); return buildListNode(tracker.listElement, '', []); }, /** * Apply one primitive structural list operation against the live tracked * DOM. * * Public API calls are translated into this lower-level operation set by * the shared schema executor so the tracker only needs to understand the * canonical primitive mutation layer. * * Supported primitive kinds: * - `insert_list_item` * - `remove_list_item` * - `move_list_item` * - `indent_list_item` * - `outdent_list_item` * - `update_list_item_text` * - `toggle_list_type` * * @param {Object|null} tracker Active list tracker. * @param {Object} rawOperation Structural operation payload. * @returns {Object|null} Result summary when applied. */ applyOperation(tracker, rawOperation, options = {}) { if (!tracker) tracker = this.active; if (!tracker?.listElement || !rawOperation || typeof rawOperation !== 'object') { return null; } const kind = typeof rawOperation.kind === 'string' ? rawOperation.kind.trim().toLowerCase() : ''; const path = rawOperation.path ?? rawOperation.itemPath ?? rawOperation.item_path ?? ''; const listItem = this.getItemByPath(tracker, path); let didApply = false; if (kind === 'remove_list_item' && listItem) { didApply = applyRemoveListItemOperation(tracker, listItem); } else if (kind === 'indent_list_item' && listItem) { didApply = applyIndentListItemOperation(tracker, listItem); } else if (kind === 'outdent_list_item' && listItem) { didApply = applyOutdentListItemOperation(tracker, listItem); } else if (kind === 'toggle_list_type') { didApply = applyToggleListTypeOperation(tracker, rawOperation, options); } else if (kind === 'update_list_item_text' && listItem) { didApply = applyUpdateListItemTextOperation(listItem, rawOperation); } else if (kind === 'insert_list_item') { didApply = applyInsertListItemOperation(tracker, rawOperation, this); } else if (kind === 'move_list_item' && listItem) { didApply = applyMoveListItemOperation(tracker, listItem, rawOperation, this); } if (!didApply) { return null; } this.syncEditableTextSurfaces(tracker.listElement); this.buildFromDOM(tracker, tracker.listElement, tracker.originalBlock || {}); return { kind, structure: this.getStructure(tracker), }; }, /** * Ensure every list item in one tree has one direct text surface. * * @param {HTMLElement|null} rootElement Candidate list root or list item. * @returns {HTMLElement|null} Normalized root element. */ syncEditableTextSurfaces(rootElement) { if (!rootElement || rootElement.nodeType !== Node.ELEMENT_NODE) { return null; } if (rootElement.tagName === 'LI') { ensureDirectItemTextSurface(rootElement); Array.from(rootElement.children || []) .filter(child => isNestedListNode(child)) .forEach(childList => this.syncEditableTextSurfaces(childList)); return rootElement; } if (rootElement.tagName !== 'UL' && rootElement.tagName !== 'OL') { return rootElement; } Array.from(rootElement.children || []) .filter(child => child.tagName === 'LI') .forEach(li => this.syncEditableTextSurfaces(li)); return rootElement; }, /** * Ensure runtime UUID attributes are unique within one live list tree. * * Native contenteditable list splitting can clone `li` and nested list * attributes verbatim before FrontEdit regains control. This pass reseeds only the * session-scoped runtime UUID attributes so freshly created structures become * distinct live API/editor targets immediately, while leaving `data-item-id` * and `data-list-id` untouched for their separate responsibilities. * * @param {HTMLElement|null} rootElement Candidate list root. * @returns {HTMLElement|null} Normalized root element. */ ensureUniqueRuntimeUuids(rootElement) { if ( !rootElement || rootElement.nodeType !== Node.ELEMENT_NODE || (rootElement.tagName !== 'UL' && rootElement.tagName !== 'OL') ) { return rootElement || null; } const seenListRuntimeUuids = new Set(); const seenItemRuntimeUuids = new Set(); const collectLists = [ rootElement, ...Array.from(rootElement.querySelectorAll('ul, ol')) ]; const collectItems = Array.from(rootElement.querySelectorAll('li')); collectLists.forEach(listElement => { const runtimeUuid = normalizeRuntimeUuid( listElement.getAttribute(LIST_RUNTIME_UUID_ATTR) ); if (!runtimeUuid) { return; } if (seenListRuntimeUuids.has(runtimeUuid)) { listElement.setAttribute(LIST_RUNTIME_UUID_ATTR, this.generateTempUuid()); return; } seenListRuntimeUuids.add(runtimeUuid); }); collectItems.forEach(listItem => { const runtimeUuid = normalizeRuntimeUuid( listItem.getAttribute(LIST_ITEM_RUNTIME_UUID_ATTR) ); if (!runtimeUuid) { return; } if (seenItemRuntimeUuids.has(runtimeUuid)) { listItem.setAttribute(LIST_ITEM_RUNTIME_UUID_ATTR, this.generateTempUuid()); return; } seenItemRuntimeUuids.add(runtimeUuid); }); return rootElement; }, /** * Ensure one live list tree has the required structural IDs and runtime UUIDs. * * On first editor activation, list elements may not yet have either identity * attribute family. Seed both from one generated UUID per element so the * initial history snapshot captures stable targeting data. Later native list * splits may intentionally copy the structural IDs; in those cases this pass * preserves the structural IDs and only reseeds duplicated runtime UUIDs. * * @param {HTMLElement|null} rootElement Candidate list root. * @returns {HTMLElement|null} Normalized root element. */ ensureIdentityAttributes(rootElement) { if ( !rootElement || rootElement.nodeType !== Node.ELEMENT_NODE || (rootElement.tagName !== 'UL' && rootElement.tagName !== 'OL') ) { return rootElement || null; } const syncIdentityPair = (element, structuralAttrName, runtimeAttrName) => { if (!element || element.nodeType !== Node.ELEMENT_NODE) { return; } let structuralId = normalizeRuntimeUuid( element.getAttribute(structuralAttrName) ); let runtimeUuid = normalizeRuntimeUuid( element.getAttribute(runtimeAttrName) ); if (!structuralId && !runtimeUuid) { runtimeUuid = this.generateTempUuid(); structuralId = runtimeUuid; } else if (!runtimeUuid) { runtimeUuid = structuralId; } else if (!structuralId) { structuralId = runtimeUuid; } element.setAttribute(structuralAttrName, structuralId); element.setAttribute(runtimeAttrName, runtimeUuid); }; syncIdentityPair(rootElement, LIST_ID_ATTR, LIST_RUNTIME_UUID_ATTR); Array.from(rootElement.querySelectorAll('ul, ol')).forEach(listElement => { syncIdentityPair(listElement, LIST_ID_ATTR, LIST_RUNTIME_UUID_ATTR); }); Array.from(rootElement.querySelectorAll('li')).forEach(listItem => { syncIdentityPair(listItem, LIST_ITEM_ID_ATTR, LIST_ITEM_RUNTIME_UUID_ATTR); }); return this.ensureUniqueRuntimeUuids(rootElement); }, getDirectItemTextSurface, normalizePathIndexes, buildPathMeta, getRuntimeUuidAttributeName, getListRuntimeUuidAttributeName() { return LIST_RUNTIME_UUID_ATTR; }, getListItemRuntimeUuidAttributeName() { return LIST_ITEM_RUNTIME_UUID_ATTR; }, getListIdAttributeName() { return LIST_ID_ATTR; }, getListItemIdAttributeName() { return LIST_ITEM_ID_ATTR; }, /** * Destroy tracker and clean up */ destroy(tracker) { if (!tracker) tracker = this.active; if (!tracker) return; tracker.uuidMap.clear(); tracker.runtimeUuidMap.clear(); if (tracker.listElement) { delete tracker.listElement._mwpListTracker; } if (this.active === tracker) this.active = null; } }; /** * Return whether one element is a live list node for runtime lookup helpers. * * @param {Element|null} element Candidate DOM element. * @returns {boolean} True when the element is `UL` or `OL`. */ function isListElementForRuntimeLookup(element) { return !!( element && element.nodeType === Node.ELEMENT_NODE && (element.tagName === 'UL' || element.tagName === 'OL') ); } // Expose globally SFE.ListBlockTracker = ListBlockTracker; })(); public Archives - Page 23 of 23 - Luxe Designs

Category: public

Your gateway to online casino fun: access secure games and exclusive bonuses

Posted on by Eric Schmid



In the vibrant world of online casinos, players enjoy the thrill of gaming from the comfort of their homes. This arena offers countless opportunities, from engaging gameplay to enticing bonuses. However, navigating through the myriad options available can be daunting. Understanding how to find secure games and exclusive promotions, such as Winserra free spins no deposit , is essential for an enjoyable and safe experience. In this article, we will explore how trust, access, and rewards are interconnected within the online casino landscape.

How trust, access, and rewards connect in casino

In the online casino world, trust and access are foundational components that enhance players’ experiences. Trust stems from a casino’s licensing, security measures, and reputation in the industry. Access refers to the ability to enjoy various games and bonuses, ensuring that players can find their favorite experiences without hassle. Rewards, including bonuses and promotions, serve to entice players and enhance their gaming experience while reinforcing the trust and access dynamic. Together, these elements build a robust online casino environment that fosters loyal players and promotes sustainable growth within the industry.

As gaming technology evolves, players have greater access to a wider array of games and platforms. This progression emphasizes the need for secure gaming environments where players can feel confident in their choices. Therefore, casinos that prioritize trust and provide easy access to games while offering appealing rewards are more likely to succeed and attract players.

How to get started with online casinos

Beginning your journey in the realm of online casinos is an exciting venture, and following these essential steps will guide you toward a successful experience.

  1. Create an Account: Sign up on a reputable online casino site by providing the necessary personal information.
  2. Verify Your Details: Complete verification by submitting required documents to ensure security and compliance.
  3. Make a Deposit: Choose a secure payment method to fund your account, enabling you to start playing your favorite games.
  4. Select Your Game: Browse the casino library and pick from a variety of games, such as slots, table games, or live dealer options.
  5. Start Playing: Dive into the gaming experience, utilizing your bonus offers and enjoying the thrill of play.
  • Easy process to get started with minimal obstacles
  • Access to various payment methods for convenience
  • Opportunity to explore different games and genres

Practical details for an enjoyable gaming experience

When exploring the online casino landscape, it’s essential to consider several practical details that can enhance your gaming experience. Firstly, look for casinos that offer a wide range of games, as this ensures that you’ll have plenty of options to choose from. Additionally, check for user-friendly interfaces that facilitate easy navigation and gameplay. A well-structured platform enhances your overall experience, allowing you to focus on enjoying the games without frustration.

Moreover, effective customer support is crucial in finding a reliable online casino. Ensure that the casino provides multiple channels for communication, such as live chat, email, and phone support. This accessibility means that if you encounter any issues, help is readily available. Additionally, keep an eye out for casinos that offer mobile-friendly platforms, enabling you to play your favorite games on the go, whether at home or while traveling.

  • Diverse game selection to maximize entertainment
  • User-friendly interface for seamless navigation
  • Responsive customer support to address concerns
  • Mobile compatibility for on-the-go gaming

By being mindful of these practical details, you can create a more enjoyable and stress-free gaming experience as you explore various online casinos.

Key benefits of online casinos

Online casinos come with a host of benefits that can significantly enhance your gaming experience, making them an attractive option for players. One of the primary advantages is convenience; players can access their favorite games anytime and anywhere, eliminating the need for travel. Additionally, online casinos often provide attractive bonuses, including welcome offers and loyalty rewards, which can increase your bankroll and extend your playtime.

  • Convenient access to games from the comfort of your home
  • Exciting bonuses and promotions to boost your playing power
  • Diverse game options to cater to varied player preferences
  • Safe and secure gaming environments to protect player information

These key benefits highlight the allure of online casinos and illustrate why so many players are choosing to embark on their gaming journeys in this digital landscape.

Trust and security in online casinos

When choosing an online casino, trust and security are paramount. Players must ensure that the casino is licensed and regulated by a recognized authority, which establishes a framework for fair play and consumer protection. Reputable casinos employ advanced encryption technologies to safeguard players’ personal and financial information, creating a secure environment for transactions.

Moreover, it’s beneficial to read customer reviews and check the casino’s reputation within the gaming community. Trustworthy casinos prioritize transparency and fair play, showcasing their commitment to providing a safe gaming experience. By selecting a casino that embodies these traits, players can enjoy peace of mind while indulging in their favorite games.

Why choose a reputable online casino

Opting for a reputable online casino enhances your gaming experience by ensuring that every aspect, from gameplay to bonuses, is handled with transparency and integrity. Choosing a trusted platform enables you to focus on enjoying the games without worrying about security or fairness. Furthermore, a well-regarded casino tends to offer better customer support, diverse gaming options, and more lucrative bonuses, creating an overall enriching experience.

In conclusion, exploring the world of online casinos can be incredibly rewarding when you prioritize elements like trust, access, and security. By following the outlined steps and considering the benefits provided by reputable casinos, you can embark on a thrilling journey filled with entertainment and potential rewards. Embrace the excitement and take the plunge into the online casino experience today!

Fast access to the casino mirror site: uninterrupted gaming at your fingertips

Posted on by Eric Schmid



In the world of online gaming, having quick and reliable access to your favorite casinos is essential. Players often look for seamless experiences that allow them to dive into the fun without unnecessary delays. The concept of a casino mirror site has emerged as a popular solution for uninterrupted access, especially in situations where the primary website may be unavailable, such as Richy Reels that offers exciting games and promotions. This article will explore everything players need to know about casino mirror sites and how they enhance the online gaming experience in 2026.

What players should know before using a casino

Understanding the landscape of online casinos can be crucial for a satisfying gaming experience. Casino mirror sites are replicas of the main gaming platforms, providing players with an alternative way to access their favorite games. These mirror sites are particularly useful during instances of downtime, whether due to technical issues or regulatory restrictions. Players should be aware of several key factors when using these sites, including the legality, security, and availability of promotions.

The rapid increase in online gaming has led many players to seek reliable alternatives. A mirror site offers the same games and functionalities as the original site, ensuring that players can enjoy a wide range of options without interruption. This accessibility significantly improves the overall gaming experience, allowing users to engage with their favorite games at any time.

How to get started with a casino mirror site

Getting started with a casino mirror site is a straightforward process. Here’s a step-by-step guide to ensure a smooth transition into uninterrupted gaming:

  1. Find the Mirror Site: Look for official announcements or trusted sources that provide the URL for the mirror site.
  2. Create an Account: If you’re new, register by providing the necessary information; if you’re a returning player, log in using your existing credentials.
  3. Verify Your Account: Complete any necessary verification steps to ensure your account is secure and functional.
  4. Make a Deposit: Fund your account using your preferred payment method to start playing.
  5. Select Your Game: Browse through the extensive library of games available on the mirror site.
  6. Start Playing: Dive into the gaming experience and enjoy the variety of games offered!
  • Instant access allows for immediate gaming without delays.
  • Familiar interface means you won’t have to learn a new layout.
  • Game libraries remain consistent across the main and mirror sites.

Practical details for using casino mirror sites

When utilizing a casino mirror site, players need to focus on a few practical aspects to enhance their gaming experience. Firstly, ensure that the mirror site is officially endorsed by the primary casino. This ensures that your gaming experience is safe and secure. Look for important indicators such as SSL certification and licensing information prominently displayed on the site. Additionally, players should be aware of ongoing promotions that may be available exclusively on the mirror site, which can enhance their gaming experience.

Another critical factor is customer support. Ensure that the mirror site provides adequate support options, whether through live chat, email, or phone. Quick access to customer service can resolve any issues that may arise while gaming, ensuring a smooth experience. Furthermore, check for compatibility with various devices. Most mirror sites are optimized for both desktop and mobile platforms, allowing players to access their favorite games on the go.

  • Look for SSL certificates to ensure your data is protected.
  • Check for available promotions that can boost your gameplay.
  • Test customer support channels to ensure they are responsive.

By keeping these details in mind, players can make the most of their time on the mirror site and enjoy their gaming adventures without interruptions.

Key benefits of using a casino mirror site

Opting for a casino mirror site comes with several significant advantages. The primary benefit is uninterrupted access, allowing players to engage with their favorite games without worrying about downtime. A mirror site effectively eliminates the frustration of being unable to access the main casino during peak times or maintenance schedules.

  • Consistent gaming experience across platforms.
  • Enhanced security measures to protect user data.
  • Access to exclusive promotions and bonuses.
  • Convenience of playing from any location without interruptions.

These benefits contribute to a more enjoyable and secure gaming environment, ensuring players can focus on their gaming without unnecessary concerns.

Trust and security in online gaming

In online gaming, trust and security are paramount. Players should always prioritize sites that are licensed and regulated. Regulatory bodies ensure that online casinos adhere to strict guidelines designed to protect players and maintain fair gaming practices. It is essential to verify that the casino’s mirror site holds an appropriate license, as this reflects the site’s commitment to security and player trust.

Furthermore, look for casinos that utilize advanced encryption technologies to protect players’ personal and financial data. This technology adds an extra layer of security, ensuring that sensitive information remains confidential. Regular audits by independent agencies can also help to affirm the integrity of the games being offered, which is an essential element for any serious online gamer.

  • Choose licensed and regulated casinos for peace of mind.
  • Check for encryption protocols to safeguard your data.
  • Look for transparent payout percentages to ensure fair gaming.

Why choose a casino mirror site

Selecting a casino mirror site can significantly enhance your online gaming experience. The primary reason to utilize these sites is the assurance of accessibility. No gamer enjoys experiencing downtime, and having a mirror site means you can swiftly navigate around any issues affecting the main platform. Moreover, these sites often replicate the same games, bonuses, and user experiences found on the original site.

As technology evolves and the gaming industry continues to adapt, players should remain informed about the tools and resources available to them. By choosing to engage with a reliable casino mirror site, players are not only ensuring convenience but also securing their gaming future. Embrace the freedom of uninterrupted access to your favorite games, and enjoy a seamless online gaming experience today!

Spinanga kaszinó promóciók: mit kínál a 2026-os év?

Posted on by Eric Schmid



A kaszinók világa mindig izgalmas lehetőségeket tartogat a játékosok számára, különösen a promóciók és bónuszok révén. 2026-ban a Spinanga kaszinó különleges ajánlatokkal várja a játékosokat, amelyek között megtalálható a spinangakaszino.hu.net site is, amelyet érdemes megismerni. A cikk célja, hogy bemutassa ezeket a lehetőségeket, valamint hogy tippeket adjon a kezdőknek, hogyan induljanak el a kaszinózás izgalmas világában.

Hogyan közelítsenek a kezdők a kaszinóhoz

Az online kaszinók közelmúltbeli népszerűsége számos új játékost vonzott a világ minden tájáról. A Spinanga kaszinó egyedülálló élményeket kínál, több játék- és bónusz lehetőséggel. Az új játékosok számára ez nemcsak szórakoztató, hanem kihívást is jelenthet. Fontos, hogy a kezdők tájékozódjanak a különböző játékok szabályairól és a kaszinó működéséről, hogy a lehető legjobban kihasználhassák a felkínált promóciókat.

Ahhoz, hogy a legjobbtól tudjuk csinálni a játékot, érdemes ismerkedni a kaszinó különböző funkcióival, mint például az élő játékok, video slotok és az asztali játékok, mindez izgalmas élményben részesíti a játékosokat.

Elindulás lépésről lépésre

A Spinanga kaszinó világába való belépés izgalmas, de fontos, hogy a kezdők tisztában legyenek a szükséges lépésekkel. Az alábbiakban bemutatjuk, hogyan lehet könnyedén elindulni:

  1. Fiók létrehozása: Először regisztrálj a Spinanga kaszinó oldalán, ahol meg kell adnod néhány alapvető információt.
  2. Adatok ellenőrzése: A fiók aktiválása előtt ellenőrizned kell az adataidat, hogy minden pontos legyen.
  3. Befizetés végrehajtása: Válassz ki egy megfelelő befizetési módot, és töltsd fel a játék egyenlegedet.
  4. Játék kiválasztása: Böngéssz a játékok között, és válaszd ki a számodra legizgalmasabbakat.
  5. Játék elkezdése: Kezd el a játékot, és élvezd a Spinanga kaszinó által kínált lehetőségeket!
  • Gyorsan létrehozhatod a fiókodat és elkezdheted a játékot
  • Böngészhetsz a bónuszok között, hogy ki tudd választani a legjobbat
  • Számtalan játék közül választhatsz, egyedi élményeket kínálva

Praktikus részletek a Spinanga kaszinóról

A Spinanga kaszinó számos lehetőséget kínál, amelyek egyedivé teszik a játékélményt. Az élő osztós játékok során valódi krupiék irányítják a játékot, így a játékosok a valódi kaszinó élményt élhetik át otthonuk kényelméből. A különböző bónuszok és promóciók segítenek abban, hogy a játékosok még többet nyerjenek és szórakozzanak játékaik során. 2026-ban a Spinanga kaszinó kiemelt hangsúlyt fektet az új játékok bevezetésére, amelyek között rengeteg különleges funkció és jackpot várja a játékosokat.

  • Élő osztós játékok széles választéka
  • Új játékok havonta, egyedi funkciókkal
  • Promóciók, amelyek extra lehetőségeket kínálnak

Mindezek mellett a Spinanga kaszinó folyamatosan javítja és frissíti platformját, hogy a felhasználói élmény mindig a legmagasabb legyen, és a játékosok valóban élvezhesse a szórakozást.

Kulcsfontosságú előnyök

A Spinanga kaszinó számos előnyt kínál, amelyek vonzóvá teszik a játékosok számára. Az alábbiakban felsoroljuk, miért érdemes itt játszani:

  • Széles játékpaletta – mindenki megtalálhatja a kedvenc játékát
  • Generózus bónuszok új játékosoknak és visszatérő látogatóknak
  • Gyors kifizetések, így a nyereményed azonnal nálad lehet
  • Felhasználóbarát felület, könnyű navigációval

Az ilyen jellegű előnyök miatt a Spinanga kaszinó kiemelkedik a piacon, és számos játékos körében népszerű választássá vált a fenntartható szórakozás szempontjából.

Bizalom és biztonság

A Spinanga kaszinó nagy hangsúlyt fektet a játékosok biztonságára és adatvédelmére. Az online platformok esetében a biztonság kulcsfontosságú tényező, hiszen a játékosok pénzügyi és személyes adatai védelmét minden esetben garantálni kell. A Spinanga kaszinó nemcsak titkosítással védi az adatokat, hanem folyamatosan figyelemmel kíséri a rendszert, hogy minden esetben a legfrissebb biztonsági intézkedések érvényesüljenek. A játékosok bízhatnak abban, hogy a legmagasabb szintű védelmet élvezik.

Ezen kívül a Spinanga kaszinó elkötelezett a felelős játék mellett, és szolgáltatásokat kínál a játékosok számára, hogy tudatosan játszhassanak és megelőzhessék a játékfüggőséget.

Miért válaszd a Spinanga kaszinót?

A Spinanga kaszinó minden szempontból remek választás a játékosok számára. A kiváló játékválaszték, a fantasztikus bónuszok és a biztonságos környezet kombinációja ideálissá teszi a platformot. A kezdők számára a lépésről lépésre követhető útmutatók és a könnyen navigálható felület lehetővé teszi az egyszerűbb elindulást. Emellett a Spinanga kaszinó folyamatosan frissülő ajánlataival a játékosok mindig új lehetőségekkel találkozhatnak, így nem csoda, hogy egyre többen választják ezt a helyet a szórakozásra.

Ha szereted a kihívásokat és az izgalmas játékokat, ne habozz, csatlakozz a Spinanga kaszinó közösségéhez, és tapasztald meg a különleges promóciókat és lehetőségeket, amelyeket a 2026-os évben kínálnak!

Claim your rewards: Best betting apps in Canada with exclusive offers for NHL enthusiasts

Posted on by Eric Schmid



In today’s digital age, online casinos and betting apps have transformed the landscape of gaming in Canada, offering players exciting opportunities to win while enjoying their favorite games. With the rise of sports betting, particularly in the context of the NHL, players seek out platforms that provide not only entertainment but also rewards and bonuses, such as sports betting promotions that enhance their overall experience. This article explores the best betting apps available in Canada for 2026, focusing on licensed operators, exclusive offers, and how enthusiasts can maximize their betting experience.

How trust, access, and rewards connect in casino

The connection between trust, access, and rewards plays a vital role in the online casino experience. Trust in a betting app is established through licensing and regulation, ensuring that players are protected and can gamble responsibly. In Canada, various provinces have launched regulated betting platforms, allowing players to choose from a safe list of operators.

Access to these platforms is straightforward, especially with the increasing popularity of mobile betting apps that allow players to engage from anywhere. Moreover, rewards come in various forms, including welcome bonuses, loyalty programs, and exclusive offers tailored for sports enthusiasts, particularly those following the NHL. Understanding this triad enhances the overall gaming experience, making it more enjoyable and rewarding for the player.

How to get started with online betting

Embarking on the journey of online betting can be thrilling yet daunting for newcomers. However, the process can be simplified with a few straightforward steps to help players dive right into the action.

  1. Create an Account: Choose a licensed betting app and complete the registration process by providing your basic details.
  2. Verify Your Details: Upload the necessary documents to verify your identity and ensure compliance with regulatory standards.
  3. Make a Deposit: Use a preferred payment method, such as Interac, to fund your account. Many apps offer quick payout options.
  4. Select Your Game: Browse through the game selection, including slots, table games, and sports betting options.
  5. Enjoy Bonuses: Take advantage of welcome bonuses or promotions specifically designed for new users.
  • Quick setup helps you start playing immediately.
  • Verification ensures a secure gaming environment.
  • Multiple deposit options facilitate quick access to funds.

Exploring the top betting apps in Canada

As we delve into the array of betting apps available in Canada for 2026, several platforms stand out for their unique offerings and user experiences. For instance, Boomerangbet emerges as a top choice, featuring a generous bonus of up to $750. This app is known for its smooth interface and extensive game selection.

On the other hand, RedRacer, operating in Ontario, offers an impressive welcome bonus of up to $10,000, making it an attractive option for new players looking to maximize their initial deposit. Additionally, NovaJackpot is popular for its hybrid format, which supports fast crypto payouts, appealing to tech-savvy users. Each of these apps incorporates unique features tailored to enhance the gaming experience.

  • Boomerangbet: Bonus up to $750.
  • RedRacer: Bonus up to $10,000.
  • NovaJackpot: Fast crypto payouts available.

With these diverse platforms, players can choose an app that fits their preferences while enjoying an enriched betting experience.

Key benefits of using licensed betting apps

Utilizing licensed betting apps offers several key benefits that enhance the overall gaming experience. Firstly, regulations guarantee that operators adhere to strict guidelines, ensuring fair play and secure transactions. When players engage with licensed platforms, they can enjoy peace of mind knowing that their information is protected, and any disputes will be fairly resolved.

  • Security: Licensed apps implement strong encryption protocols to safeguard user data.
  • Fair Gaming: Regular audits and compliance checks ensure a level playing field for all users.
  • Variety of Games: Access to a wide range of games, from traditional casinos to live sports betting.
  • Promotions: Licensed platforms often provide player loyalty programs and exclusive bonuses, especially for NHL fans.

These advantages position licensed betting apps as an attractive option for Canadian players, allowing them to enjoy their gaming experience with confidence and excitement.

Trust and security in online betting

Trust and security are paramount when engaging in online betting. Players must choose licensed operators, as these platforms are subject to governmental oversight and adhere to strict regulatory measures to protect players. In Canada, the Alcohol and Gaming Commission of Ontario (AGCO) oversees licensing for operators, ensuring they meet established standards for fairness and security.

Additionally, reputable betting apps utilize advanced encryption technologies to protect user information and transactions, instilling confidence in players. This level of security is essential, especially given the financial transactions involved in online gambling. Players can bet with peace of mind, knowing that their data is safe and their games are fair.

  • Licensed operators ensure adherence to regulatory practices.
  • Advanced encryption protects users’ financial and personal information.
  • Regular audits guarantee the integrity of games offered.

Why choose licensed betting apps in Canada?

Choosing licensed betting apps in Canada positions players to enjoy a safe, reliable, and rewarding gaming experience. The combination of comprehensive regulation, security measures, and the numerous available rewards makes these platforms ideal for both new and seasoned players. With a growing number of licensed operators in Ontario and Alberta, the variety is vast, providing options that cater to every type of bettor.

Ultimately, whether you’re placing bets on your favorite NHL team or exploring the diverse gaming options, opting for a licensed betting app ensures that your experience is not only enjoyable but also secure. Dive into the exciting world of online betting in Canada today, and discover the potential for thrilling wins and great rewards!

Shikaka Casino: Jak maximálně využít své EUR a uvítací bonusy

Posted on by Eric Schmid



V dnešním digitálním světě se online kasina stávají stále populárnějšími a Shikaka Casino je jedním z nejzajímavějších hráčů na trhu. Nabízí širokou škálu her a lákavé bonusy, což jej činí atraktivním pro hráče v Česká republika a široko daleko. Pokud hledáte kvalitní zábavu, https://shikaka.cz/ vám poskytne skvělou příležitost vyzkoušet nové hry a užít si vzrušení. Tento článek vám ukáže, jak maximálně využít své EUR a uvítací bonusy na této platformě.

Co zkontrolovat před začátkem s Shikaka Casino

Předtím, než se pustíte do světa online hazardu, je důležité mít na paměti několik klíčových aspektů. Šikaka Casino poskytuje bezpečné a zabezpečené prostředí pro své uživatele. Před registrací se ujistěte, že jste obeznámeni s podmínkami bonusů a možnostmi her. Můžete se těšit na uvítací bonus až 400% do výše 15 000 EUR a 400 volných spinů. To je skvělý start pro každého nového hráče.

Dále je důležité zkontrolovat, zda vaše zařízení je kompatibilní s platformou a jak rychle je možné se zaregistrovat. V Shikaka Casino trvá registrace jen několik minut a je přístupná na všech zařízeních, což zaručuje pohodlné hraní.

Jak začít s Shikaka Casino

Začít hrát v Shikaka Casino je snadné a rychlé. Zde je návod, jak to udělat krok za krokem:

  1. Vytvořte účet: Navštivte webové stránky Shikaka Casino a zaregistrujte se pomocí e-mailu a hesla.
  2. Ověřte své údaje: Sledujte pokyny k ověření vaší identity, což zaručuje bezpečnost vašich prostředků.
  3. Vložte peníze: Zvolte si preferovaný způsob platby a vložte EUR nebo kryptoměnu.
  4. Vyberte si hru: Prozkoumejte širokou nabídku her a vyberte si tu, která vás nejvíce zaujme.
  5. Začněte hrát: Užívejte si hraní a nezapomeňte využít svůj uvítací bonus!
  • Rychlá registrace, které vám umožní začít hrát téměř okamžitě.
  • Bezpečné ověření, které chrání vaše osobní údaje.
  • Možnost vložení v různých měnách, včetně EUR a kryptoměn.

Praktické detaily pro Shikaka Casino

Při používání Shikaka Casino si můžete užít různé hry od špičkových vývojářů. Všechny hry jsou certifikovány, což zajišťuje jejich spravedlnost a kvalitu. Kromě toho platforma nabízí vynikající uživatelské rozhraní, které usnadňuje navigaci a hledání vašich oblíbených her. Pokud se rozhodnete hrát na mobilním zařízení, můžete si být jisti, že zážitek bude stejně kvalitní jako na počítači.

  • Široká škála her, včetně automatů, stolních her a živého kasina.
  • Podpora více měn, což usnadňuje transakce.
  • Skvělá uživatelská zkušenost na všech typech zařízení.

Při využívání těchto funkcí nezapomeňte také na to, že Shikaka Casino nabízí různé bonusy a akce. Využijte příležitosti a získejte výhody při svých hrách!

Klíčové výhody Shikaka Casino

Zde je několik klíčových výhod, které Shikaka Casino nabízí svým hráčům:

  • Generózní uvítací bonus, který může dosáhnout až 15 000 EUR.
  • 400 volných spinů, které vám umožní vyzkoušet nové hry bez rizika.
  • Bezpečné a zabezpečené prostředí pro vaše hráčské aktivity.
  • Kompatibilita se všemi zařízeními, což znamená, že můžete hrát kdykoliv a kdekoliv.

Tyto výhody vám pomohou maximalizovat váš herní zážitek a zvýšit šance na výhru.

Důvěra a bezpečnost

Bezpečnost je pro hráče vždy na prvním místě. Shikaka Casino využívá SSL šifrování, aby zajistilo, že všechny vaše osobní a finanční údaje jsou chráněny před neoprávněným přístupem. To znamená, že se můžete plně soustředit na svou hru, aniž byste se museli obávat o své údaje.

Další výhodou je, že platforma spolupracuje pouze s certifikovanými vývojáři softwaru, což zaručuje bezpečné a férové hraní. Ochrana hráčů je zde brána velmi vážně, takže se můžete cítit bezstarostně při vyzkoušení různých her.

Proč si vybrat Shikaka Casino

Shikaka Casino se ukazuje jako skvělá volba pro všechny, kteří hledají bezpečné a zábavné online herní prostředí. Jeho široká nabídka her, atraktivní bonusy a snadná dostupnost činí tuto platformu ideální pro nové i zkušené hráče. Ať už hledáte vzrušení z automatů nebo strategie stolních her, Shikaka Casino má co nabídnout každému.

Tak neváhejte a připojte se k Shikaka Casino. Vyzkoušejte si své štěstí a užijte si úžasný herní zážitek, který této platforma nabízí!

Avantages et inconvénients des jeux mobiles : vaut-il la peine de passer aux applications

Posted on by Eric Schmid



Les avantages des jeux de casino mobiles

Les jeux de casino mobiles offrent une expérience de divertissement qui est à la fois pratique et accessible. Avec l’essor des smartphones et des tablettes, les joueurs peuvent désormais accéder à leurs jeux préférés n’importe où et n’importe quand. Que ce soit pendant un trajet en transport en commun ou dans le confort de leur maison, la commodité des jeux mobiles est un atout majeur. De plus, de nombreuses applications de jeux de casino proposent ainsi des fonctionnalités telles que des bonus et promotions intéressantes, comme sur Shuffle Casino , ce qui améliore considérablement l’expérience de jeu.

En outre, les casinos en ligne mobiles offrent souvent des promotions exclusives et des bonus pour encourager les joueurs à télécharger leurs applications. Ces incitatifs peuvent inclure des tours gratuits, des bonus de bienvenue ou des programmes de fidélité qui récompensent les joueurs pour leur engagement. Cela permet aux joueurs d’optimiser leur expérience et d’augmenter leurs chances de gains sans avoir à dépenser beaucoup d’argent.

Les inconvénients des jeux de casino mobiles

Malgré leurs avantages, les jeux de casino mobiles présentent également certains inconvénients. L’un des principaux problèmes est lié à la sécurité des transactions. Les joueurs doivent être vigilants quant aux applications qu’ils téléchargent, car certaines peuvent ne pas offrir le niveau de sécurité adéquat pour protéger les données personnelles et financières. Il est donc essentiel de choisir des applications de casino réputées et bien évaluées pour éviter les risques liés à la fraude.

De plus, la taille de l’écran peut être un facteur limitant pour certains jeux, en particulier ceux qui requièrent des graphiques détaillés ou une interface complexe. Certains joueurs préfèrent l’expérience immersive offerte par un ordinateur de bureau, où ils peuvent bénéficier d’un écran plus grand et d’un meilleur son. Par conséquent, bien que les jeux mobiles soient pratiques, ils ne remplacent pas toujours l’expérience de jeu sur des plateformes plus traditionnelles.

Les tendances du marché des jeux de casino mobiles

Le marché des jeux de casino mobiles est en constante évolution, avec de nouveaux développements technologiques qui transforment la manière dont les joueurs interagissent avec les jeux. L’intégration de la réalité augmentée et de la réalité virtuelle dans les applications de casino commence à offrir des expériences plus immersives et engageantes. Ces technologies permettent aux joueurs de se plonger dans un environnement de casino virtuel, ajoutant une nouvelle dimension au plaisir du jeu.

De plus, l’essor des crypto-monnaies est en train de modifier le paysage des jeux de casino mobiles. De plus en plus de plateformes acceptent les paiements en crypto-monnaies, offrant ainsi aux joueurs une option de transaction rapide et sécurisée. Cela favorise également l’anonymat des joueurs, ce qui est un atout pour ceux qui préfèrent garder leur activité de jeu privée.

Les défis réglementaires dans le secteur des jeux mobiles

Les jeux de casino mobiles sont soumis à une réglementation stricte qui varie d’un pays à l’autre. Cela peut poser des défis pour les développeurs d’applications et les opérateurs de casinos en ligne, qui doivent s’assurer qu’ils respectent toutes les lois en vigueur dans les juridictions où ils opèrent. Les restrictions peuvent affecter l’accès des joueurs aux jeux, ainsi que la disponibilité de certaines promotions ou fonctionnalités.

En outre, les autorités de régulation cherchent à protéger les joueurs contre les comportements de jeu problématiques. Cela peut entraîner l’imposition de limites sur les mises ou des exigences de vérification d’identité plus strictes, ce qui peut être perçu comme un inconvénient par certains joueurs. C’est un aspect important à considérer pour ceux qui envisagent de s’engager dans le jeu mobile de manière régulière.

Conclusion sur les jeux de casino mobiles

En conclusion, les jeux de casino mobiles représentent une alternative attrayante pour les amateurs de jeux d’argent, offrant à la fois commodité et accessibilité. Toutefois, il est crucial de peser les avantages contre les inconvénients, notamment en ce qui concerne la sécurité et l’expérience utilisateur. Alors que le marché continue d’évoluer avec de nouvelles technologies et des réglementations, les joueurs doivent être informés et prudents dans leur approche des jeux de casino en ligne. La décision de passer aux applications de jeu mobile mérite réflexion, mais avec un choix judicieux, elle peut révéler de belles opportunités de divertissement et de gains.

Coronavirus disease 2019

Posted on by Eric Schmid

COVID-19 is a contagious disease caused by the coronavirus SARS-CoV-2. In January 2020, the disease spread worldwide, resulting in the COVID-19 pandemic.

The symptoms of COVID‑19 can vary but often include fever,[7] fatigue, cough, breathing difficulties, loss of smell, and loss of taste.[8][9][10] Symptoms may begin one to fourteen days after exposure to the virus. At least a third of people who are infected do not develop noticeable symptoms.[11][12] Of those who develop symptoms noticeable enough to be classified as patients, most (81%) develop mild to moderate symptoms (up to mild pneumonia), while 14% develop severe symptoms (dyspnea, hypoxia, or more than 50% lung involvement on imaging), and 5% develop critical symptoms (respiratory failure, shock, or multiorgan dysfunction).[13] Older people have a higher risk of developing severe symptoms. Some complications result in death. Some people continue to experience a range of effects (long COVID) for months or years after infection, and damage to organs has been observed.[14] Multi-year studies on the long-term effects are ongoing.[15]

COVID‑19 transmission occurs when infectious particles are breathed in or come into contact with the eyes, nose, or mouth. The risk is highest when people are in close proximity, but small airborne particles containing the virus can remain suspended in the air and travel over longer distances, particularly indoors. Transmission can also occur when people touch their eyes, nose, or mouth after touching surfaces or objects that have been contaminated by the virus. People remain contagious for up to 20 days and can spread the virus even if they do not develop symptoms.[16]

Testing methods for COVID-19 to detect the virus’s nucleic acid include real-time reverse transcription polymerase chain reaction (RT‑PCR),[17][18] transcription-mediated amplification,[17][18][19] and reverse transcription loop-mediated isothermal amplification (RT‑LAMP)[17][18] from a nasopharyngeal swab.[20]

Several COVID-19 vaccines have been approved and distributed in various countries, many of which have initiated mass vaccination campaigns. Other preventive measures include physical or social distancing, quarantining, ventilation of indoor spaces, use of face masks or coverings in public, covering coughs and sneezes, hand washing, and keeping unwashed hands away from the face. While drugs have been developed to inhibit the virus, the primary treatment is still symptomatic, managing the disease through supportive care, isolation, and experimental measures.