@fr0st/ui-passwordstrength 2.0.8 → 3.0.0

package/dist/frost-ui-passwordstrength.js

@@ -1,341 +1,428 @@
-(function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@fr0st/ui'), require('@fr0st/query')) :
-    typeof define === 'function' && define.amd ? define(['exports', '@fr0st/ui', '@fr0st/query'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.UI = global.UI || {}, global.UI, global.fQuery));
-})(this, (function (exports, ui, $) { 'use strict';
-
-    /**
-     * PasswordStrength Class
-     * @class
-     */
-    class PasswordStrength extends ui.BaseComponent {
-        /**
-         * New PasswordStrength constructor.
-         * @param {HTMLElement} node The input node.
-         * @param {object} [options] The options to create the PasswordStrength with.
-         */
-        constructor(node, options) {
-            super(node, options);
-
-            if (this._options.container) {
-                this._container = $.findOne(this._options.container);
-            } else {
-                this._container = $.closest(this._node, ':not(.form-input):not(.input-group)');
-            }
-
-            this._render();
-            this._refresh();
-            this._events();
-        }
-
-        /**
-         * Dispose the PasswordStrength.
-         */
-        dispose() {
-            $.remove(this._progress);
-            $.removeEvent(this._node, 'input.ui.passwordstrength');
-            $.removeAttribute(this._node, 'aria-describedby');
-
-            this._container = null;
-            this._progress = null;
-            this._progressBar = null;
-
-            super.dispose();
-        }
-
-        /**
-         * Get the password strength.
-         * @return {number} The password strength. (0, 100)
-         */
-        getStrength() {
-            const value = $.getValue(this._node);
-
-            return this.constructor.getStrength(value);
-        }
-    }
-
-    /**
-     * Attach events for the PasswordStrength.
-     */
-    function _events() {
-        $.addEvent(this._node, 'input.ui.passwordstrength', (_) => {
-            this._refresh();
-        });
-    }
-
-    /**
-     * Refresh the password strength.
-     */
-    function _refresh() {
-        const strength = this.getStrength();
-
-        let nextLevel;
-        for (const level of this._options.levels) {
-            if (strength < level.score) {
-                break;
-            }
-
-            nextLevel = level;
-        }
-
-        $.setStyle(this._progressBar, { width: `${strength}%` });
-        $.setAttribute(this._progressBar, {
-            'class': this.constructor.classes.progressBar,
-            'aria-valuenow': strength,
-        });
-
-        $.addClass(this._progressBar, nextLevel.class);
-
-        if (this._options.striped) {
-            $.addClass(this._progressBar, this.constructor.classes.progressBarStriped);
-        }
-
-        if (nextLevel.text) {
-            $.setText(this._progressBar, nextLevel.text);
-        }
-    }
-
-    /**
-     * Render the password strength element.
-     */
-    function _render() {
-        this._progress = $.create('div', {
-            class: this.constructor.classes.progress,
-        });
-
-        const id = ui.generateId('password-strength');
-
-        this._progressBar = $.create('div', {
-            attributes: {
-                'id': id,
-                'role': 'progressbar',
-                'aria-valuemin': 0,
-                'aria-valuemax': 100,
-            },
-        });
-
-        $.append(this._progress, this._progressBar);
-        $.append(this._container, this._progress);
-
-        $.setAttribute(this._node, {
-            'aria-describedby': id,
-        });
-    }
-
-    /**
-     * Find character sequences in a string.
-     * @param {string} string The input string.
-     * @param {array} locations The character locations.
-     * @return {array} The character sequences.
-     */
-    function findSequences(string, locations) {
-        const sequences = [];
-        let sequence = [];
-
-        for (let i = 0; i < locations.length - 1; i++) {
-            const current = locations[i];
-            const next = locations[i + 1];
-            const distance = next - current;
-
-            const char = string[current];
-            const nextChar = string[next];
-            const charDistance = nextChar.charCodeAt(0) - char.charCodeAt(0);
-
-            if (distance === 1 && charDistance === 1) {
-                if (!sequence.length) {
-                    sequence.push(char);
-                }
-                sequence.push(nextChar);
-            } else if (sequence.length) {
-                sequences.push(sequence);
-                sequence = [];
-            }
-        }
-
-        if (sequence.length) {
-            sequences.push(sequence);
-        }
-
-        return sequences;
-    }
-    /**
-     * Get the strength of a password.
-     * @param {string} password The password.
-     * @return {number} The password strength.
-     */
-    function getStrength(password) {
-        if (password.match(/^password/i)) {
-            password = password.substring(8);
-        }
-
-        const length = password.length;
-
-        let score = 0;
-
-        if (length) {
-            score += length * 6;
-        }
-
-        const upper = [];
-        const lower = [];
-        const numbers = [];
-        const symbols = [];
-        const dictionary = {};
-
-        for (let i = 0; i < length; i++) {
-            const char = password[i];
-            const code = char.charCodeAt(0);
-
-            if (code >= 48 && code <= 57) {
-                numbers.push(i);
-            } else if (code >= 65 && code <= 90) {
-                upper.push(i);
-            } else if (code >= 97 && code <= 122) {
-                lower.push(i);
-            } else {
-                symbols.push(i);
-            }
-
-            if (!(char in dictionary)) {
-                dictionary[char] = 0;
-            }
-
-            dictionary[char]++;
-        }
-
-        // reward upper/lower case
-        if (upper.length !== length && lower.length !== length) {
-            if (upper.length) {
-                score += length - upper.length;
-            }
-
-            if (lower.length) {
-                score += length - lower.length;
-            }
-        }
-
-        // reward numbers
-        if (numbers.length !== length) {
-            score += numbers.length * 3;
-        }
-
-        // reward symbols
-        score += symbols.length * 6;
-
-        // reward inner numbers/symbols
-        for (const list of [numbers, symbols]) {
-            const reward = list.filter((v) => v && v !== length - 1).length;
-            score += reward * 3;
-        }
-
-        // punish only letters
-        if (!numbers.length && !symbols.length) {
-            score -= length;
-        }
-
-        // punish only numbers
-        if (!upper.length && !lower.length && !symbols.length) {
-            score -= length;
-        }
-
-        // punish no symbols
-        if (!symbols.length) {
-            score -= length;
-        }
-
-        // repeating characters
-        const repeats = Object.values(dictionary)
-            .reduce((acc, count) => acc + count - 1, 0);
-
-        if (repeats > 0) {
-            score -= repeats;
-        }
-
-        if (length >= 2) {
-            // consecutive characters
-            const matches = password.matchAll(/(.)\1+/g);
-
-            for (const match of matches) {
-                score -= Math.min(match[0].length, 12) * 3;
-            }
-
-            const lowerPassword = password.toLowerCase();
-
-            // sequential letters
-            const letters = upper.concat(lower);
-            const letterSequences = findSequences(lowerPassword, letters);
-            for (const sequence of letterSequences) {
-                if (sequence.length > 2) {
-                    score -= (Math.min(sequence.length - 2, 16)) * 3;
-                }
-            }
-
-            // sequential numbers
-            const numberSequences = findSequences(lowerPassword, numbers);
-            for (const sequence of numberSequences) {
-                if (sequence.length > 2) {
-                    score -= (Math.min(sequence.length - 2, 16)) * 3;
-                }
-            }
-        }
-
-        return $._clamp(score, 0, 100);
-    }
-
-    // PasswordStrength default options
-    PasswordStrength.defaults = {
-        levels: [
-            {
-                score: 0,
-                class: 'text-bg-danger',
-                text: 'Very Weak',
-            },
-            {
-                score: 20,
-                class: 'text-bg-danger',
-                text: 'Weak',
-            },
-            {
-                score: 40,
-                class: 'text-bg-warning',
-                text: 'Normal',
-            },
-            {
-                score: 60,
-                class: 'text-bg-success',
-                text: 'Strong',
-            },
-            {
-                score: 80,
-                class: 'text-bg-success',
-                text: 'Very Strong',
-            },
-        ],
-        container: null,
-        striped: false,
-    };
-
-    // PasswordStrength classes
-    PasswordStrength.classes = {
-        progress: 'progress mt-2',
-        progressBar: 'progress-bar',
-        progressBarStriped: 'progress-bar-striped',
-    };
-
-    // PasswordStrength static
-    PasswordStrength.getStrength = getStrength;
-
-    // PasswordStrength prototype
-    const proto = PasswordStrength.prototype;
-
-    proto._events = _events;
-    proto._refresh = _refresh;
-    proto._render = _render;
-
-    // PasswordStrength init
-    ui.initComponent('passwordstrength', PasswordStrength);
-
-    exports.PasswordStrength = PasswordStrength;
-
-}));
-//# sourceMappingURL=frost-ui-passwordstrength.js.map
+(function(global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ?  factory(exports, require('@fr0st/ui'), require('@fr0st/query')) :
+  typeof define === 'function' && define.amd ? define(['exports', '@fr0st/ui', '@fr0st/query'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.UI = global.UI || {}), global.UI,global.fQuery));
+})(this, function(exports, _fr0st_ui, _fr0st_query) {
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+//#region \0rolldown/runtime.js
+	var __create = Object.create;
+	var __defProp = Object.defineProperty;
+	var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+	var __getOwnPropNames = Object.getOwnPropertyNames;
+	var __getProtoOf = Object.getPrototypeOf;
+	var __hasOwnProp = Object.prototype.hasOwnProperty;
+	var __copyProps = (to, from, except, desc) => {
+		if (from && typeof from === "object" || typeof from === "function") {
+			for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+				key = keys[i];
+				if (!__hasOwnProp.call(to, key) && key !== except) {
+					__defProp(to, key, {
+						get: ((k) => from[k]).bind(null, key),
+						enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+					});
+				}
+			}
+		}
+		return to;
+	};
+	var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+		value: mod,
+		enumerable: true
+	}) : target, mod));
+
+//#endregion
+_fr0st_query = __toESM(_fr0st_query, 1);
+
+//#region src/strength.js
+	var characterTypes = [
+		{
+			pattern: /\p{Ll}/u,
+			type: "lower"
+		},
+		{
+			pattern: /\p{Lu}/u,
+			type: "upper"
+		},
+		{
+			pattern: /\p{N}/u,
+			type: "number"
+		}
+	];
+	var keyboardSequences = [
+		"1234567890",
+		"qwertyuiop",
+		"asdfghjkl",
+		"zxcvbnm"
+	].flatMap((row) => [row, Array.from(row).reverse().join("")]);
+	var leetCharacters = {
+		"$": "s",
+		"0": "o",
+		"3": "e",
+		"4": "a",
+		"5": "s",
+		"7": "t",
+		"@": "a"
+	};
+	var lengthBands = [
+		{
+			end: 5,
+			max: 19,
+			min: 1,
+			start: 1
+		},
+		{
+			end: 8,
+			max: 39,
+			min: 20,
+			start: 6
+		},
+		{
+			end: 11,
+			max: 59,
+			min: 40,
+			start: 9
+		},
+		{
+			end: 15,
+			max: 79,
+			min: 60,
+			start: 12
+		},
+		{
+			end: 24,
+			max: 100,
+			min: 80,
+			start: 16
+		}
+	];
+	/**
+	* Gets the type of a password character.
+	* @param {string} character The character.
+	* @returns {string} The character type.
+	*/
+	var getCharacterType = (character) => characterTypes.find(({ pattern }) => pattern.test(character))?.type || "symbol";
+	/**
+	* Gets a length-based password strength.
+	* @param {string[]} characters The password characters.
+	* @returns {number} The password strength.
+	*/
+	var getLengthStrength = (characters) => {
+		const band = lengthBands.find(({ end }) => characters.length <= end) || lengthBands.at(-1);
+		const score = Math.round(_fr0st_query.default._map(Math.min(characters.length, band.end), band.start, band.end, band.min, band.max));
+		const diversity = new Set(characters.map(getCharacterType)).size;
+		return Math.min(score + (diversity - 1) * 2, band.max);
+	};
+	/**
+	* Gets the smallest repeated pattern.
+	* @param {string[]} characters The password characters.
+	* @returns {string[]|null} The repeated pattern.
+	*/
+	var getRepeatedPattern = (characters) => {
+		const maxLength = Math.floor(characters.length / 2);
+		for (let length = 1; length <= maxLength; length++) if (characters.length % length === 0 && characters.every((character, index) => character === characters[index % length])) return characters.slice(0, length);
+		return null;
+	};
+	/**
+	* Normalizes common password matching.
+	* @param {string} password The password.
+	* @returns {string} The normalized password.
+	*/
+	var normalizePassword = (password) => String(password).normalize("NFKC").toLowerCase();
+	/**
+	* Normalizes common leet substitutions.
+	* @param {string} password The password.
+	* @returns {string} The normalized password.
+	*/
+	var normalizeLeet = (password) => Array.from(password, (character) => leetCharacters[character] || character).join("");
+	/**
+	* Gets normalized variants used to match common passwords.
+	* @param {string} password The normalized password.
+	* @returns {Set<string>} The password variants.
+	*/
+	var getPasswordVariants = (password) => {
+		const variants = [password, password.replace(/[^\p{L}\p{N}]/gu, normalizeLeet)].flatMap((value) => {
+			const undecorated = value.replace(/^[^\p{L}\p{N}]+|[^\p{L}\p{N}]+$/gu, "");
+			return [undecorated, undecorated.replace(/^\d+|\d+$/g, "")];
+		});
+		return /* @__PURE__ */ new Set([
+			normalizeLeet(password),
+			...variants,
+			...variants.map(normalizeLeet)
+		]);
+	};
+	/**
+	* Gets the score for a common password.
+	* @param {string} password The normalized password.
+	* @param {string[]} commonPasswords The common passwords.
+	* @returns {number|null} The common-password score.
+	*/
+	var getCommonPasswordStrength = (password, commonPasswords) => {
+		const common = new Set(commonPasswords.map(normalizePassword));
+		if (common.has(password)) return 0;
+		return common.isDisjointFrom(getPasswordVariants(password)) ? null : 5;
+	};
+	/**
+	* Checks whether characters form an ascending or descending sequence.
+	* @param {string[]} characters The password characters.
+	* @returns {boolean} Whether the characters form a sequence.
+	*/
+	var isSequence = (characters) => {
+		const [first, second, third] = characters.map((character) => character.toLowerCase());
+		const type = getCharacterType(first);
+		const direction = second.codePointAt(0) - first.codePointAt(0);
+		return ["lower", "number"].includes(type) && getCharacterType(second) === type && getCharacterType(third) === type && Math.abs(direction) === 1 && third.codePointAt(0) - second.codePointAt(0) === direction;
+	};
+	/**
+	* Checks whether characters form a keyboard sequence.
+	* @param {string[]} characters The password characters.
+	* @returns {boolean} Whether the characters form a keyboard sequence.
+	*/
+	var isKeyboardSequence = (characters) => {
+		const sequence = characters.join("").toLowerCase();
+		return keyboardSequences.some((keyboardSequence) => keyboardSequence.includes(sequence));
+	};
+	/**
+	* Checks whether characters form a predictable pattern.
+	* @param {string[]} characters The password characters.
+	* @returns {boolean} Whether the characters form a predictable pattern.
+	*/
+	var isPredictable = (characters) => new Set(characters).size === 1 || isSequence(characters) || isKeyboardSequence(characters);
+	/**
+	* Gets the number of characters in predictable patterns.
+	* @param {string[]} characters The password characters.
+	* @returns {number} The number of predictable characters.
+	*/
+	var getPredictableCount = (characters) => {
+		const indices = /* @__PURE__ */ new Set();
+		for (let i = 0; i + 2 < characters.length; i++) if (isPredictable(characters.slice(i, i + 3))) {
+			indices.add(i);
+			indices.add(i + 1);
+			indices.add(i + 2);
+		}
+		return indices.size;
+	};
+	/**
+	* Calculates the strength of a password.
+	* @param {string} password The password.
+	* @param {string[]} [commonPasswords=[]] Passwords to score as very weak.
+	* @returns {number} The password strength, from 0 to 100.
+	*/
+	var getStrength = (password, commonPasswords = []) => {
+		const normalizedPassword = password.normalize("NFKC");
+		const characters = Array.from(normalizedPassword);
+		if (!characters.length) return 0;
+		const commonStrength = getCommonPasswordStrength(normalizedPassword.toLowerCase(), commonPasswords);
+		if (commonStrength !== null) return commonStrength;
+		const score = getLengthStrength(characters);
+		const repeatedPattern = getRepeatedPattern(characters);
+		if (repeatedPattern?.length === 1) return 0;
+		if (repeatedPattern) return Math.min(score, getLengthStrength(repeatedPattern), 15);
+		const predictableCount = getPredictableCount(characters);
+		return _fr0st_query.default._clamp(score - predictableCount, 0, predictableCount === characters.length ? 15 : 100);
+	};
+
+//#endregion
+//#region src/password-strength.js
+/**
+	* @typedef {object} PasswordStrengthLevel
+	* @property {string} class The CSS class applied to the progress bar.
+	* @property {number} score The minimum score for the level.
+	* @property {string} [text] The label displayed in the progress bar.
+	*/
+	/**
+	* @callback PasswordStrengthScorer
+	* @param {string} password The password.
+	* @param {string[]} commonPasswords The common passwords.
+	* @returns {number} The password strength, from 0 to 100.
+	*/
+	/**
+	* @typedef {object} PasswordStrengthOptions
+	* @property {string[]} [commonPasswords] Passwords to score as very weak.
+	* @property {string|null} [container=null] The selector for the progress container.
+	* @property {PasswordStrengthLevel[]} [levels] The ordered password-strength levels.
+	* @property {PasswordStrengthScorer} [scorer] Calculates the password strength.
+	* @property {boolean} [striped=false] Whether to display a striped progress bar.
+	*/
+	/**
+	* Displays the strength of a password input as a progress bar.
+	* @augments {BaseComponent<PasswordStrengthOptions>}
+	*/
+	var PasswordStrength = class extends _fr0st_ui.BaseComponent {
+		static classes = {
+			progress: "progress mt-2",
+			progressBar: "progress-bar",
+			progressBarStriped: "progress-bar-striped"
+		};
+		/** @type {PasswordStrengthOptions} */
+		static defaults = {
+			commonPasswords: [
+				"123456",
+				"12345678",
+				"123456789",
+				"1234567890",
+				"000000",
+				"111111",
+				"abc123",
+				"admin",
+				"dragon",
+				"iloveyou",
+				"letmein",
+				"monkey",
+				"password",
+				"password1",
+				"password123",
+				"qwerty",
+				"qwerty123",
+				"welcome"
+			],
+			levels: [
+				{
+					score: 0,
+					class: "text-bg-danger",
+					text: "Very Weak"
+				},
+				{
+					score: 20,
+					class: "text-bg-danger",
+					text: "Weak"
+				},
+				{
+					score: 40,
+					class: "text-bg-warning",
+					text: "Normal"
+				},
+				{
+					score: 60,
+					class: "text-bg-success",
+					text: "Strong"
+				},
+				{
+					score: 80,
+					class: "text-bg-success",
+					text: "Very Strong"
+				}
+			],
+			container: null,
+			scorer: getStrength,
+			striped: false
+		};
+		#container;
+		#describedBy;
+		#form;
+		#progress;
+		#progressBar;
+		#resetHandler;
+		/**
+		* Calculates the strength of a password.
+		* @param {string} password The password.
+		* @param {string[]} [commonPasswords=this.defaults.commonPasswords] Passwords to score as very weak.
+		* @returns {number} The password strength, from 0 to 100.
+		*/
+		static getStrength(password, commonPasswords = this.defaults.commonPasswords) {
+			return getStrength(password, commonPasswords);
+		}
+		/**
+		* Creates a PasswordStrength.
+		* @param {HTMLElement} node The input node.
+		* @param {PasswordStrengthOptions} [options] The PasswordStrength options.
+		*/
+		constructor(node, options) {
+			super(node, options);
+			const overrides = {
+				...(0, _fr0st_ui.getDataset)(node),
+				...options
+			};
+			for (const key of ["levels", "commonPasswords"]) if (Array.isArray(overrides[key])) {
+				this.options[key].length = 0;
+				_fr0st_query.default._extend(this.options[key], overrides[key]);
+			}
+			this.#form = this.node.form;
+			if (this.options.container) this.#container = _fr0st_query.default.findOne(this.options.container);
+			else this.#container = _fr0st_query.default.closest(this.node, ":not(.form-input):not(.input-group)").shift();
+			this.#render();
+			this.#refresh();
+			this.#events();
+		}
+		/** @inheritdoc */
+		dispose() {
+			_fr0st_query.default.remove(this.#progress);
+			_fr0st_query.default.removeEvent(this.node, "input.ui.passwordstrength");
+			if (this.#form) _fr0st_query.default.removeEvent(this.#form, "reset.ui.passwordstrength", this.#resetHandler);
+			if (this.#describedBy === null) _fr0st_query.default.removeAttribute(this.node, "aria-describedby");
+			else _fr0st_query.default.setAttribute(this.node, { "aria-describedby": this.#describedBy });
+			this.#container = null;
+			this.#form = null;
+			this.#progress = null;
+			this.#progressBar = null;
+			this.#resetHandler = null;
+			super.dispose();
+		}
+		/**
+		* Gets the password strength.
+		* @returns {number} The password strength, from 0 to 100.
+		*/
+		getStrength() {
+			const value = _fr0st_query.default.getValue(this.node);
+			const strength = Number(this.options.scorer(value, this.options.commonPasswords));
+			return Number.isFinite(strength) ? _fr0st_query.default._clamp(strength, 0, 100) : 0;
+		}
+		/**
+		* Attaches events for the PasswordStrength.
+		*/
+		#events() {
+			if (this.#form) {
+				this.#resetHandler = (event) => {
+					setTimeout(() => {
+						if (this.node && !event.defaultPrevented) this.#refresh();
+					}, 0);
+				};
+				_fr0st_query.default.addEvent(this.#form, "reset.ui.passwordstrength", this.#resetHandler);
+			}
+			_fr0st_query.default.addEvent(this.node, "input.ui.passwordstrength", (_) => {
+				this.#refresh();
+			});
+		}
+		/**
+		* Refreshes the password strength.
+		*/
+		#refresh() {
+			const strength = this.getStrength();
+			const nextLevel = this.options.levels.findLast((level) => strength >= level.score);
+			_fr0st_query.default.setStyle(this.#progressBar, { width: `${strength}%` });
+			_fr0st_query.default.setAttribute(this.#progressBar, {
+				"class": this.constructor.classes.progressBar,
+				"aria-valuenow": strength
+			});
+			_fr0st_query.default.addClass(this.#progressBar, nextLevel.class);
+			if (this.options.striped) _fr0st_query.default.addClass(this.#progressBar, this.constructor.classes.progressBarStriped);
+			_fr0st_query.default.setText(this.#progressBar, nextLevel.text ?? "");
+		}
+		/**
+		* Renders the password strength element.
+		*/
+		#render() {
+			this.#describedBy = _fr0st_query.default.getAttribute(this.node, "aria-describedby");
+			this.#progress = _fr0st_query.default.create("div", { class: this.constructor.classes.progress });
+			const id = (0, _fr0st_ui.generateId)("password-strength");
+			this.#progressBar = _fr0st_query.default.create("div", { attributes: {
+				"id": id,
+				"role": "progressbar",
+				"aria-valuemin": 0,
+				"aria-valuemax": 100
+			} });
+			_fr0st_query.default.append(this.#progress, this.#progressBar);
+			_fr0st_query.default.append(this.#container, this.#progress);
+			const describedBy = [this.#describedBy, id].filter(Boolean).join(" ");
+			_fr0st_query.default.setAttribute(this.node, { "aria-describedby": describedBy });
+		}
+	};
+
+//#endregion
+//#region src/index.js
+	(0, _fr0st_ui.initComponent)("passwordstrength", PasswordStrength);
+	var src_default = PasswordStrength;
+
+//#endregion
+exports.PasswordStrength = src_default;
+});
+//# sourceMappingURL=frost-ui-passwordstrength.js.map