@socketsecurity/lib 5.28.0 → 6.0.0

package/dist/perf/report.js

@@ -0,0 +1,85 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var report_exports = {};
+__export(report_exports, {
+  generatePerformanceReport: () => generatePerformanceReport,
+  printPerformanceSummary: () => printPerformanceSummary
+});
+module.exports = __toCommonJS(report_exports);
+var import_output = require("../debug/output");
+var import_math = require("../primordials/math");
+var import_object = require("../primordials/object");
+var import_internal = require("./_internal");
+var import_enabled = require("./enabled");
+var import_metrics = require("./metrics");
+function generatePerformanceReport() {
+  if (!(0, import_enabled.isPerfEnabled)() || import_internal.performanceMetrics.length === 0) {
+    return "(no performance data collected - enable with DEBUG=perf)";
+  }
+  const summary = (0, import_metrics.getPerformanceSummary)();
+  const operations = (0, import_object.ObjectKeys)(summary).sort();
+  let report = "\n\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557\n";
+  report += "\u2551         Performance Report                    \u2551\n";
+  report += "\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D\n\n";
+  for (const operation of operations) {
+    const stats = summary[operation];
+    report += `${operation}:
+`;
+    report += `  Calls: ${stats.count}
+`;
+    report += `  Avg:   ${stats.avg}ms
+`;
+    report += `  Min:   ${stats.min}ms
+`;
+    report += `  Max:   ${stats.max}ms
+`;
+    report += `  Total: ${stats.total}ms
+
+`;
+  }
+  const totalDuration = (0, import_object.ObjectValues)(summary).reduce(
+    (sum, s) => sum + s.total,
+    0
+  );
+  report += `Total measured time: ${(0, import_math.MathRound)(totalDuration * 100) / 100}ms
+`;
+  return report;
+}
+function printPerformanceSummary() {
+  if (!(0, import_enabled.isPerfEnabled)() || import_internal.performanceMetrics.length === 0) {
+    return;
+  }
+  const summary = (0, import_metrics.getPerformanceSummary)();
+  const operations = (0, import_object.ObjectKeys)(summary).sort();
+  (0, import_output.debugLog)("[perf]\n=== Performance Summary ===");
+  for (const operation of operations) {
+    const stats = summary[operation];
+    (0, import_output.debugLog)(
+      `[perf] ${operation}: ${stats.count} calls, avg ${stats.avg}ms (min ${stats.min}ms, max ${stats.max}ms, total ${stats.total}ms)`
+    );
+  }
+  (0, import_output.debugLog)("[perf] =========================\n");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  generatePerformanceReport,
+  printPerformanceSummary
+});

package/dist/perf/timer.d.ts

