How to use the sizzle function in sizzle

_converse.onMAMPreferences = function (iq, feature) {
            /* Handle returned IQ stanza containing Message Archive
             * Management (XEP-0313) preferences.
             *
             * XXX: For now we only handle the global default preference.
             * The XEP also provides for per-JID preferences, which is
             * currently not supported in converse.js.
             *
             * Per JID preferences will be set in chat boxes, so it'll
             * probbaly be handled elsewhere in any case.
             */
            const preference = sizzle(`prefs[xmlns="${Strophe.NS.MAM}"]`, iq).pop();
            const default_pref = preference.getAttribute('default');
            if (default_pref !== _converse.message_archiving) {
                const stanza = $iq({'type': 'set'})
                    .c('prefs', {
                        'xmlns':Strophe.NS.MAM,
                        'default':_converse.message_archiving
                    });
                Array.from(preference.children).forEach(child => stanza.cnode(child).up());

                // XXX: Strictly speaking, the server should respond with the updated prefs
                // (see example 18: https://xmpp.org/extensions/xep-0313.html#config)
                // but Prosody doesn't do this, so we don't rely on it.
                _converse.api.sendIQ(stanza)
                    .then(() => feature.save({'preferences': {'default':_converse.message_archiving}}))
                    .catch(_converse.onMAMError);
            } else {

return tpl_form_url({
            'label': field.getAttribute('label') || '',
            'value': _.get(field.querySelector('value'), 'textContent')
        });
    } else if (field.getAttribute('var') === 'username') {
        return tpl_form_username({
            'domain': ' @'+options.domain,
            'name': field.getAttribute('var'),
            'type': XFORM_TYPE_MAP[field.getAttribute('type')],
            'label': field.getAttribute('label') || '',
            'value': _.get(field.querySelector('value'), 'textContent'),
            'required': !!field.querySelector('required')
        });
    } else if (field.getAttribute('var') === 'ocr') { // Captcha
        const uri = field.querySelector('uri');
        const el = sizzle('data[cid="'+uri.textContent.replace(/^cid:/, '')+'"]', stanza)[0];
        return tpl_form_captcha({
            'label': field.getAttribute('label'),
            'name': field.getAttribute('var'),
            'data': _.get(el, 'textContent'),
            'type': uri.getAttribute('type'),
            'required': !!field.querySelector('required')
        });
    } else {
        const name = field.getAttribute('var');
        return tpl_form_input({
            'id': u.getUniqueId(),
            'label': field.getAttribute('label') || '',
            'name': name,
            'fixed_username': options.fixed_username,
            'autocomplete': getAutoCompleteProperty(name, options),
            'placeholder': null,

onDiscoItems (stanza) {
                sizzle(`query[xmlns="${Strophe.NS.DISCO_ITEMS}"] item`, stanza).forEach(item => {
                    if (item.getAttribute("node")) {
                        // XXX: Ignore nodes for now.
                        // See: https://xmpp.org/extensions/xep-0030.html#items-nodes
                        return;
                    }
                    const jid = item.getAttribute('jid');
                    if (this.items.get(jid) === undefined) {
                        const entity = _converse.disco_entities.get(jid);
                        if (entity) {
                            this.items.add(entity);
                        } else {
                            this.items.create({'jid': jid});
                        }
                    }
                });
            },

return isImage(url).then(img => {
                        const i = new Image();
                        i.src = img.src;
                        i.addEventListener('load', resolve);
                        // We also resolve (instead of reject) for non-images,
                        // otherwise the Promise.all resolves prematurely.
                        i.addEventListener('error', resolve);
                        const { __ } = _converse;
                        sizzle(`a[href="${url}"]`, el)
                            .forEach(a => (a.outerHTML = tpl_image({url, 'label_download': __('Download')})));
                    }).catch(resolve)
                } else {

async function onDomainDiscovered (response) {
    const text = await response.text();
    const xrd = (new window.DOMParser()).parseFromString(text, "text/xml").firstElementChild;
    if (xrd.nodeName != "XRD" || xrd.namespaceURI != "http://docs.oasis-open.org/ns/xri/xrd-1.0") {
        return log.warn("Could not discover XEP-0156 connection methods");
    }
    const bosh_links = sizzle(`Link[rel="urn:xmpp:alt-connections:xbosh"]`, xrd);
    const ws_links = sizzle(`Link[rel="urn:xmpp:alt-connections:websocket"]`, xrd);
    const bosh_methods = bosh_links.map(el => el.getAttribute('href'));
    const ws_methods = ws_links.map(el => el.getAttribute('href'));
    // TODO: support multiple endpoints
    _converse.websocket_url = ws_methods.pop();
    _converse.bosh_service_url = bosh_methods.pop();
    if (bosh_methods.length === 0 && ws_methods.length === 0) {
        log.warn(
            "onDomainDiscovered: neither BOSH nor WebSocket connection methods have been specified with XEP-0156."
        );
    }
}

first(selector, node = this.dom) {
    const results = new Sizzle(selector, node);
    if (results.length === 0) return undefined;
    return results[0];
  }

getModerationAttributes (stanza, original_stanza, room) {
        const fastening = sizzle(`apply-to[xmlns="${Strophe.NS.FASTEN}"]`, stanza).pop();
        if (fastening) {
            const applies_to_id = fastening.getAttribute('id');
            const moderated = sizzle(`moderated[xmlns="${Strophe.NS.MODERATE}"]`, fastening).pop();
            if (moderated) {
                const retracted = sizzle(`retract[xmlns="${Strophe.NS.RETRACT}"]`, moderated).pop();
                if (retracted) {
                    const from = stanza.getAttribute('from');
                    if (from !== room.get('jid')) {
                        log.warn("getModerationAttributes: ignore moderation stanza that's not from the MUC!");
                        log.error(original_stanza);
                        return {};
                    }
                    return {
                        'edtiable': false,
                        'moderated': 'retracted',
                        'moderated_by': moderated.getAttribute('by'),
                        'moderated_id': applies_to_id,
                        'moderation_reason': get(moderated.querySelector('reason'), 'textContent')
                    }

log.error(original_stanza);
                        return {};
                    }
                    return {
                        'edtiable': false,
                        'moderated': 'retracted',
                        'moderated_by': moderated.getAttribute('by'),
                        'moderated_id': applies_to_id,
                        'moderation_reason': get(moderated.querySelector('reason'), 'textContent')
                    }
                }
            }
        } else {
            const tombstone = sizzle(`> moderated[xmlns="${Strophe.NS.MODERATE}"]`, stanza).pop();
            if (tombstone) {
                const retracted = sizzle(`retracted[xmlns="${Strophe.NS.RETRACT}"]`, tombstone).pop();
                if (retracted) {
                    return {
                        'edtiable': false,
                        'is_tombstone': true,
                        'moderated_by': tombstone.getAttribute('by'),
                        'retracted': tombstone.getAttribute('stamp'),
                        'moderation_reason': get(tombstone.querySelector('reason'), 'textContent')

                    }
                }
            }
        }
        return {};
    },

const iq_result = await _converse.api.sendIQ(stanza, _converse.message_archiving_timeout, false)
                    if (iq_result === null) {
                        const err_msg = "Timeout while trying to fetch archived messages.";
                        log.error(err_msg);
                        error = new _converse.TimeoutError(err_msg);
                        return { messages, error };

                    } else if (u.isErrorStanza(iq_result)) {
                        log.error("Error stanza received while trying to fetch archived messages");
                        log.error(iq_result);
                        return { messages };
                    }
                    _converse.connection.deleteHandler(message_handler);

                    let rsm;
                    const fin = iq_result && sizzle(`fin[xmlns="${Strophe.NS.MAM}"]`, iq_result).pop();
                    if (fin && [null, 'false'].includes(fin.getAttribute('complete'))) {
                        const set = sizzle(`set[xmlns="${Strophe.NS.RSM}"]`, fin).pop();
                        if (set) {
                            rsm = new _converse.RSM({'xml': set});
                            Object.assign(rsm, Object.assign(pick(options, [...MAM_ATTRIBUTES, ..._converse.RSM_ATTRIBUTES]), rsm));
                        }
                    }
                    return { messages, rsm, error };
                }
            }

getCorrectionAttributes (stanza, original_stanza) {
        const el = sizzle(`replace[xmlns="${Strophe.NS.MESSAGE_CORRECT}"]`, stanza).pop();
        if (el) {
            const replaced_id = el.getAttribute('id');
            const msgid = replaced_id;
            if (replaced_id) {
                const delay = sizzle(`delay[xmlns="${Strophe.NS.DELAY}"]`, original_stanza).pop();
                const time = delay ? dayjs(delay.getAttribute('stamp')).toISOString() : (new Date()).toISOString();
                return {
                    msgid,
                    replaced_id,
                    'edited': time
                }
            }
        }
        return {};
    },