@reforgium/internal 2.0.4 → 2.0.6

package/fesm2022/reforgium-internal.mjs

@@ -6,38 +6,83 @@ class LocalStorage {
         this.prefix = prefix;
     }
     get length() {
-        return Object.keys(localStorage).filter((key) => key.startsWith(this.safePrefix())).length;
+        const storage = this.storage;
+        if (!storage) {
+            return 0;
+        }
+        try {
+            return Object.keys(storage).filter((key) => key.startsWith(this.safePrefix())).length;
+        }
+        catch {
+            return 0;
+        }
     }
     get(key) {
-        const storageKey = this.getSafePrefix(key);
-        const raw = localStorage.getItem(storageKey);
-        if (raw == null) {
+        const storage = this.storage;
+        if (!storage) {
             return null;
         }
+        const storageKey = this.getSafePrefix(key);
         try {
-            const parsed = JSON.parse(raw);
-            return parsed ?? null;
+            const raw = storage.getItem(storageKey);
+            if (raw == null) {
+                return null;
+            }
+            return JSON.parse(raw);
         }
         catch {
-            localStorage.removeItem(storageKey);
+            try {
+                storage.removeItem(storageKey);
+            }
+            catch {
+                /* noop */
+            }
             return null;
         }
     }
     set(key, value) {
-        localStorage.setItem(this.getSafePrefix(key), JSON.stringify(value));
+        try {
+            this.storage?.setItem(this.getSafePrefix(key), JSON.stringify(value));
+        }
+        catch {
+            /* Storage is optional and may reject writes (SSR, quota, privacy mode). */
+        }
     }
     remove(key) {
-        localStorage.removeItem(this.getSafePrefix(key));
+        try {
+            this.storage?.removeItem(this.getSafePrefix(key));
+        }
+        catch {
+            /* noop */
+        }
     }
     clear() {
-        const keys = Object.keys(localStorage).filter((key) => key.startsWith(this.safePrefix()));
-        keys.forEach((key) => localStorage.removeItem(key));
+        const storage = this.storage;
+        if (!storage) {
+            return;
+        }
+        try {
+            Object.keys(storage)
+                .filter((key) => key.startsWith(this.safePrefix()))
+                .forEach((key) => storage.removeItem(key));
+        }
+        catch {
+            /* noop */
+        }
+    }
+    get storage() {
+        try {
+            return typeof localStorage === 'undefined' ? null : localStorage;
+        }
+        catch {
+            return null;
+        }
     }
     getSafePrefix(key) {
-        return this.prefix ? `${this.prefix}:${key}` : String(key);
+        return this.prefix ? this.prefix + ':' + String(key) : String(key);
     }
     safePrefix() {
-        return this.prefix ? `${this.prefix}:` : '';
+        return this.prefix ? this.prefix + ':' : '';
     }
 }
 
