@runlith/tagma 0.0.0-stage → 0.2.3

package/types/node/path/posix.d.ts

@@ -0,0 +1,8 @@
+declare module "node:path/posix" {
+    import path = require("node:path");
+    export = path.posix;
+}
+declare module "path/posix" {
+    import path = require("path");
+    export = path.posix;
+}

package/types/node/path/win32.d.ts

@@ -0,0 +1,8 @@
+declare module "node:path/win32" {
+    import path = require("node:path");
+    export = path.win32;
+}
+declare module "path/win32" {
+    import path = require("path");
+    export = path.win32;
+}

package/types/node/path.d.ts

@@ -0,0 +1,40 @@
+declare module "node:path" {
+    namespace path {
+        interface ParsedPath {
+            root: string;
+            dir: string;
+            base: string;
+            ext: string;
+            name: string;
+        }
+        interface FormatInputPathObject {
+            root?: string | undefined;
+            dir?: string | undefined;
+            base?: string | undefined;
+            ext?: string | undefined;
+            name?: string | undefined;
+        }
+        function normalize(path: string): string;
+        function join(...paths: string[]): string;
+        function resolve(...paths: string[]): string;
+        function matchesGlob(path: string, pattern: string): boolean;
+        function isAbsolute(path: string): boolean;
+        function relative(from: string, to: string): string;
+        function dirname(path: string): string;
+        function basename(path: string, suffix?: string): string;
+        function extname(path: string): string;
+        const sep: "\\" | "/";
+        const delimiter: ";" | ":";
+        function parse(path: string): ParsedPath;
+        function format(pathObject: FormatInputPathObject): string;
+        function toNamespacedPath(path: string): string;
+    }
+    namespace path {
+        export { path as posix, path as win32, };
+    }
+    export = path;
+}
+declare module "path" {
+    import path = require("node:path");
+    export = path;
+}

package/types/node/perf_hooks.d.ts

