angular-toolbox 0.0.8 → 0.9.0

package/esm2022/lib/framework/mock/http/path-to-regexp/string-to-token-data.mjs

@@ -0,0 +1,87 @@
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ *
+ * This source code is derived from the following original source code:
+ * - https://github.com/pillarjs/path-to-regexp
+ * - Copyright (c) 2014 Blake Embrey (hello@blakeembrey.com)
+ *
+ * Use of the original source code is governed by an MIT-style license
+ * that can be found in the LICENSE file at
+ * https://github.com/pillarjs/path-to-regexp/blob/master/LICENSE
+ */
+import { EMPTY_STRING } from "../../../../util";
+import { ASTERISK, RIGHT_CURLY_BRACE, DEFAULT_DELIMITER, END, NAME, LEFT_CURLY_BRACE, PATTERN, SEMI_COLON } from "./constants";
+import { TokenData } from "./token-data";
+import { lexer } from "./lexer";
+/**
+ * @private
+ * A NOOP `Endoder` function.
+ * @param value The input string value.
+ * @returns The input string value.
+ */
+const NOOP_VALUE = (value) => value;
+/**
+ * @private
+ * Parse a string for the raw tokens.
+ */
+export const stringToTokenData = (str, options = {}) => {
+    const { delimiter = DEFAULT_DELIMITER, encodePath = NOOP_VALUE, } = options;
+    const tokens = [];
+    const it = lexer(str);
+    let keyIndex = 0;
+    do {
+        const path = it.text();
+        if (path)
+            tokens.push(encodePath(path));
+        const name = it.tryConsume(NAME);
+        const pattern = it.tryConsume(PATTERN);
+        if (name || pattern) {
+            tokens.push({
+                name: name || String(keyIndex++),
+                pattern,
+            });
+            const next = it.peek();
+            if (next.type === ASTERISK) {
+                throw new TypeError(`Unexpected * at ${next.index}, you probably want \`/*\` or \`{/:foo}*\`: https://git.new/pathToRegexpError`);
+            }
+            continue;
+        }
+        const asterisk = it.tryConsume(ASTERISK);
+        if (asterisk) {
+            tokens.push({
+                name: String(keyIndex++),
+                pattern: `[^${escape(delimiter)}]*`,
+                modifier: ASTERISK,
+                separator: delimiter,
+            });
+            continue;
+        }
+        const open = it.tryConsume(LEFT_CURLY_BRACE);
+        if (open) {
+            const prefix = it.text();
+            const name = it.tryConsume(NAME);
+            const pattern = it.tryConsume(PATTERN);
+            const suffix = it.text();
+            const separator = it.tryConsume(SEMI_COLON) ? it.text() : prefix + suffix;
+            it.consume(RIGHT_CURLY_BRACE);
+            const modifier = it.modifier();
+            tokens.push({
+                name: name || (pattern ? String(keyIndex++) : EMPTY_STRING),
+                prefix: encodePath(prefix),
+                suffix: encodePath(suffix),
+                pattern,
+                modifier,
+                separator,
+            });
+            continue;
+        }
+        it.consume(END);
+        break;
+    } while (true);
+    return new TokenData(tokens, delimiter);
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"string-to-token-data.js","sourceRoot":"","sources":["../../../../../../../../projects/angular-toolbox/src/lib/framework/mock/http/path-to-regexp/string-to-token-data.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAChD,OAAO,EAAE,QAAQ,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,GAAG,EAAE,IAAI,EAAE,gBAAgB,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAI/H,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAKhC;;;;;GAKG;AACH,MAAM,UAAU,GAAW,CAAC,KAAa,EAAU,EAAE,CAAC,KAAK,CAAC;AAE5D;;;GAGG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAyB,CAAC,GAAW,EAAE,UAAwB,EAAE,EAAa,EAAE;IAC5G,MAAM,EACJ,SAAS,GAAG,iBAAiB,EAC7B,UAAU,GAAG,UAAU,GACxB,GAAG,OAAO,CAAC;IACZ,MAAM,MAAM,GAAY,EAAE,CAAC;IAC3B,MAAM,EAAE,GAAS,KAAK,CAAC,GAAG,CAAC,CAAC;IAC5B,IAAI,QAAQ,GAAW,CAAC,CAAC;IAEzB,GAAG,CAAC;QACF,MAAM,IAAI,GAAW,EAAE,CAAC,IAAI,EAAE,CAAC;QAC/B,IAAI,IAAI;YAAE,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC;QACxC,MAAM,IAAI,GAAuB,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;QACrD,MAAM,OAAO,GAAuB,EAAE,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;QAC3D,IAAI,IAAI,IAAI,OAAO,EAAE,CAAC;YACpB,MAAM,CAAC,IAAI,CAAC;gBACV,IAAI,EAAE,IAAI,IAAI,MAAM,CAAC,QAAQ,EAAE,CAAC;gBAChC,OAAO;aACR,CAAC,CAAC;YACH,MAAM,IAAI,GAAa,EAAE,CAAC,IAAI,EAAE,CAAC;YACjC,IAAI,IAAI,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;gBAC3B,MAAM,IAAI,SAAS,CACjB,mBAAmB,IAAI,CAAC,KAAK,+EAA+E,CAC7G,CAAC;YACJ,CAAC;YACD,SAAS;QACX,CAAC;QACD,MAAM,QAAQ,GAAG,EAAE,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;QACzC,IAAI,QAAQ,EAAE,CAAC;YACb,MAAM,CAAC,IAAI,CAAC;gBACV,IAAI,EAAE,MAAM,CAAC,QAAQ,EAAE,CAAC;gBACxB,OAAO,EAAE,KAAK,MAAM,CAAC,SAAS,CAAC,IAAI;gBACnC,QAAQ,EAAE,QAAQ;gBAClB,SAAS,EAAE,SAAS;aACrB,CAAC,CAAC;YACH,SAAS;QACX,CAAC;QAED,MAAM,IAAI,GAAuB,EAAE,CAAC,UAAU,CAAC,gBAAgB,CAAC,CAAC;QACjE,IAAI,IAAI,EAAE,CAAC;YACT,MAAM,MAAM,GAAW,EAAE,CAAC,IAAI,EAAE,CAAC;YACjC,MAAM,IAAI,GAAuB,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;YACrD,MAAM,OAAO,GAAuB,EAAE,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;YAC3D,MAAM,MAAM,GAAW,EAAE,CAAC,IAAI,EAAE,CAAC;YACjC,MAAM,SAAS,GAAuB,EAAE,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,MAAM,GAAG,MAAM,CAAC;YAE9F,EAAE,CAAC,OAAO,CAAC,iBAAiB,CAAC,CAAC;YAE9B,MAAM,QAAQ,GAAG,EAAE,CAAC,QAAQ,EAAE,CAAC;YAE/B,MAAM,CAAC,IAAI,CAAC;gBACV,IAAI,EAAE,IAAI,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC;gBAC3D,MAAM,EAAE,UAAU,CAAC,MAAM,CAAC;gBAC1B,MAAM,EAAE,UAAU,CAAC,MAAM,CAAC;gBAC1B,OAAO;gBACP,QAAQ;gBACR,SAAS;aACV,CAAC,CAAC;YACH,SAAS;QACX,CAAC;QAED,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QAChB,MAAM;IACR,CAAC,QAAQ,IAAI,EAAE;IAEf,OAAO,IAAI,SAAS,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;AAC1C,CAAC,CAAA","sourcesContent":["/**\r\n * @license\r\n * Copyright Pascal ECHEMANN. All Rights Reserved.\r\n *\r\n * Use of this source code is governed by an MIT-style license that can be found in\r\n * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license\r\n *\r\n * This source code is derived from the following original source code:\r\n * - https://github.com/pillarjs/path-to-regexp\r\n * - Copyright (c) 2014 Blake Embrey (hello@blakeembrey.com)\r\n * \r\n * Use of the original source code is governed by an MIT-style license \r\n * that can be found in the LICENSE file at\r\n * https://github.com/pillarjs/path-to-regexp/blob/master/LICENSE\r\n */\r\n\r\nimport { EMPTY_STRING } from \"../../../../util\";\r\nimport { ASTERISK, RIGHT_CURLY_BRACE, DEFAULT_DELIMITER, END, NAME, LEFT_CURLY_BRACE, PATTERN, SEMI_COLON } from \"./constants\";\r\nimport { Iter } from \"./iter\";\r\nimport { ParseOptions } from \"./model/parse-options\";\r\nimport { Token } from \"./model/token\";\r\nimport { TokenData } from \"./token-data\";\r\nimport { lexer } from \"./lexer\";\r\nimport { Encode } from \"./model/encode\";\r\nimport { RouteStringTokenizer } from \"./model/route-string-tokenizer\";\r\nimport { LexToken } from \"./model/lex-token\";\r\n\r\n/**\r\n * @private\r\n * A NOOP `Endoder` function.\r\n * @param value The input string value.\r\n * @returns The input string value.\r\n */\r\nconst NOOP_VALUE: Encode = (value: string): string => value;\r\n\r\n/**\r\n * @private\r\n * Parse a string for the raw tokens.\r\n */\r\nexport const stringToTokenData: RouteStringTokenizer = (str: string, options: ParseOptions = {}): TokenData => {\r\n  const {\r\n    delimiter = DEFAULT_DELIMITER,\r\n    encodePath = NOOP_VALUE,\r\n  } = options;\r\n  const tokens: Token[] = [];\r\n  const it: Iter = lexer(str);\r\n  let keyIndex: number = 0;\r\n\r\n  do {\r\n    const path: string = it.text();\r\n    if (path) tokens.push(encodePath(path));\r\n    const name: string | undefined = it.tryConsume(NAME);\r\n    const pattern: string | undefined = it.tryConsume(PATTERN);\r\n    if (name || pattern) {\r\n      tokens.push({\r\n        name: name || String(keyIndex++),\r\n        pattern,\r\n      });\r\n      const next: LexToken = it.peek();\r\n      if (next.type === ASTERISK) {\r\n        throw new TypeError(\r\n          `Unexpected * at ${next.index}, you probably want \\`/*\\` or \\`{/:foo}*\\`: https://git.new/pathToRegexpError`,\r\n        );\r\n      }\r\n      continue;\r\n    }\r\n    const asterisk = it.tryConsume(ASTERISK);\r\n    if (asterisk) {\r\n      tokens.push({\r\n        name: String(keyIndex++),\r\n        pattern: `[^${escape(delimiter)}]*`,\r\n        modifier: ASTERISK,\r\n        separator: delimiter,\r\n      });\r\n      continue;\r\n    }\r\n\r\n    const open: string | undefined = it.tryConsume(LEFT_CURLY_BRACE);\r\n    if (open) {\r\n      const prefix: string = it.text();\r\n      const name: string | undefined = it.tryConsume(NAME);\r\n      const pattern: string | undefined = it.tryConsume(PATTERN);\r\n      const suffix: string = it.text();\r\n      const separator: string | undefined = it.tryConsume(SEMI_COLON) ? it.text() : prefix + suffix;\r\n\r\n      it.consume(RIGHT_CURLY_BRACE);\r\n\r\n      const modifier = it.modifier();\r\n\r\n      tokens.push({\r\n        name: name || (pattern ? String(keyIndex++) : EMPTY_STRING),\r\n        prefix: encodePath(prefix),\r\n        suffix: encodePath(suffix),\r\n        pattern,\r\n        modifier,\r\n        separator,\r\n      });\r\n      continue;\r\n    }\r\n\r\n    it.consume(END);\r\n    break;\r\n  } while (true);\r\n\r\n  return new TokenData(tokens, delimiter);\r\n}\r\n"]}

package/esm2022/lib/framework/mock/http/path-to-regexp/to-key-regexp.mjs

@@ -0,0 +1,41 @@
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ *
+ * This source code is derived from the following original source code:
+ * - https://github.com/pillarjs/path-to-regexp
+ * - Copyright (c) 2014 Blake Embrey (hello@blakeembrey.com)
+ *
+ * Use of the original source code is governed by an MIT-style license
+ * that can be found in the LICENSE file at
+ * https://github.com/pillarjs/path-to-regexp/blob/master/LICENSE
+ */
+import { EMPTY_STRING } from "../../../../util";
+import { ASTERISK, PLUS, QUESTION_MARK } from "./constants";
+import { escapeRegexpString } from "./escape-to-regexp-string";
+/**
+ * @private
+ * Returns a function that converts a token into a regexp string.
+ */
+export const toKeyRegexp = (stringify, delimiter) => {
+    const segmentPattern = `[^${escapeRegexpString(delimiter)}]+?`;
+    return (key) => {
+        const prefix = key.prefix ? stringify(key.prefix) : EMPTY_STRING;
+        const suffix = key.suffix ? stringify(key.suffix) : EMPTY_STRING;
+        const modifier = key.modifier || EMPTY_STRING;
+        if (key.name) {
+            const pattern = key.pattern || segmentPattern;
+            if (key.modifier === PLUS || key.modifier === ASTERISK) {
+                const mod = key.modifier === ASTERISK ? QUESTION_MARK : EMPTY_STRING;
+                const split = key.separator ? stringify(key.separator) : EMPTY_STRING;
+                return `(?:${prefix}((?:${pattern})(?:${split}(?:${pattern}))*)${suffix})${mod}`;
+            }
+            return `(?:${prefix}(${pattern})${suffix})${modifier}`;
+        }
+        return `(?:${prefix}${suffix})${modifier}`;
+    };
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/framework/mock/http/path-to-regexp/to-stringify.mjs

@@ -0,0 +1,29 @@
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ *
+ * This source code is derived from the following original source code:
+ * - https://github.com/pillarjs/path-to-regexp
+ * - Copyright (c) 2014 Blake Embrey (hello@blakeembrey.com)
+ *
+ * Use of the original source code is governed by an MIT-style license
+ * that can be found in the LICENSE file at
+ * https://github.com/pillarjs/path-to-regexp/blob/master/LICENSE
+ */
+import { G_FLAG } from "./constants";
+import { escapeRegexpString } from "./escape-to-regexp-string";
+import { looseReplacer } from "./loose-replacer";
+/**
+ * @private
+ * Encode all non-delimiter characters using the encode function.
+ */
+export const toStringify = (loose, delimiter) => {
+    if (!loose)
+        return escapeRegexpString;
+    const re = new RegExp(`[^${escapeRegexpString(delimiter)}]+|(.)`, G_FLAG);
+    return (value) => value.replace(re, looseReplacer);
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/framework/mock/http/path-to-regexp/token-data-to-regexp.mjs

@@ -0,0 +1,49 @@
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ *
+ * This source code is derived from the following original source code:
+ * - https://github.com/pillarjs/path-to-regexp
+ * - Copyright (c) 2014 Blake Embrey (hello@blakeembrey.com)
+ *
+ * Use of the original source code is governed by an MIT-style license
+ * that can be found in the LICENSE file at
+ * https://github.com/pillarjs/path-to-regexp/blob/master/LICENSE
+ */
+import { EMPTY_STRING, STRING } from "../../../../util";
+import { CARRET, DOLLAR } from "./constants";
+import { escapeRegexpString } from "./escape-to-regexp-string";
+import { getFlags } from "./get-flags";
+import { toKeyRegexp } from "./to-key-regexp";
+import { toStringify } from "./to-stringify";
+/**
+ * @Private
+ * Expose a function for taking tokens and returning a RegExp.
+ */
+export const tokenDataToRegexp = (data, keys, options) => {
+    const { trailing = true, start = true, end = true, loose = true, } = options;
+    const stringify = toStringify(loose, data.delimiter);
+    const keyToRegexp = toKeyRegexp(stringify, data.delimiter);
+    let pattern = start ? CARRET : EMPTY_STRING;
+    for (const token of data.tokens) {
+        if (typeof token === STRING) {
+            pattern += stringify(token);
+        }
+        else {
+            if (token.name)
+                keys.push(token);
+            pattern += keyToRegexp(token);
+        }
+    }
+    if (trailing)
+        pattern += `(?:${stringify(data.delimiter)})?`;
+    pattern += end ? DOLLAR : `(?=${escapeRegexpString(data.delimiter)}|$)`;
+    // URLs in general are case-sensitive (with the exception of machine names).
+    // See https://www.w3.org/TR/WD-html40-970708/htmlweb.html
+    // Note that default modifier is "i".
+    return new RegExp(pattern, getFlags(options));
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9rZW4tZGF0YS10by1yZWdleHAuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLXRvb2xib3gvc3JjL2xpYi9mcmFtZXdvcmsvbW9jay9odHRwL3BhdGgtdG8tcmVnZXhwL3Rva2VuLWRhdGEtdG8tcmVnZXhwLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7OztHQWNHO0FBRUgsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUN4RCxPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUU3QyxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUUvRCxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sYUFBYSxDQUFDO0FBSXZDLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUM5QyxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFHN0M7OztHQUdHO0FBQ0gsTUFBTSxDQUFDLE1BQU0saUJBQWlCLEdBQTJCLENBQUMsSUFBZSxFQUFFLElBQVcsRUFBRSxPQUE0QixFQUFVLEVBQUU7SUFDOUgsTUFBTSxFQUNKLFFBQVEsR0FBRyxJQUFJLEVBQ2YsS0FBSyxHQUFHLElBQUksRUFDWixHQUFHLEdBQUcsSUFBSSxFQUNWLEtBQUssR0FBRyxJQUFJLEdBQ2IsR0FBRyxPQUFPLENBQUM7SUFDWixNQUFNLFNBQVMsR0FBVyxXQUFXLENBQUMsS0FBSyxFQUFFLElBQUksQ0FBQyxTQUFTLENBQUMsQ0FBQztJQUM3RCxNQUFNLFdBQVcsR0FBc0IsV0FBVyxDQUFDLFNBQVMsRUFBRSxJQUFJLENBQUMsU0FBUyxDQUFDLENBQUM7SUFDOUUsSUFBSSxPQUFPLEdBQVcsS0FBSyxDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLFlBQVksQ0FBQztJQUVwRCxLQUFLLE1BQU0sS0FBSyxJQUFJLElBQUksQ0FBQyxNQUFhLEVBQUUsQ0FBQztRQUN2QyxJQUFJLE9BQU8sS0FBSyxLQUFLLE1BQU0sRUFBRSxDQUFDO1lBQzVCLE9BQU8sSUFBSSxTQUFTLENBQUMsS0FBSyxDQUFDLENBQUM7UUFDOUIsQ0FBQzthQUFNLENBQUM7WUFDTixJQUFJLEtBQUssQ0FBQyxJQUFJO2dCQUFFLElBQUksQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUM7WUFDakMsT0FBTyxJQUFJLFdBQVcsQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUNoQyxDQUFDO0lBQ0gsQ0FBQztJQUVELElBQUksUUFBUTtRQUFFLE9BQU8sSUFBSSxNQUFNLFNBQVMsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQztJQUM3RCxPQUFPLElBQUksR0FBRyxDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLE1BQU0sa0JBQWtCLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxLQUFLLENBQUM7SUFFeEUsNEVBQTRFO0lBQzVFLDBEQUEwRDtJQUMxRCxxQ0FBcUM7SUFDckMsT0FBTyxJQUFJLE1BQU0sQ0FBQyxPQUFPLEVBQUUsUUFBUSxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUM7QUFDaEQsQ0FBQyxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXHJcbiAqIEBsaWNlbnNlXHJcbiAqIENvcHlyaWdodCBQYXNjYWwgRUNIRU1BTk4uIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXHJcbiAqXHJcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlIGZvdW5kIGluXHJcbiAqIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9wYXNjYWxlY2hlbWFubi5jb20vYW5ndWxhci10b29sYm94L3Jlc291cmNlcy9saWNlbnNlXHJcbiAqXHJcbiAqIFRoaXMgc291cmNlIGNvZGUgaXMgZGVyaXZlZCBmcm9tIHRoZSBmb2xsb3dpbmcgb3JpZ2luYWwgc291cmNlIGNvZGU6XHJcbiAqIC0gaHR0cHM6Ly9naXRodWIuY29tL3BpbGxhcmpzL3BhdGgtdG8tcmVnZXhwXHJcbiAqIC0gQ29weXJpZ2h0IChjKSAyMDE0IEJsYWtlIEVtYnJleSAoaGVsbG9AYmxha2VlbWJyZXkuY29tKVxyXG4gKiBcclxuICogVXNlIG9mIHRoZSBvcmlnaW5hbCBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSBcclxuICogdGhhdCBjYW4gYmUgZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdFxyXG4gKiBodHRwczovL2dpdGh1Yi5jb20vcGlsbGFyanMvcGF0aC10by1yZWdleHAvYmxvYi9tYXN0ZXIvTElDRU5TRVxyXG4gKi9cclxuXHJcbmltcG9ydCB7IEVNUFRZX1NUUklORywgU1RSSU5HIH0gZnJvbSBcIi4uLy4uLy4uLy4uL3V0aWxcIjtcclxuaW1wb3J0IHsgQ0FSUkVULCBET0xMQVIgfSBmcm9tIFwiLi9jb25zdGFudHNcIjtcclxuaW1wb3J0IHsgRW5jb2RlIH0gZnJvbSBcIi4vbW9kZWwvZW5jb2RlXCI7XHJcbmltcG9ydCB7IGVzY2FwZVJlZ2V4cFN0cmluZyB9IGZyb20gXCIuL2VzY2FwZS10by1yZWdleHAtc3RyaW5nXCI7XHJcbmltcG9ydCB7IEtleSB9IGZyb20gXCIuL21vZGVsL2tleVwiO1xyXG5pbXBvcnQgeyBnZXRGbGFncyB9IGZyb20gXCIuL2dldC1mbGFnc1wiO1xyXG5pbXBvcnQgeyBQYXRoVG9SZWdleHBPcHRpb25zIH0gZnJvbSBcIi4vbW9kZWwvcGF0aC10by1yZWdleHAtb3B0aW9uc1wiO1xyXG5pbXBvcnQgeyBUb2tlbkRhdGEgfSBmcm9tIFwiLi90b2tlbi1kYXRhXCI7XHJcbmltcG9ydCB7IERlY29kZUtleVRvU3RyaW5nIH0gZnJvbSBcIi4vbW9kZWwvZGVjb2RlLWtleS10by1zdHJpbmdcIjtcclxuaW1wb3J0IHsgdG9LZXlSZWdleHAgfSBmcm9tIFwiLi90by1rZXktcmVnZXhwXCI7XHJcbmltcG9ydCB7IHRvU3RyaW5naWZ5IH0gZnJvbSBcIi4vdG8tc3RyaW5naWZ5XCI7XHJcbmltcG9ydCB7IFRva2VuRGF0YVJlZ0V4cEZhY3RvcnkgfSBmcm9tIFwiLi9tb2RlbC90b2tlbi1kYXRhLXJlZ2V4cC1mYWN0b3J5XCI7XHJcblxyXG4vKipcclxuICogQFByaXZhdGVcclxuICogRXhwb3NlIGEgZnVuY3Rpb24gZm9yIHRha2luZyB0b2tlbnMgYW5kIHJldHVybmluZyBhIFJlZ0V4cC5cclxuICovXHJcbmV4cG9ydCBjb25zdCB0b2tlbkRhdGFUb1JlZ2V4cDogVG9rZW5EYXRhUmVnRXhwRmFjdG9yeSA9IChkYXRhOiBUb2tlbkRhdGEsIGtleXM6IEtleVtdLCBvcHRpb25zOiBQYXRoVG9SZWdleHBPcHRpb25zKTogUmVnRXhwID0+IHtcclxuICBjb25zdCB7XHJcbiAgICB0cmFpbGluZyA9IHRydWUsXHJcbiAgICBzdGFydCA9IHRydWUsXHJcbiAgICBlbmQgPSB0cnVlLFxyXG4gICAgbG9vc2UgPSB0cnVlLFxyXG4gIH0gPSBvcHRpb25zO1xyXG4gIGNvbnN0IHN0cmluZ2lmeTogRW5jb2RlID0gdG9TdHJpbmdpZnkobG9vc2UsIGRhdGEuZGVsaW1pdGVyKTtcclxuICBjb25zdCBrZXlUb1JlZ2V4cDogRGVjb2RlS2V5VG9TdHJpbmcgPSB0b0tleVJlZ2V4cChzdHJpbmdpZnksIGRhdGEuZGVsaW1pdGVyKTtcclxuICBsZXQgcGF0dGVybjogc3RyaW5nID0gc3RhcnQgPyBDQVJSRVQgOiBFTVBUWV9TVFJJTkc7XHJcbiAgXHJcbiAgZm9yIChjb25zdCB0b2tlbiBvZiBkYXRhLnRva2VucyBhcyBhbnkpIHtcclxuICAgIGlmICh0eXBlb2YgdG9rZW4gPT09IFNUUklORykge1xyXG4gICAgICBwYXR0ZXJuICs9IHN0cmluZ2lmeSh0b2tlbik7XHJcbiAgICB9IGVsc2Uge1xyXG4gICAgICBpZiAodG9rZW4ubmFtZSkga2V5cy5wdXNoKHRva2VuKTtcclxuICAgICAgcGF0dGVybiArPSBrZXlUb1JlZ2V4cCh0b2tlbik7XHJcbiAgICB9XHJcbiAgfVxyXG5cclxuICBpZiAodHJhaWxpbmcpIHBhdHRlcm4gKz0gYCg/OiR7c3RyaW5naWZ5KGRhdGEuZGVsaW1pdGVyKX0pP2A7XHJcbiAgcGF0dGVybiArPSBlbmQgPyBET0xMQVIgOiBgKD89JHtlc2NhcGVSZWdleHBTdHJpbmcoZGF0YS5kZWxpbWl0ZXIpfXwkKWA7XHJcblxyXG4gIC8vIFVSTHMgaW4gZ2VuZXJhbCBhcmUgY2FzZS1zZW5zaXRpdmUgKHdpdGggdGhlIGV4Y2VwdGlvbiBvZiBtYWNoaW5lIG5hbWVzKS5cclxuICAvLyBTZWUgaHR0cHM6Ly93d3cudzMub3JnL1RSL1dELWh0bWw0MC05NzA3MDgvaHRtbHdlYi5odG1sXHJcbiAgLy8gTm90ZSB0aGF0IGRlZmF1bHQgbW9kaWZpZXIgaXMgXCJpXCIuXHJcbiAgcmV0dXJuIG5ldyBSZWdFeHAocGF0dGVybiwgZ2V0RmxhZ3Mob3B0aW9ucykpO1xyXG59XHJcbiJdfQ==

package/esm2022/lib/framework/mock/http/path-to-regexp/token-data.mjs

@@ -0,0 +1,33 @@
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ *
+ * This source code is derived from the following original source code:
+ * - https://github.com/pillarjs/path-to-regexp
+ * - Copyright (c) 2014 Blake Embrey (hello@blakeembrey.com)
+ *
+ * Use of the original source code is governed by an MIT-style license
+ * that can be found in the LICENSE file at
+ * https://github.com/pillarjs/path-to-regexp/blob/master/LICENSE
+ */
+/**
+ * @private
+ * Tokenized path instance.
+ */
+export class TokenData {
+    /**
+     * @private
+     * Creates a new `TokenData` instance.
+     *
+     * @param tokens A list of `Token` objects.
+     * @param delimiter the string delimiter for this `TokenData` instance.
+     */
+    constructor(tokens, delimiter) {
+        this.tokens = tokens;
+        this.delimiter = delimiter;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/framework/mock/http/util/data-storage.builder.mjs

@@ -0,0 +1,35 @@
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+import { EMPTY_STRING } from "projects/angular-toolbox/src/public-api";
+/**
+ * @private
+ * A static utility class for building `DataStorage` objects.
+ */
+export class DataStorageBuilder {
+    /**
+     * @private
+     * Builds and returns a new `DataStorage` objects.
+     *
+     * @param httpResponse The `HttpResponseMock` to be stored by the framework.
+     * @param data The data of the HTTP response to be stored by the framework.
+     *
+     * @returns A new `DataStorage` objects.
+     */
+    static buildDataStorage(httpResponse, data) {
+        // TODO: add support for different data types (string, Blob, etc.)
+        const stringifiedData = data ? JSON.stringify(data) : EMPTY_STRING;
+        return {
+            httpResponse: httpResponse,
+            loaded: 0,
+            total: data ? new Blob([stringifiedData]).size : 0,
+            data: data,
+            stringifiedData: stringifiedData
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/framework/mock/http/util/http-headers-mock.builder.mjs

@@ -0,0 +1,138 @@
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+import { HttpHeaders } from "@angular/common/http";
+/**
+ * A statefull builder for creating new `HttpHeaders` instances.
+ */
+export class HttpHeadersMockBuilder {
+    constructor() {
+        /**
+         * @private
+         */
+        this._headers = new HttpHeaders();
+    }
+    /**
+     * Sets the `"Cache-Control"` property of the new `HttpHeaders` instance with the specified value.
+     *
+     * @param value The value used to set the `"Cache-Control"` property of the new `HttpHeaders` instance.
+     * Default value is `"no-cache"`.
+     *
+     * @returns A reference to this `HttpResponseMockBuilder` instance.
+     */
+    cacheControl(value = "no-cache") {
+        this.setHeader("Cache-Control", value);
+        return this;
+    }
+    /**
+     * Sets the `"CContent-Type"` property of the new `HttpHeaders` instance with the specified value.
+     *
+     * @param value The value used to set the `"Content-Type"` property of the new `HttpHeaders` instance.
+     * Default value is `"application/json; charset=utf-8"`.
+     *
+     * @returns A reference to this `HttpResponseMockBuilder` instance.
+     */
+    contentType(value = "application/json; charset=utf-8") {
+        this.setHeader("Content-Type", value);
+        return this;
+    }
+    /**
+     * Sets the `"Priority"` property of the new `HttpHeaders` instance with the specified value.
+     *
+     * @param value The value used to set the `"Priority"` property of the new `HttpHeaders` instance.
+     * Default value is `"u=0, i"`.
+     *
+     * @returns A reference to this `HttpResponseMockBuilder` instance.
+     */
+    priority(value = "u=0, i") {
+        this.setHeader("Priority", value);
+        return this;
+    }
+    /**
+     * Sets the `"User-Agent"` property of the new `HttpHeaders` instance with the specified value.
+     *
+     * @param value The value used to set the `"User-Agent"` property of the new `HttpHeaders` instance.
+     * Default value is the navigator user agent.
+     *
+     * @returns A reference to this `HttpResponseMockBuilder` instance.
+     */
+    userAgent(value = null) {
+        this.setHeader("User-Agent", value || navigator.userAgent);
+        return this;
+    }
+    /**
+     * Sets the `"Accept-Language"` property of the new `HttpHeaders` instance with the specified value.
+     *
+     * @param value The value used to set the `"Accept-Language"` property of the new `HttpHeaders` instance.
+     * Default value is the navigator language.
+     *
+     * @returns A reference to this `HttpResponseMockBuilder` instance.
+     */
+    acceptLanguage(value = null) {
+        this.setHeader("Accept-Language", value || navigator.language);
+        return this;
+    }
+    /**
+     * Sets the `"Accept"` property of the new `HttpHeaders` instance with the specified value.
+     *
+     * @param value The value used to set the `"Accept"` property of the new `HttpHeaders` instance.
+     * Default value is `'*\/*'`.
+     *
+     * @returns A reference to this `HttpResponseMockBuilder` instance.
+     */
+    accept(value = "*/*") {
+        this.setHeader("Accept", value);
+        return this;
+    }
+    /**
+     * Sets the `"Accept-Encoding"` property of the new `HttpHeaders` instance with the specified value.
+     *
+     * @param value The value used to set the `"Accept-Encoding"` property of the new `HttpHeaders` instance.
+     * Default value is `"ngzip, deflate, br, zstd"`.
+     *
+     * @returns A reference to this `HttpResponseMockBuilder` instance.
+     */
+    acceptEncoding(value = "gzip, deflate, br, zstd") {
+        this.setHeader("Accept-Encoding", value);
+        return this;
+    }
+    /**
+     * Sets or modifies a value of the new `HttpHeaders` instance.
+     *
+     * @param name The header name.
+     * @param value The value or values to set or override for the given header.
+     *
+     * @returns A reference to this `HttpResponseMockBuilder` instance.
+     */
+    set(name, value) {
+        this.setHeader(name, value);
+        return this;
+    }
+    /**
+     * Return a new `HttpHeaders` instance, built from the properties specified with the
+     * `HttpHeadersMockBuilder` methods.
+     *
+     * @returns A new `HttpHeaders` instance.
+     */
+    headers() {
+        return this._headers;
+    }
+    /**
+     * @private
+     */
+    setHeader(name, value) {
+        const values = Array.isArray(value) ? value.join(", ") : value;
+        this._headers = this._headers.set(name, values);
+    }
+}
+/**
+ * A utility function used to create new "chainable" `HttpHeadersMockBuilder` instances.
+ *
+ * @returns A new `HttpHeadersMockBuilder` instance;
+ */
+export const httpHeadersMock = () => new HttpHeadersMockBuilder();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http-headers-mock.builder.js","sourceRoot":"","sources":["../../../../../../../../projects/angular-toolbox/src/lib/framework/mock/http/util/http-headers-mock.builder.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAEnD;;GAEG;AACH,MAAM,OAAO,sBAAsB;IAAnC;QAEI;;WAEG;QACK,aAAQ,GAAgB,IAAI,WAAW,EAAE,CAAC;IA2HtD,CAAC;IAzHG;;;;;;;OAOG;IACI,YAAY,CAAC,QAAgB,UAAU;QAC1C,IAAI,CAAC,SAAS,CAAC,eAAe,EAAE,KAAK,CAAC,CAAC;QACvC,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;;;;OAOG;IACI,WAAW,CAAC,QAAgB,iCAAiC;QAChE,IAAI,CAAC,SAAS,CAAC,cAAc,EAAE,KAAK,CAAC,CAAC;QACtC,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;;;;OAOG;IACI,QAAQ,CAAC,QAAgB,QAAQ;QACpC,IAAI,CAAC,SAAS,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;QAClC,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;;;;OAOG;IACI,SAAS,CAAC,QAAuB,IAAI;QACxC,IAAI,CAAC,SAAS,CAAC,YAAY,EAAE,KAAK,IAAI,SAAS,CAAC,SAAS,CAAC,CAAC;QAC3D,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;;;;OAOG;IACI,cAAc,CAAC,QAAuB,IAAI;QAC7C,IAAI,CAAC,SAAS,CAAC,iBAAiB,EAAE,KAAK,IAAI,SAAS,CAAC,QAAQ,CAAC,CAAC;QAC/D,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;;;;OAOG;IACI,MAAM,CAAC,QAAgB,KAAK;QAC/B,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;QAChC,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;;;;OAOG;IACI,cAAc,CAAC,QAAgB,yBAAyB;QAC3D,IAAI,CAAC,SAAS,CAAC,iBAAiB,EAAE,KAAK,CAAC,CAAC;QACzC,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;;;;OAOG;IACI,GAAG,CAAC,IAAY,EAAE,KAAwB;QAC7C,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;QAC5B,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;;OAKG;IACI,OAAO;QACV,OAAO,IAAI,CAAC,QAAQ,CAAC;IACzB,CAAC;IAED;;OAEG;IACK,SAAS,CAAC,IAAY,EAAE,KAAwB;QACpD,MAAM,MAAM,GAAW,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;QACvE,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;IACpD,CAAC;CACJ;AAED;;;;GAIG;AACH,MAAM,CAAC,MAAM,eAAe,GAA+B,GAAE,EAAE,CAAC,IAAI,sBAAsB,EAAE,CAAC","sourcesContent":["/**\r\n * @license\r\n * Copyright Pascal ECHEMANN. All Rights Reserved.\r\n *\r\n * Use of this source code is governed by an MIT-style license that can be found in\r\n * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license\r\n */\r\n\r\nimport { HttpHeaders } from \"@angular/common/http\";\r\n\r\n/**\r\n * A statefull builder for creating new `HttpHeaders` instances.\r\n */\r\nexport class HttpHeadersMockBuilder {\r\n\r\n    /**\r\n     * @private\r\n     */\r\n    private _headers: HttpHeaders = new HttpHeaders();\r\n\r\n    /**\r\n     * Sets the `\"Cache-Control\"` property of the new `HttpHeaders` instance with the specified value.\r\n     * \r\n     * @param value The value used to set the `\"Cache-Control\"` property of the new `HttpHeaders` instance.\r\n     * Default value is `\"no-cache\"`.\r\n     * \r\n     * @returns A reference to this `HttpResponseMockBuilder` instance.\r\n     */\r\n    public cacheControl(value: string = \"no-cache\"): HttpHeadersMockBuilder {\r\n        this.setHeader(\"Cache-Control\", value);\r\n        return this;\r\n    }\r\n    \r\n    /**\r\n     * Sets the `\"CContent-Type\"` property of the new `HttpHeaders` instance with the specified value.\r\n     * \r\n     * @param value The value used to set the `\"Content-Type\"` property of the new `HttpHeaders` instance.\r\n     * Default value is `\"application/json; charset=utf-8\"`.\r\n     * \r\n     * @returns A reference to this `HttpResponseMockBuilder` instance.\r\n     */\r\n    public contentType(value: string = \"application/json; charset=utf-8\"): HttpHeadersMockBuilder {\r\n        this.setHeader(\"Content-Type\", value);\r\n        return this;\r\n    }\r\n\r\n    /**\r\n     * Sets the `\"Priority\"` property of the new `HttpHeaders` instance with the specified value.\r\n     * \r\n     * @param value The value used to set the `\"Priority\"` property of the new `HttpHeaders` instance.\r\n     * Default value is `\"u=0, i\"`.\r\n     * \r\n     * @returns A reference to this `HttpResponseMockBuilder` instance.\r\n     */\r\n    public priority(value: string = \"u=0, i\"): HttpHeadersMockBuilder {\r\n        this.setHeader(\"Priority\", value);\r\n        return this;\r\n    }\r\n\r\n    /**\r\n     * Sets the `\"User-Agent\"` property of the new `HttpHeaders` instance with the specified value.\r\n     * \r\n     * @param value The value used to set the `\"User-Agent\"` property of the new `HttpHeaders` instance.\r\n     * Default value is the navigator user agent.\r\n     * \r\n     * @returns A reference to this `HttpResponseMockBuilder` instance.\r\n     */\r\n    public userAgent(value: string | null = null): HttpHeadersMockBuilder {\r\n        this.setHeader(\"User-Agent\", value || navigator.userAgent);\r\n        return this;\r\n    }\r\n\r\n    /**\r\n     * Sets the `\"Accept-Language\"` property of the new `HttpHeaders` instance with the specified value.\r\n     * \r\n     * @param value The value used to set the `\"Accept-Language\"` property of the new `HttpHeaders` instance.\r\n     * Default value is the navigator language.\r\n     * \r\n     * @returns A reference to this `HttpResponseMockBuilder` instance.\r\n     */\r\n    public acceptLanguage(value: string | null = null): HttpHeadersMockBuilder {\r\n        this.setHeader(\"Accept-Language\", value || navigator.language);\r\n        return this;\r\n    }\r\n\r\n    /**\r\n     * Sets the `\"Accept\"` property of the new `HttpHeaders` instance with the specified value.\r\n     * \r\n     * @param value The value used to set the `\"Accept\"` property of the new `HttpHeaders` instance.\r\n     * Default value is `'*\\/*'`.\r\n     * \r\n     * @returns A reference to this `HttpResponseMockBuilder` instance.\r\n     */\r\n    public accept(value: string = \"*/*\"): HttpHeadersMockBuilder {\r\n        this.setHeader(\"Accept\", value);\r\n        return this;\r\n    }\r\n\r\n    /**\r\n     * Sets the `\"Accept-Encoding\"` property of the new `HttpHeaders` instance with the specified value.\r\n     * \r\n     * @param value The value used to set the `\"Accept-Encoding\"` property of the new `HttpHeaders` instance.\r\n     * Default value is `\"ngzip, deflate, br, zstd\"`.\r\n     * \r\n     * @returns A reference to this `HttpResponseMockBuilder` instance.\r\n     */\r\n    public acceptEncoding(value: string = \"gzip, deflate, br, zstd\"): HttpHeadersMockBuilder {\r\n        this.setHeader(\"Accept-Encoding\", value);\r\n        return this;\r\n    }\r\n\r\n    /**\r\n     * Sets or modifies a value of the new `HttpHeaders` instance.\r\n     *\r\n     * @param name The header name.\r\n     * @param value The value or values to set or override for the given header.\r\n     * \r\n     * @returns A reference to this `HttpResponseMockBuilder` instance.\r\n     */\r\n    public set(name: string, value: string | string[]): HttpHeadersMockBuilder {\r\n        this.setHeader(name, value);\r\n        return this;\r\n    }\r\n\r\n    /**\r\n     * Return a new `HttpHeaders` instance, built from the properties specified with the\r\n     * `HttpHeadersMockBuilder` methods.\r\n     * \r\n     * @returns A new `HttpHeaders` instance.\r\n     */\r\n    public headers(): HttpHeaders {\r\n        return this._headers;\r\n    }\r\n\r\n    /**\r\n     * @private\r\n     */\r\n    private setHeader(name: string, value: string | string[]): void {\r\n        const values: string = Array.isArray(value) ? value.join(\", \") : value;\r\n        this._headers = this._headers.set(name, values);\r\n    }\r\n}\r\n\r\n/**\r\n * A utility function used to create new \"chainable\" `HttpHeadersMockBuilder` instances.\r\n * \r\n * @returns A new `HttpHeadersMockBuilder` instance;\r\n */\r\nexport const httpHeadersMock:()=> HttpHeadersMockBuilder = ()=> new HttpHeadersMockBuilder();"]}

package/esm2022/lib/framework/mock/http/util/http-headers.util.mjs

@@ -0,0 +1,56 @@
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+import { EMPTY_STRING } from "../../../../util";
+import { httpHeadersMock } from "./http-headers-mock.builder";
+/**
+ * @private
+ * Internal reference to a new line character.
+ */
+const NL = "\n";
+/**
+ * @private
+ * A set of static utilities for manipulating `HttpHeaders` objects.
+ */
+export class HttpHeadersUtil {
+    /**
+     * @private
+     * Returns a string representation the the specified `HttpHeaders `object, compatible with the format
+     * expected by the `XMLHttpRequest.getAllResponseHeaders()` method.
+     *
+     * @param headers The `HttpHeaders` object to format.
+     *
+     * @returns A string compatible with the format expected by the `XMLHttpRequest.getAllResponseHeaders()` method.
+     */
+    static stringify(headers) {
+        let result = EMPTY_STRING;
+        if (!headers)
+            return result;
+        const keys = headers.keys();
+        const last = keys.length - 1;
+        keys.forEach((key, index) => {
+            result += `${key}: ${headers.getAll(key)}${index !== last ? NL : EMPTY_STRING}`;
+        });
+        return result;
+    }
+    /**
+     * @private
+     * Creates the default `HttpHeaders` object for a mocked HTTP request.
+     *
+     * @returns The default `HttpHeaders` object for a mocked HTTP request.
+     */
+    static createDefaultRequestHeaders() {
+        // "Accept" header is set by Angular framework when missing
+        return httpHeadersMock().cacheControl()
+            .acceptEncoding()
+            .acceptLanguage()
+            .priority()
+            .userAgent()
+            .headers();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/framework/mock/http/util/http-method-ref.enum.mjs

@@ -0,0 +1,60 @@
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+/**
+ * @private
+ * Provides the list of HTTP verbs.
+ */
+export var HTTPMethodRef;
+(function (HTTPMethodRef) {
+    /**
+     * @private
+     * A reference to the `connect` route associated with the `CONNECT` HTTP verb.
+     */
+    HTTPMethodRef["CONNECT"] = "connect";
+    /**
+     * @private
+     * A reference to the `delete` route associated with the `DELETE` HTTP verb.
+     */
+    HTTPMethodRef["DELETE"] = "delete";
+    /**
+     * @private
+     * A reference to the `get` route associated with the `GET` HTTP verb.
+     */
+    HTTPMethodRef["GET"] = "get";
+    /**
+     * @private
+     * A reference to the `head` route associated with the `HEAD` HTTP verb.
+     */
+    HTTPMethodRef["HEAD"] = "head";
+    /**
+     * @private
+     * A reference to the `options` route associated with the `OPTIONS` HTTP verb.
+     */
+    HTTPMethodRef["OPTIONS"] = "options";
+    /**
+     * @private
+     * A reference to the `patch` route associated with the `PATCH` HTTP verb.
+     */
+    HTTPMethodRef["PATCH"] = "patch";
+    /**
+     * @private
+     * A reference to the `post` route associated with the `POST` HTTP verb.
+     */
+    HTTPMethodRef["POST"] = "post";
+    /**
+     * @private
+     * A reference to the `put` route associated with the `PUT` HTTP verb.
+     */
+    HTTPMethodRef["PUT"] = "put";
+    /**
+     * @private
+     * A reference to the `trace` route associated with the `TRACE` HTTP verb.
+     */
+    HTTPMethodRef["TRACE"] = "trace";
+})(HTTPMethodRef || (HTTPMethodRef = {}));
+//# sourceMappingURL=data:application/json;base64,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