@codady/utils 0.0.37 → 0.0.39

package/src/cleanQueryString.ts

@@ -0,0 +1,20 @@
+/**
+ * @since Last modified: 2026/01/20 13:55:13
+ * Cleans a query string by removing the leading '?' or '&' character if it exists.
+ * This ensures that the string is in a valid format for use in URLSearchParams.
+ * 
+ * @param {string} data - The query string to clean.
+ * @returns {string} The cleaned query string without leading '?' or '&'.
+ * 
+ * @example
+ * cleanQueryString('?key=value&name=John'); // Returns 'key=value&name=John'
+ * cleanQueryString('&key=value&name=John'); // Returns 'key=value&name=John'
+ * cleanQueryString('key=value&name=John'); // Returns 'key=value&name=John'
+ */
+const cleanQueryString = (data: string): string => {
+    return typeof data === 'string' && (data.startsWith('?') || data.startsWith('&'))
+        ? data.slice(1)  // Remove the leading '?' or '&'
+        : data;  // Return the string as-is if no leading character is present
+};
+
+export default cleanQueryString;

package/src/comma - /345/211/257/346/234/254.js"

@@ -0,0 +1,2 @@
+const COMMA = ',';
+export default COMMA;

package/src/escapeCharsMaps.js

@@ -0,0 +1,73 @@
+/**
+ * @since Last modified: 2026/01/16 14:49:39
+ * escapeCharsMaps
+ * A collection of character escape mappings for different contexts in HTML and URI encoding.
+ *
+ * This object provides a set of character replacement mappings for use in different contexts such as:
+ * - `basic`: For basic HTML encoding (useful for preventing basic HTML injection).
+ * - `attribute`: For encoding characters within HTML attributes (useful for attributes like `src`, `href`).
+ * - `content`: For encoding characters within HTML content (useful for preventing XSS).
+ * - `uri`: For encoding characters in URIs (useful in attributes like `href` or `src`).
+ * - `paranoid`: A very strict escape for all potentially dangerous characters (useful for paranoid security contexts).
+ *
+ */
+const escapeCharsMaps = {
+    //code或pre标签中代码高亮是使用basic
+    basic: {
+        '&': '&',
+        '<': '&lt;',
+        '>': '&gt;',
+    },
+    //需要用在标签属性上attribute
+    attribute: {
+        '&': '&amp;',
+        '<': '&lt;',
+        '>': '&gt;',
+        '"': '&quot;',
+        "'": '&apos;',
+        '`': '&#x60;',
+    },
+    //html中的正文内容使用content
+    content: {
+        '&': '&amp;',
+        '<': '&lt;',
+        '>': '&gt;',
+        '"': '&quot;',
+        "'": '&apos;',
+        '/': '&#x2F;',
+    },
+    //用于url链接则使用uri
+    uri: {
+        '&': '&amp;',
+        '<': '&lt;',
+        '>': '&gt;',
+        '"': '&quot;',
+        "'": '&apos;',
+        '(': '&#40;',
+        ')': '&#41;',
+        '[': '&#91;',
+        ']': '&#93;',
+    },
+    //极致转意，避免任何注入或非法代码
+    paranoid: {
+        '&': '&amp;',
+        '<': '&lt;',
+        '>': '&gt;',
+        '"': '&quot;',
+        "'": '&apos;',
+        '`': '&#x60;',
+        '/': '&#x2F;',
+        '=': '&#x3D;',
+        '!': '&#x21;',
+        '#': '&#x23;',
+        '(': '&#40;',
+        ')': '&#41;',
+        '[': '&#91;',
+        ']': '&#93;',
+        '{': '&#x7B;',
+        '}': '&#x7D;',
+        ':': '&#x3A;',
+        ';': '&#x3B;',
+    },
+};
+export default escapeCharsMaps;

package/src/escapeCharsMaps.ts