@@ -0,0 +1,100 @@
+/**
+ * @file Recording-side helpers — `perfTimer` (returns a stop() closure),
+ *   `measure` / `measureSync` (timed wrappers around an async / sync function),
+ *   `perfCheckpoint` (zero-duration marker), and `trackMemory` (records
+ *   heap-used at a label). All push rows into the shared metrics array when
+ *   `isPerfEnabled()` is true.
+ */
+/**
+ * Measure execution time of an async function.
+ *
+ * @example
+ *   import { measure } from '@socketsecurity/lib/perf/timer'
+ *
+ *   const { result, duration } = await measure('fetch-packages', async () => {
+ *     return await fetchPackages()
+ *   })
+ *   console.log(`Fetched packages in ${duration}ms`)
+ *
+ * @param operation - Name of the operation.
+ * @param fn - Async function to measure.
+ * @param metadata - Optional metadata.
+ *
+ * @returns Result of the function and duration
+ */
+export declare function measure<T>(operation: string, fn: () => Promise<T>, metadata?: Record<string, unknown>): Promise<{
+    result: T;
+    duration: number;
+}>;
+/**
+ * Measure synchronous function execution time.
+ *
+ * @example
+ *   import { measureSync } from '@socketsecurity/lib/perf/timer'
+ *
+ *   const { result, duration } = measureSync('parse-json', () => {
+ *     return JSON.parse(data)
+ *   })
+ *
+ * @param operation - Name of the operation.
+ * @param fn - Synchronous function to measure.
+ * @param metadata - Optional metadata.
+ *
+ * @returns Result of the function and duration
+ */
+export declare function measureSync<T>(operation: string, fn: () => T, metadata?: Record<string, unknown>): {
+    result: T;
+    duration: number;
+};
+/**
+ * Mark a checkpoint in performance tracking. Useful for tracking progress
+ * through complex operations.
+ *
+ * @example
+ *   import { perfCheckpoint } from '@socketsecurity/lib/perf/timer'
+ *
+ *   perfCheckpoint('start-scan')
+ *   // ... do work ...
+ *   perfCheckpoint('fetch-packages', { count: 50 })
+ *   // ... do work ...
+ *   perfCheckpoint('analyze-issues', { issueCount: 10 })
+ *   perfCheckpoint('end-scan')
+ *
+ * @param checkpoint - Name of the checkpoint.
+ * @param metadata - Optional metadata.
+ */
+export declare function perfCheckpoint(checkpoint: string, metadata?: Record<string, unknown>): void;
+/**
+ * Start a performance timer for an operation. Returns a stop function that
+ * records the duration.
+ *
+ * @example
+ *   import { perfTimer } from '@socketsecurity/lib/perf/timer'
+ *
+ *   const stop = perfTimer('api-call')
+ *   await fetchData()
+ *   stop({ endpoint: '/npm/lodash/score' })
+ *
+ * @param operation - Name of the operation being timed.
+ * @param metadata - Optional metadata to attach to the metric.
+ *
+ * @returns Stop function that completes the timing
+ */
+export declare function perfTimer(operation: string, metadata?: Record<string, unknown>): (additionalMetadata?: Record<string, unknown>) => void;
+/**
+ * Track memory usage at a specific point. Only available when DEBUG=perf is
+ * enabled.
+ *
+ * @example
+ *   import { trackMemory } from '@socketsecurity/lib/perf/timer'
+ *
+ *   const memBefore = trackMemory('before-operation')
+ *   await heavyOperation()
+ *   const memAfter = trackMemory('after-operation')
+ *   console.log(`Memory increased by ${memAfter - memBefore}MB`)
+ *
+ * @param label - Label for this memory snapshot.
+ *
+ * @returns Memory usage in MB
+ */
+export declare function trackMemory(label: string): number;

package/dist/perf/timer.js

