@socketsecurity/lib 6.0.9 → 6.0.10

package/dist/versions/compare.d.ts

@@ -14,7 +14,11 @@
  *     "invalid version" throw into `undefined` for the caller's convenience;
  *     all other ops surface whatever the underlying impl returns. The vendored
  *     `semver` export has no `neq` helper, so when we fall back to it we route
- *     `neq` through `!eq` to match smol's semantics.
+ *     `neq` through `!eq` to match smol's semantics. Snapshot safety: each
+ *     export is a thin forwarding function that resolves `getImpl()` at FIRST
+ *     CALL, not at module-eval. Binding the impl methods at module load
+ *     (`impl.eq.bind(impl)`) pinned the native-handle-bearing semver/npm-pack
+ *     bundle into the heap and aborted `node --build-snapshot`.
  */
 /**
  * Compare two semantic version strings.
@@ -25,27 +29,29 @@ export declare function compare(a: string, b: string): -1 | 0 | 1 | undefined;
 /**
  * Check if a equals b.
  */
-export declare const eq: (a: string, b: string) => boolean;
-/**
- * Check if a does not equal b.
- */
-export declare const neq: (a: string, b: string) => boolean;
+export declare function eq(a: string, b: string): boolean;
 /**
  * Check if a is greater than b.
  */
-export declare const gt: (a: string, b: string) => boolean;
+export declare function gt(a: string, b: string): boolean;
 /**
  * Check if a is greater than or equal to b.
  */
-export declare const gte: (a: string, b: string) => boolean;
+export declare function gte(a: string, b: string): boolean;
 /**
  * Check if a is less than b.
  */
-export declare const lt: (a: string, b: string) => boolean;
+export declare function lt(a: string, b: string): boolean;
 /**
  * Check if a is less than or equal to b.
  */
-export declare const lte: (a: string, b: string) => boolean;
+export declare function lte(a: string, b: string): boolean;
+/**
+ * Check if a does not equal b. The vendored `semver` export exposes no `neq`
+ * helper, so on the fallback path we route through `!eq` to match smol's
+ * semantics; smol-versions has a native `.neq` and uses it directly.
+ */
+export declare function neq(a: string, b: string): boolean;
 /**
  * Sort versions in descending order.
  */

package/dist/versions/compare.js

@@ -20,7 +20,11 @@ const require_versions__internal = require('./_internal.js');
 *     "invalid version" throw into `undefined` for the caller's convenience;
 *     all other ops surface whatever the underlying impl returns. The vendored
 *     `semver` export has no `neq` helper, so when we fall back to it we route
