besper-frontend-site-dev-0935
Version:
Professional B-esper Frontend Site - Site-wide integration toolkit for full website bot deployment
1,175 lines (1,140 loc) • 2.06 MB
JavaScript
// B-esper Frontend Site - Making functions globally available
if (typeof window !== 'undefined') {
// Ensure compatibility with script tag usage
window._besperSiteLoaded = true;
}
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
typeof define === 'function' && define.amd ? define(['exports'], factory) :
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.BesperSite = {}));
})(this, (function (exports) { 'use strict';
/**
* Centralized API Service for B-esper Frontend Toolkit
* Consolidates all API endpoint definitions and provides consistent API calling interface
* Uses dynamic endpoints from build-time environment variables for APIM deployment flexibility
*/
// Dynamic base URL from build-time environment (NO FALLBACKS ALLOWED)
const APIM_BASE_ENDPOINT = "https://apimdev0935internal.azure-api.net";
/**
* Get the base APIM endpoint (dynamic only, no fallbacks)
*/
function getBaseAPIEndpoint() {
// Return only the dynamic endpoint - no fallback logic allowed
return APIM_BASE_ENDPOINT;
}
// API service paths
const API_PATHS = {
// Bot operations (chat, messaging)
botOperations: '/api/bot-operations',
// Bot management (configuration, settings)
botManagement: '/api/bot-management',
// Root API for general operations
root: '/api',
// Management operations (legacy mgmt path if needed)
management: '/mgmt'
};
/**
* Get the complete API endpoint URL for a specific service
* Uses ONLY the dynamic base endpoint from build-time environment variables
* NO FALLBACKS ALLOWED - ensures consistent infrastructure naming
* @param {string} service - Service name from API_PATHS
* @returns {string} Complete API endpoint URL
*/
function getServiceEndpoint(service = 'botOperations') {
// Use ONLY the dynamic base endpoint - no fallbacks allowed
const baseUrl = getBaseAPIEndpoint();
const path = API_PATHS[service] || API_PATHS.botOperations;
// Ensure no double slashes
const endpoint = `${baseUrl}${path}`.replace(/\/+/g, '/').replace('http:/', 'http://').replace('https:/', 'https://');
// Only log in development/debug mode to reduce console noise
if (typeof window !== 'undefined' && window.location?.hostname?.includes('localhost')) {
console.log(`[API] API Endpoint for ${service}:`, endpoint);
}
return endpoint;
}
/**
* Get bot operations endpoint (for chat functionality)
* Uses dynamic endpoint from build-time configuration
* @returns {string} Bot operations API endpoint
*/
function getBotOperationsEndpoint() {
return getServiceEndpoint('botOperations');
}
/**
* Get bot management endpoint (for configuration management)
* Uses dynamic endpoint from build-time configuration
* @returns {string} Bot management API endpoint
*/
function getBotManagementEndpoint() {
return getServiceEndpoint('botManagement');
}
/**
* Get root API endpoint (for general operations)
* Uses dynamic endpoint from build-time configuration
* @returns {string} Root API endpoint
*/
function getRootApiEndpoint() {
return getServiceEndpoint('root');
}
/**
* Generic API call helper with enhanced error handling and logging
* @param {string} endpoint - Full API endpoint URL
* @param {string} method - HTTP method (GET, POST, PUT, DELETE)
* @param {Object} body - Request body for POST/PUT requests
* @param {Object} headers - Additional headers
* @returns {Promise<Object>} API response data
*/
async function apiCall(endpoint, method = 'GET', body = null, headers = {}) {
const config = {
method,
headers: {
'Content-Type': 'application/json',
Accept: 'application/json',
'X-Requested-With': 'XMLHttpRequest',
'Cache-Control': 'no-cache',
Pragma: 'no-cache',
...headers
}
};
if (body && method !== 'GET') {
config.body = JSON.stringify(body);
}
// Debug logging (reduced in production)
const isDebugMode = typeof window !== 'undefined' && (window.location?.hostname?.includes('localhost') || window.location?.search?.includes('debug=true'));
if (isDebugMode) {
console.log(`[API] Making ${method} request to:`, endpoint);
if (body) {
console.log(`📦 Request payload:`, body);
}
}
try {
const response = await fetch(endpoint, config);
if (isDebugMode) {
console.log(`📡 Response status: ${response.status} ${response.statusText}`);
}
if (!response.ok) {
let errorMessage = `HTTP ${response.status}: ${response.statusText}`;
// Try to get error details from response body
try {
const errorData = await response.text();
if (errorData) {
if (isDebugMode) {
console.log(`[ERROR] Error response body:`, errorData);
}
errorMessage += ` - ${errorData}`;
}
} catch (parseError) {
if (isDebugMode) {
console.log(`[ERROR] Could not parse error response:`, parseError);
}
}
throw new Error(errorMessage);
}
const data = await response.json();
if (isDebugMode) {
console.log(`[SUCCESS] Response data:`, data);
}
return data;
} catch (error) {
// Always log errors for debugging, but make them less verbose in production
if (isDebugMode) {
console.error(`[ERROR] API call failed:`, error);
} else {
console.error(`[ERROR] API call failed: ${error.message}`);
}
throw error;
}
}
/**
* Make a bot management API call
* @param {string} path - API path (e.g., 'get_config_json', 'config')
* @param {string} method - HTTP method
* @param {Object} body - Request body
* @param {Object} headers - Additional headers
* @returns {Promise<Object>} API response
*/
async function managementApiCall(path, method = 'GET', body = null, headers = {}) {
const baseEndpoint = getBotManagementEndpoint();
const fullEndpoint = `${baseEndpoint}/${path}`.replace(/\/+/g, '/').replace('http:/', 'http://').replace('https:/', 'https://');
return apiCall(fullEndpoint, method, body, headers);
}
/**
* Make a bot operations API call
* @param {string} path - API path (e.g., 'create_session', 'generate_response')
* @param {string} method - HTTP method
* @param {Object} body - Request body
* @param {Object} headers - Additional headers
* @returns {Promise<Object>} API response
*/
async function operationsApiCall(path, method = 'GET', body = null, headers = {}) {
const baseEndpoint = getBotOperationsEndpoint();
const fullEndpoint = `${baseEndpoint}/${path}`.replace(/\/+/g, '/').replace('http:/', 'http://').replace('https:/', 'https://');
return apiCall(fullEndpoint, method, body, headers);
}
// Internationalization for chat widget - European languages and major languages
const translations = {
// Input placeholder text
typeYourMessage: {
en: 'Type your message here...',
de: 'Geben Sie hier Ihre Nachricht ein...',
fr: 'Tapez votre message ici...',
es: 'Escribe tu mensaje aquí...',
it: 'Digita il tuo messaggio qui...',
pt: 'Digite sua mensagem aqui...',
nl: 'Typ hier uw bericht...',
pl: 'Wpisz tutaj swoją wiadomość...',
sv: 'Skriv ditt meddelande här...',
da: 'Skriv din besked her...',
fi: 'Kirjoita viestisi tähän...',
no: 'Skriv meldingen din her...',
cs: 'Zde napište svou zprávu...',
hu: 'Írja ide üzenetét...',
ro: 'Introduceți mesajul aici...',
sk: 'Sem napíšte svoju správu...',
hr: 'Ovdje unesite poruku...',
bg: 'Въведете съобщението си тук...',
sl: 'Tukaj vnesite svoje sporočilo...',
et: 'Sisestage oma sõnum siia...',
lv: 'Ievadiet savu ziņu šeit...',
lt: 'Čia įveskite savo žinutę...',
el: 'Πληκτρολογήστε το μήνυμά σας εδώ...',
ru: 'Введите ваше сообщение здесь...',
uk: 'Введіть ваше повідомлення тут...',
// Major Asian and world languages
ja: 'ここにメッセージを入力してください...',
zh: '在此输入您的消息...',
ko: '여기에 메시지를 입력하세요...',
ar: 'اكتب رسالتك هنا...',
hi: 'अपना संदेश यहाँ टाइप करें...',
id: 'Ketik pesan Anda di sini...',
tr: 'Mesajınızı buraya yazın...',
th: 'พิมพ์ข้อความของคุณที่นี่...',
vi: 'Nhập tin nhắn của bạn tại đây...',
he: 'הקלד את ההודעה שלך כאן...',
fa: 'پیام خود را اینجا تایپ کنید...',
ms: 'Taip mesej anda di sini...',
tl: 'I-type ang inyong mensahe dito...'
},
// Tooltip texts
tooltips: {
downloadConversation: {
en: 'Download Conversation',
de: 'Unterhaltung herunterladen',
fr: 'Télécharger la conversation',
es: 'Descargar conversación',
it: 'Scarica conversazione',
pt: 'Baixar conversa',
nl: 'Gesprek downloaden',
pl: 'Pobierz rozmowę',
sv: 'Ladda ner konversation',
da: 'Download samtale',
fi: 'Lataa keskustelu',
no: 'Last ned samtale',
cs: 'Stáhnout konverzaci',
hu: 'Beszélgetés letöltése',
ro: 'Descarcă conversația',
sk: 'Stiahnuť konverzáciu',
hr: 'Preuzmi razgovor',
bg: 'Изтегли разговор',
sl: 'Prenesi pogovor',
et: 'Laadi alla vestlus',
lv: 'Lejupielādēt sarunu',
lt: 'Atsisiųsti pokalbį',
el: 'Λήψη συνομιλίας',
ru: 'Скачать беседу',
uk: 'Завантажити розмову',
// Major Asian and world languages
ja: '会話をダウンロード',
zh: '下载对话',
ko: '대화 다운로드',
ar: 'تحميل المحادثة',
hi: 'बातचीत डाउनलोड करें',
id: 'Unduh Percakapan',
tr: 'Konuşmayı İndir',
th: 'ดาวน์โหลดการสนทนา',
vi: 'Tải cuộc trò chuyện',
he: 'הורד שיחה',
fa: 'دانلود مکالمه',
ms: 'Muat turun Perbualan',
tl: 'I-download ang Pag-uusap'
},
restartConversation: {
en: 'Restart Conversation',
de: 'Unterhaltung neu starten',
fr: 'Redémarrer la conversation',
es: 'Reiniciar conversación',
it: 'Riavvia conversazione',
pt: 'Reiniciar conversa',
nl: 'Gesprek herstarten',
pl: 'Uruchom ponownie rozmowę',
sv: 'Starta om konversation',
da: 'Genstart samtale',
fi: 'Aloita keskustelu uudelleen',
no: 'Start samtale på nytt',
cs: 'Restartovat konverzaci',
hu: 'Beszélgetés újraindítása',
ro: 'Repornește conversația',
sk: 'Reštartovať konverzáciu',
hr: 'Ponovno pokreni razgovor',
bg: 'Рестартирай разговор',
sl: 'Ponovno zaženi pogovor',
et: 'Taaskäivita vestlus',
lv: 'Atsākt sarunu',
lt: 'Paleisti pokalbį iš naujo',
el: 'Επανεκκίνηση συνομιλίας',
ru: 'Перезапустить беседу',
uk: 'Перезапустити розмову',
// Major Asian and world languages
ja: '会話を再開',
zh: '重新开始对话',
ko: '대화 재시작',
ar: 'إعادة تشغيل المحادثة',
hi: 'बातचीत पुनः आरंभ करें',
id: 'Mulai Ulang Percakapan',
tr: 'Konuşmayı Yeniden Başlat',
th: 'เริ่มการสนทนาใหม่',
vi: 'Khởi động lại cuộc trò chuyện',
he: 'הפעל מחדש שיחה',
fa: 'راه اندازی مجدد مکالمه',
ms: 'Mulakan semula Perbualan',
tl: 'Simulan muli ang Pag-uusap'
},
deleteConversation: {
en: 'Delete Conversation',
de: 'Unterhaltung löschen',
fr: 'Supprimer la conversation',
es: 'Eliminar conversación',
it: 'Elimina conversazione',
pt: 'Excluir conversa',
nl: 'Gesprek verwijderen',
pl: 'Usuń rozmowę',
sv: 'Radera konversation',
da: 'Slet samtale',
fi: 'Poista keskustelu',
no: 'Slett samtale',
cs: 'Smazat konverzaci',
hu: 'Beszélgetés törlése',
ro: 'Șterge conversația',
sk: 'Vymazať konverzáciu',
hr: 'Obriši razgovor',
bg: 'Изтрий разговор',
sl: 'Izbriši pogovor',
et: 'Kustuta vestlus',
lv: 'Dzēst sarunu',
lt: 'Ištrinti pokalbį',
el: 'Διαγραφή συνομιλίας',
ru: 'Удалить беседу',
uk: 'Видалити розмову',
// Major Asian and world languages
ja: '会話を削除',
zh: '删除对话',
ko: '대화 삭제',
ar: 'حذف المحادثة',
hi: 'बातचीत हटाएं',
id: 'Hapus Percakapan',
tr: 'Konuşmayı Sil',
th: 'ลบการสนทนา',
vi: 'Xóa cuộc trò chuyện',
he: 'מחק שיחה',
fa: 'حذف مکالمه',
ms: 'Padam Perbualan',
tl: 'Tanggalin ang Pag-uusap'
},
expandView: {
en: 'Optimize view for better readability',
de: 'Ansicht für bessere Lesbarkeit optimieren',
fr: 'Optimiser la vue pour une meilleure lisibilité',
es: 'Optimizar vista para mejor legibilidad',
it: 'Ottimizza vista per migliore leggibilità',
pt: 'Otimizar visualização para melhor legibilidade',
nl: 'Optimaliseer weergave voor betere leesbaarheid',
pl: 'Zoptymalizuj widok dla lepszej czytelności',
sv: 'Optimera vy för bättre läsbarhet',
da: 'Optimer visning for bedre læsbarhed',
fi: 'Optimoi näkymä parempaa luettavuutta varten',
no: 'Optimaliser visning for bedre lesbarhet',
cs: 'Optimalizovat zobrazení pro lepší čitelnost',
hu: 'Nézet optimalizálása a jobb olvashatóságért',
ro: 'Optimizează vizualizarea pentru o mai bună lizibilitate',
sk: 'Optimalizovať zobrazenie pre lepšiu čitateľnosť',
hr: 'Optimiziraj prikaz za bolju čitljivost',
bg: 'Оптимизирай изгледа за по-добра четимост',
sl: 'Optimiziraj pogled za boljšo berljivost',
et: 'Optimeeri vaade parema loetavuse jaoks',
lv: 'Optimizēt skatu labākai lasāmībai',
lt: 'Optimizuoti vaizdą geresniam skaitomumui',
el: 'Βελτιστοποίηση προβολής για καλύτερη αναγνωσιμότητα',
ru: 'Оптимизировать вид для лучшей читаемости',
uk: 'Оптимізувати вигляд для кращої читабельності',
// Major Asian and world languages
ja: '読みやすさのためにビューを最適化',
zh: '优化视图以提高可读性',
ko: '가독성을 위한 보기 최적화',
ar: 'تحسين العرض لقابلية قراءة أفضل',
hi: 'बेहतर पठनीयता के लिए दृश्य को अनुकूलित करें',
id: 'Optimalkan tampilan untuk keterbacaan yang lebih baik',
tr: 'Daha iyi okunabilirlik için görünümü optimize edin',
th: 'ปรับแต่งมุมมองเพื่อการอ่านที่ดีขึ้น',
vi: 'Tối ưu hóa chế độ xem để dễ đọc hơn',
he: 'אופטימיזציה של התצוגה לקריאה טובה יותר',
fa: 'بهینه سازی نمایش برای خوانایی بهتر',
ms: 'Optimalkan paparan untuk kebolehbacaan yang lebih baik',
tl: 'I-optimize ang view para sa mas magandang pagkakabasa'
},
minimizeChat: {
en: 'Minimize',
de: 'Minimieren',
fr: 'Réduire',
es: 'Minimizar',
it: 'Riduci',
pt: 'Minimizar',
nl: 'Minimaliseren',
pl: 'Minimalizuj',
sv: 'Minimera',
da: 'Minimer',
fi: 'Pienennä',
no: 'Minimer',
cs: 'Minimalizovat',
hu: 'Minimalizálás',
ro: 'Minimizează',
sk: 'Minimalizovať',
hr: 'Minimiziraj',
bg: 'Минимизирай',
sl: 'Minimiziraj',
et: 'Minimeeri',
lv: 'Minimizēt',
lt: 'Sumažinti',
el: 'Ελαχιστοποίηση',
ru: 'Свернуть',
uk: 'Згорнути',
// Major Asian and world languages
ja: '最小化',
zh: '最小化',
ko: '최소화',
ar: 'تصغير',
hi: 'न्यूनतम करें',
id: 'Kecilkan',
tr: 'Küçült',
th: 'ย่อขนาด',
vi: 'Thu nhỏ',
he: 'מזער',
fa: 'کمینه کردن',
ms: 'Kecilkan',
tl: 'Paliitin'
},
dataPolicy: {
en: 'Data Policy',
de: 'Datenschutzrichtlinie',
fr: 'Politique de données',
es: 'Política de datos',
it: 'Politica sui dati',
pt: 'Política de dados',
nl: 'Gegevensbeleid',
pl: 'Polityka danych',
sv: 'Datapolicy',
da: 'Datapolitik',
fi: 'Tietopolitiikka',
no: 'Datapolicy',
cs: 'Zásady dat',
hu: 'Adatkezelési irányelvek',
ro: 'Politica datelor',
sk: 'Zásady údajov',
hr: 'Politika podataka',
bg: 'Политика за данни',
sl: 'Politika podatkov',
et: 'Andmepoliitika',
lv: 'Datu politika',
lt: 'Duomenų politika',
el: 'Πολιτική δεδομένων',
ru: 'Политика данных',
uk: 'Політика даних',
// Major Asian and world languages
ja: 'データポリシー',
zh: '数据政策',
ko: '데이터 정책',
ar: 'سياسة البيانات',
hi: 'डेटा नीति',
id: 'Kebijakan Data',
tr: 'Veri Politikası',
th: 'นโยบายข้อมูล',
vi: 'Chính sách dữ liệu',
he: 'מדיניות נתונים',
fa: 'سیاست داده',
ms: 'Dasar Data',
tl: 'Patakaran sa Data'
}
},
// Status messages
statusMessages: {
connecting: {
en: 'Connecting...',
de: 'Verbindet...',
fr: 'Connexion...',
es: 'Conectando...',
it: 'Connessione...',
pt: 'Conectando...',
nl: 'Verbinden...',
pl: 'Łączenie...',
sv: 'Ansluter...',
da: 'Forbinder...',
fi: 'Yhdistetään...',
no: 'Kobler til...',
cs: 'Připojování...',
hu: 'Csatlakozás...',
ro: 'Se conectează...',
sk: 'Pripájanie...',
hr: 'Povezivanje...',
bg: 'Свързване...',
sl: 'Povezovanje...',
et: 'Ühendamine...',
lv: 'Savienojas...',
lt: 'Jungiamasi...',
el: 'Σύνδεση...',
ru: 'Подключение...',
uk: 'Підключення...',
// Major Asian and world languages
ja: '接続中...',
zh: '正在连接...',
ko: '연결 중...',
ar: 'جاري الاتصال...',
hi: 'कनेक्ट हो रहा है...',
id: 'Menghubungkan...',
tr: 'Bağlanıyor...',
th: 'กำลังเชื่อมต่อ...',
vi: 'Đang kết nối...',
he: 'מתחבר...',
fa: 'در حال اتصال...',
ms: 'Menyambung...',
tl: 'Kumukonekta...'
},
typing: {
en: 'Typing...',
de: 'Schreibt...',
fr: 'Saisie...',
es: 'Escribiendo...',
it: 'Scrivendo...',
pt: 'Digitando...',
nl: 'Typen...',
pl: 'Pisze...',
sv: 'Skriver...',
da: 'Skriver...',
fi: 'Kirjoittaa...',
no: 'Skriver...',
cs: 'Píše...',
hu: 'Gépel...',
ro: 'Scrie...',
sk: 'Píše...',
hr: 'Piše...',
bg: 'Пише...',
sl: 'Piše...',
et: 'Kirjutab...',
lv: 'Raksta...',
lt: 'Rašo...',
el: 'Πληκτρολογεί...',
ru: 'Печатает...',
uk: 'Друкує...',
// Major Asian and world languages
ja: '入力中...',
zh: '正在输入...',
ko: '입력 중...',
ar: 'يكتب...',
hi: 'टाइप कर रहा है...',
id: 'Mengetik...',
tr: 'Yazıyor...',
th: 'กำลังพิมพ์...',
vi: 'Đang gõ...',
he: 'מקליד...',
fa: 'در حال تایپ...',
ms: 'Menaip...',
tl: 'Nagta-type...'
}
}
};
/**
* Get browser language with enhanced fallback for mobile and PC compatibility
*/
function getBrowserLanguage() {
let lang = 'en'; // Default fallback
try {
// Try multiple browser language detection methods for better mobile compatibility
if (typeof navigator !== 'undefined') {
// Primary: navigator.language (most reliable)
lang = navigator.language;
// Fallback 1: navigator.languages array (modern browsers)
if (!lang && navigator.languages && navigator.languages.length > 0) {
lang = navigator.languages[0];
}
// Fallback 2: navigator.userLanguage (IE/older browsers)
if (!lang && navigator.userLanguage) {
lang = navigator.userLanguage;
}
// Fallback 3: navigator.browserLanguage (IE/older browsers)
if (!lang && navigator.browserLanguage) {
lang = navigator.browserLanguage;
}
// Fallback 4: navigator.systemLanguage (IE/older browsers)
if (!lang && navigator.systemLanguage) {
lang = navigator.systemLanguage;
}
}
// Ensure we have a valid string
if (!lang || typeof lang !== 'string') {
lang = 'en';
}
// Extract main language code (e.g., 'en-US' becomes 'en')
lang = lang.split('-')[0].toLowerCase();
// Validate the language code (basic check for 2-3 character codes)
if (!/^[a-z]{2,3}$/.test(lang)) {
lang = 'en';
}
} catch (error) {
// If any error occurs, fallback to English
console.warn('Language detection failed:', error);
lang = 'en';
}
return lang;
}
/**
* Get localized text with fallback to English
*/
function getLocalizedText(category, key, language = null) {
const lang = language || getBrowserLanguage();
if (translations[category] && translations[category][key]) {
return translations[category][key][lang] || translations[category][key]['en'] || key;
}
return key;
}
/**
* Get all translations for a category in current language
*/
function getLocalizedCategory(category, language = null) {
const lang = language || getBrowserLanguage();
if (!translations[category]) return {};
const result = {};
for (const key in translations[category]) {
result[key] = translations[category][key][lang] || translations[category][key]['en'] || key;
}
return result;
}
/**
* Get direct translation for a top-level key
*/
function getTranslation(key, language = null) {
const lang = language || getBrowserLanguage();
if (translations[key]) {
return translations[key][lang] || translations[key]['en'];
}
return key;
}
/*! @license DOMPurify 3.2.6 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/3.2.6/LICENSE */
const {
entries,
setPrototypeOf,
isFrozen,
getPrototypeOf,
getOwnPropertyDescriptor
} = Object;
let {
freeze,
seal,
create
} = Object; // eslint-disable-line import/no-mutable-exports
let {
apply,
construct
} = typeof Reflect !== 'undefined' && Reflect;
if (!freeze) {
freeze = function freeze(x) {
return x;
};
}
if (!seal) {
seal = function seal(x) {
return x;
};
}
if (!apply) {
apply = function apply(fun, thisValue, args) {
return fun.apply(thisValue, args);
};
}
if (!construct) {
construct = function construct(Func, args) {
return new Func(...args);
};
}
const arrayForEach = unapply(Array.prototype.forEach);
const arrayLastIndexOf = unapply(Array.prototype.lastIndexOf);
const arrayPop = unapply(Array.prototype.pop);
const arrayPush = unapply(Array.prototype.push);
const arraySplice = unapply(Array.prototype.splice);
const stringToLowerCase = unapply(String.prototype.toLowerCase);
const stringToString = unapply(String.prototype.toString);
const stringMatch = unapply(String.prototype.match);
const stringReplace = unapply(String.prototype.replace);
const stringIndexOf = unapply(String.prototype.indexOf);
const stringTrim = unapply(String.prototype.trim);
const objectHasOwnProperty = unapply(Object.prototype.hasOwnProperty);
const regExpTest = unapply(RegExp.prototype.test);
const typeErrorCreate = unconstruct(TypeError);
/**
* Creates a new function that calls the given function with a specified thisArg and arguments.
*
* @param func - The function to be wrapped and called.
* @returns A new function that calls the given function with a specified thisArg and arguments.
*/
function unapply(func) {
return function (thisArg) {
if (thisArg instanceof RegExp) {
thisArg.lastIndex = 0;
}
for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
args[_key - 1] = arguments[_key];
}
return apply(func, thisArg, args);
};
}
/**
* Creates a new function that constructs an instance of the given constructor function with the provided arguments.
*
* @param func - The constructor function to be wrapped and called.
* @returns A new function that constructs an instance of the given constructor function with the provided arguments.
*/
function unconstruct(func) {
return function () {
for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
args[_key2] = arguments[_key2];
}
return construct(func, args);
};
}
/**
* Add properties to a lookup table
*
* @param set - The set to which elements will be added.
* @param array - The array containing elements to be added to the set.
* @param transformCaseFunc - An optional function to transform the case of each element before adding to the set.
* @returns The modified set with added elements.
*/
function addToSet(set, array) {
let transformCaseFunc = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : stringToLowerCase;
if (setPrototypeOf) {
// Make 'in' and truthy checks like Boolean(set.constructor)
// independent of any properties defined on Object.prototype.
// Prevent prototype setters from intercepting set as a this value.
setPrototypeOf(set, null);
}
let l = array.length;
while (l--) {
let element = array[l];
if (typeof element === 'string') {
const lcElement = transformCaseFunc(element);
if (lcElement !== element) {
// Config presets (e.g. tags.js, attrs.js) are immutable.
if (!isFrozen(array)) {
array[l] = lcElement;
}
element = lcElement;
}
}
set[element] = true;
}
return set;
}
/**
* Clean up an array to harden against CSPP
*
* @param array - The array to be cleaned.
* @returns The cleaned version of the array
*/
function cleanArray(array) {
for (let index = 0; index < array.length; index++) {
const isPropertyExist = objectHasOwnProperty(array, index);
if (!isPropertyExist) {
array[index] = null;
}
}
return array;
}
/**
* Shallow clone an object
*
* @param object - The object to be cloned.
* @returns A new object that copies the original.
*/
function clone(object) {
const newObject = create(null);
for (const [property, value] of entries(object)) {
const isPropertyExist = objectHasOwnProperty(object, property);
if (isPropertyExist) {
if (Array.isArray(value)) {
newObject[property] = cleanArray(value);
} else if (value && typeof value === 'object' && value.constructor === Object) {
newObject[property] = clone(value);
} else {
newObject[property] = value;
}
}
}
return newObject;
}
/**
* This method automatically checks if the prop is function or getter and behaves accordingly.
*
* @param object - The object to look up the getter function in its prototype chain.
* @param prop - The property name for which to find the getter function.
* @returns The getter function found in the prototype chain or a fallback function.
*/
function lookupGetter(object, prop) {
while (object !== null) {
const desc = getOwnPropertyDescriptor(object, prop);
if (desc) {
if (desc.get) {
return unapply(desc.get);
}
if (typeof desc.value === 'function') {
return unapply(desc.value);
}
}
object = getPrototypeOf(object);
}
function fallbackValue() {
return null;
}
return fallbackValue;
}
const html$1 = freeze(['a', 'abbr', 'acronym', 'address', 'area', 'article', 'aside', 'audio', 'b', 'bdi', 'bdo', 'big', 'blink', 'blockquote', 'body', 'br', 'button', 'canvas', 'caption', 'center', 'cite', 'code', 'col', 'colgroup', 'content', 'data', 'datalist', 'dd', 'decorator', 'del', 'details', 'dfn', 'dialog', 'dir', 'div', 'dl', 'dt', 'element', 'em', 'fieldset', 'figcaption', 'figure', 'font', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hgroup', 'hr', 'html', 'i', 'img', 'input', 'ins', 'kbd', 'label', 'legend', 'li', 'main', 'map', 'mark', 'marquee', 'menu', 'menuitem', 'meter', 'nav', 'nobr', 'ol', 'optgroup', 'option', 'output', 'p', 'picture', 'pre', 'progress', 'q', 'rp', 'rt', 'ruby', 's', 'samp', 'section', 'select', 'shadow', 'small', 'source', 'spacer', 'span', 'strike', 'strong', 'style', 'sub', 'summary', 'sup', 'table', 'tbody', 'td', 'template', 'textarea', 'tfoot', 'th', 'thead', 'time', 'tr', 'track', 'tt', 'u', 'ul', 'var', 'video', 'wbr']);
const svg$1 = freeze(['svg', 'a', 'altglyph', 'altglyphdef', 'altglyphitem', 'animatecolor', 'animatemotion', 'animatetransform', 'circle', 'clippath', 'defs', 'desc', 'ellipse', 'filter', 'font', 'g', 'glyph', 'glyphref', 'hkern', 'image', 'line', 'lineargradient', 'marker', 'mask', 'metadata', 'mpath', 'path', 'pattern', 'polygon', 'polyline', 'radialgradient', 'rect', 'stop', 'style', 'switch', 'symbol', 'text', 'textpath', 'title', 'tref', 'tspan', 'view', 'vkern']);
const svgFilters = freeze(['feBlend', 'feColorMatrix', 'feComponentTransfer', 'feComposite', 'feConvolveMatrix', 'feDiffuseLighting', 'feDisplacementMap', 'feDistantLight', 'feDropShadow', 'feFlood', 'feFuncA', 'feFuncB', 'feFuncG', 'feFuncR', 'feGaussianBlur', 'feImage', 'feMerge', 'feMergeNode', 'feMorphology', 'feOffset', 'fePointLight', 'feSpecularLighting', 'feSpotLight', 'feTile', 'feTurbulence']);
// List of SVG elements that are disallowed by default.
// We still need to know them so that we can do namespace
// checks properly in case one wants to add them to
// allow-list.
const svgDisallowed = freeze(['animate', 'color-profile', 'cursor', 'discard', 'font-face', 'font-face-format', 'font-face-name', 'font-face-src', 'font-face-uri', 'foreignobject', 'hatch', 'hatchpath', 'mesh', 'meshgradient', 'meshpatch', 'meshrow', 'missing-glyph', 'script', 'set', 'solidcolor', 'unknown', 'use']);
const mathMl$1 = freeze(['math', 'menclose', 'merror', 'mfenced', 'mfrac', 'mglyph', 'mi', 'mlabeledtr', 'mmultiscripts', 'mn', 'mo', 'mover', 'mpadded', 'mphantom', 'mroot', 'mrow', 'ms', 'mspace', 'msqrt', 'mstyle', 'msub', 'msup', 'msubsup', 'mtable', 'mtd', 'mtext', 'mtr', 'munder', 'munderover', 'mprescripts']);
// Similarly to SVG, we want to know all MathML elements,
// even those that we disallow by default.
const mathMlDisallowed = freeze(['maction', 'maligngroup', 'malignmark', 'mlongdiv', 'mscarries', 'mscarry', 'msgroup', 'mstack', 'msline', 'msrow', 'semantics', 'annotation', 'annotation-xml', 'mprescripts', 'none']);
const text = freeze(['#text']);
const html = freeze(['accept', 'action', 'align', 'alt', 'autocapitalize', 'autocomplete', 'autopictureinpicture', 'autoplay', 'background', 'bgcolor', 'border', 'capture', 'cellpadding', 'cellspacing', 'checked', 'cite', 'class', 'clear', 'color', 'cols', 'colspan', 'controls', 'controlslist', 'coords', 'crossorigin', 'datetime', 'decoding', 'default', 'dir', 'disabled', 'disablepictureinpicture', 'disableremoteplayback', 'download', 'draggable', 'enctype', 'enterkeyhint', 'face', 'for', 'headers', 'height', 'hidden', 'high', 'href', 'hreflang', 'id', 'inputmode', 'integrity', 'ismap', 'kind', 'label', 'lang', 'list', 'loading', 'loop', 'low', 'max', 'maxlength', 'media', 'method', 'min', 'minlength', 'multiple', 'muted', 'name', 'nonce', 'noshade', 'novalidate', 'nowrap', 'open', 'optimum', 'pattern', 'placeholder', 'playsinline', 'popover', 'popovertarget', 'popovertargetaction', 'poster', 'preload', 'pubdate', 'radiogroup', 'readonly', 'rel', 'required', 'rev', 'reversed', 'role', 'rows', 'rowspan', 'spellcheck', 'scope', 'selected', 'shape', 'size', 'sizes', 'span', 'srclang', 'start', 'src', 'srcset', 'step', 'style', 'summary', 'tabindex', 'title', 'translate', 'type', 'usemap', 'valign', 'value', 'width', 'wrap', 'xmlns', 'slot']);
const svg = freeze(['accent-height', 'accumulate', 'additive', 'alignment-baseline', 'amplitude', 'ascent', 'attributename', 'attributetype', 'azimuth', 'basefrequency', 'baseline-shift', 'begin', 'bias', 'by', 'class', 'clip', 'clippathunits', 'clip-path', 'clip-rule', 'color', 'color-interpolation', 'color-interpolation-filters', 'color-profile', 'color-rendering', 'cx', 'cy', 'd', 'dx', 'dy', 'diffuseconstant', 'direction', 'display', 'divisor', 'dur', 'edgemode', 'elevation', 'end', 'exponent', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'filterunits', 'flood-color', 'flood-opacity', 'font-family', 'font-size', 'font-size-adjust', 'font-stretch', 'font-style', 'font-variant', 'font-weight', 'fx', 'fy', 'g1', 'g2', 'glyph-name', 'glyphref', 'gradientunits', 'gradienttransform', 'height', 'href', 'id', 'image-rendering', 'in', 'in2', 'intercept', 'k', 'k1', 'k2', 'k3', 'k4', 'kerning', 'keypoints', 'keysplines', 'keytimes', 'lang', 'lengthadjust', 'letter-spacing', 'kernelmatrix', 'kernelunitlength', 'lighting-color', 'local', 'marker-end', 'marker-mid', 'marker-start', 'markerheight', 'markerunits', 'markerwidth', 'maskcontentunits', 'maskunits', 'max', 'mask', 'media', 'method', 'mode', 'min', 'name', 'numoctaves', 'offset', 'operator', 'opacity', 'order', 'orient', 'orientation', 'origin', 'overflow', 'paint-order', 'path', 'pathlength', 'patterncontentunits', 'patterntransform', 'patternunits', 'points', 'preservealpha', 'preserveaspectratio', 'primitiveunits', 'r', 'rx', 'ry', 'radius', 'refx', 'refy', 'repeatcount', 'repeatdur', 'restart', 'result', 'rotate', 'scale', 'seed', 'shape-rendering', 'slope', 'specularconstant', 'specularexponent', 'spreadmethod', 'startoffset', 'stddeviation', 'stitchtiles', 'stop-color', 'stop-opacity', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke', 'stroke-width', 'style', 'surfacescale', 'systemlanguage', 'tabindex', 'tablevalues', 'targetx', 'targety', 'transform', 'transform-origin', 'text-anchor', 'text-decoration', 'text-rendering', 'textlength', 'type', 'u1', 'u2', 'unicode', 'values', 'viewbox', 'visibility', 'version', 'vert-adv-y', 'vert-origin-x', 'vert-origin-y', 'width', 'word-spacing', 'wrap', 'writing-mode', 'xchannelselector', 'ychannelselector', 'x', 'x1', 'x2', 'xmlns', 'y', 'y1', 'y2', 'z', 'zoomandpan']);
const mathMl = freeze(['accent', 'accentunder', 'align', 'bevelled', 'close', 'columnsalign', 'columnlines', 'columnspan', 'denomalign', 'depth', 'dir', 'display', 'displaystyle', 'encoding', 'fence', 'frame', 'height', 'href', 'id', 'largeop', 'length', 'linethickness', 'lspace', 'lquote', 'mathbackground', 'mathcolor', 'mathsize', 'mathvariant', 'maxsize', 'minsize', 'movablelimits', 'notation', 'numalign', 'open', 'rowalign', 'rowlines', 'rowspacing', 'rowspan', 'rspace', 'rquote', 'scriptlevel', 'scriptminsize', 'scriptsizemultiplier', 'selection', 'separator', 'separators', 'stretchy', 'subscriptshift', 'supscriptshift', 'symmetric', 'voffset', 'width', 'xmlns']);
const xml = freeze(['xlink:href', 'xml:id', 'xlink:title', 'xml:space', 'xmlns:xlink']);
// eslint-disable-next-line unicorn/better-regex
const MUSTACHE_EXPR = seal(/\{\{[\w\W]*|[\w\W]*\}\}/gm); // Specify template detection regex for SAFE_FOR_TEMPLATES mode
const ERB_EXPR = seal(/<%[\w\W]*|[\w\W]*%>/gm);
const TMPLIT_EXPR = seal(/\$\{[\w\W]*/gm); // eslint-disable-line unicorn/better-regex
const DATA_ATTR = seal(/^data-[\-\w.\u00B7-\uFFFF]+$/); // eslint-disable-line no-useless-escape
const ARIA_ATTR = seal(/^aria-[\-\w]+$/); // eslint-disable-line no-useless-escape
const IS_ALLOWED_URI = seal(/^(?:(?:(?:f|ht)tps?|mailto|tel|callto|sms|cid|xmpp|matrix):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i // eslint-disable-line no-useless-escape
);
const IS_SCRIPT_OR_DATA = seal(/^(?:\w+script|data):/i);
const ATTR_WHITESPACE = seal(/[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u205F\u3000]/g // eslint-disable-line no-control-regex
);
const DOCTYPE_NAME = seal(/^html$/i);
const CUSTOM_ELEMENT = seal(/^[a-z][.\w]*(-[.\w]+)+$/i);
var EXPRESSIONS = /*#__PURE__*/Object.freeze({
__proto__: null,
ARIA_ATTR: ARIA_ATTR,
ATTR_WHITESPACE: ATTR_WHITESPACE,
CUSTOM_ELEMENT: CUSTOM_ELEMENT,
DATA_ATTR: DATA_ATTR,
DOCTYPE_NAME: DOCTYPE_NAME,
ERB_EXPR: ERB_EXPR,
IS_ALLOWED_URI: IS_ALLOWED_URI,
IS_SCRIPT_OR_DATA: IS_SCRIPT_OR_DATA,
MUSTACHE_EXPR: MUSTACHE_EXPR,
TMPLIT_EXPR: TMPLIT_EXPR
});
/* eslint-disable @typescript-eslint/indent */
// https://developer.mozilla.org/en-US/docs/Web/API/Node/nodeType
const NODE_TYPE = {
element: 1,
text: 3,
// Deprecated
progressingInstruction: 7,
comment: 8,
document: 9};
const getGlobal = function getGlobal() {
return typeof window === 'undefined' ? null : window;
};
/**
* Creates a no-op policy for internal use only.
* Don't export this function outside this module!
* @param trustedTypes The policy factory.
* @param purifyHostElement The Script element used to load DOMPurify (to determine policy name suffix).
* @return The policy created (or null, if Trusted Types
* are not supported or creating the policy failed).
*/
const _createTrustedTypesPolicy = function _createTrustedTypesPolicy(trustedTypes, purifyHostElement) {
if (typeof trustedTypes !== 'object' || typeof trustedTypes.createPolicy !== 'function') {
return null;
}
// Allow the callers to control the unique policy name
// by adding a data-tt-policy-suffix to the script element with the DOMPurify.
// Policy creation with duplicate names throws in Trusted Types.
let suffix = null;
const ATTR_NAME = 'data-tt-policy-suffix';
if (purifyHostElement && purifyHostElement.hasAttribute(ATTR_NAME)) {
suffix = purifyHostElement.getAttribute(ATTR_NAME);
}
const policyName = 'dompurify' + (suffix ? '#' + suffix : '');
try {
return trustedTypes.createPolicy(policyName, {
createHTML(html) {
return html;
},
createScriptURL(scriptUrl) {
return scriptUrl;
}
});
} catch (_) {
// Policy creation failed (most likely another DOMPurify script has
// already run). Skip creating the policy, as this will only cause errors
// if TT are enforced.
console.warn('TrustedTypes policy ' + policyName + ' could not be created.');
return null;
}
};
const _createHooksMap = function _createHooksMap() {
return {
afterSanitizeAttributes: [],
afterSanitizeElements: [],
afterSanitizeShadowDOM: [],
beforeSanitizeAttributes: [],
beforeSanitizeElements: [],
beforeSanitizeShadowDOM: [],
uponSanitizeAttribute: [],
uponSanitizeElement: [],
uponSanitizeShadowNode: []
};
};
function createDOMPurify() {
let window = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : getGlobal();
const DOMPurify = root => createDOMPurify(root);
DOMPurify.version = '3.2.6';
DOMPurify.removed = [];
if (!window || !window.document || window.document.nodeType !== NODE_TYPE.document || !window.Element) {
// Not running in a browser, provide a factory function
// so that you can pass your own Window
DOMPurify.isSupported = false;
return DOMPurify;
}
let {
document
} = window;
const originalDocument = document;
const currentScript = originalDocument.currentScript;
const {
DocumentFragment,
HTMLTemplateElement,
Node,
Element,
NodeFilter,
NamedNodeMap = window.NamedNodeMap || window.MozNamedAttrMap,
HTMLFormElement,
DOMParser,
trustedTypes
} = window;
const ElementPrototype = Element.prototype;
const cloneNode = lookupGetter(ElementPrototype, 'cloneNode');
const remove = lookupGetter(ElementPrototype, 'remove');
const getNextSibling = lookupGetter(ElementPrototype, 'nextSibling');
const getChildNodes = lookupGetter(ElementPrototype, 'childNodes');
const getParentNode = lookupGetter(ElementPrototype, 'parentNode');
// As per issue #47, the web-components registry is inherited by a
// new document created via createHTMLDocument. As per the spec
// (http://w3c.github.io/webcomponents/spec/custom/#creating-and-passing-registries)
// a new empty registry is used when creating a template contents owner
// document, so we use that as our parent document to ensure nothing
// is inherited.
if (typeof HTMLTemplateElement === 'function') {
const template = document.createElement('template');
if (template.content && template.content.ownerDocument) {
document = template.content.ownerDocument;
}
}
let trustedTypesPolicy;
let emptyHTML = '';
const {
implementation,
createNodeIterator,
createDocumentFragment,
getElementsByTagName
} = document;
const {
importNode
} = originalDocument;
let hooks = _createHooksMap();
/**
* Expose whether this browser supports running the full DOMPurify.
*/
DOMPurify.isSupported = typeof entries === 'function' && typeof getParentNode === 'function' && implementation && implementation.createHTMLDocument !== undefined;
const {
MUSTACHE_EXPR,
ERB_EXPR,
TMPLIT_EXPR,
DATA_ATTR,
ARIA_ATTR,
IS_SCRIPT_OR_DATA,
ATTR_WHITESPACE,
CUSTOM_ELEMENT
} = EXPRESSIONS;
let {
IS_ALLOWED_URI: IS_ALLOWED_URI$1
} = EXPRESSIONS;
/**
* We consider the elements and attributes below to be safe. Ideally
* don't add any new ones but feel free to remove unwanted ones.
*/
/* allowed element names */
let ALLOWED_TAGS = null;
const DEFAULT_ALLOWED_TAGS = addToSet({}, [...html$1, ...svg$1, ...svgFilters, ...mathMl$1, ...text]);
/* Allowed attribute names */
let ALLOWED_ATTR = null;
const DEFAULT_ALLOWED_ATTR = addToSet({}, [...html, ...svg, ...mathMl, ...xml]);
/*
* Configure how DOMPurify should handle custom elements and their attributes as well as customized built-in elements.
* @property {RegExp|Function|null} tagNameCheck one of [null, regexPattern, predicate]. Default: `null` (disallow any custom elements)
* @property {RegExp|Function|null} attributeNameCheck one of [null, regexPattern, predicate]. Default: `null` (disallow any attributes not on the allow list)
* @property {boolean} allowCustomizedBuiltInElements allow custom elements derived from built-ins if they pass CUSTOM_ELEMENT_HANDLING.tagNameCheck. Default: `false`.
*/
let CUSTOM_ELEMENT_HANDLING = Object.seal(create(null, {
tagNameCheck: {
writable: true,
configurable: false,
enumerable: true,
value: null
},
attributeNameCheck: {
writable: true,
configurable: false,
enumerable: true,
value: null
},
allowCustomizedBuiltInElements: {
writable: true,
configurable: false,
enumerable: true,
value: false
}
}));
/* Explicitly forbidden tags (overrides ALLOWED_TAGS/ADD_TAGS) */
let FORBID_TAGS = null;
/* Explicitly forbidden attributes (overrides ALLOWED_ATTR/ADD_ATTR) */
let FORBID_ATTR = null;
/* Decide if ARIA attributes are okay */
let ALLOW_ARIA_ATTR = true;
/* Decide if custom data attributes are okay */
let ALLOW_DATA_ATTR = true;
/* Decide if unknown protocols are okay */
let ALLOW_UNKNOWN_PROTOCOLS = false;
/* Decide if self-closing tags in attributes are allowed.
* Usually removed due to a mXSS issue in jQuery 3.0 */
let ALLOW_SELF_CLOSE_IN_ATTR = true;
/* Output should be safe for common template engines.
* This means, DOMPurify removes data attributes, mustaches and ERB
*/
let SAFE_FOR_TEMPLATES = false;
/* Output should be safe even for XML used within HTML and alike.
* This means, DOMPurify removes comments when containing risky content.
*/
let SAFE_FOR_XML = true;
/* Decide if document with <html>... should be returned */
let WHOLE_DOCUMENT = false;
/* Track whether config is already set on this instance of DOMPurify. */
let SET_CONFIG = false;
/* Decide if all elements (e.g. style, script) must be children of
* document.body. By default, browsers might move them to document.head */
let FORCE_BODY = false;
/* Decide if a DOM `HTMLBodyElement` should be returned, instead of a html
* string (or a TrustedHTML object if Trusted Types are supported).
* If `WHOLE_DOCUMENT` is enabled a `HTMLHtmlElement` will be returned instead
*/
let RETURN_DOM = false;
/* Decide if a DOM `DocumentFragment` should be returned, instead of a html
* string (or a TrustedHTML object if Trusted Types are supported) */
let RETURN_DOM_FRAGMENT = false;
/* Try to return a Trusted Type object instead of a string, return a string in
* case Trusted Types are not supported */
let RETURN_TRUSTED_TYPE = false;
/* Output should be free from DOM clobbering attacks?
* This sanitizes markups named with colliding, clobberable built-in DOM APIs.
*/
let SANITIZE_DOM = true;
/* Achieve full DOM Clobbering protection by isolating the namespace of named
* properties and JS variables, mitigating attacks that abuse the HTML/DOM spec rules.
*
* HTML/DOM spec rules that enable DOM Clobbering:
* - Named Access on Window (§7.3.3)
* - DOM Tree Accessors (§3.1.5)
* - Form Element Parent-Child Relations (§4.10.3)
* - Iframe srcdoc / Nested WindowProxies (§4.8.5)
* - HTMLCollection (§4.2.10.2)
*
* Namespace isolation is implemented by prefixing `id` and `name` attributes
* with a constant string, i.e., `user-content-`
*/
let SANITIZE_NAMED_PROPS = false;
const SANITIZE_NAMED_PROPS_PREFIX = 'user-content-';
/* Keep element content when removing element? */
let KEEP_CONTENT = true;
/* If a `Node` is passed to sanitize(), then performs sanitization in-place instead
* of importing it into a new Document and returning a sanitized copy */
let IN_PLACE = false;
/* Allow usage of profiles like html, svg and mathMl */
let USE_PROFILES = {};
/* Tags to ignore content of when KEEP_CONTENT is true */
let FORBID_CONTENTS = null;
const DEFAULT_FORBID_CONTENTS = addToSet({}, ['annotation-xml', 'audio', 'colgroup', 'desc', 'foreignobject', 'head', 'iframe', 'math', 'mi', 'mn', 'mo', 'ms', 'mtext', 'noembed', 'noframes', 'noscript', 'plaintext', 'script', 'style', 'svg', 'template', 'thead', 'title', 'video', 'xmp']);
/* Tags that are safe for data: URIs */
let DATA_URI_TAGS = null;
const DEFAULT_DATA_URI_TAGS = addToSet({}, ['audio', 'video', 'img', 'source', 'image', 'track']);
/* Attributes safe for values like "javascript:" */
let URI_SAFE_ATTRIBUTES = null;
const DEFAULT_URI_SAFE_ATTRIBUTES = addToSet({}, ['alt', 'class', 'for', 'id', 'label', 'name', 'pattern', 'placeholder', 'role', 'summary', 'title', 'value', 'style', 'xmlns']);
const MATHML_NAMESPACE = 'http://www.w3.org/1998/Math/MathML';
const SVG_NAMESPACE = 'http://www.w3.org/2000/svg';
const HTML_NAMESPACE = 'http://www.w3.org/1999/xhtml';
/* Document namespace */
let NAMESPACE = HTML_NAMESPACE;
let IS_EMPTY_INPUT = false;
/* Allowed XHTML+XML namespaces */
let ALLOWED_NAMESPACES = null;
const DEFAULT_ALLOWED_NAMESPACES = addToSet({}, [MATHML_NAMESPACE, SVG_NAMESPACE, HTML_NAMESPACE], stringToString);
let MATHML_TEXT_INTEGRATION_POINTS = addToSet({}, ['mi', 'mo', 'mn', 'ms', 'mtext']);
let HTML_INTEGRATION_POINTS = addToSet({}, ['annotation-xml']);
// Certain elements are allowed in both SVG and HTML
// namespace. We need to specify them explicitly
// so that they don't get erroneously deleted from
// HTML namespace.
const COMMON_SVG_AND_HTML_ELEMENTS = addToSet({}, ['title', 'style', 'font', 'a', 'script']);
/* Parsing of strict XHTML documents */
let PARSER_MEDIA_TYPE = null;
const SUPPORTED_PARSER_MEDIA_TYPES = ['application/xhtml+xml', 'text/html'];
const DEFAULT_PARSER_MEDIA_TYPE = 'text/html';
let transformCaseFunc = null;
/* Keep a reference to config to pass to hooks */
let CONFIG = null;
/* Ideally, do not touch anything below this line */
/* ______________________________________________ */
const formElement = document.createElement('form');
const isRegexOrFunction = function isRegexOrFunction(testValue) {
return testValue instanceof RegExp || testValue instanceof Function;
};
/**
* _parseConfig
*
* @param cfg optional config literal
*/
// eslint-disable-next-line complexity
const _parseConfig = function _parseConfig() {
let cfg = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
if (CONFIG && CONFIG === cfg) {
return;
}
/* Shield configuration object from tampering */
if (!cfg || typeof cfg !== 'object') {
cfg = {};
}
/* Shield configuration object fro