@@ -55,6 +100,13 @@ class LruCache {
     }
     set limit(value) {
         this._limit = Math.max(1, Math.floor(value || 0));
+        while (this.map.size > this._limit) {
+            const oldest = this.map.keys().next().value;
+            if (oldest === undefined) {
+                break;
+            }
+            this.map.delete(oldest);
+        }
     }
     get(key) {
         if (!this.map.has(key)) {
@@ -129,38 +181,83 @@ class SessionStorage {
         this.prefix = prefix;
     }
     get length() {
-        return Object.keys(sessionStorage).filter((key) => key.startsWith(this.safePrefix())).length;
+        const storage = this.storage;
+        if (!storage) {
+            return 0;
+        }
+        try {
+            return Object.keys(storage).filter((key) => key.startsWith(this.safePrefix())).length;
+        }
+        catch {
+            return 0;
+        }
     }
     get(key) {
-        const storageKey = this.getSafePrefix(key);
-        const raw = sessionStorage.getItem(storageKey);
-        if (raw == null) {
+        const storage = this.storage;
+        if (!storage) {
             return null;
         }
+        const storageKey = this.getSafePrefix(key);
         try {
-            const parsed = JSON.parse(raw);
-            return parsed ?? null;
+            const raw = storage.getItem(storageKey);
+            if (raw == null) {
+                return null;
+            }
+            return JSON.parse(raw);
         }
         catch {
-            sessionStorage.removeItem(storageKey);
+            try {
+                storage.removeItem(storageKey);
+            }
+            catch {
+                /* noop */
+            }
             return null;
         }
     }
     set(key, value) {
-        sessionStorage.setItem(this.getSafePrefix(key), JSON.stringify(value));
+        try {
+            this.storage?.setItem(this.getSafePrefix(key), JSON.stringify(value));
+        }
+        catch {
+            /* Storage is optional and may reject writes (SSR, quota, privacy mode). */
+        }
     }
     remove(key) {
-        sessionStorage.removeItem(this.getSafePrefix(key));
+        try {
+            this.storage?.removeItem(this.getSafePrefix(key));
+        }
+        catch {
+            /* noop */
+        }
     }
     clear() {
-        const keys = Object.keys(sessionStorage).filter((key) => key.startsWith(this.safePrefix()));
-        keys.forEach((key) => sessionStorage.removeItem(key));
+        const storage = this.storage;
+        if (!storage) {
+            return;
+        }
+        try {
+            Object.keys(storage)
+                .filter((key) => key.startsWith(this.safePrefix()))
+                .forEach((key) => storage.removeItem(key));
+        }
+        catch {
+            /* noop */
+        }
+    }
+    get storage() {
+        try {
+            return typeof sessionStorage === 'undefined' ? null : sessionStorage;
+        }
+        catch {
+            return null;
+        }
     }
     getSafePrefix(key) {
-        return this.prefix ? `${this.prefix}:${key}` : String(key);
+        return this.prefix ? this.prefix + ':' + String(key) : String(key);
     }
     safePrefix() {
-        return this.prefix ? `${this.prefix}:` : '';
+        return this.prefix ? this.prefix + ':' : '';
     }
 }
 
@@ -412,16 +509,28 @@ const debounceSignal = (src, ms = 150, opts) => {
  */
 const throttleSignal = (src, ms = 100, opts) => {
     const out = signal(src(), ...(ngDevMode ? [{ debugName: "out" }] : /* istanbul ignore next */ []));
-    let last = 0;
-    let queued;
+    let lastEmissionAt = null;
+    let queuedValue;
+    let hasQueuedValue = false;
     let timeoutRef;
+    const clearPendingTimer = () => {
+        if (timeoutRef) {
+            clearTimeout(timeoutRef);
+            timeoutRef = null;
+        }
+    };
+    const emitNow = (value) => {
+        out.set(value);
+        lastEmissionAt = performance.now();
+        hasQueuedValue = false;
+        clearPendingTimer();
+    };
     const flush = () => {
-        if (queued !== undefined) {
-            out.set(queued);
-            queued = undefined;
-            last = performance.now();
+        timeoutRef = null;
+        if (!hasQueuedValue) {
+            return;
         }
-        timeoutRef = 0;
+        emitNow(queuedValue);
     };
     effect((onCleanup) => {
         const v = src();
@@ -430,24 +539,19 @@ const throttleSignal = (src, ms = 100, opts) => {
         }
         untracked(() => {
             const now = performance.now();
-            if (now - last >= ms) {
-                out.set(v);
-                last = now;
-                clearTimeout(timeoutRef);
-                timeoutRef = null;
-                queued = undefined;
+            if (lastEmissionAt == null || now - lastEmissionAt >= ms) {
+                emitNow(v);
+                return;
             }
-            else {
-                queued = v;
-                timeoutRef = setTimeout(flush, ms - (now - last));
+            queuedValue = v;
+            hasQueuedValue = true;
+            if (!timeoutRef) {
+                timeoutRef = setTimeout(flush, ms - (now - lastEmissionAt));
             }
         });
         onCleanup(() => {
-            if (timeoutRef) {
-                clearTimeout(timeoutRef);
-                timeoutRef = null;
-            }
-            queued = undefined;
+            clearPendingTimer();
+            hasQueuedValue = false;
         });
     }, { injector: opts?.injector });
     return out.asReadonly();
@@ -534,7 +638,12 @@ const parseToDate = (value, format = 'dd.MM.yyyy') => {
     };
     tokens.forEach((token, i) => map[token]?.(i));
     const date = new Date(year, month, day, hours, minutes, seconds);
-    if (date.getFullYear() !== year || date.getMonth() !== month || date.getDate() !== day) {
+    if ((tokens.includes('yyyy') && date.getFullYear() !== year) ||
+        (tokens.includes('MM') && date.getMonth() !== month) ||
+        (tokens.includes('dd') && date.getDate() !== day) ||
+        (tokens.includes('HH') && date.getHours() !== hours) ||
+        (tokens.includes('mm') && date.getMinutes() !== minutes) ||
+        (tokens.includes('ss') && date.getSeconds() !== seconds)) {
         return null;
     }
     return date;
@@ -606,7 +715,7 @@ const toDate = (v) => {
  * Converts a date string from a given format to ISO (UTC).
  * Example:
  *   reformatDateToISO("24.11.2025", "dd.MM.yyyy")
- *   → "2025-11-24T00:00:00.000Z"
+ *   > "2025-11-24T00:00:00.000Z"
  */
 function reformatDateToISO(dateStr, mask) {
     if (!dateStr || !mask) {
@@ -851,20 +960,25 @@ function getChainedValue(obj, path) {
 }
 
 const encodeSpacesAsPercent20 = (query) => query.replace(/\+/g, '%20');
+const URL_PARTS_RE = /^([a-zA-Z][a-zA-Z\d+.-]*:)?(\/\/[^/?#]*)?([^?#]*)(\?[^#]*)?(#.*)?$/;
 /**
  * Normalizes a given URL by removing redundant slashes, resolving dot segments,
- * and ensuring there are no trailing slashes at the end of the URL.
+ * and ensuring there are no trailing slashes at the end of the pathname.
+ *
+ * Query strings and hashes are preserved byte-for-byte.
  *
  * @param {string} url - The URL string to normalize.
  * @return {string} - The normalized URL string.
  */
 function normalizeUrl(url) {
-    const [protocol, rest] = url.split('://');
-    const cleaned = (rest ?? protocol)
-        .replace(/\/{2,}/g, '/')
-        .replace(/\/\.\//g, '/')
-        .replace(/\/$/, '');
-    return rest ? `${protocol}://${cleaned}` : cleaned;
+    const match = url.match(URL_PARTS_RE);
+    if (!match) {
+        return url;
+    }
+    const [, protocol = '', authority = '', pathname = '', query = '', hash = ''] = match;
+    const normalizedPath = normalizePathname(pathname);
+    const withoutRootSlash = authority && normalizedPath === '/' ? '' : normalizedPath;
+    return `${protocol}${authority}${withoutRootSlash}${query}${hash}`;
 }
 /**
  * Replaces placeholders in the provided URL template with corresponding values from the params object.
@@ -873,15 +987,59 @@ function normalizeUrl(url) {
  * @param {string} template URL template containing placeholders to replace.
  * @param {AnyDict} [params] Optional dictionary containing key-value pairs.
  * Keys correspond to placeholders in the template, and values will replace them.
+ * @param {FillUrlWithParamsOptions} [options] Placeholder materialization options.
  * @return {string} URL with placeholders replaced by corresponding values from the params object.
  * Defaults to the original template if params is not provided.
  */
-function fillUrlWithParams(template, params) {
+function fillUrlWithParams(template, params, options = {}) {
     if (!params) {
         return template;
     }
-    return template.replace(/:([a-zA-Z0-9_]+)/g, (_, k) => encodeURIComponent(params[k] ?? ''));
+    return template.replace(/:([a-zA-Z0-9_]+)/g, (_, key) => {
+        const value = params[key];
+        if (value == null) {
+            switch (options.missingParam ?? 'throw') {
+                case 'keep':
+                    return `:${key}`;
+                case 'empty':
+                    return '';
+                case 'throw':
+                default:
+                    throw new Error(`Missing URL parameter "${key}"`);
+            }
+        }
+        const encoded = encodeURIComponent(String(value));
+        return options.preserveSlash ? encoded.replaceAll('%2F', '/') : encoded;
+    });
 }
+const normalizePathname = (pathname) => {
+    if (!pathname) {
+        return '';
+    }
+    const hasLeadingSlash = pathname.startsWith('/');
+    const segments = pathname.split('/');
+    const normalized = [];
+    for (const segment of segments) {
+        if (!segment || segment === '.') {
+            continue;
+        }
+        if (segment === '..') {
+            if (normalized.length && normalized[normalized.length - 1] !== '..') {
+                normalized.pop();
+            }
+            else if (!hasLeadingSlash) {
+                normalized.push(segment);
+            }
+            continue;
+        }
+        normalized.push(segment);
+    }
+    const nextPath = `${hasLeadingSlash ? '/' : ''}${normalized.join('/')}`;
+    if (nextPath === '/') {
+        return nextPath;
+    }
+    return nextPath.replace(/\/$/, '');
+};
 /**
  * Low-level URL helper for appending query parameters to an existing URL.
  *
@@ -1001,18 +1159,17 @@ const makeQuery = (object, concatType, resolveConcatType) => {
  * @param {string} pureRoute - Template route path to match, which may include placeholders
  * (e.g., `:id`).
  * @param {boolean} [withSubroute=false] - Determines whether to allow subroute matching. If true,
- * actualRoute must start with the filled pureRoute.
+ * actualRoute must match the template exactly or continue on a segment boundary.
  * @return {boolean} Returns true if the actual route matches the template
  * route (and optional subroute condition if enabled), otherwise false.
  */
 const compareRoutes = (actualRoute, pureRoute, withSubroute = false) => {
-    if (!pureRoute.includes(':')) {
-        return withSubroute ? actualRoute.startsWith(pureRoute) : pureRoute === actualRoute;
-    }
-    else {
-        const filled = fillRouteTemplate(actualRoute, pureRoute);
-        return withSubroute ? actualRoute.startsWith(filled) : filled === actualRoute;
+    const actualSegments = splitRouteSegments(actualRoute);
+    const templateSegments = splitRouteSegments(pureRoute);
+    if ((!withSubroute && actualSegments.length !== templateSegments.length) || actualSegments.length < templateSegments.length) {
+        return false;
     }
+    return templateSegments.every((segment, index) => segment.startsWith(':') || segment === actualSegments[index]);
 };
 /**
  * Processes and materializes a route path by decoding and, if necessary, replacing route parameters.
@@ -1023,25 +1180,30 @@ const compareRoutes = (actualRoute, pureRoute, withSubroute = false) => {
  * @returns {string} Fully materialized and decoded route path.
  */
 const materializeRoutePath = (actualRoute, pureRoute) => {
-    if (!pureRoute.includes(':')) {
-        return decodeURIComponent(pureRoute);
-    }
-    else {
-        return decodeURIComponent(fillRouteTemplate(actualRoute, pureRoute));
-    }
+    const materialized = pureRoute.includes(':') ? fillRouteTemplate(actualRoute, pureRoute) : pureRoute;
+    return safeDecodeRoute(materialized);
 };
+const splitRouteSegments = (route) => route.split('/').filter(Boolean);
 const fillRouteTemplate = (actualRoute, pureRoute) => {
-    const actualSegments = actualRoute.split('/').filter(Boolean);
-    const templateSegments = pureRoute.split('/').filter(Boolean);
+    const actualSegments = splitRouteSegments(actualRoute);
+    const templateSegments = splitRouteSegments(pureRoute);
     const prefix = actualRoute.startsWith('/') ? '/' : '';
     const segments = [];
     for (let i = 0; i < templateSegments.length; i++) {
         const tempSegment = templateSegments[i];
         const actSegment = actualSegments[i];
-        segments.push(tempSegment.startsWith(':') ? actSegment : tempSegment);
+        segments.push(tempSegment.startsWith(':') ? (actSegment ?? tempSegment) : tempSegment);
     }
     return prefix + segments.join('/');
 };
+const safeDecodeRoute = (route) => {
+    try {
+        return decodeURIComponent(route);
+    }
+    catch {
+        return route;
+    }
+};
 
 /**
  * Recommended high-level entrypoint for query-string work in `internal`.
@@ -1208,61 +1370,92 @@ function sortInputToTokens(sort) {
     return normalizeSortInput(sort).map((item) => sortRuleToToken(item));
 }
 
+const getComparableKind = (value) => {
+    if (Array.isArray(value))
+        return 'array';
+    if (value instanceof Date)
+        return 'date';
+    if (value instanceof Map)
+        return 'map';
+    if (value instanceof Set)
+        return 'set';
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null ? 'plain-object' : 'unsupported';
+};
+const getMemo = (memo, a, b) => memo.get(a)?.get(b);
+const setMemo = (memo, a, b, value) => {
+    let comparisons = memo.get(a);
+    if (!comparisons) {
+        comparisons = new WeakMap();
+        memo.set(a, comparisons);
+    }
+    comparisons.set(b, value);
+};
+const memoizePair = (memo, a, b, value) => {
+    setMemo(memo, a, b, value);
+    setMemo(memo, b, a, value);
+};
 /**
- * Recursively checks the equality of two objects, including nested structures and special cases
- * such as arrays, sets, maps, dates, and NaN.
+ * Recursively compares primitives, arrays, plain objects, Date, Map, and Set values.
  *
- * `Map` and `Set` values are compared in iteration order because they are materialized into arrays
- * before comparison. This keeps the helper predictable for transport/state snapshots, but it is not
- * a mathematical set-equivalence check.
+ * Map and Set values are compared in iteration order. Object comparison includes own enumerable
+ * string keys only. Symbol and non-enumerable object keys are intentionally excluded.
  *
- * @param {AnyType} a - The first object to compare.
- * @param {AnyType} b - The second object to compare.
- * @param {Map} [seen=new Map()] - A map used to detect cyclic references
- * during deep equality check.
- * @return {boolean} - Returns true if the objects are deeply equal, otherwise returns false.
+ * @param {AnyType} a - The first value to compare.
+ * @param {AnyType} b - The second value to compare.
+ * @return {boolean} - Returns true if the supported values are deeply equal, otherwise false.
  */
-function deepEqual(a, b, seen = new Map()) {
-    if (a === b) {
-        return true;
-    }
-    if (Number.isNaN(a) && Number.isNaN(b)) {
-        return true;
-    }
-    if (a && b && typeof a === 'object' && typeof b === 'object') {
-        if (seen.get(a) === b) {
-            return true;
-        }
-        seen.set(a, b);
-        if (Array.isArray(a)) {
-            if (!Array.isArray(b) || a.length !== b.length) {
-                return false;
-            }
-            for (let i = 0; i < a.length; i++) {
-                if (!deepEqual(a[i], b[i], seen)) {
-                    return false;
-                }
-            }
-            return true;
-        }
-        if (a instanceof Date || a instanceof RegExp) {
-            return String(a) === String(b);
-        }
-        if (a instanceof Map) {
-            return deepEqual(Array.from(a.entries()), Array.from(b.entries()), seen);
-        }
-        if (a instanceof Set) {
-            return deepEqual(Array.from(a.values()), Array.from(b.values()), seen);
-        }
-        const keysA = Object.keys(a);
-        if (keysA.length !== Object.keys(b).length)
-            return false;
-        for (const k of keysA)
-            if (!Object.prototype.hasOwnProperty.call(b, k) || !deepEqual(a[k], b[k], seen))
-                return false;
+const deepEqualInternal = (a, b, memo, activeLeftToRight, activeRightToLeft) => {
+    if (Object.is(a, b))
         return true;
-    }
-    return false;
+    if (!a || !b || typeof a !== 'object' || typeof b !== 'object')
+        return false;
+    const kindA = getComparableKind(a);
+    const kindB = getComparableKind(b);
+    if (kindA !== kindB || kindA === 'unsupported')
+        return false;
+    const cached = getMemo(memo, a, b);
+    if (cached !== undefined)
+        return cached;
+    const activeMatch = activeLeftToRight.get(a);
+    if (activeMatch || activeRightToLeft.has(b)) {
+        return activeMatch === b && activeRightToLeft.get(b) === a;
+    }
+    activeLeftToRight.set(a, b);
+    activeRightToLeft.set(b, a);
+    let result = false;
+    switch (kindA) {
+        case 'array':
+            result =
+                a.length === b.length &&
+                    a.every((item, index) => deepEqualInternal(item, b[index], memo, activeLeftToRight, activeRightToLeft));
+            break;
+        case 'date':
+            result = Object.is(a.getTime(), b.getTime());
+            break;
+        case 'map':
+            result = deepEqualInternal(Array.from(a.entries()), Array.from(b.entries()), memo, activeLeftToRight, activeRightToLeft);
+            break;
+        case 'set':
+            result = deepEqualInternal(Array.from(a.values()), Array.from(b.values()), memo, activeLeftToRight, activeRightToLeft);
+            break;
+        case 'plain-object': {
+            const keysA = Object.keys(a);
+            const keysB = Object.keys(b);
+            result =
+                keysA.length === keysB.length &&
+                    keysA.every((key) => Object.prototype.hasOwnProperty.call(b, key) &&
+                        deepEqualInternal(a[key], b[key], memo, activeLeftToRight, activeRightToLeft));
+            break;
+        }
+    }
+    activeLeftToRight.delete(a);
+    activeRightToLeft.delete(b);
+    memoizePair(memo, a, b, result);
+    return result;
+};
+function deepEqual(a, b) {
+    return deepEqualInternal(a, b, new WeakMap(), new WeakMap(), new WeakMap());
 }
 
 /**
@@ -1421,7 +1614,7 @@ class Serializer {
         }
         if (typedField?.type === 'nullable' || isNullable(value, this.config.mapNullable?.includeEmptyString)) {
             const nullableVal = value ?? null;
-            return this.config.mapNullable.format?.(nullableVal) || this.config.mapNullable.replaceWith || nullableVal;
+            return this.config.mapNullable.format?.(nullableVal) ?? this.config.mapNullable.replaceWith ?? nullableVal;
         }
         if (typedField?.type === 'string') {
             return serializeString(this.config, value);
@@ -1492,27 +1685,40 @@ class Serializer {
             }
         }
         if (typedField?.type === 'nullable' || isNullable(value, this.config.mapNullable?.includeEmptyString)) {
-            return this.config.mapNullable.parse?.(value) || value;
+            return this.config.mapNullable.parse?.(value) ?? value;
+        }
+        if (typedField?.type === 'boolean') {
+            const parsed = this.config.mapBoolean.parse?.(value);
+            if (parsed !== undefined) {
+                return parsed;
+            }
+            if (value === true || value === false) {
+                return value;
+            }
+            if (value === this.config.mapBoolean.true || value === 'true') {
+                return true;
+            }
+            if (value === this.config.mapBoolean.false || value === 'false') {
+                return false;
+            }
+            throw new SerializerFieldError(key || '', 'parse', new Error(`Unknown boolean value: ${String(value)}`));
         }
-        if (typedField?.type === 'boolean' ||
-            typeof value === 'boolean' ||
-            value === this.config.mapBoolean.true ||
-            value === this.config.mapBoolean.false) {
+        if (typeof value === 'boolean' || value === this.config.mapBoolean.true || value === this.config.mapBoolean.false) {
             return this.config.mapBoolean.parse?.(value) ?? (value === this.config.mapBoolean.true || value === true);
         }
         const maybeDate = parseToDate(value, this.config.mapDate.dateFormat);
         if (typedField?.type === 'date' || maybeDate) {
-            return this.config.mapDate.parse?.(value) || maybeDate;
+            return this.config.mapDate.parse?.(value) ?? maybeDate;
         }
         const periodTransform = this.config.mapPeriod.transformMode;
         if (periodTransform.mode === 'join') {
             const maybePeriod = parseToDatePeriod(value, this.config.mapPeriod.dateFormat);
             if (typedField?.type === 'period' || (maybePeriod || []).some(Boolean)) {
-                return this.config.mapPeriod.parse?.(value) || maybePeriod;
+                return this.config.mapPeriod.parse?.(value) ?? maybePeriod;
             }
         }
         if (typedField?.type === 'number' || isNumber(value, this.config.mapNumber.fromString)) {
-            return this.config.mapNumber.parse?.(value) || Number(String(value).trim());
+            return this.config.mapNumber.parse?.(value) ?? Number(String(value).trim());
         }
         if (typedField?.type === 'string' || typeof value === 'string') {
             const parsed = this.config.mapString.parse?.(value);

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.0.4",
+  "version": "2.0.6",
   "name": "@reforgium/internal",
   "description": "Hidden Reforgium foundation package for shared primitives, tokens, and infrastructure.",
   "author": "rtommievich",
@@ -25,9 +25,6 @@
     "foundation",
     "infrastructure"
   ],
-  "types": "./src/public-api.ts",
-  "typings": "types/reforgium-internal.d.ts",
-  "module": "fesm2022/reforgium-internal.mjs",
   "files": [
     "fesm2022/*.mjs",
     "types/*.d.ts",
@@ -36,6 +33,14 @@
     "CHANGELOG.md",
     "LICENSE*"
   ],
+  "dependencies": {
+    "tslib": "^2.8.1"
+  },
+  "peerDependencies": {
+    "@angular/core": ">=18.0.0"
+  },
+  "module": "fesm2022/reforgium-internal.mjs",
+  "typings": "types/reforgium-internal.d.ts",
   "exports": {
     "./package.json": {
       "default": "./package.json"
@@ -44,11 +49,5 @@
       "types": "./types/reforgium-internal.d.ts",
       "default": "./fesm2022/reforgium-internal.mjs"
     }
-  },
-  "dependencies": {
-    "tslib": "^2.8.1"
-  },
-  "peerDependencies": {
-    "@angular/core": ">=19.0.0"
   }
 }

package/types/reforgium-internal.d.ts

@@ -271,6 +271,7 @@ declare class LocalStorage<Key = string, Type extends AnyType = AnyDict> impleme
     set(key: Key, value: Type): void;
     remove(key: Key): void;
     clear(): void;
+    private get storage();
     private getSafePrefix;
     private safePrefix;
 }
@@ -311,6 +312,7 @@ declare class SessionStorage<Key = string, Type extends AnyType = AnyDict> imple
     set(key: Key, value: Type): void;
     remove(key: Key): void;
     clear(): void;
+    private get storage();
     private getSafePrefix;
     private safePrefix;
 }
@@ -650,7 +652,7 @@ declare const toDate: (v: unknown) => Date;
  * Converts a date string from a given format to ISO (UTC).
  * Example:
  *   reformatDateToISO("24.11.2025", "dd.MM.yyyy")
- *   → "2025-11-24T00:00:00.000Z"
+ *   > "2025-11-24T00:00:00.000Z"
  */
 declare function reformatDateToISO(dateStr?: string | null, mask?: string | null): string | null;
 
@@ -729,9 +731,15 @@ type ParseQueryParams = {
     (query: string): Record<string, string>;
     (query: string, arrayMode: QueryArrayMode): Record<string, string | string[]>;
 };
+type FillUrlWithParamsOptions = {
+    missingParam?: 'empty' | 'keep' | 'throw';
+    preserveSlash?: boolean;
+};
 /**
  * Normalizes a given URL by removing redundant slashes, resolving dot segments,
- * and ensuring there are no trailing slashes at the end of the URL.
+ * and ensuring there are no trailing slashes at the end of the pathname.
+ *
+ * Query strings and hashes are preserved byte-for-byte.
  *
  * @param {string} url - The URL string to normalize.
  * @return {string} - The normalized URL string.
@@ -744,10 +752,11 @@ declare function normalizeUrl(url: string): string;
  * @param {string} template URL template containing placeholders to replace.
  * @param {AnyDict} [params] Optional dictionary containing key-value pairs.
  * Keys correspond to placeholders in the template, and values will replace them.
+ * @param {FillUrlWithParamsOptions} [options] Placeholder materialization options.
  * @return {string} URL with placeholders replaced by corresponding values from the params object.
  * Defaults to the original template if params is not provided.
  */
-declare function fillUrlWithParams(template: string, params?: AnyDict): string;
+declare function fillUrlWithParams(template: string, params?: AnyDict, options?: FillUrlWithParamsOptions): string;
 /**
  * Low-level URL helper for appending query parameters to an existing URL.
  *
@@ -803,7 +812,7 @@ declare const makeQuery: (object: AnyDict, concatType: QueryArrayMode, resolveCo
  * @param {string} pureRoute - Template route path to match, which may include placeholders
  * (e.g., `:id`).
  * @param {boolean} [withSubroute=false] - Determines whether to allow subroute matching. If true,
- * actualRoute must start with the filled pureRoute.
+ * actualRoute must match the template exactly or continue on a segment boundary.
  * @return {boolean} Returns true if the actual route matches the template
  * route (and optional subroute condition if enabled), otherwise false.
  */
@@ -899,21 +908,7 @@ declare function normalizeSortInput<Field extends string = string>(sort: SortInp
  */
 declare function sortInputToTokens<Field extends string = string>(sort: SortInput<Field>): SortToken<Field>[];
 
-/**
- * Recursively checks the equality of two objects, including nested structures and special cases
- * such as arrays, sets, maps, dates, and NaN.
- *
- * `Map` and `Set` values are compared in iteration order because they are materialized into arrays
- * before comparison. This keeps the helper predictable for transport/state snapshots, but it is not
- * a mathematical set-equivalence check.
- *
- * @param {AnyType} a - The first object to compare.
- * @param {AnyType} b - The second object to compare.
- * @param {Map} [seen=new Map()] - A map used to detect cyclic references
- * during deep equality check.
- * @return {boolean} - Returns true if the objects are deeply equal, otherwise returns false.
- */
-declare function deepEqual(a: AnyType, b: AnyType, seen?: Map<any, any>): boolean;
+declare function deepEqual(a: AnyType, b: AnyType): boolean;
 
 /**
  * Generates a short pseudo-random identifier.