@@ -0,0 +1,137 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var timer_exports = {};
+__export(timer_exports, {
+  measure: () => measure,
+  measureSync: () => measureSync,
+  perfCheckpoint: () => perfCheckpoint,
+  perfTimer: () => perfTimer,
+  trackMemory: () => trackMemory
+});
+module.exports = __toCommonJS(timer_exports);
+var import_node_process = __toESM(require("node:process"));
+var import_output = require("../debug/output");
+var import_message = require("../errors/message");
+var import_date = require("../primordials/date");
+var import_math = require("../primordials/math");
+var import_internal = require("./_internal");
+var import_enabled = require("./enabled");
+async function measure(operation, fn, metadata) {
+  const stop = perfTimer(operation, metadata);
+  try {
+    const result = await fn();
+    stop({ success: true });
+    const metric = import_internal.performanceMetrics[import_internal.performanceMetrics.length - 1];
+    return { result, duration: metric?.duration || 0 };
+  } catch (e) {
+    stop({
+      success: false,
+      error: (0, import_message.errorMessage)(e)
+    });
+    throw e;
+  }
+}
+function measureSync(operation, fn, metadata) {
+  const stop = perfTimer(operation, metadata);
+  try {
+    const result = fn();
+    stop({ success: true });
+    const metric = import_internal.performanceMetrics[import_internal.performanceMetrics.length - 1];
+    return { result, duration: metric?.duration || 0 };
+  } catch (e) {
+    stop({
+      success: false,
+      error: (0, import_message.errorMessage)(e)
+    });
+    throw e;
+  }
+}
+function perfCheckpoint(checkpoint, metadata) {
+  if (!(0, import_enabled.isPerfEnabled)()) {
+    return;
+  }
+  const metric = {
+    operation: `checkpoint:${checkpoint}`,
+    duration: 0,
+    timestamp: (0, import_date.DateNow)(),
+    ...metadata ? { metadata } : {}
+  };
+  import_internal.performanceMetrics.push(metric);
+  (0, import_output.debugLog)(`[perf] [CHECKPOINT] ${checkpoint}`);
+}
+function perfTimer(operation, metadata) {
+  if (!(0, import_enabled.isPerfEnabled)()) {
+    return () => {
+    };
+  }
+  const start = performance.now();
+  (0, import_output.debugLog)(`[perf] [START] ${operation}`);
+  return (additionalMetadata) => {
+    const duration = performance.now() - start;
+    const metric = {
+      operation,
+      // Round to 2 decimals
+      duration: (0, import_math.MathRound)(duration * 100) / 100,
+      timestamp: (0, import_date.DateNow)(),
+      metadata: { ...metadata, ...additionalMetadata }
+    };
+    import_internal.performanceMetrics.push(metric);
+    (0, import_output.debugLog)(`[perf] [END] ${operation} - ${metric.duration}ms`);
+  };
+}
+function trackMemory(label) {
+  if (!(0, import_enabled.isPerfEnabled)()) {
+    return 0;
+  }
+  const usage = import_node_process.default.memoryUsage();
+  const heapUsedMB = (0, import_math.MathRound)(usage.heapUsed / 1024 / 1024 * 100) / 100;
+  (0, import_output.debugLog)(`[perf] [MEMORY] ${label}: ${heapUsedMB}MB heap used`);
+  const metric = {
+    operation: `checkpoint:memory:${label}`,
+    duration: 0,
+    timestamp: (0, import_date.DateNow)(),
+    metadata: {
+      heapUsed: heapUsedMB,
+      heapTotal: (0, import_math.MathRound)(usage.heapTotal / 1024 / 1024 * 100) / 100,
+      external: (0, import_math.MathRound)(usage.external / 1024 / 1024 * 100) / 100
+    }
+  };
+  import_internal.performanceMetrics.push(metric);
+  return heapUsedMB;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  measure,
+  measureSync,
+  perfCheckpoint,
+  perfTimer,
+  trackMemory
+});

package/dist/perf/types.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @file Public type surface for `perf/*` modules — the `PerformanceMetrics` row
+ *   shape pushed onto the shared metrics array by `perfTimer` / `measure` /
+ *   `measureSync` / `perfCheckpoint` / `trackMemory`. Pure types, no runtime
+ *   side effects.
+ */
+/**
+ * Performance metrics collected during execution.
+ */
+export type PerformanceMetrics = {
+    operation: string;
+    duration: number;
+    timestamp: number;
+    metadata?: Record<string, unknown>;
+};

package/dist/perf/types.js

@@ -0,0 +1,18 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/pkg-ext/data.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @file Package extensions for compatibility adjustments. Package extensions
+ *   allow modifying package.json fields of dependencies to fix compatibility
+ *   issues, missing peer dependencies, etc.
+ */
+import type { PackageExtension } from './types';
+declare const packageExtensions: readonly PackageExtension[];
+export { packageExtensions };

package/dist/{package-extensions.js → pkg-ext/data.js}