-*     `neq` through `!eq` to match smol's semantics.
+*     `neq` through `!eq` to match smol's semantics. Snapshot safety: each
+*     export is a thin forwarding function that resolves `getImpl()` at FIRST
+*     CALL, not at module-eval. Binding the impl methods at module load
+*     (`impl.eq.bind(impl)`) pinned the native-handle-bearing semver/npm-pack
+*     bundle into the heap and aborted `node --build-snapshot`.
 */
 /**
 * Compare two semantic version strings.
@@ -29,7 +33,7 @@ const require_versions__internal = require('./_internal.js');
 */
 function compare(a, b) {
 	try {
-		return require_versions__internal.impl.compare(a, b);
+		return require_versions__internal.getImpl().compare(a, b);
 	} catch {
 		return;
 	}
@@ -37,42 +41,58 @@ function compare(a, b) {
 /**
 * Check if a equals b.
 */
-const eq = require_versions__internal.impl.eq.bind(require_versions__internal.impl);
-/**
-* Check if a does not equal b.
-*/
-/* c8 ignore start - smol-versions exposes .neq, so the bind arm is taken;
-the polyfill fallback fires only on a hypothetical impl that lacks .neq. */
-const neq = typeof require_versions__internal.impl.neq === "function" ? require_versions__internal.impl.neq.bind(require_versions__internal.impl) : (a, b) => !require_versions__internal.impl.eq(a, b);
-/* c8 ignore stop */
+function eq(a, b) {
+	return require_versions__internal.getImpl().eq(a, b);
+}
 /**
 * Check if a is greater than b.
 */
-const gt = require_versions__internal.impl.gt.bind(require_versions__internal.impl);
+function gt(a, b) {
+	return require_versions__internal.getImpl().gt(a, b);
+}
 /**
 * Check if a is greater than or equal to b.
 */
-const gte = require_versions__internal.impl.gte.bind(require_versions__internal.impl);
+function gte(a, b) {
+	return require_versions__internal.getImpl().gte(a, b);
+}
 /**
 * Check if a is less than b.
 */
-const lt = require_versions__internal.impl.lt.bind(require_versions__internal.impl);
+function lt(a, b) {
+	return require_versions__internal.getImpl().lt(a, b);
+}
 /**
 * Check if a is less than or equal to b.
 */
-const lte = require_versions__internal.impl.lte.bind(require_versions__internal.impl);
+function lte(a, b) {
+	return require_versions__internal.getImpl().lte(a, b);
+}
+/**
+* Check if a does not equal b. The vendored `semver` export exposes no `neq`
+* helper, so on the fallback path we route through `!eq` to match smol's
+* semantics; smol-versions has a native `.neq` and uses it directly.
+*/
+function neq(a, b) {
+	const impl = require_versions__internal.getImpl();
+	/* c8 ignore start - smol-versions exposes .neq, so the native arm is taken;
+	the polyfill fallback fires only on a hypothetical impl that lacks .neq. */
+	if (typeof impl.neq === "function") return impl.neq(a, b);
+	return !impl.eq(a, b);
+	/* c8 ignore stop */
+}
 /**
 * Sort versions in descending order.
 */
 function rsort(versions) {
-	return require_versions__internal.impl.rsort([...versions]);
+	return require_versions__internal.getImpl().rsort([...versions]);
 }
 /**
 * Sort versions in ascending order. The input is spread so callers can pass a
 * `readonly string[]` even when the impl mutates internally.
 */
 function sort(versions) {
-	return require_versions__internal.impl.sort([...versions]);
+	return require_versions__internal.getImpl().sort([...versions]);
 }
 
 //#endregion

package/dist/versions/parse.js

@@ -69,7 +69,7 @@ function getPatchVersion(version) {
 */
 function isValidVersion(version) {
 	/* c8 ignore next - External semver call */
-	return require_versions__internal.impl.valid(version) != null;
+	return require_versions__internal.getImpl().valid(version) != null;
 }
 /**
 * Parse a version string and return major, minor, patch components.

package/dist/versions/range.js

@@ -22,7 +22,8 @@ const require_versions__internal = require('./_internal.js');
 */
 function filterVersions(versions, range) {
 	/* c8 ignore next - External semver call */
-	return versions.filter((v) => require_versions__internal.impl.satisfies(v, range));
+	const impl = require_versions__internal.getImpl();
+	return versions.filter((v) => impl.satisfies(v, range));
 }
 /**
 * Get the highest version from an array of versions.
@@ -57,7 +58,7 @@ function minVersion(versions) {
 */
 function satisfiesVersion(version, range) {
 	/* c8 ignore next - External semver call */
-	return require_versions__internal.impl.satisfies(version, range);
+	return require_versions__internal.getImpl().satisfies(version, range);
 }
 
 //#endregion

package/dist/words/pluralize.js

@@ -62,7 +62,10 @@ function pluralize(word, options) {
 		__proto__: null,
 		...options
 	};
-	if (forms) return forms[CLDR_TO_FIELD[getRules(locale, type).select(count)]] ?? forms.plural;
+	if (forms) {
+		const category = getRules(locale, type).select(count);
+		return forms[CLDR_TO_FIELD[category]] ?? forms.plural;
+	}
 	return count === 1 ? word : `${word}s`;
 }