@@ -0,0 +1,74 @@
+/**
+ * @since Last modified: 2026/01/16 14:49:39
+ * escapeCharsMaps
+ * A collection of character escape mappings for different contexts in HTML and URI encoding.
+ *
+ * This object provides a set of character replacement mappings for use in different contexts such as:
+ * - `basic`: For basic HTML encoding (useful for preventing basic HTML injection).
+ * - `attribute`: For encoding characters within HTML attributes (useful for attributes like `src`, `href`).
+ * - `content`: For encoding characters within HTML content (useful for preventing XSS).
+ * - `uri`: For encoding characters in URIs (useful in attributes like `href` or `src`).
+ * - `paranoid`: A very strict escape for all potentially dangerous characters (useful for paranoid security contexts).
+ * 
+ */
+
+const escapeCharsMaps : Record<string, Record<string, string>> = {
+    //code或pre标签中代码高亮是使用basic
+    basic: {
+        '&': '&amp;',
+        '<': '&lt;',
+        '>': '&gt;',
+    },
+    //需要用在标签属性上attribute
+    attribute: {
+        '&': '&amp;',
+        '<': '&lt;',
+        '>': '&gt;',
+        '"': '&quot;',
+        "'": '&apos;',
+        '`': '&#x60;',
+    },
+    //html中的正文内容使用content
+    content: {
+        '&': '&amp;',
+        '<': '&lt;',
+        '>': '&gt;',
+        '"': '&quot;',
+        "'": '&apos;',
+        '/': '&#x2F;',
+    },
+    //用于url链接则使用uri
+    uri: {
+        '&': '&amp;',
+        '<': '&lt;',
+        '>': '&gt;',
+        '"': '&quot;',
+        "'": '&apos;',
+        '(': '&#40;',
+        ')': '&#41;',
+        '[': '&#91;',
+        ']': '&#93;',
+    },
+    //极致转意，避免任何注入或非法代码
+    paranoid: {
+        '&': '&amp;',
+        '<': '&lt;',
+        '>': '&gt;',
+        '"': '&quot;',
+        "'": '&apos;',
+        '`': '&#x60;',
+        '/': '&#x2F;',
+        '=': '&#x3D;',
+        '!': '&#x21;',
+        '#': '&#x23;',
+        '(': '&#40;',
+        ')': '&#41;',
+        '[': '&#91;',
+        ']': '&#93;',
+        '{': '&#x7B;',
+        '}': '&#x7D;',
+        ':': '&#x3A;',
+        ';': '&#x3B;',
+    },
+};
+export default escapeCharsMaps;

package/src/escapeHTML.js

@@ -1,29 +1,27 @@
 /**
+ * @since Last modified: 2026/01/16 14:47:26
  * @function escapeHTML
- * @description Escapes HTML characters in a string to prevent XSS attacks.
- * This function replaces special characters such as <, >, &, ", ', etc. with their corresponding HTML entities.
- *
- * @param {string} str - The input string to be escaped.
- * @returns {string} - The escaped string with special HTML characters replaced by HTML entities.
- *
- * @example
- * escapeHTML("<div>Hello & 'world'</div>");
- * // returns "&lt;div&gt;Hello &amp; &#39;world&#39;&lt;/div&gt;"
+* Escapes special characters in a string to prevent Cross-Site Scripting (XSS) attacks.
+ * * @param str - The raw string to be escaped.
+ * @param context - The context where the escaped string will be placed.
+ * Defaults to 'basic'.
+ * @returns The escaped string safe for the specified HTML context.
+ * * @example
+ * // Basic usage (HTML Body)
+ * escapeHTML('<script>', 'basic'); // "&lt;script&gt;"
+ * * @example
+ * // Attribute usage (e.g., <input value="...">)
+ * escapeHTML('value" onmouseover="alert(1)', 'attribute');
  */
