eslint-plugin-jsdoc 61.1.8 → 61.1.9

package/dist/rules/preferImportTag.cjs

@@ -7,7 +7,7 @@ exports.default = void 0;
 var _iterateJsdoc = _interopRequireWildcard(require("../iterateJsdoc.cjs"));
 var _jsdoccomment = require("@es-joy/jsdoccomment");
 var _parseImportsExports = require("parse-imports-exports");
-var _toValidIdentifier = _interopRequireDefault(require("to-valid-identifier"));
+var _toValidIdentifier = _interopRequireDefault(require("../to-valid-identifier.cjs"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
 var _default = exports.default = (0, _iterateJsdoc.default)(({

package/dist/to-valid-identifier.cjs

@@ -0,0 +1,261 @@
+'use strict';
+
+// https://262.ecma-international.org/14.0/#sec-keywords-and-reserved-words
+// 14 is ES2023
+const identifiers = [
+	// Keywords
+	'await',
+	'break',
+	'case',
+	'catch',
+	'class',
+	'const',
+	'continue',
+	'debugger',
+	'default',
+	'delete',
+	'do',
+	'else',
+	'enum',
+	'export',
+	'extends',
+	'false',
+	'finally',
+	'for',
+	'function',
+	'if',
+	'import',
+	'in',
+	'instanceof',
+	'new',
+	'null',
+	'return',
+	'super',
+	'switch',
+	'this',
+	'throw',
+	'true',
+	'try',
+	'typeof',
+	'var',
+	'void',
+	'while',
+	'with',
+	'yield',
+
+	// Future reserved keywords
+	'implements',
+	'interface',
+	'package',
+	'private',
+	'protected',
+	'public',
+
+	// Not keywords, but still restricted
+	'arguments',
+	'eval',
+];
+
+// https://262.ecma-international.org/14.0/#sec-value-properties-of-the-global-object
+const globalProperties = [
+	'globalThis',
+	'Infinity',
+	'NaN',
+	'undefined',
+];
+
+function reservedIdentifiers$1({includeGlobalProperties = false} = {}) {
+	return new Set([
+		...identifiers,
+		...(includeGlobalProperties ? globalProperties : []),
+	]);
+}
+
+/* eslint-disable no-bitwise */
+
+const BASE = 62;
+const BASE_BIGINT = 62n;
+const DEFAULT_ALPHABET = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
+
+const cachedEncoder = new globalThis.TextEncoder();
+const cachedDecoder = new globalThis.TextDecoder();
+
+function assertString(value, label) {
+	if (typeof value !== 'string') {
+		throw new TypeError(`The \`${label}\` parameter must be a string, got \`${value}\` (${typeof value}).`);
+	}
+}
+
+function validateAlphabet(alphabet) {
+	if (typeof alphabet !== 'string') {
+		throw new TypeError(`The alphabet must be a string, got \`${alphabet}\` (${typeof alphabet}).`);
+	}
+
+	if (alphabet.length !== BASE) {
+		throw new TypeError(`The alphabet must be exactly ${BASE} characters long, got ${alphabet.length}.`);
+	}
+
+	const uniqueCharacters = new Set(alphabet);
+	if (uniqueCharacters.size !== BASE) {
+		throw new TypeError(`The alphabet must contain ${BASE} unique characters, got ${uniqueCharacters.size}.`);
+	}
+}
+
+class Base62 {
+	constructor(options = {}) {
+		const alphabet = options.alphabet ?? DEFAULT_ALPHABET;
+		validateAlphabet(alphabet);
+		this.alphabet = [...alphabet];
+		this.indices = new Map(this.alphabet.map((character, index) => [character, index]));
+	}
+
+	#getIndex(character) {
+		const index = this.indices.get(character);
+
+		if (index === undefined) {
+			throw new TypeError(`Unexpected character for Base62 encoding: \`${character}\`.`);
+		}
+
+		return index;
+	}
+
+	encodeString(string) {
+		assertString(string, 'string');
+		return this.encodeBytes(cachedEncoder.encode(string));
+	}
+
+	decodeString(encodedString) {
+		assertString(encodedString, 'encodedString');
+		return cachedDecoder.decode(this.decodeBytes(encodedString));
+	}
+
+	encodeBytes(bytes) {
+		if (!(bytes instanceof Uint8Array)) {
+			throw new TypeError('The `bytes` parameter must be an instance of Uint8Array.');
+		}
+
+		if (bytes.length === 0) {
+			return '';
+		}
+
+		// Prepend 0x01 to the byte array before encoding to ensure the BigInt conversion
+		// does not strip any leading zeros and to prevent any byte sequence from being
+		// interpreted as a numerically zero value.
+		let value = 1n;
+
+		for (const byte of bytes) {
+			value = (value << 8n) | BigInt(byte);
+		}
+
+		return this.encodeBigInt(value);
+	}
+
+	decodeBytes(encodedString) {
+		assertString(encodedString, 'encodedString');
+
+		if (encodedString.length === 0) {
+			return new Uint8Array();
+		}
+
+		let value = this.decodeBigInt(encodedString);
+
+		const byteArray = [];
+		while (value > 0n) {
+			byteArray.push(Number(value & 0xFFn));
+			value >>= 8n;
+		}
+
+		// Remove the 0x01 that was prepended during encoding.
+		return Uint8Array.from(byteArray.reverse().slice(1));
+	}
+
+	encodeInteger(integer) {
+		if (!Number.isInteger(integer)) {
+			throw new TypeError(`Expected an integer, got \`${integer}\` (${typeof integer}).`);
+		}
+
+		if (integer < 0) {
+			throw new TypeError('The integer must be non-negative.');
+		}
+
+		if (integer === 0) {
+			return this.alphabet[0];
+		}
+
+		let encodedString = '';
+		while (integer > 0) {
+			encodedString = this.alphabet[integer % BASE] + encodedString;
+			integer = Math.floor(integer / BASE);
+		}
+
+		return encodedString;
+	}
+
+	decodeInteger(encodedString) {
+		assertString(encodedString, 'encodedString');
+
+		let integer = 0;
+		for (const character of encodedString) {
+			integer = (integer * BASE) + this.#getIndex(character);
+		}
+
+		return integer;
+	}
+
+	encodeBigInt(bigint) {
+		if (typeof bigint !== 'bigint') {
+			throw new TypeError(`Expected a bigint, got \`${bigint}\` (${typeof bigint}).`);
+		}
+
+		if (bigint < 0) {
+			throw new TypeError('The bigint must be non-negative.');
+		}
+
+		if (bigint === 0n) {
+			return this.alphabet[0];
+		}
+
+		let encodedString = '';
+		while (bigint > 0n) {
+			encodedString = this.alphabet[Number(bigint % BASE_BIGINT)] + encodedString;
+			bigint /= BASE_BIGINT;
+		}
+
+		return encodedString;
+	}
+
+	decodeBigInt(encodedString) {
+		assertString(encodedString, 'encodedString');
+
+		let bigint = 0n;
+		for (const character of encodedString) {
+			bigint = (bigint * BASE_BIGINT) + BigInt(this.#getIndex(character));
+		}
+
+		return bigint;
+	}
+}
+
+// Create default instance with standard alphabet
+const defaultBase62 = new Base62();
+const encodeInteger = integer => defaultBase62.encodeInteger(integer);
+
+const reservedIdentifiers = reservedIdentifiers$1({includeGlobalProperties: true});
+
+const encodeCodePoint = x => `$${encodeInteger(x.codePointAt(0))}$`;
+
+function toValidIdentifier(value) {
+	if (typeof value !== 'string') {
+		throw new TypeError(`Expected a string, got \`${typeof value}\`.`);
+	}
+
+	if (reservedIdentifiers.has(value)) {
+		// We prefix with underscore to avoid any potential conflicts with the Base62 encoded string.
+		return `$_${value}$`;
+	}
+
+	return value.replaceAll(/(?<!^)\P{ID_Continue}/gu, encodeCodePoint)
+		.replaceAll(/^[^_\p{ID_Start}]/gu, encodeCodePoint);
+}
+
+module.exports = toValidIdentifier;

package/package.json

@@ -33,6 +33,7 @@
     "@es-joy/jsdoc-eslint-parser": "^0.25.0",
     "@eslint/core": "^0.16.0",
     "@hkdobrev/run-if-changed": "^0.6.3",
+    "@rollup/plugin-node-resolve": "^16.0.3",
     "@semantic-release/commit-analyzer": "^13.0.1",
     "@semantic-release/github": "^12.0.0",
     "@semantic-release/npm": "^13.1.1",
@@ -69,6 +70,7 @@
     "playwright": "^1.56.1",
     "replace": "^1.2.2",
     "rimraf": "^6.0.1",
+    "rollup": "^4.52.5",
     "semantic-release": "^25.0.1",
     "sinon": "^21.0.0",
     "typescript": "5.9.3",
@@ -167,7 +169,8 @@
     "tsc": "tsc",
     "tsc-build": "tsc -p tsconfig-prod.json",
     "tsc-cjs": "tsc -p tsconfig-cjs.json",
-    "build": "node ./src/bin/buildEntryFileForTS.js && rimraf ./dist && NODE_ENV=production babel ./src --out-file-extension .cjs --out-dir ./dist --copy-files --source-maps --ignore ./src/bin/*.js --no-copy-ignored && replace 'require\\(\"\\.(.*?)\\.[^.]*?\"\\)' 'require(\".$1.cjs\")' 'dist' -r --include=\"*.cjs\" && pnpm tsc-build && pnpm tsc-cjs",
+    "rollup": "rollup -c",
+    "build": "node ./src/bin/buildEntryFileForTS.js && rimraf ./dist && pnpm rollup && NODE_ENV=production babel ./src --out-file-extension .cjs --out-dir ./dist --copy-files --source-maps --ignore ./src/bin/*.js --no-copy-ignored && replace 'to-valid-identifier' '../to-valid-identifier.cjs' 'dist' -r --include=\"*.cjs\" && replace 'require\\(\"\\.(.*?)\\.[^.]*?\"\\)' 'require(\".$1.cjs\")' 'dist' -r --include=\"*.cjs\" && pnpm tsc-build && pnpm tsc-cjs",
     "attw": "attw --pack .",
     "check-docs": "node ./src/bin/generateDocs.js --check",
     "create-docs": "pnpm run create-options && node ./src/bin/generateDocs.js && pnpm ruleTypes",
@@ -182,5 +185,5 @@
     "test-cov": "TIMING=1 c8 --reporter text pnpm run test-no-cov",
     "test-index": "pnpm run test-no-cov test/rules/index.js"
   },
-  "version": "61.1.8"
+  "version": "61.1.9"
 }

package/rollup.config.js

@@ -0,0 +1,16 @@
+import {
+  nodeResolve,
+} from '@rollup/plugin-node-resolve';
+
+export default [
+  {
+    input: 'node_modules/to-valid-identifier/index.js',
+    output: {
+      file: 'dist/to-valid-identifier.cjs',
+      format: 'cjs',
+    },
+    plugins: [
+      nodeResolve(),
+    ],
+  },
+];