@@ -28,12 +28,12 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var package_extensions_exports = {};
-__export(package_extensions_exports, {
+var data_exports = {};
+__export(data_exports, {
   packageExtensions: () => packageExtensions
 });
-module.exports = __toCommonJS(package_extensions_exports);
-var yarnPkgExtensions = __toESM(require("./external/@yarnpkg/extensions"));
+module.exports = __toCommonJS(data_exports);
+var yarnPkgExtensions = __toESM(require("../external/@yarnpkg/extensions"));
 const { freeze: ObjectFreeze } = Object;
 const packageExtensions = ObjectFreeze(
   [

package/dist/pkg-ext/types.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @file Public type surface for `pkg-ext/*` modules — the `PackageExtension`
+ *   tuple shape used by the merged Yarn / Socket-curated extensions list. Pure
+ *   types, no runtime side effects.
+ */
+export type PackageExtension = readonly [string, Record<string, unknown>];

package/dist/pkg-ext/types.js

@@ -0,0 +1,18 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/primordials/array.d.ts

@@ -0,0 +1,73 @@
+/**
+ * @file Safe references to `Array`, typed-array, `ArrayBuffer`, `DataView`,
+ *   `Atomics`, and shared iterator-prototype primordials. `Array.fromAsync` and
+ *   `Array.prototype.with` are ES2024 / ES2023; the primordial captures the
+ *   live reference at module load so consumers never see a tampered global.
+ */
+export declare const ArrayCtor: ArrayConstructor;
+export declare const ArrayBufferCtor: ArrayBufferConstructor;
+export declare const DataViewCtor: DataViewConstructor;
+export declare const Float32ArrayCtor: Float32ArrayConstructor;
+export declare const Float64ArrayCtor: Float64ArrayConstructor;
+export declare const Int8ArrayCtor: Int8ArrayConstructor;
+export declare const Int16ArrayCtor: Int16ArrayConstructor;
+export declare const Int32ArrayCtor: Int32ArrayConstructor;
+export declare const Uint8ArrayCtor: Uint8ArrayConstructor;
+export declare const Uint8ClampedArrayCtor: Uint8ClampedArrayConstructor;
+export declare const Uint16ArrayCtor: Uint16ArrayConstructor;
+export declare const Uint32ArrayCtor: Uint32ArrayConstructor;
+export declare const ArrayFrom: {
+    <T>(arrayLike: ArrayLike<T>): T[];
+    <T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+    <T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+    <T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+};
+export type ArrayFromAsync = <T>(source: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>) => Promise<T[]>;
+export declare const ArrayFromAsync: ArrayFromAsync | undefined;
+export declare const ArrayIsArray: (arg: any) => arg is any[];
+export declare const ArrayOf: <T>(...items: T[]) => T[];
+export declare const ArrayBufferIsView: (arg: any) => arg is ArrayBufferView;
+export declare const AtomicsWait: {
+    (typedArray: Int32Array<ArrayBufferLike>, index: number, value: number, timeout?: number): "ok" | "not-equal" | "timed-out";
+    (typedArray: BigInt64Array<ArrayBufferLike>, index: number, value: bigint, timeout?: number): "ok" | "not-equal" | "timed-out";
+};
+export declare const ArrayPrototypeAt: (self: unknown, index: number) => any;
+export declare const ArrayPrototypeConcat: <T>(self: T[], ...items: Array<T | readonly T[]>) => T[];
+export declare const ArrayPrototypeCopyWithin: (self: unknown, target: number, start: number, end?: number | undefined) => any[];
+export declare const ArrayPrototypeEntries: (self: unknown) => ArrayIterator<[number, any]>;
+export declare const ArrayPrototypeEvery: (self: unknown, predicate: (value: any, index: number, array: any[]) => unknown, thisArg?: any) => boolean;
+export declare const ArrayPrototypeFill: (self: unknown, value: any, start?: number | undefined, end?: number | undefined) => any[];
+export declare const ArrayPrototypeFilter: (self: unknown, predicate: (value: any, index: number, array: any[]) => unknown, thisArg?: any) => any[];
+export declare const ArrayPrototypeFind: (self: unknown, predicate: (value: any, index: number, obj: any[]) => unknown, thisArg?: any) => any;
+export declare const ArrayPrototypeFindIndex: (self: unknown, predicate: (value: any, index: number, obj: any[]) => unknown, thisArg?: any) => number;
+export declare const ArrayPrototypeFindLast: (self: unknown, predicate: (value: any, index: number, array: any[]) => unknown, thisArg?: any) => any;
+export declare const ArrayPrototypeFindLastIndex: (self: unknown, predicate: (value: any, index: number, array: any[]) => unknown, thisArg?: any) => number;
+export declare const ArrayPrototypeFlat: <A, D extends number = 1>(self: A, depth?: D | undefined) => FlatArray<A, D>[];
+export declare const ArrayPrototypeFlatMap: <U, This = undefined>(self: unknown, callback: (this: This, value: any, index: number, array: any[]) => U | readonly U[], thisArg?: This | undefined) => U[];
+export declare const ArrayPrototypeForEach: (self: unknown, callbackfn: (value: any, index: number, array: any[]) => void, thisArg?: any) => void;
+export declare const ArrayPrototypeIncludes: (self: unknown, searchElement: any, fromIndex?: number | undefined) => boolean;
+export declare const ArrayPrototypeIndexOf: (self: unknown, searchElement: any, fromIndex?: number | undefined) => number;
+export declare const ArrayPrototypeJoin: (self: unknown, separator?: string | undefined) => string;
+export declare const ArrayPrototypeKeys: (self: unknown) => ArrayIterator<number>;
+export declare const ArrayPrototypeLastIndexOf: (self: unknown, searchElement: any, fromIndex?: number | undefined) => number;
+export declare const ArrayPrototypeMap: <U>(self: unknown, callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[];
+export declare const ArrayPrototypePop: (self: unknown) => any;
+export declare const ArrayPrototypePush: <T>(self: T[], ...items: T[]) => number;
+export declare const ArrayPrototypeReduce: (self: unknown, callbackfn: (previousValue: unknown, currentValue: any, currentIndex: number, array: any[]) => unknown, initialValue: unknown) => unknown;
+export declare const ArrayPrototypeReduceRight: (self: unknown, callbackfn: (previousValue: unknown, currentValue: any, currentIndex: number, array: any[]) => unknown, initialValue: unknown) => unknown;
+export declare const ArrayPrototypeReverse: (self: unknown) => any[];
+export declare const ArrayPrototypeShift: (self: unknown) => any;
+export declare const ArrayPrototypeSlice: (self: unknown, start?: number | undefined, end?: number | undefined) => any[];
+export declare const ArrayPrototypeSome: (self: unknown, predicate: (value: any, index: number, array: any[]) => unknown, thisArg?: any) => boolean;
+export declare const ArrayPrototypeSort: (self: unknown, compareFn?: ((a: any, b: any) => number) | undefined) => any[];
+export declare const ArrayPrototypeSplice: <T>(self: T[], start: number, deleteCount?: number, ...items: T[]) => T[];
+export declare const ArrayPrototypeToLocaleString: (self: unknown, locales: string | string[], options?: (Intl.NumberFormatOptions & Intl.DateTimeFormatOptions) | undefined) => string;
+export declare const ArrayPrototypeToReversed: (self: unknown) => any[];
+export declare const ArrayPrototypeToSorted: (self: unknown, compareFn?: ((a: any, b: any) => number) | undefined) => any[];
+export declare const ArrayPrototypeToSpliced: <T>(self: T[], start: number, deleteCount?: number, ...items: T[]) => T[];
+export declare const ArrayPrototypeToString: (self: unknown) => string;
+export declare const ArrayPrototypeUnshift: <T>(self: T[], ...items: T[]) => number;
+export declare const ArrayPrototypeValues: (self: unknown) => ArrayIterator<any>;
+export declare const ArrayPrototypeWith: <T>(self: T[], index: number, value: T) => T[];
+export declare const IteratorPrototypeNext: (self: Iterator<unknown, any, any>) => IteratorResult<unknown, any>;
+export declare const IteratorPrototypeReturn: ((self: Iterator<unknown, any, any>, value?: unknown) => IteratorResult<unknown, any>) | undefined;