-export const escapeHTML = (str) => {
-    // Mapping of HTML special characters to their corresponding HTML entities
-    const escapes = {
-        '&': '&amp;',
-        '<': '&lt;',
-        '>': '&gt;',
-        '"': '&quot;',
-        "'": '&#39;',
-        '`': '&#96;',
-        '=': '&#61;',
-        '/': '&#47;'
-    };
-    // Replace each special character in the input string with its corresponding HTML entity
-    return str.replace(/[&<>"'`=\/]/g, (match) => {
-        return escapes[match];
-    });
+import escapeCharsMaps from "./escapeCharsMaps";
+import escapeRegexMaps from "./escapeRegexMaps";
+const escapeHTML = (str, strength = 'attribute') => {
+    // Return empty string if input is null, undefined, or not a string
+    if (typeof str !== 'string')
+        return '';
+    const map = escapeCharsMaps[strength], regex = escapeRegexMaps[strength];
+    // Use String.prototype.replace with a global regex.
+    // The callback function retrieves the replacement from the map using the matched character as key.
+    return str.replace(regex, (match) => map[match]);
 };
+export default escapeHTML;

package/src/escapeHTML.ts

@@ -1,30 +1,34 @@
 /**
+ * @since Last modified: 2026/01/16 14:47:26
  * @function escapeHTML
- * @description Escapes HTML characters in a string to prevent XSS attacks.
- * This function replaces special characters such as <, >, &, ", ', etc. with their corresponding HTML entities.
- * 
- * @param {string} str - The input string to be escaped.
- * @returns {string} - The escaped string with special HTML characters replaced by HTML entities.
- * 
- * @example
- * escapeHTML("<div>Hello & 'world'</div>"); 
- * // returns "&lt;div&gt;Hello &amp; &#39;world&#39;&lt;/div&gt;"
+* Escapes special characters in a string to prevent Cross-Site Scripting (XSS) attacks.
+ * * @param str - The raw string to be escaped.
+ * @param context - The context where the escaped string will be placed. 
+ * Defaults to 'basic'.
+ * @returns The escaped string safe for the specified HTML context.
+ * * @example
+ * // Basic usage (HTML Body)
+ * escapeHTML('<script>', 'basic'); // "&lt;script&gt;"
+ * * @example
+ * // Attribute usage (e.g., <input value="...">)
+ * escapeHTML('value" onmouseover="alert(1)', 'attribute');
  */
-export const escapeHTML = (str: string): string => {
-    // Mapping of HTML special characters to their corresponding HTML entities
-    const escapes: { [key: string]: string } = {
-        '&': '&amp;',
-        '<': '&lt;',
-        '>': '&gt;',
-        '"': '&quot;',
-        "'": '&#39;',
-        '`': '&#96;',
-        '=': '&#61;',
-        '/': '&#47;'
-    };
+import escapeCharsMaps from "./escapeCharsMaps";
+import escapeRegexMaps from "./escapeRegexMaps";
 
-    // Replace each special character in the input string with its corresponding HTML entity
-    return str.replace(/[&<>"'`=\/]/g, (match) => {
-        return escapes[match];
-    });
+export type EscapeStrength = 'basic' | 'attribute' | 'content' | 'uri' | 'paranoid';
+
+const escapeHTML = (
+    str: string,
+    strength: EscapeStrength = 'attribute'
+): string => {
+    // Return empty string if input is null, undefined, or not a string
+    if (typeof str !== 'string') return '';
+
+    const map = escapeCharsMaps[strength],
+        regex = escapeRegexMaps[strength];
+    // Use String.prototype.replace with a global regex.
+    // The callback function retrieves the replacement from the map using the matched character as key.
+    return str.replace(regex, (match) => map[match]);
 };
+export default escapeHTML;

package/src/escapeRegexMaps.js

@@ -0,0 +1,19 @@
+/**
+ * @since Last modified: 2026/01/16 11:07:17
+ * @function escapeRegexMaps
+ * Generates a set of regular expressions that match the characters to be escaped
+ * in different contexts such as HTML content, attributes, and URIs.
+ *
+ * This function uses the `escapeCharsMaps` object to create regular expressions for
+ * matching characters that need to be escaped based on the context.
+ *
+ */
+import escapeCharsMaps from "./escapeCharsMaps";
+const escapeRegexMaps = (Object.keys(escapeCharsMaps)).reduce((acc, key) => {
+    const chars = Object.keys(escapeCharsMaps[key]);
+    // Escape special regex characters to avoid issues in the regex. [ => \[
+    const escapedChars = chars.map((c) => c.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
+    acc[key] = new RegExp(`[${escapedChars.join('')}]`, 'g');
+    return acc;
+}, {});
+export default escapeRegexMaps;

package/src/escapeRegexMaps.ts

@@ -0,0 +1,26 @@
+
+
+/**
+ * @since Last modified: 2026/01/16 11:07:17
+ * @function escapeRegexMaps
+ * Generates a set of regular expressions that match the characters to be escaped 
+ * in different contexts such as HTML content, attributes, and URIs.
+ * 
+ * This function uses the `escapeCharsMaps` object to create regular expressions for 
+ * matching characters that need to be escaped based on the context.
+ * 
+ */
+
+import escapeCharsMaps from "./escapeCharsMaps";
+
+const escapeRegexMaps: Record<string, RegExp> = (Object.keys(escapeCharsMaps)).reduce(
+    (acc, key) => {
+        const chars = Object.keys(escapeCharsMaps[key]);
+        // Escape special regex characters to avoid issues in the regex. [ => \[
+        const escapedChars = chars.map((c) => c.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
+        acc[key] = new RegExp(`[${escapedChars.join('')}]`, 'g');
+        return acc;
+    },
+    {} as Record<string, RegExp>
+);
+export default escapeRegexMaps;

package/src/getBodyHTML.js

@@ -0,0 +1,53 @@
+/**
+* @since Last modified: 2026/01/19 15:58:30
+ * Extract the inner content of the <body> tag from an HTML string.
+ * This method uses the browser's native DOMParser for reliable parsing,
+ * which is safer and more robust than using Regular Expressions.
+ * * @param {string} htmlText - The raw HTML string received from an asynchronous request.
+ * @param {string} [selector] - Optional ID or selector (e.g., '.hello' or '#hello').
+ * @returns {string} - The trimmed innerHTML of the body, or the original text if parsing fails.
+ */
+const getBodyHTML = (htmlText, selector) => {
+    // Return early if the input is not a valid string or doesn't look like HTML
+    if (!htmlText || typeof htmlText !== 'string') {
+        return '';
+    }
+    try {
+        /**
+         * 1. Initialize DOMParser
+         * DOMParser can parse XML or HTML source code from a string into a DOM Document.
+         */
+        const parser = new DOMParser(), 
+        /**
+         * 2. Parse the string into a Document object
+         * The 'text/html' mime type tells the parser to use the HTML lifting/error-correction algorithms.
+         */
+        doc = parser.parseFromString(htmlText, 'text/html'), 
+        /**
+         * 3. Extract body content
+         * Accessing doc.body automatically skips <!DOCTYPE>, <html>, and <head> sections.
+         * We use trim() to remove leading/trailing whitespace common in server responses.
+         */
+        bodyContent = doc.body.innerHTML;
+        if (selector) {
+            // Normalize hash: ensure it's a valid ID selector
+            const targetEl = doc.querySelector(selector);
+            if (targetEl) {
+                return targetEl.innerHTML;
+            }
+            // If hash is provided but element not found, we fallback to body or warn
+            console.warn(`Element with selector "${selector}" not found in the HTML.`);
+        }
+        return bodyContent ? bodyContent.trim() : htmlText;
+    }
+    catch (error) {
+        /**
+         * Fallback mechanism
+         * If the environment (like Node.js without JSDOM) doesn't support DOMParser,
+         * or the string is malformed, we log the error and return the raw text.
+         */
+        console.error("Failed to parse HTML content using DOMParser:", error);
+        return htmlText;
+    }
+};
+export default getBodyHTML;

package/src/getBodyHTML.ts

@@ -0,0 +1,61 @@
+/**
+* @since Last modified: 2026/01/19 15:58:30
+ * Extract the inner content of the <body> tag from an HTML string.
+ * This method uses the browser's native DOMParser for reliable parsing,
+ * which is safer and more robust than using Regular Expressions.
+ * * @param {string} htmlText - The raw HTML string received from an asynchronous request.
+ * @param {string} [selector] - Optional ID or selector (e.g., '.hello' or '#hello').
+ * @returns {string} - The trimmed innerHTML of the body, or the original text if parsing fails.
+ */
+const getBodyHTML = (htmlText: string, selector?: string): string => {
+  // Return early if the input is not a valid string or doesn't look like HTML
+  if (!htmlText || typeof htmlText !== 'string') {
+    return '';
+  }
+
+  try {
+    /**
+     * 1. Initialize DOMParser
+     * DOMParser can parse XML or HTML source code from a string into a DOM Document.
+     */
+    const parser: DOMParser = new DOMParser(),
+
+      /**
+       * 2. Parse the string into a Document object
+       * The 'text/html' mime type tells the parser to use the HTML lifting/error-correction algorithms.
+       */
+      doc: Document = parser.parseFromString(htmlText, 'text/html'),
+
+      /**
+       * 3. Extract body content
+       * Accessing doc.body automatically skips <!DOCTYPE>, <html>, and <head> sections.
+       * We use trim() to remove leading/trailing whitespace common in server responses.
+       */
+      bodyContent: string = doc.body.innerHTML;
+
+    if (selector) {
+      // Normalize hash: ensure it's a valid ID selector
+      const targetEl = doc.querySelector(selector);
+
+      if (targetEl) {
+        return targetEl.innerHTML;
+      }
+
+      // If hash is provided but element not found, we fallback to body or warn
+      console.warn(`Element with selector "${selector}" not found in the HTML.`);
+    }
+
+
+    return bodyContent ? bodyContent.trim() : htmlText;
+  } catch (error) {
+    /**
+     * Fallback mechanism
+     * If the environment (like Node.js without JSDOM) doesn't support DOMParser,
+     * or the string is malformed, we log the error and return the raw text.
+     */
+    console.error("Failed to parse HTML content using DOMParser:", error);
+    return htmlText;
+  }
+};
+
+export default getBodyHTML;

package/src/getEl.js

@@ -1,5 +1,5 @@
 /**
- * @since Last modified: 2026/01/05 10:56:38
+ * @since Last modified: 2026/01/19 10:15:24
  * @function getEl
  * @description Get a DOM node (real or virtual). Supports obtaining nodes from various types (not just HTMLElement).
  * @param {string|Node} obj - Can be a node selector (e.g., #id, .classname, NODENAME, [attribute]) or any node type (HTMLElement, Node, DocumentFragment, etc.).

package/src/getEl.ts

@@ -1,5 +1,5 @@
 /**
- * @since Last modified: 2026/01/05 10:56:38
+ * @since Last modified: 2026/01/19 10:15:24
  * @function getEl
  * @description Get a DOM node (real or virtual). Supports obtaining nodes from various types (not just HTMLElement).
  * @param {string|Node} obj - Can be a node selector (e.g., #id, .classname, NODENAME, [attribute]) or any node type (HTMLElement, Node, DocumentFragment, etc.).
@@ -16,20 +16,21 @@
 'use strict';
 import getDataType from './getDataType';
 
+export type QueryableNode = Document | DocumentFragment | Element | SVGElement | HTMLElement | ShadowRoot;
 
-const getEl = (obj: string | Node | null, wrap: Node | string | null = document.body): Node | null => {
+const getEl = (obj: string | QueryableNode | null, wrap: string | QueryableNode | null = document.body): QueryableNode | null => {
     let objType = getDataType(obj),
         parType = getDataType(wrap),
         parent = parType.includes('HTML') ||  parType === 'ShadowRoot' ? wrap : document.querySelector(wrap as string),
         //如果parent是template节点，需要通过node.content.querySelector取得子节点
         root = parent && parent instanceof HTMLTemplateElement ? parent.content : parent,
-        result: Node | null = null;
+        result: QueryableNode | null = null;
     if (obj) {
         if (objType.includes('HTML')) {
-            result = (obj as Node);
+            result = (obj as QueryableNode);
         } else if (objType === 'String') {
             try {
-                result = (((root as Node) || document) as any).querySelector((obj as string).trim());
+                result = ((root as QueryableNode)  || document).querySelector((obj as string).trim());
                 //可能会报错，报错则返回null
             } catch {
                 result = null;

package/src/getEls.js

@@ -1,5 +1,5 @@
 /**
- * @since Last modified: 2026/01/05 10:29:34
+ * @since Last modified: 2026/01/19 10:10:38
  * @function getEls
  * @description Get the node array.
  * @param {*} data  - It can be a single node selector or a node array.

package/src/getEls.ts

@@ -1,5 +1,5 @@
 /**
- * @since Last modified: 2026/01/05 10:29:34
+ * @since Last modified: 2026/01/19 10:10:38
  * @function getEls
  * @description Get the node array.
  * @param {*} data  - It can be a single node selector or a node array.
@@ -19,15 +19,15 @@
 //返回：一个节点数组。
 'use strict';
 import getDataType from './getDataType';
-import getEl from './getEl';
+import getEl, { QueryableNode } from './getEl';
 import isEmpty from './isEmpty';
 
-const getEls = (data: Node | string |  null | (Node | string)[], parent: Node | string | null = document.body): (Node | string)[] => {
+const getEls = (data: string | QueryableNode | null | (string | QueryableNode)[], parent: string | QueryableNode | null = document.body): QueryableNode[] => {
     let type = getDataType(data),
         parentEl = getEl(parent),
         root = parentEl && parentEl instanceof HTMLTemplateElement ? parentEl.content : (parentEl || document),
         result: any[] = [];
-        //data为空直接返回空数组
+    //data为空直接返回空数组
     if (isEmpty(data)) { return result; }
     if (type.includes('HTML')) {
         //一个节点
@@ -39,7 +39,7 @@ const getEls = (data: Node | string |  null | (Node | string)[], parent: Node |
             return [...(root as any).querySelectorAll(k)];
         }).flat();
     } else if (type === 'Array') {
-        result = (data as (Node | string)[]).map((k: any) => {
+        result = (data as QueryableNode[]).map((k: any) => {
             return getEl(k, parentEl);
         });
     }

package/src/getUrlHash.js

@@ -0,0 +1,37 @@
+/**
+* @since Last modified: 2026/01/19 09:56:44
+ * Extracts the hash (fragment) portion of a given URL or file path.
+ * * This function utilizes the native `URL` constructor to parse the input.
+ * It is a pure logical operation and does not trigger any network requests.
+ * * @param {string} url - The URL string or file path to parse (e.g., 'index.html#section', 'https://example.com#top').
+ * @returns {string} - The hash part of the URL including the '#' character (e.g., '#section').
+ * Returns an empty string if no hash is present or if the input is invalid.
+ * * @example
+ * getUrlHash('https://example.com/page#header'); // Returns '#header'
+ * getUrlHash('src/assets/style.css#debug');      // Returns '#debug'
+ */
+const getUrlHash = (url) => {
+    // Return empty if input is null, undefined, or not a string
+    if (!url || typeof url !== 'string') {
+        return '';
+    }
+    try {
+        /**
+         * Use window.location.origin as the base URL to support relative paths.
+         * The URL constructor follows the WHATWG spec:
+         * 1. If 'url' is absolute (e.g., starts with http://), the base is ignored.
+         * 2. If 'url' is relative (e.g., starts with ../), it is resolved against the base.
+         * In both cases, the .hash property correctly extracts the fragment.
+         */
+        const baseUrl = window?.location?.origin || 'https://www.axui.cn', urlObj = new URL(url, baseUrl);
+        return urlObj.hash;
+    }
+    catch (error) {
+        /**
+         * Catch parsing errors for malformed strings.
+         * Since this is a utility, we fail silently and return an empty string.
+         */
+        return '';
+    }
+};
+export default getUrlHash;

package/src/getUrlHash.ts

@@ -0,0 +1,39 @@
+/**
+* @since Last modified: 2026/01/19 09:56:44
+ * Extracts the hash (fragment) portion of a given URL or file path.
+ * * This function utilizes the native `URL` constructor to parse the input.
+ * It is a pure logical operation and does not trigger any network requests.
+ * * @param {string} url - The URL string or file path to parse (e.g., 'index.html#section', 'https://example.com#top').
+ * @returns {string} - The hash part of the URL including the '#' character (e.g., '#section'). 
+ * Returns an empty string if no hash is present or if the input is invalid.
+ * * @example
+ * getUrlHash('https://example.com/page#header'); // Returns '#header'
+ * getUrlHash('src/assets/style.css#debug');      // Returns '#debug'
+ */
+const getUrlHash = (url: string): string => {
+  // Return empty if input is null, undefined, or not a string
+  if (!url || typeof url !== 'string') {
+    return '';
+  }
+
+  try {
+    /**
+     * Use window.location.origin as the base URL to support relative paths.
+     * The URL constructor follows the WHATWG spec:
+     * 1. If 'url' is absolute (e.g., starts with http://), the base is ignored.
+     * 2. If 'url' is relative (e.g., starts with ../), it is resolved against the base.
+     * In both cases, the .hash property correctly extracts the fragment.
+     */
+    const baseUrl: string = window?.location?.origin || 'https://www.axui.cn',
+      urlObj: URL = new URL(url, baseUrl);
+    return urlObj.hash;
+  } catch (error) {
+    /**
+     * Catch parsing errors for malformed strings.
+     * Since this is a utility, we fail silently and return an empty string.
+     */
+    return '';
+  }
+};
+
+export default getUrlHash;