@@ -0,0 +1,236 @@
+declare module "node:perf_hooks" {
+    import { InternalEventTargetEventProperties } from "node:events";
+    type EntryType = "dns" | "function" | "gc" | "http2" | "http" | "mark" | "measure" | "net" | "node" | "resource";
+    interface ConnectionTimingInfo {
+        domainLookupStartTime: number;
+        domainLookupEndTime: number;
+        connectionStartTime: number;
+        connectionEndTime: number;
+        secureConnectionStartTime: number;
+        ALPNNegotiatedProtocol: string;
+    }
+    interface FetchTimingInfo {
+        startTime: number;
+        redirectStartTime: number;
+        redirectEndTime: number;
+        postRedirectStartTime: number;
+        finalServiceWorkerStartTime: number;
+        finalNetworkRequestStartTime: number;
+        finalNetworkResponseStartTime: number;
+        endTime: number;
+        finalConnectionTimingInfo: ConnectionTimingInfo | null;
+        encodedBodySize: number;
+        decodedBodySize: number;
+    }
+    type PerformanceEntryList = PerformanceEntry[];
+    interface PerformanceMarkOptions {
+        detail?: any;
+        startTime?: number;
+    }
+    interface PerformanceMeasureOptions {
+        detail?: any;
+        duration?: number;
+        end?: string | number;
+        start?: string | number;
+    }
+    interface PerformanceObserverCallback {
+        (entries: PerformanceObserverEntryList, observer: PerformanceObserver): void;
+    }
+    interface PerformanceObserverInit {
+        buffered?: boolean;
+        entryTypes?: EntryType[];
+        type?: EntryType;
+    }
+    interface PerformanceTimerifyOptions extends TimerifyOptions {
+    }
+    interface PerformanceEventMap {
+        "resourcetimingbufferfull": Event;
+    }
+    interface Performance extends EventTarget, InternalEventTargetEventProperties<PerformanceEventMap> {
+        readonly nodeTiming: PerformanceNodeTiming;
+        readonly timeOrigin: number;
+        clearMarks(markName?: string): void;
+        clearMeasures(measureName?: string): void;
+        clearResourceTimings(resourceTimingName?: string): void;
+        getEntries(): PerformanceEntryList;
+        getEntriesByName(name: string, type?: EntryType): PerformanceEntryList;
+        getEntriesByType(type: EntryType): PerformanceEntryList;
+        mark(markName: string, markOptions?: PerformanceMarkOptions): PerformanceMark;
+        markResourceTiming(timingInfo: FetchTimingInfo, requestedUrl: string, initiatorType: string, global: unknown, cacheMode: string, bodyInfo: unknown, responseStatus: number, deliveryType?: string): PerformanceResourceTiming;
+        measure(measureName: string, startMark?: string, endMark?: string): PerformanceMeasure;
+        measure(measureName: string, options: PerformanceMeasureOptions, endMark?: string): PerformanceMeasure;
+        now(): number;
+        setResourceTimingBufferSize(maxSize: number): void;
+        toJSON(): any;
+        addEventListener<K extends keyof PerformanceEventMap>(type: K, listener: (ev: PerformanceEventMap[K]) => void, options?: AddEventListenerOptions | boolean): void;
+        addEventListener(type: string, listener: EventListener | EventListenerObject, options?: AddEventListenerOptions | boolean): void;
+        removeEventListener<K extends keyof PerformanceEventMap>(type: K, listener: (ev: PerformanceEventMap[K]) => void, options?: EventListenerOptions | boolean): void;
+        removeEventListener(type: string, listener: EventListener | EventListenerObject, options?: EventListenerOptions | boolean): void;
+        eventLoopUtilization(utilization1?: EventLoopUtilization, utilization2?: EventLoopUtilization): EventLoopUtilization;
+        timerify<T extends (...args: any[]) => any>(fn: T, options?: TimerifyOptions): T;
+    }
+    var Performance: {
+        prototype: Performance;
+        new (): Performance;
+    };
+    interface PerformanceEntry {
+        readonly duration: number;
+        readonly entryType: EntryType;
+        readonly name: string;
+        readonly startTime: number;
+        toJSON(): any;
+    }
+    var PerformanceEntry: {
+        prototype: PerformanceEntry;
+        new (): PerformanceEntry;
+    };
+    interface PerformanceMark extends PerformanceEntry {
+        readonly detail: any;
+        readonly entryType: "mark";
+    }
+    var PerformanceMark: {
+        prototype: PerformanceMark;
+        new (markName: string, markOptions?: PerformanceMarkOptions): PerformanceMark;
+    };
+    interface PerformanceMeasure extends PerformanceEntry {
+        readonly detail: any;
+        readonly entryType: "measure";
+    }
+    var PerformanceMeasure: {
+        prototype: PerformanceMeasure;
+        new (): PerformanceMeasure;
+    };
+    interface PerformanceObserver {
+        disconnect(): void;
+        observe(options: PerformanceObserverInit): void;
+        takeRecords(): PerformanceEntryList;
+    }
+    var PerformanceObserver: {
+        prototype: PerformanceObserver;
+        new (callback: PerformanceObserverCallback): PerformanceObserver;
+        readonly supportedEntryTypes: readonly EntryType[];
+    };
+    interface PerformanceObserverEntryList {
+        getEntries(): PerformanceEntryList;
+        getEntriesByName(name: string, type?: EntryType): PerformanceEntryList;
+        getEntriesByType(type: EntryType): PerformanceEntryList;
+    }
+    var PerformanceObserverEntryList: {
+        prototype: PerformanceObserverEntryList;
+        new (): PerformanceObserverEntryList;
+    };
+    interface PerformanceResourceTiming extends PerformanceEntry {
+        readonly connectEnd: number;
+        readonly connectStart: number;
+        readonly decodedBodySize: number;
+        readonly domainLookupEnd: number;
+        readonly domainLookupStart: number;
+        readonly encodedBodySize: number;
+        readonly entryType: "resource";
+        readonly fetchStart: number;
+        readonly initiatorType: string;
+        readonly nextHopProtocol: string;
+        readonly redirectEnd: number;
+        readonly redirectStart: number;
+        readonly requestStart: number;
+        readonly responseEnd: number;
+        readonly responseStart: number;
+        readonly responseStatus: number;
+        readonly secureConnectionStart: number;
+        readonly transferSize: number;
+        readonly workerStart: number;
+        toJSON(): any;
+    }
+    var PerformanceResourceTiming: {
+        prototype: PerformanceResourceTiming;
+        new (): PerformanceResourceTiming;
+    };
+    var performance: Performance;
+    class PerformanceNodeEntry extends PerformanceEntry {
+        readonly detail: any;
+        readonly entryType: "dns" | "function" | "gc" | "http2" | "http" | "net" | "node";
+    }
+    interface UVMetrics {
+        readonly loopCount: number;
+        readonly events: number;
+        readonly eventsWaiting: number;
+    }
+    interface PerformanceNodeTiming extends PerformanceEntry {
+        readonly bootstrapComplete: number;
+        readonly entryType: "node";
+        readonly environment: number;
+        readonly idleTime: number;
+        readonly loopExit: number;
+        readonly loopStart: number;
+        readonly nodeStart: number;
+        readonly uvMetricsInfo: UVMetrics;
+        readonly v8Start: number;
+    }
+    namespace constants {
+        const NODE_PERFORMANCE_GC_MAJOR: number;
+        const NODE_PERFORMANCE_GC_MINOR: number;
+        const NODE_PERFORMANCE_GC_INCREMENTAL: number;
+        const NODE_PERFORMANCE_GC_WEAKCB: number;
+        const NODE_PERFORMANCE_GC_FLAGS_NO: number;
+        const NODE_PERFORMANCE_GC_FLAGS_CONSTRUCT_RETAINED: number;
+        const NODE_PERFORMANCE_GC_FLAGS_FORCED: number;
+        const NODE_PERFORMANCE_GC_FLAGS_SYNCHRONOUS_PHANTOM_PROCESSING: number;
+        const NODE_PERFORMANCE_GC_FLAGS_ALL_AVAILABLE_GARBAGE: number;
+        const NODE_PERFORMANCE_GC_FLAGS_ALL_EXTERNAL_MEMORY: number;
+        const NODE_PERFORMANCE_GC_FLAGS_SCHEDULE_IDLE: number;
+    }
+    interface EventLoopMonitorOptions {
+        resolution?: number | undefined;
+    }
+    interface Histogram {
+        readonly count: number;
+        readonly countBigInt: bigint;
+        readonly exceeds: number;
+        readonly exceedsBigInt: bigint;
+        readonly max: number;
+        readonly maxBigInt: number;
+        readonly mean: number;
+        readonly min: number;
+        readonly minBigInt: bigint;
+        percentile(percentile: number): number;
+        percentileBigInt(percentile: number): bigint;
+        readonly percentiles: Map<number, number>;
+        readonly percentilesBigInt: Map<bigint, bigint>;
+        reset(): void;
+        readonly stddev: number;
+    }
+    interface IntervalHistogram extends Histogram {
+        enable(): boolean;
+        disable(): boolean;
+        [Symbol.dispose](): void;
+    }
+    interface RecordableHistogram extends Histogram {
+        record(val: number | bigint): void;
+        recordDelta(): void;
+        add(other: RecordableHistogram): void;
+    }
+    interface EventLoopUtilization {
+        idle: number;
+        active: number;
+        utilization: number;
+    }
+    function eventLoopUtilization(utilization1?: EventLoopUtilization, utilization2?: EventLoopUtilization): EventLoopUtilization;
+    function monitorEventLoopDelay(options?: EventLoopMonitorOptions): IntervalHistogram;
+    interface TimerifyOptions {
+        histogram?: RecordableHistogram | undefined;
+    }
+    function timerify<T extends (...args: any[]) => any>(fn: T, options?: TimerifyOptions): T;
+    interface CreateHistogramOptions {
+        lowest?: number | bigint | undefined;
+        highest?: number | bigint | undefined;
+        figures?: number | undefined;
+    }
+    function createHistogram(options?: CreateHistogramOptions): RecordableHistogram;
+    interface MarkOptions extends PerformanceMarkOptions {
+    }
+    interface MeasureOptions extends PerformanceMeasureOptions {
+    }
+}
+declare module "perf_hooks" {
+    export * from "node:perf_hooks";
+}