tiny-essentials 1.28.0 → 1.28.1

package/dist/v1/basics/deprecated/html.mjs

@@ -0,0 +1,190 @@
+import { trackFetchProgress } from '../html.mjs';
+import { isJsonObject } from '../objChecker.mjs';
+/**
+ * @typedef {Object} FetchTemplateOptions
+ * @property {string} [method="GET"] - HTTP method to use (GET, POST, etc.).
+ * @property {any} [body] - Request body (only for methods like POST, PUT).
+ * @property {number} [timeout=0] - Timeout in milliseconds (ignored if signal is provided).
+ * @property {number} [retries=0] - Number of retry attempts (ignored if signal is provided).
+ * @property {Headers|Record<string, *>} [headers={}] - Additional headers.
+ * @property {AbortSignal|null} [signal] - External AbortSignal; disables timeout and retries.
+ * @property {import('../html.mjs').FetchOnProgressResult} [onProgress] - Track the load progress.
+ * @deprecated
+ */
+/**
+ * @param {string} url - The full URL to fetch data from.
+ * @param {FetchTemplateOptions} [options] - Optional settings.
+ * @returns {Promise<Response>} Result data.
+ * @throws {Error} Throws if fetch fails, times out.
+ */
+async function fetchTemplate(url, options = {}) {
+    if (options !== null && typeof options !== 'object') {
+        throw new TypeError('The "options" argument must be an object.');
+    }
+    const { method = 'GET', body, timeout = 0, retries = 0, headers = {}, signal = null, onProgress, } = options;
+    if (typeof url !== 'string' ||
+        (!url.startsWith('../') &&
+            !url.startsWith('./') &&
+            !url.startsWith('/') &&
+            !url.startsWith('https://') &&
+            !url.startsWith('http://')))
+        throw new Error('Invalid URL: must be a valid http or https address.');
+    if (typeof method !== 'string' || !method.trim())
+        throw new Error('Invalid method: must be a non-empty string.');
+    if (headers !== null && typeof headers !== 'object') {
+        throw new TypeError('The "headers" option must be an object.');
+    }
+    if (signal !== null && !(signal instanceof AbortSignal)) {
+        throw new TypeError('The "signal" option must be an instance of AbortSignal.');
+    }
+    if (onProgress !== undefined && typeof onProgress !== 'function') {
+        throw new TypeError('The "onProgress" option must be a function.');
+    }
+    if (!signal) {
+        if (typeof timeout !== 'number' ||
+            !Number.isFinite(timeout) ||
+            Number.isNaN(timeout) ||
+            timeout < 0)
+            throw new Error('Invalid timeout: must be a positive number.');
+        if (typeof retries !== 'number' ||
+            !Number.isFinite(retries) ||
+            Number.isNaN(retries) ||
+            retries < 0)
+            throw new Error('Invalid retries: must be a positive number.');
+    }
+    const attempts = signal ? 1 : retries + 1;
+    /** @type {Error|null} */
+    let lastError = null;
+    for (let attempt = 0; attempt < attempts; attempt++) {
+        const controller = signal ? null : new AbortController();
+        const localSignal = signal || (controller?.signal ?? null);
+        const timer = !signal && timeout && controller ? setTimeout(() => controller.abort(), timeout) : null;
+        try {
+            const response = await fetch(url, {
+                method: method.toUpperCase(),
+                headers: {
+                    Accept: 'application/json',
+                    ...headers,
+                },
+                body: body !== undefined ? (isJsonObject(body) ? JSON.stringify(body) : body) : undefined,
+                signal: localSignal,
+            });
+            if (timer)
+                clearTimeout(timer);
+            if (!response.ok)
+                throw new Error(`HTTP error: ${response.status} ${response.statusText}`);
+            // If onProgress is not provided or body is null, return original response
+            if (!onProgress)
+                return response;
+            return trackFetchProgress(response, onProgress);
+        }
+        catch (err) {
+            lastError = /** @type {Error} */ (err);
+            if (signal)
+                break; // if an external signal came, it does not retry
+            if (attempt < retries)
+                await new Promise((resolve) => setTimeout(resolve, 300 * (attempt + 1)));
+        }
+    }
+    throw new Error(`Failed to fetch JSON from "${url}"${lastError ? `: ${lastError.message}` : '.'}`);
+}
+/**
+ * Loads and parses a JSON from a remote URL using Fetch API.
+ *
+ * @param {string} url - The full URL to fetch JSON from.
+ * @param {FetchTemplateOptions} [options] - Optional settings.
+ * @returns {Promise<any[] | Record<string | number | symbol, unknown>>} Parsed JSON object.
+ * @throws {Error} Throws if fetch fails, times out, or returns invalid JSON.
+ * @deprecated
+ */
+export async function fetchJson(url, options) {
+    if (typeof url !== 'string') {
+        return Promise.reject(new TypeError('The "url" argument must be a string.'));
+    }
+    if (options !== undefined && (options === null || typeof options !== 'object')) {
+        return Promise.reject(new TypeError('The "options" argument must be an object.'));
+    }
+    return new Promise((resolve, reject) => {
+        fetchTemplate(url, options)
+            .then(async (res) => {
+            const contentType = res.headers.get('content-type') || '';
+            if (!contentType.includes('application/json'))
+                throw new Error(`Unexpected content-type: ${contentType}`);
+            const data = await res.json();
+            if (!Array.isArray(data) && !isJsonObject(data))
+                throw new Error('Received invalid data instead of valid JSON.');
+            return resolve(data);
+        })
+            .catch(reject);
+    });
+}
+/**
+ * Loads a remote file as a Blob using Fetch API.
+ *
+ * @param {string} url - The full URL to fetch the file from.
+ * @param {string[]} [allowedMimeTypes] - Optional list of accepted MIME types (e.g., ['image/jpeg']).
+ * @param {FetchTemplateOptions} [options] - Optional fetch options.
+ * @returns {Promise<Blob>} - The fetched file as a Blob.
+ * @throws {Error} Throws if fetch fails, response is not ok, or MIME type is not allowed.
+ * @deprecated
+ */
+export async function fetchBlob(url, allowedMimeTypes, options) {
+    if (typeof url !== 'string') {
+        return Promise.reject(new TypeError('The "url" argument must be a string.'));
+    }
+    if (allowedMimeTypes !== undefined && !Array.isArray(allowedMimeTypes)) {
+        return Promise.reject(new TypeError('The "allowedMimeTypes" argument must be an array of strings.'));
+    }
+    if (options !== undefined && (options === null || typeof options !== 'object')) {
+        return Promise.reject(new TypeError('The "options" argument must be an object.'));
+    }
+    return new Promise((resolve, reject) => {
+        fetchTemplate(url, options)
+            .then(async (res) => {
+            const contentType = res.headers.get('content-type') || '';
+            if (Array.isArray(allowedMimeTypes) &&
+                allowedMimeTypes.length > 0 &&
+                !allowedMimeTypes.some((type) => contentType.includes(type))) {
+                throw new Error(`Blocked MIME type: ${contentType}`);
+            }
+            const data = await res.blob();
+            return resolve(data);
+        })
+            .catch(reject);
+    });
+}
+/**
+ * Loads a remote file as a text using Fetch API.
+ *
+ * @param {string} url - The full URL to fetch the file from.
+ * @param {string[]} [allowedMimeTypes] - Optional list of accepted MIME types (e.g., ['image/jpeg']).
+ * @param {FetchTemplateOptions} [options] - Optional fetch options.
+ * @returns {Promise<string>} - The fetched file as a text.
+ * @throws {Error} Throws if fetch fails, response is not ok, or MIME type is not allowed.
+ * @deprecated
+ */
+export async function fetchText(url, allowedMimeTypes, options) {
+    if (typeof url !== 'string') {
+        return Promise.reject(new TypeError('The "url" argument must be a string.'));
+    }
+    if (allowedMimeTypes !== undefined && !Array.isArray(allowedMimeTypes)) {
+        return Promise.reject(new TypeError('The "allowedMimeTypes" argument must be an array of strings.'));
+    }
+    if (options !== undefined && (options === null || typeof options !== 'object')) {
+        return Promise.reject(new TypeError('The "options" argument must be an object.'));
+    }
+    return new Promise((resolve, reject) => {
+        fetchTemplate(url, options)
+            .then(async (res) => {
+            const contentType = res.headers.get('content-type') || '';
+            if (Array.isArray(allowedMimeTypes) &&
+                allowedMimeTypes.length > 0 &&
+                !allowedMimeTypes.some((type) => contentType.includes(type))) {
+                throw new Error(`Blocked MIME type: ${contentType}`);
+            }
+            const data = await res.text();
+            return resolve(data);
+        })
+            .catch(reject);
+    });
+}

package/dist/v1/basics/html.cjs

@@ -7,14 +7,28 @@ var objChecker = require('./objChecker.cjs');
 /**
  * Reads the contents of a file using the specified FileReader method.
  *
- * @param {File} file - The file to be read.
+ * @param {File|Blob} file - The file to be read.
  * @param {'readAsArrayBuffer'|'readAsDataURL'|'readAsText'|'readAsBinaryString'} method -
- *   The FileReader method to use for reading the file.
+ * The FileReader method to use for reading the file.
  * @returns {Promise<any>} - A promise that resolves with the file content, according to the chosen method.
+ * @throws {TypeError} - If arguments don't match expected types.
  * @throws {Error} - If an unexpected error occurs while handling the result.
  * @throws {DOMException} - If the FileReader encounters an error while reading the file.
  */
 function readFileBlob(file, method) {
+  if (!(file instanceof Blob)) {
+    return Promise.reject(
+      new TypeError('The "file" argument must be an instance of Blob or File.'),
+    );
+  }
+
+  const validMethods = ['readAsArrayBuffer', 'readAsDataURL', 'readAsText', 'readAsBinaryString'];
+  if (typeof method !== 'string' || !validMethods.includes(method)) {
+    return Promise.reject(
+      new TypeError(`The "method" argument must be one of: ${validMethods.join(', ')}.`),
+    );
+  }
+
   return new Promise((resolve, reject) => {
     const reader = new FileReader();
     reader.onload = () => {
@@ -36,9 +50,9 @@ function readFileBlob(file, method) {
  *
  * Performs strict validation to ensure the result is a valid Base64 string or a proper data URL.
  *
- * @param {File} file - The file to be read.
+ * @param {File|Blob} file - The file to be read.
  * @param {boolean|string} [isDataUrl=false] - If true, returns a full data URL; if false, returns only the Base64 string;
- *   if a string is passed, it is used as the MIME type in the data URL.
+ * if a string is passed, it is used as the MIME type in the data URL.
  * @returns {Promise<string>} - A promise that resolves with the Base64 string or data URL.
  *
  * @throws {TypeError} - If the result is not a string or if `isDataUrl` is not a valid type.
@@ -46,9 +60,18 @@ function readFileBlob(file, method) {
  * @throws {DOMException} - If the FileReader fails to read the file.
  */
 function readBase64Blob(file, isDataUrl = false) {
+  // Validação do argumento 'file'
+  if (!(file instanceof Blob)) {
+    return Promise.reject(
+      new TypeError('The "file" argument must be an instance of Blob or File.'),
+    );
+  }
+
+  if (typeof isDataUrl !== 'string' && typeof isDataUrl !== 'boolean') {
+    return Promise.reject(new TypeError('The isDataUrl parameter must be a boolean or a string.'));
+  }
+
   return new Promise((resolve, reject) => {
-    if (typeof isDataUrl !== 'string' && typeof isDataUrl !== 'boolean')
-      reject(new TypeError('The isDataUrl parameter must be a boolean or a string.'));
     readFileBlob(file, 'readAsDataURL')
       .then(
         /**
@@ -80,7 +103,7 @@ function readBase64Blob(file, isDataUrl = false) {
  *
  * Performs several checks to ensure the file contains valid, parsable JSON data.
  *
- * @param {File} file - The file to be read. It must contain valid JSON as plain text.
+ * @param {File|Blob} file - The file to be read. It must contain valid JSON as plain text.
  * @returns {Promise<Record<string|number|symbol, any>|any[]>} - A promise that resolves with the parsed JSON object.
  *
  * @throws {SyntaxError} - If the file content is not valid JSON syntax.
@@ -89,6 +112,12 @@ function readBase64Blob(file, isDataUrl = false) {
  * @throws {DOMException} - If the FileReader fails to read the file.
  */
 function readJsonBlob(file) {
+  if (!(file instanceof Blob)) {
+    return Promise.reject(
+      new TypeError('The "file" argument must be an instance of Blob or File.'),
+    );
+  }
+
   return new Promise((resolve, reject) =>
     readFileBlob(file, 'readAsText')
       .then((data) => {
@@ -109,8 +138,16 @@ function readJsonBlob(file) {
  * @param {string} filename
  * @param {any} data
  * @param {number} [spaces=2]
+ * @throws {TypeError} - If arguments do not match expected types.
  */
 function saveJsonFile(filename, data, spaces = 2) {
+  if (typeof filename !== 'string') {
+    throw new TypeError('The "filename" argument must be a string.');
+  }
+  if (typeof spaces !== 'number' || !Number.isInteger(spaces) || spaces < 0) {
+    throw new TypeError('The "spaces" argument must be a non-negative integer.');
+  }
+
   const json = JSON.stringify(data, null, spaces);
   const blob = new Blob([json], { type: 'application/json' });
   const url = URL.createObjectURL(blob);
@@ -126,17 +163,6 @@ function saveJsonFile(filename, data, spaces = 2) {
   URL.revokeObjectURL(url);
 }
 
-/**
- * @typedef {Object} FetchTemplateOptions
- * @property {string} [method="GET"] - HTTP method to use (GET, POST, etc.).
- * @property {any} [body] - Request body (only for methods like POST, PUT).
- * @property {number} [timeout=0] - Timeout in milliseconds (ignored if signal is provided).
- * @property {number} [retries=0] - Number of retry attempts (ignored if signal is provided).
- * @property {Headers|Record<string, *>} [headers={}] - Additional headers.
- * @property {AbortSignal|null} [signal] - External AbortSignal; disables timeout and retries.
- * @property {FetchOnProgressResult} [onProgress] - Track the load progress.
- */
-
 /**
  * Callback function used to report the progress of a data download.
  *
@@ -155,9 +181,21 @@ function saveJsonFile(filename, data, spaces = 2) {
  *
  * @param {Response} response - The original response object to be tracked.
  * @param {FetchOnProgressResult} onProgress - The callback function to handle progress events.
+ * @param {(res: Response) => ResponseInit} [returnResponse] - The callback function to return the ResponseInit to ReadableStream.
  * @returns {Response} A new Response object with the tracked stream.
  */
-function trackFetchProgress(response, onProgress) {
+function trackFetchProgress(
+  response,
+  onProgress,
+  returnResponse = (res) => ({
+    headers: res.headers,
+    status: res.status,
+    statusText: res.statusText,
+  }),
+) {
+  if (!(response instanceof Response)) {
+    throw new TypeError('The "response" argument must be an instance of Response.');
+  }
   if (typeof onProgress !== 'function')
     throw new TypeError('The "onProgress" argument must be a function.');
   if (!response.body) return response;
@@ -181,107 +219,33 @@ function trackFetchProgress(response, onProgress) {
     },
   });
 
-  return new Response(stream, {
-    headers: response.headers,
-    status: response.status,
-    statusText: response.statusText,
-  });
-}
-
-/**
- * @param {string} url - The full URL to fetch data from.
- * @param {FetchTemplateOptions} [options] - Optional settings.
- * @returns {Promise<Response>} Result data.
- * @throws {Error} Throws if fetch fails, times out.
- */
-async function fetchTemplate(
-  url,
-  { method = 'GET', body, timeout = 0, retries = 0, headers = {}, signal = null, onProgress } = {},
-) {
-  if (
-    typeof url !== 'string' ||
-    (!url.startsWith('../') &&
-      !url.startsWith('./') &&
-      !url.startsWith('/') &&
-      !url.startsWith('https://') &&
-      !url.startsWith('http://'))
-  )
-    throw new Error('Invalid URL: must be a valid http or https address.');
-
-  if (typeof method !== 'string' || !method.trim())
-    throw new Error('Invalid method: must be a non-empty string.');
-
-  if (!signal) {
-    if (
-      typeof timeout !== 'number' ||
-      !Number.isFinite(timeout) ||
-      Number.isNaN(timeout) ||
-      timeout < 0
-    )
-      throw new Error('Invalid timeout: must be a positive number.');
-
-    if (
-      typeof retries !== 'number' ||
-      !Number.isFinite(retries) ||
-      Number.isNaN(retries) ||
-      retries < 0
-    )
-      throw new Error('Invalid retries: must be a positive number.');
-  }
-
-  const attempts = signal ? 1 : retries + 1;
-  /** @type {Error|null} */
-  let lastError = null;
-
-  for (let attempt = 0; attempt < attempts; attempt++) {
-    const controller = signal ? null : new AbortController();
-    const localSignal = signal || (controller?.signal ?? null);
-    const timer =
-      !signal && timeout && controller ? setTimeout(() => controller.abort(), timeout) : null;
-
-    try {
-      const response = await fetch(url, {
-        method: method.toUpperCase(),
-        headers: {
-          Accept: 'application/json',
-          ...headers,
-        },
-        body: body !== undefined ? (objChecker.isJsonObject(body) ? JSON.stringify(body) : body) : undefined,
-        signal: localSignal,
-      });
-
-      if (timer) clearTimeout(timer);
-
-      if (!response.ok) throw new Error(`HTTP error: ${response.status} ${response.statusText}`);
-
-      // If onProgress is not provided or body is null, return original response
-      if (!onProgress) return response;
-      return trackFetchProgress(response, onProgress);
-    } catch (err) {
-      lastError = /** @type {Error} */ (err);
-      if (signal) break; // if an external signal came, it does not retry
-      if (attempt < retries)
-        await new Promise((resolve) => setTimeout(resolve, 300 * (attempt + 1)));
-    }
-  }
-
-  throw new Error(
-    `Failed to fetch JSON from "${url}"${lastError ? `: ${lastError.message}` : '.'}`,
-  );
+  return new Response(stream, returnResponse(response));
 }
 
 /**
  * Loads and parses a JSON from a remote URL using Fetch API.
  *
- * @param {string} url - The full URL to fetch JSON from.
- * @param {FetchTemplateOptions} [options] - Optional settings.
+ * @param {string | URL | Request} url - The full URL to fetch JSON from.
+ * @param {RequestInit|null} [options] - Optional settings.
+ * @param {FetchOnProgressResult} [onProgress] - Track the load progress.
  * @returns {Promise<any[] | Record<string | number | symbol, unknown>>} Parsed JSON object.
  * @throws {Error} Throws if fetch fails, times out, or returns invalid JSON.
  */
-async function fetchJson(url, options) {
+async function fetchJson(url, options, onProgress) {
+  if (typeof url !== 'string') {
+    return Promise.reject(new TypeError('The "url" argument must be a string.'));
+  }
+  if (options !== undefined && typeof options !== 'object') {
+    return Promise.reject(new TypeError('The "options" argument must be an object.'));
+  }
+  if (onProgress !== undefined && typeof onProgress !== 'function') {
+    return Promise.reject(new TypeError('The "onProgress" option must be a function.'));
+  }
+
   return new Promise((resolve, reject) => {
-    fetchTemplate(url, options)
-      .then(async (res) => {
+    fetch(url, options ?? undefined)
+      .then(async (response) => {
+        const res = onProgress ? trackFetchProgress(response, onProgress) : response;
         const contentType = res.headers.get('content-type') || '';
         if (!contentType.includes('application/json'))
           throw new Error(`Unexpected content-type: ${contentType}`);
@@ -300,16 +264,33 @@ async function fetchJson(url, options) {
 /**
  * Loads a remote file as a Blob using Fetch API.
  *
- * @param {string} url - The full URL to fetch the file from.
- * @param {FetchTemplateOptions} [options] - Optional fetch options.
+ * @param {string | URL | Request} url - The full URL to fetch the file from.
  * @param {string[]} [allowedMimeTypes] - Optional list of accepted MIME types (e.g., ['image/jpeg']).
+ * @param {RequestInit|null} [options] - Optional fetch options.
+ * @param {FetchOnProgressResult} [onProgress] - Track the load progress.
  * @returns {Promise<Blob>} - The fetched file as a Blob.
  * @throws {Error} Throws if fetch fails, response is not ok, or MIME type is not allowed.
  */
-async function fetchBlob(url, allowedMimeTypes, options) {
+async function fetchBlob(url, allowedMimeTypes, options, onProgress) {
+  if (typeof url !== 'string') {
+    return Promise.reject(new TypeError('The "url" argument must be a string.'));
+  }
+  if (allowedMimeTypes !== undefined && !Array.isArray(allowedMimeTypes)) {
+    return Promise.reject(
+      new TypeError('The "allowedMimeTypes" argument must be an array of strings.'),
+    );
+  }
+  if (options !== undefined && typeof options !== 'object') {
+    return Promise.reject(new TypeError('The "options" argument must be an object.'));
+  }
+  if (onProgress !== undefined && typeof onProgress !== 'function') {
+    return Promise.reject(new TypeError('The "onProgress" option must be a function.'));
+  }
+
   return new Promise((resolve, reject) => {
-    fetchTemplate(url, options)
-      .then(async (res) => {
+    fetch(url, options ?? undefined)
+      .then(async (response) => {
+        const res = onProgress ? trackFetchProgress(response, onProgress) : response;
         const contentType = res.headers.get('content-type') || '';
 
         if (
@@ -329,17 +310,33 @@ async function fetchBlob(url, allowedMimeTypes, options) {
 
 /**
  * Loads a remote file as a text using Fetch API.
- *
- * @param {string} url - The full URL to fetch the file from.
- * @param {FetchTemplateOptions} [options] - Optional fetch options.
+ * @param {string | URL | Request} url - The full URL to fetch the file from.
  * @param {string[]} [allowedMimeTypes] - Optional list of accepted MIME types (e.g., ['image/jpeg']).
+ * @param {RequestInit|null} [options] - Optional fetch options.
+ * @param {FetchOnProgressResult} [onProgress] - Track the load progress.
  * @returns {Promise<string>} - The fetched file as a text.
  * @throws {Error} Throws if fetch fails, response is not ok, or MIME type is not allowed.
  */
-async function fetchText(url, allowedMimeTypes, options) {
+async function fetchText(url, allowedMimeTypes, options, onProgress) {
+  if (typeof url !== 'string') {
+    return Promise.reject(new TypeError('The "url" argument must be a string.'));
+  }
+  if (allowedMimeTypes !== undefined && !Array.isArray(allowedMimeTypes)) {
+    return Promise.reject(
+      new TypeError('The "allowedMimeTypes" argument must be an array of strings.'),
+    );
+  }
+  if (options !== undefined && typeof options !== 'object') {
+    return Promise.reject(new TypeError('The "options" argument must be an object.'));
+  }
+  if (onProgress !== undefined && typeof onProgress !== 'function') {
+    return Promise.reject(new TypeError('The "onProgress" option must be a function.'));
+  }
+
   return new Promise((resolve, reject) => {
-    fetchTemplate(url, options)
-      .then(async (res) => {
+    fetch(url, options ?? undefined)
+      .then(async (response) => {
+        const res = onProgress ? trackFetchProgress(response, onProgress) : response;
         const contentType = res.headers.get('content-type') || '';
 
         if (
@@ -389,7 +386,23 @@ async function fetchText(url, allowedMimeTypes, options) {
  * @param {(event: Event, startTime: number) => void} [options.onLoading]
  * @returns {Promise<ImageLoadResult>}
  */
-async function loadImage({ url, onLoading, crossOrigin = 'anonymous' }) {
+async function loadImage(options) {
+  if (options === null || typeof options !== 'object') {
+    return Promise.reject(new TypeError('The "options" argument must be an object.'));
+  }
+
+  const { url, onLoading, crossOrigin = 'anonymous' } = options;
+
+  if (typeof url !== 'string') {
+    return Promise.reject(new TypeError('The "url" option must be a string.'));
+  }
+  if (typeof crossOrigin !== 'string') {
+    return Promise.reject(new TypeError('The "crossOrigin" option must be a string.'));
+  }
+  if (onLoading !== undefined && typeof onLoading !== 'function') {
+    return Promise.reject(new TypeError('The "onLoading" option must be a function.'));
+  }
+
   return new Promise((resolve, reject) => {
     const img = new Image();
     let startTime = performance.now();
@@ -465,13 +478,19 @@ async function loadImage({ url, onLoading, crossOrigin = 'anonymous' }) {
  * @returns {() => void} Function that removes all installed event listeners.
  * @throws {TypeError} If any provided setting is invalid.
  */
-function installWindowHiddenScript({
-  element = document.body,
-  hiddenClass = 'windowHidden',
-  visibleClass = 'windowVisible',
-  onVisible,
-  onHidden,
-} = {}) {
+function installWindowHiddenScript(settings = {}) {
+  if (settings === null || typeof settings !== 'object') {
+    throw new TypeError('The "settings" argument must be an object.');
+  }
+
+  const {
+    element = document.body,
+    hiddenClass = 'windowHidden',
+    visibleClass = 'windowVisible',
+    onVisible,
+    onHidden,
+  } = settings;
+
   if (!(element instanceof Element))
     throw new TypeError(`"element" must be an instance of Element.`);
   if (typeof hiddenClass !== 'string') throw new TypeError(`"hiddenClass" must be a string.`);