From b2314f6fe6cd77d8e456c3bfde967503effcbd5b Mon Sep 17 00:00:00 2001 From: M_Viper Date: Thu, 22 Oct 2026 07:02:28 +0000 Subject: [PATCH] Upload via GUI (7543 Dateien) --- node_modules/@peculiar/utils/LICENSE | 21 + node_modules/@peculiar/utils/README.md | 299 ++++++++ .../utils/build/types/legacy/convert.d.ts | 52 ++ .../utils/build/types/legacy/functions.d.ts | 16 + .../utils/build/types/legacy/index.d.ts | 5 + .../utils/build/types/pem/index.d.ts | 3 + .../@peculiar/utils/build/types/pem/pem.d.ts | 34 + .../utils/build/types/pem/types.d.ts | 48 ++ node_modules/@peculiar/utils/package.json | 111 +++ node_modules/@peculiar/webcrypto/LICENSE.md | 21 + node_modules/@peculiar/webcrypto/README.md | 97 +++ node_modules/@peculiar/webcrypto/index.d.ts | 12 + node_modules/@peculiar/webcrypto/package.json | 86 +++ node_modules/@sindresorhus/is/dist/index.d.ts | 232 ++++++ node_modules/@sindresorhus/is/dist/index.js | 434 ++++++++++++ node_modules/@sindresorhus/is/dist/types.d.ts | 25 + node_modules/@sindresorhus/is/dist/types.js | 3 + node_modules/@sindresorhus/is/license | 9 + node_modules/@sindresorhus/is/package.json | 96 +++ node_modules/@sindresorhus/is/readme.md | 669 ++++++++++++++++++ node_modules/@szmarczak/http-timer/LICENSE | 21 + node_modules/@szmarczak/http-timer/README.md | 93 +++ .../http-timer/dist/source/index.d.ts | 32 + .../http-timer/dist/source/index.js | 126 ++++ .../@szmarczak/http-timer/package.json | 72 ++ node_modules/@types/cacheable-request/LICENSE | 21 + .../@types/cacheable-request/README.md | 16 + .../@types/cacheable-request/index.d.ts | 137 ++++ .../@types/cacheable-request/package.json | 35 + node_modules/@types/debug/LICENSE | 21 + node_modules/@types/debug/README.md | 69 ++ node_modules/@types/debug/index.d.ts | 50 ++ node_modules/@types/debug/package.json | 58 ++ node_modules/@types/fs-extra/LICENSE | 21 + node_modules/@types/fs-extra/README.md | 16 + node_modules/@types/fs-extra/index.d.ts | 563 +++++++++++++++ node_modules/@types/fs-extra/package.json | 67 ++ .../@types/http-cache-semantics/LICENSE | 21 + .../@types/http-cache-semantics/README.md | 15 + .../@types/http-cache-semantics/index.d.ts | 251 +++++++ .../@types/http-cache-semantics/package.json | 26 + node_modules/@types/keyv/LICENSE | 21 + node_modules/@types/keyv/README.md | 16 + node_modules/@types/keyv/index.d.ts | 90 +++ node_modules/@types/keyv/package.json | 32 + node_modules/@types/ms/LICENSE | 21 + node_modules/@types/ms/README.md | 82 +++ node_modules/@types/ms/index.d.ts | 63 ++ node_modules/@types/ms/package.json | 26 + node_modules/@types/node/assert/strict.d.ts | 111 +++ 50 files changed, 4466 insertions(+) create mode 100644 node_modules/@peculiar/utils/LICENSE create mode 100644 node_modules/@peculiar/utils/README.md create mode 100644 node_modules/@peculiar/utils/build/types/legacy/convert.d.ts create mode 100644 node_modules/@peculiar/utils/build/types/legacy/functions.d.ts create mode 100644 node_modules/@peculiar/utils/build/types/legacy/index.d.ts create mode 100644 node_modules/@peculiar/utils/build/types/pem/index.d.ts create mode 100644 node_modules/@peculiar/utils/build/types/pem/pem.d.ts create mode 100644 node_modules/@peculiar/utils/build/types/pem/types.d.ts create mode 100644 node_modules/@peculiar/utils/package.json create mode 100644 node_modules/@peculiar/webcrypto/LICENSE.md create mode 100644 node_modules/@peculiar/webcrypto/README.md create mode 100644 node_modules/@peculiar/webcrypto/index.d.ts create mode 100644 node_modules/@peculiar/webcrypto/package.json create mode 100644 node_modules/@sindresorhus/is/dist/index.d.ts create mode 100644 node_modules/@sindresorhus/is/dist/index.js create mode 100644 node_modules/@sindresorhus/is/dist/types.d.ts create mode 100644 node_modules/@sindresorhus/is/dist/types.js create mode 100644 node_modules/@sindresorhus/is/license create mode 100644 node_modules/@sindresorhus/is/package.json create mode 100644 node_modules/@sindresorhus/is/readme.md create mode 100644 node_modules/@szmarczak/http-timer/LICENSE create mode 100644 node_modules/@szmarczak/http-timer/README.md create mode 100644 node_modules/@szmarczak/http-timer/dist/source/index.d.ts create mode 100644 node_modules/@szmarczak/http-timer/dist/source/index.js create mode 100644 node_modules/@szmarczak/http-timer/package.json create mode 100644 node_modules/@types/cacheable-request/LICENSE create mode 100644 node_modules/@types/cacheable-request/README.md create mode 100644 node_modules/@types/cacheable-request/index.d.ts create mode 100644 node_modules/@types/cacheable-request/package.json create mode 100644 node_modules/@types/debug/LICENSE create mode 100644 node_modules/@types/debug/README.md create mode 100644 node_modules/@types/debug/index.d.ts create mode 100644 node_modules/@types/debug/package.json create mode 100644 node_modules/@types/fs-extra/LICENSE create mode 100644 node_modules/@types/fs-extra/README.md create mode 100644 node_modules/@types/fs-extra/index.d.ts create mode 100644 node_modules/@types/fs-extra/package.json create mode 100644 node_modules/@types/http-cache-semantics/LICENSE create mode 100644 node_modules/@types/http-cache-semantics/README.md create mode 100644 node_modules/@types/http-cache-semantics/index.d.ts create mode 100644 node_modules/@types/http-cache-semantics/package.json create mode 100644 node_modules/@types/keyv/LICENSE create mode 100644 node_modules/@types/keyv/README.md create mode 100644 node_modules/@types/keyv/index.d.ts create mode 100644 node_modules/@types/keyv/package.json create mode 100644 node_modules/@types/ms/LICENSE create mode 100644 node_modules/@types/ms/README.md create mode 100644 node_modules/@types/ms/index.d.ts create mode 100644 node_modules/@types/ms/package.json create mode 100644 node_modules/@types/node/assert/strict.d.ts diff --git a/node_modules/@peculiar/utils/LICENSE b/node_modules/@peculiar/utils/LICENSE new file mode 100644 index 0000000..5c99cc6 --- /dev/null +++ b/node_modules/@peculiar/utils/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2017-2026 Peculiar Ventures, LLC + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/node_modules/@peculiar/utils/README.md b/node_modules/@peculiar/utils/README.md new file mode 100644 index 0000000..086b004 --- /dev/null +++ b/node_modules/@peculiar/utils/README.md @@ -0,0 +1,299 @@ +# @peculiar/utils + +[![npm version](https://img.shields.io/npm/v/%40peculiar%2Futils.svg)](https://www.npmjs.com/package/@peculiar/utils) +[![Test](https://github.com/PeculiarVentures/pvtsutils/actions/workflows/test.yml/badge.svg?branch=master)](https://github.com/PeculiarVentures/pvtsutils/actions/workflows/test.yml) +[![Coverage Status](https://coveralls.io/repos/github/PeculiarVentures/pvtsutils/badge.svg?branch=master)](https://coveralls.io/github/PeculiarVentures/pvtsutils?branch=master) +[![License: MIT](https://img.shields.io/github/license/PeculiarVentures/pvtsutils.svg)](https://github.com/PeculiarVentures/pvtsutils/blob/master/LICENSE) + +Modern byte, text, converter registry, and PEM utilities for TypeScript projects. + +The package is designed around a modular v2 API: + +- multi-entry exports for tree-shake-friendly imports; +- `encode` and `decode` terminology; +- an extensible runtime converter registry; +- generic PEM helpers without PKI-specific parsing; +- a legacy compatibility layer for historical `pvtsutils` consumers. + +## Install + +```bash +npm install @peculiar/utils +``` + +## Entry Points + +```ts +import { bytes } from "@peculiar/utils"; +import { hex, base64, base64url } from "@peculiar/utils/encoding"; +import { pem } from "@peculiar/utils/pem"; +import { convert, createConverterRegistry, defaultConverters } from "@peculiar/utils/converters"; +import { Convert } from "@peculiar/utils/legacy"; +``` + +## Bytes Helpers + +`@peculiar/utils/bytes` stays focused on stateless byte sequence utilities. It does not include stateful readers, writers, ASN.1 parsing, PDF parsing, or other structured binary readers. For structured binary parsing, use a dedicated binary reader package. + +```ts +import { bytes } from "@peculiar/utils"; + +const offset = bytes.indexOf(new Uint8Array([0x25, 0x25, 0x45, 0x4f, 0x46]), "%%EOF", { + encoding: "ascii", +}); + +const suffix = bytes.endsWith(new Uint8Array([0x25, 0x25, 0x45, 0x4f, 0x46]), "%%EOF", { + encoding: "ascii", +}); +``` + +### Find `startxref` In A PDF Tail + +```ts +import { lastIndexOf } from "@peculiar/utils/bytes"; + +const tailStart = Math.max(0, pdf.byteLength - 4096); + +const offset = lastIndexOf(pdf, "startxref", { + encoding: "ascii", + start: pdf.byteLength, + end: tailStart, +}); + +if (offset === -1) { + throw new Error("PDF startxref marker not found"); +} +``` + +### Find `startxref` Via `tail` + +```ts +import { lastIndexOf, tail } from "@peculiar/utils/bytes"; + +const pdfTail = tail(pdf, 4096); + +const localOffset = lastIndexOf(pdfTail, "startxref", { + encoding: "ascii", +}); + +const offset = + localOffset === -1 + ? -1 + : pdf.byteLength - pdfTail.byteLength + localOffset; +``` + +### Check Prefixes And Suffixes + +```ts +import { bytes } from "@peculiar/utils"; + +bytes.startsWith(data, "-----BEGIN", { encoding: "ascii" }); +bytes.endsWith(data, "%%EOF", { encoding: "ascii" }); +``` + +### Compare Byte Sequences + +```ts +import { bytes } from "@peculiar/utils"; + +const result = bytes.compare(a, b); + +if (result === 0) { + console.log("equal"); +} +``` + +## Convert API + +The default `convert` facade is a convenience singleton backed by the built-in registry. + +```ts +import { convert } from "@peculiar/utils/converters"; + +const bytes = convert.decode("base64", "AQID"); +const text = convert.encode("hex", bytes, { case: "upper" }); +``` + +Deprecated `convert.to(...)` and `convert.from(...)` aliases are still available for temporary migration, but the primary v2 API is `encode` and `decode`. + +## Transcode + +Direct text-to-text transcoding goes through the registry without a manual intermediate step. + +```ts +import { convert } from "@peculiar/utils/converters"; +import { hex } from "@peculiar/utils/encoding"; + +const pemText = convert.transcode("AQID", { + from: "base64", + to: "pem", + toOptions: { + label: "CERTIFICATE", + }, +}); + +const hexText = convert.transcode(pemText, { + from: "pem", + fromOptions: { label: "CERTIFICATE" }, + to: "hex", + toOptions: hex.formats.colonUpper, +}); +``` + +There is intentionally no chain API. + +## Hex Formatting + +The `hex` codec accepts common input styles and can format output explicitly. + +```ts +import { hex } from "@peculiar/utils/encoding"; + +hex.decode("0102030405060708090a0b0c"); +hex.decode("01020304 05060708 090a0b0c"); +hex.decode("01:02:03:04:05:06:07:08:09:0A:0B:0C"); +hex.decode("0x0102030405060708090a0b0c"); + +hex.encode(new Uint8Array([1, 2, 3, 4]), hex.formats.colonUpper); +hex.encode(new Uint8Array([1, 2, 3, 4]), { + prefix: "0x", + group: { + size: 2, + separator: " ", + }, +}); +``` + +Available presets: + +- `hex.formats.compact` +- `hex.formats.upper` +- `hex.formats.colon` +- `hex.formats.colonUpper` +- `hex.formats.groupsOf4` +- `hex.formats.prefixed` + +## Preserve Formatting + +Use `parse` and `format` when you want to keep the original visual style of a hex string. + +```ts +import { hex } from "@peculiar/utils/encoding"; + +const parsed = hex.parse("01:02:03:04:05:06"); + +parsed.bytes; +parsed.format; +parsed.normalized; + +const updated = hex.format(new Uint8Array([0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff]), parsed.format); +``` + +The same capabilities are available through the registry facade: + +```ts +import { convert } from "@peculiar/utils/converters"; + +const parsed = convert.parse("hex", "01:02:03:04"); +const formatted = convert.format("hex", new Uint8Array([0xaa, 0xbb, 0xcc, 0xdd]), parsed.format); +``` + +## PEM Helpers + +PEM support stays generic. The package does not parse ASN.1, validate PKI semantics, or handle encrypted PEM containers. + +```ts +import { pem } from "@peculiar/utils/pem"; + +const text = pem.encode("CERTIFICATE", new Uint8Array([1, 2, 3])); +const blocks = pem.decode(text); +const block = pem.find(text, "CERTIFICATE"); +const matches = pem.findAll(text, "CERTIFICATE"); + +const bundle = pem.encodeMany([ + { label: "CERTIFICATE", data: new Uint8Array([1, 2, 3]) }, + { label: "PRIVATE KEY", data: new Uint8Array([4, 5, 6]) }, +]); +``` + +## Safe Decode And Detection + +```ts +import { convert } from "@peculiar/utils/converters"; + +const result = convert.tryDecode("hex", "01:02:03"); + +if (result.ok) { + console.log(result.bytes); +} else { + console.error(result.error); +} + +const candidates = convert.detect("-----BEGIN DATA-----\nAQID\n-----END DATA-----\n", { + formats: ["pem", "base64", "hex"], +}); +``` + +## Custom Registries + +Applications can create isolated registries instead of mutating global state. + +```ts +import { createConverterRegistry, defaultConverters } from "@peculiar/utils/converters"; + +const registry = createConverterRegistry(defaultConverters); + +registry.register({ + name: "base58btc", + aliases: ["b58"], + encode(data) { + return base58btcEncode(data); + }, + decode(text) { + return base58btcDecode(text); + }, +}); +``` + +Name and alias conflicts throw by default. Use `{ override: true }` only when replacement is intentional. + +## Typed Converter Options + +Built-in converters expose typed options through the registry facade. + +```ts +import { convert } from "@peculiar/utils/converters"; + +convert.encode("hex", new Uint8Array([1, 2, 3]), { + case: "upper", +}); +``` + +Wrong options are rejected by TypeScript: + +```ts +convert.encode("hex", new Uint8Array([1, 2, 3]), { + label: "CERTIFICATE", +}); +``` + +Custom converters can extend the options map via module augmentation: + +```ts +declare module "@peculiar/utils/converters" { + interface ConverterOptionsMap { + base58btc: { + encode: Base58EncodeOptions; + decode: Base58DecodeOptions; + }; + } +} +``` + +## Legacy Compatibility + +The old `pvtsutils`-style surface is preserved under the legacy entry point. + +```ts +import { BufferSourceConverter, Convert, assign, combine, isEqual } from "@peculiar/utils/legacy"; +``` diff --git a/node_modules/@peculiar/utils/build/types/legacy/convert.d.ts b/node_modules/@peculiar/utils/build/types/legacy/convert.d.ts new file mode 100644 index 0000000..73a051d --- /dev/null +++ b/node_modules/@peculiar/utils/build/types/legacy/convert.d.ts @@ -0,0 +1,52 @@ +import type { BufferSourceLike } from "../bytes/index.js"; +import { type BufferEncoding } from "../converters/index.js"; +import type { Utf16Options } from "../encoding/utf16.js"; +/** Legacy text encodings accepted by the deprecated facade. */ +export type TextEncoding = "ascii" | "utf8" | "utf16" | "utf16be" | "utf16le" | "usc2"; +/** + * Legacy converter facade that mirrors the historical API surface. + * @deprecated Use the camelCase `convert` object or specific encoding modules instead. + */ +export declare class Convert { + /** Default UTF-8 encoding used by the legacy facade. */ + static DEFAULT_UTF8_ENCODING: TextEncoding; + /** Checks whether the input is hexadecimal text. */ + static isHex(data: unknown): data is string; + /** Checks whether the input is Base64 text. */ + static isBase64(data: unknown): data is string; + /** Checks whether the input is Base64Url text. */ + static isBase64Url(data: unknown): data is string; + /** Converts buffer data to text. */ + static ToString(buffer: BufferSourceLike, enc?: BufferEncoding): string; + /** Converts text to bytes. */ + static FromString(str: string, enc?: BufferEncoding): ArrayBufferLike; + /** Encodes bytes as Base64 text. */ + static ToBase64(buffer: BufferSourceLike): string; + /** Decodes Base64 text into bytes. */ + static FromBase64(base64: string): ArrayBufferLike; + /** Decodes Base64Url text into bytes. */ + static FromBase64Url(base64url: string): ArrayBufferLike; + /** Encodes bytes as Base64Url text. */ + static ToBase64Url(data: BufferSourceLike): string; + /** Converts UTF-8 or UTF-16 text to bytes. */ + static FromUtf8String(text: string, encoding?: TextEncoding): ArrayBufferLike; + /** Converts bytes to UTF-8 or UTF-16 text. */ + static ToUtf8String(buffer: BufferSourceLike, encoding?: TextEncoding): string; + /** Decodes binary text into bytes. */ + static FromBinary(text: string): ArrayBufferLike; + /** Encodes bytes as binary text. */ + static ToBinary(buffer: BufferSourceLike): string; + /** Encodes bytes as hexadecimal text. */ + static ToHex(buffer: BufferSourceLike): string; + /** Decodes hexadecimal text into bytes. */ + static FromHex(hexString: string): ArrayBufferLike; + /** Converts UTF-16 bytes into text. */ + static ToUtf16String(buffer: BufferSourceLike, littleEndian?: boolean): string; + /** Converts UTF-16 text into bytes. */ + static FromUtf16String(text: string, littleEndian?: boolean): ArrayBufferLike; + protected static Base64Padding(base64: string): string; + /** Normalizes whitespace in Base64-style text. */ + static formatString(data: string): string; +} +/** Legacy text encoding aliases re-exported for compatibility. */ +export type { BufferEncoding, Utf16Options }; diff --git a/node_modules/@peculiar/utils/build/types/legacy/functions.d.ts b/node_modules/@peculiar/utils/build/types/legacy/functions.d.ts new file mode 100644 index 0000000..133b382 --- /dev/null +++ b/node_modules/@peculiar/utils/build/types/legacy/functions.d.ts @@ -0,0 +1,16 @@ +import type { BufferSourceLike } from "../bytes/index.js"; +/** + * Assigns own properties from source objects into the target object. + * @deprecated Prefer object spread or Object.assign. + */ +export declare function assign(target: T, ...sources: (Partial | undefined | null)[]): T; +/** + * Concatenates buffer sources into a single ArrayBuffer. + * @deprecated Use `concat` from `@peculiar/utils/bytes` instead. + */ +export declare function combine(...buf: BufferSourceLike[]): ArrayBufferLike; +/** + * Compares two buffer sources for equality. + * @deprecated Use `equal` from `@peculiar/utils/bytes` instead. + */ +export declare function isEqual(bytes1: BufferSourceLike, bytes2: BufferSourceLike): boolean; diff --git a/node_modules/@peculiar/utils/build/types/legacy/index.d.ts b/node_modules/@peculiar/utils/build/types/legacy/index.d.ts new file mode 100644 index 0000000..84f01b4 --- /dev/null +++ b/node_modules/@peculiar/utils/build/types/legacy/index.d.ts @@ -0,0 +1,5 @@ +/** Barrel export for the deprecated compatibility layer. */ +export { BufferSourceConverter } from "./buffer-source-converter.js"; +export { Convert } from "./convert.js"; +export type { BufferEncoding, TextEncoding } from "./convert.js"; +export { assign, combine, isEqual } from "./functions.js"; diff --git a/node_modules/@peculiar/utils/build/types/pem/index.d.ts b/node_modules/@peculiar/utils/build/types/pem/index.d.ts new file mode 100644 index 0000000..370d520 --- /dev/null +++ b/node_modules/@peculiar/utils/build/types/pem/index.d.ts @@ -0,0 +1,3 @@ +/** Barrel export for PEM helpers, codecs, and related types. */ +export type { PemBlock, PemCodec, PemDecodeOptions, PemEncodeBlock, PemEncodeOptions, PemFormat } from "./types.js"; +export { decode, decodeFirst, encode, encodeMany, find, findAll, format, parse, pem, pemConverter } from "./pem.js"; diff --git a/node_modules/@peculiar/utils/build/types/pem/pem.d.ts b/node_modules/@peculiar/utils/build/types/pem/pem.d.ts new file mode 100644 index 0000000..68cc8be --- /dev/null +++ b/node_modules/@peculiar/utils/build/types/pem/pem.d.ts @@ -0,0 +1,34 @@ +import type { BufferSourceLike } from "../bytes/index.js"; +import type { ParsedBytes, Converter } from "../converters/types.js"; +import type { PemBlock, PemDecodeOptions, PemEncodeBlock, PemEncodeOptions, PemFormat } from "./types.js"; +/** Encodes buffer data into a PEM block. */ +export declare function encode(label: string, data: BufferSourceLike, options?: PemEncodeOptions): string; +/** Encodes multiple PEM blocks into one PEM bundle. */ +export declare function encodeMany(blocks: readonly PemEncodeBlock[], options?: PemEncodeOptions): string; +/** Decodes PEM text into the contained blocks. */ +export declare function decode(text: string, options?: PemDecodeOptions): PemBlock[]; +/** Finds the first PEM block with the requested label. */ +export declare function find(text: string, label: string): PemBlock | undefined; +/** Finds all PEM blocks with the requested label. */ +export declare function findAll(text: string, label: string): PemBlock[]; +/** Decodes the first matching PEM block. */ +export declare function decodeFirst(text: string, label?: string): Uint8Array; +/** Parses the first matching PEM block and preserves its formatting metadata. */ +export declare function parse(text: string, options?: PemDecodeOptions): ParsedBytes; +/** Formats bytes with preserved PEM metadata. */ +export declare function format(data: BufferSourceLike, value: PemFormat): string; +/** PEM codec helpers. */ +export declare const pem: { + readonly decode: typeof decode; + readonly decodeFirst: typeof decodeFirst; + readonly encode: typeof encode; + readonly encodeMany: typeof encodeMany; + readonly find: typeof find; + readonly findAll: typeof findAll; + readonly format: typeof format; + readonly parse: typeof parse; +}; +/** Converter wrapper for PEM text. */ +export declare const pemConverter: Converter; diff --git a/node_modules/@peculiar/utils/build/types/pem/types.d.ts b/node_modules/@peculiar/utils/build/types/pem/types.d.ts new file mode 100644 index 0000000..43ca01d --- /dev/null +++ b/node_modules/@peculiar/utils/build/types/pem/types.d.ts @@ -0,0 +1,48 @@ +import type { BufferSourceLike } from "../bytes/index.js"; +import type { ParsedBytes } from "../converters/types.js"; +/** Represents a decoded PEM block with label, data, and optional headers. */ +export interface PemBlock { + readonly label: string; + readonly data: Uint8Array; + readonly headers?: Readonly>; +} +/** Options that control PEM encoding. */ +export interface PemEncodeOptions { + lineLength?: number; + newline?: "\n" | "\r\n"; + headers?: Readonly>; +} +/** Options that control PEM decoding. */ +export interface PemDecodeOptions { + label?: string; + strict?: boolean; +} +/** Format metadata that can be reused to re-encode PEM text. */ +export interface PemFormat extends PemEncodeOptions { + readonly label: string; +} +/** Input block used by multi-block PEM encoding helpers. */ +export interface PemEncodeBlock { + readonly label: string; + readonly data: BufferSourceLike; + readonly headers?: Readonly>; +} +/** Encodes and decodes PEM blocks. */ +export interface PemCodec { + /** Encodes a buffer source into a PEM block. */ + encode(label: string, data: BufferSourceLike, options?: PemEncodeOptions): string; + /** Encodes multiple PEM blocks into a single string. */ + encodeMany(blocks: readonly PemEncodeBlock[], options?: PemEncodeOptions): string; + /** Decodes PEM text into blocks. */ + decode(text: string, options?: PemDecodeOptions): PemBlock[]; + /** Decodes the first matching PEM block. */ + decodeFirst(text: string, label?: string): Uint8Array; + /** Finds the first PEM block with the requested label. */ + find(text: string, label: string): PemBlock | undefined; + /** Finds all PEM blocks with the requested label. */ + findAll(text: string, label: string): PemBlock[]; + /** Parses the first matching PEM block and preserves the detected formatting. */ + parse(text: string, options?: PemDecodeOptions): ParsedBytes; + /** Formats bytes with previously detected PEM metadata. */ + format(data: BufferSourceLike, format: PemFormat): string; +} diff --git a/node_modules/@peculiar/utils/package.json b/node_modules/@peculiar/utils/package.json new file mode 100644 index 0000000..c4bcc49 --- /dev/null +++ b/node_modules/@peculiar/utils/package.json @@ -0,0 +1,111 @@ +{ + "name": "@peculiar/utils", + "version": "2.0.3", + "description": "Modern byte, encoding, converter registry, and PEM utilities for TypeScript projects.", + "type": "module", + "main": "./build/cjs/index.js", + "module": "./build/esm/index.js", + "types": "./build/types/index.d.ts", + "exports": { + ".": { + "types": "./build/types/index.d.ts", + "import": "./build/esm/index.js", + "require": "./build/cjs/index.js" + }, + "./bytes": { + "types": "./build/types/bytes/index.d.ts", + "import": "./build/esm/bytes/index.js", + "require": "./build/cjs/bytes/index.js" + }, + "./encoding": { + "types": "./build/types/encoding/index.d.ts", + "import": "./build/esm/encoding/index.js", + "require": "./build/cjs/encoding/index.js" + }, + "./encoding/*": { + "types": "./build/types/encoding/*.d.ts", + "import": "./build/esm/encoding/*.js", + "require": "./build/cjs/encoding/*.js" + }, + "./converters": { + "types": "./build/types/converters/index.d.ts", + "import": "./build/esm/converters/index.js", + "require": "./build/cjs/converters/index.js" + }, + "./pem": { + "types": "./build/types/pem/index.d.ts", + "import": "./build/esm/pem/index.js", + "require": "./build/cjs/pem/index.js" + }, + "./legacy": { + "types": "./build/types/legacy/index.d.ts", + "import": "./build/esm/legacy/index.js", + "require": "./build/cjs/legacy/index.js" + }, + "./package.json": "./package.json" + }, + "files": [ + "build/cjs/**/*.js", + "build/cjs/package.json", + "build/esm/**/*.js", + "build/types/**/*.d.ts", + "README.md", + "LICENSE" + ], + "publishConfig": { + "access": "public" + }, + "scripts": { + "test": "vitest run", + "coverage": "vitest run --coverage", + "clear": "rimraf build", + "rebuild": "npm run clear && npm run build", + "build": "node scripts/prune-legacy-build-outputs.mjs && tsc -p tsconfig.build.types.json && tsc -p tsconfig.build.esm.json && tsc -p tsconfig.build.cjs.json && node scripts/write-cjs-package-json.mjs", + "prepack": "npm run build", + "publish:manual": "npm run check && npm run build && npm publish --ignore-scripts", + "lint:check": "eslint . --fix-dry-run", + "check": "npm run lint:check && tsc --noEmit && npm test", + "lint": "eslint .", + "lint:fix": "eslint . --fix" + }, + "keywords": [ + "typescript", + "utils", + "buffer", + "bytes", + "convert", + "encoding", + "base64", + "base64url", + "hex", + "utf8", + "utf16", + "pem", + "pki", + "peculiar" + ], + "author": "PeculiarVentures", + "contributors": [ + "Miroshin Stepan" + ], + "license": "MIT", + "repository": { + "type": "git", + "url": "https://github.com/PeculiarVentures/pvtsutils" + }, + "bugs": { + "url": "https://github.com/PeculiarVentures/pvtsutils/issues" + }, + "homepage": "https://github.com/PeculiarVentures/pvtsutils#readme", + "dependencies": { + "tslib": "^2.8.1" + }, + "devDependencies": { + "@peculiar/eslint-config-base": "^0.2.9", + "@types/node": "^25.6.0", + "@vitest/coverage-v8": "^4.1.5", + "rimraf": "^6.1.3", + "typescript": "^6.0.3", + "vitest": "^4.1.5" + } +} diff --git a/node_modules/@peculiar/webcrypto/LICENSE.md b/node_modules/@peculiar/webcrypto/LICENSE.md new file mode 100644 index 0000000..ff9129e --- /dev/null +++ b/node_modules/@peculiar/webcrypto/LICENSE.md @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2019-2026 Peculiar Ventures, LLC + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/node_modules/@peculiar/webcrypto/README.md b/node_modules/@peculiar/webcrypto/README.md new file mode 100644 index 0000000..2442efe --- /dev/null +++ b/node_modules/@peculiar/webcrypto/README.md @@ -0,0 +1,97 @@ +

+ @peculiar/webcrypto +

+ +
+ +![NPM License](https://img.shields.io/npm/l/@peculiar/webcrypto) +![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/PeculiarVentures/webcrypto/test.yml?label=test) +[![npm version](https://img.shields.io/npm/v/@peculiar/webcrypto.svg)](https://www.npmjs.com/package/@peculiar/webcrypto) +![Coveralls](https://img.shields.io/coverallsCoverage/github/PeculiarVentures/webcrypto) +[![npm downloads](https://img.shields.io/npm/dm/@peculiar/webcrypto.svg)](https://www.npmjs.com/package/@peculiar/webcrypto) + +
+ +We wanted to be able to write Javascript that used crypto on both the client and the server but we did not want to rely on Javascript implementations of crypto. The only native cryptography available in browser is [Web Crypto](http://caniuse.com/#search=cryptography), this resulted in us creating a `@peculiar/webcrypto`. + +## Table Of Contents + +* [WARNING](#warning) +* [Installing](#installing) +* [Using](#using) +* [Examples](#examples) +* [Bug Reporting](#bug-reporting) +* [Related](#related) + +## WARNING + +**At this time this solution should be considered suitable for research and experimentation, further code and security review is needed before utilization in a production application.** + +**Module is based on the Node.js crypto API. It requires Node v14.18.0 or higher.** + +## Installing + +``` +npm install @peculiar/webcrypto +``` + +## Supported algorithms + +| Algorithm name | generateKey | digest | export/import | sign/verify | encrypt/decrypt | wrapKey/unwrapKey | derive | +|-------------------|-------------|---------|---------------|-------------|-----------------|-------------------|---------| +| SHA-1 | | X | | | | | | +| SHA-256 | | X | | | | | | +| SHA-384 | | X | | | | | | +| SHA-512 | | X | | | | | | +| HMAC | X | | X | X | | | | +| RSASSA-PKCS1-v1_5 | X | | X | X | | | | +| RSAES-PKCS1-v1_52| X | | X | | X | X | | +| RSA-PSS | X | | X | X | | | | +| RSA-OAEP | X | | X | | X | X | | +| AES-CMAC | X | | X | X | | | | +| AES-CBC | X | | X | | X | X | | +| AES-CTR | X | | X | | X | X | | +| AES-ECB | X | | X | | X | X | | +| AES-GCM | X | | X | | X | X | | +| AES-KW | X | | X | | | X | | +| ECDSA1 | X | | X | X | | | | +| ECDH1 | X | | X | | | | X | +| EdDSA2,3 | X | | X | X | | | | +| ECDH-ES2,4 | X | | X | | | | X | +| HKDF | | | X | | | | X | +| PBKDF2 | | | X | | | | X | +| DES-CBC2| X | | X | | X | X | | +| DES-EDE3-CBC2| X | | X | | X | X | | +| shake1282| | X | | | | | | +| shake2562| | X | | | | | | + +1 Mechanism supports extended list of named curves `P-256`, `P-384`, `P-521`, `K-256`, +`brainpoolP160r1`, `brainpoolP160t1`, `brainpoolP192r1`, `brainpoolP192t1`, `brainpoolP224r1`, `brainpoolP224t1`, `brainpoolP256r1`, `brainpoolP256t1`, `brainpoolP320r1`, `brainpoolP320t1`, `brainpoolP384r1`, `brainpoolP384t1`, `brainpoolP512r1`, and `brainpoolP512t1` + +2 Mechanism is not defined by the WebCrypto specifications. Use of mechanism in a safe way is hard, it was added for the purpose of enabling interoperability with an existing system. We recommend against its use unless needed for interoperability. + +3 Mechanism supports extended list of named curves `Ed25519`, and `Ed448` + +4 Mechanism supports extended list of named curves `X25519`, and `X448` + +## Using + +```javascript +const { Crypto } = require("@peculiar/webcrypto"); + +const crypto = new Crypto(); +``` + +## Examples + +See [WebCrypto Docs](https://github.com/PeculiarVentures/webcrypto-docs/blob/master/README.md) for examples + +## Bug Reporting + +Please report bugs either as pull requests or as issues in the issue tracker. `@peculiar/webcrypto` has a full disclosure vulnerability policy. Please do NOT attempt to report any security vulnerability in this code privately to anybody. + +## Related + +* [node-webcrypto-ossl](https://github.com/PeculiarVentures/node-webcrypto-ossl) +* [node-webcrypto-p11](https://github.com/PeculiarVentures/node-webcrypto-p11) +* [webcrypto-liner](https://github.com/PeculiarVentures/webcrypto-liner) diff --git a/node_modules/@peculiar/webcrypto/index.d.ts b/node_modules/@peculiar/webcrypto/index.d.ts new file mode 100644 index 0000000..8275665 --- /dev/null +++ b/node_modules/@peculiar/webcrypto/index.d.ts @@ -0,0 +1,12 @@ +export declare class Crypto implements globalThis.Crypto { + public subtle: SubtleCrypto; + public getRandomValues(array: T): T; + randomUUID(): `${string}-${string}-${string}-${string}-${string}`; +} + +export declare class CryptoKey implements globalThis.CryptoKey { + public algorithm: KeyAlgorithm; + public extractable: boolean; + public type: KeyType; + public usages: KeyUsage[]; +} diff --git a/node_modules/@peculiar/webcrypto/package.json b/node_modules/@peculiar/webcrypto/package.json new file mode 100644 index 0000000..c0624b1 --- /dev/null +++ b/node_modules/@peculiar/webcrypto/package.json @@ -0,0 +1,86 @@ +{ + "name": "@peculiar/webcrypto", + "version": "1.7.1", + "description": "A WebCrypto Polyfill for NodeJS", + "repository": { + "type": "git", + "url": "https://github.com/PeculiarVentures/webcrypto" + }, + "exports": { + ".": { + "types": "./index.d.ts", + "import": "./build/webcrypto.es.js", + "require": "./build/webcrypto.js" + }, + "./package.json": "./package.json" + }, + "files": [ + "build/**/*.{ts,js}", + "index.d.ts", + "README.md", + "LICENSE.md" + ], + "main": "build/webcrypto.js", + "module": "build/webcrypto.es.js", + "react-native": "build/webcrypto.es.js", + "types": "index.d.ts", + "scripts": { + "test": "vitest run", + "test:watch": "vitest", + "coverage": "vitest --coverage", + "build": "rollup -c", + "clear": "rimraf build/*", + "rebuild": "npm run clear && npm run build", + "typecheck": "tsc --noEmit", + "lint": "eslint", + "lint:fix": "eslint --fix" + }, + "keywords": [ + "webcrypto", + "crypto", + "sha", + "rsa", + "ec", + "aes", + "des", + "hmac", + "pbkdf2", + "eddsa", + "x25519", + "ed25519", + "x448", + "ed448", + "shake128", + "shake256" + ], + "author": "PeculiarVentures", + "contributors": [ + "Miroshin Stepan" + ], + "license": "MIT", + "bugs": { + "url": "https://github.com/PeculiarVentures/webcrypto/issues" + }, + "homepage": "https://github.com/PeculiarVentures/webcrypto#readme", + "devDependencies": { + "@peculiar/eslint-config-base": "^0.2.9", + "@peculiar/webcrypto-test": "^2.0.0", + "@rollup/plugin-typescript": "^12.3.0", + "@types/node": "^25.6.0", + "@vitest/coverage-v8": "^4.1.5", + "rimraf": "^6.1.3", + "rollup": "^4.60.2", + "typescript": "^6.0.3", + "vitest": "^4.1.5" + }, + "dependencies": { + "@peculiar/asn1-schema": "^2.7.0", + "@peculiar/json-schema": "^1.1.12", + "@peculiar/utils": "^2.0.2", + "tslib": "^2.8.1", + "webcrypto-core": "^1.9.2" + }, + "engines": { + "node": ">=14.18.0" + } +} diff --git a/node_modules/@sindresorhus/is/dist/index.d.ts b/node_modules/@sindresorhus/is/dist/index.d.ts new file mode 100644 index 0000000..dbb8cbd --- /dev/null +++ b/node_modules/@sindresorhus/is/dist/index.d.ts @@ -0,0 +1,232 @@ +/// +/// +/// +import { Class, Falsy, TypedArray, ObservableLike, Primitive } from './types'; +declare const objectTypeNames: readonly ["Function", "Generator", "AsyncGenerator", "GeneratorFunction", "AsyncGeneratorFunction", "AsyncFunction", "Observable", "Array", "Buffer", "Blob", "Object", "RegExp", "Date", "Error", "Map", "Set", "WeakMap", "WeakSet", "ArrayBuffer", "SharedArrayBuffer", "DataView", "Promise", "URL", "FormData", "URLSearchParams", "HTMLElement", ...("Int8Array" | "Uint8Array" | "Uint8ClampedArray" | "Int16Array" | "Uint16Array" | "Int32Array" | "Uint32Array" | "Float32Array" | "Float64Array" | "BigInt64Array" | "BigUint64Array")[]]; +declare type ObjectTypeName = typeof objectTypeNames[number]; +declare const primitiveTypeNames: readonly ["null", "undefined", "string", "number", "bigint", "boolean", "symbol"]; +declare type PrimitiveTypeName = typeof primitiveTypeNames[number]; +export declare type TypeName = ObjectTypeName | PrimitiveTypeName; +declare function is(value: unknown): TypeName; +declare namespace is { + var undefined: (value: unknown) => value is undefined; + var string: (value: unknown) => value is string; + var number: (value: unknown) => value is number; + var bigint: (value: unknown) => value is bigint; + var function_: (value: unknown) => value is Function; + var null_: (value: unknown) => value is null; + var class_: (value: unknown) => value is Class; + var boolean: (value: unknown) => value is boolean; + var symbol: (value: unknown) => value is symbol; + var numericString: (value: unknown) => value is string; + var array: (value: unknown, assertion?: ((value: T) => value is T) | undefined) => value is T[]; + var buffer: (value: unknown) => value is Buffer; + var blob: (value: unknown) => value is Blob; + var nullOrUndefined: (value: unknown) => value is null | undefined; + var object: (value: unknown) => value is object; + var iterable: (value: unknown) => value is Iterable; + var asyncIterable: (value: unknown) => value is AsyncIterable; + var generator: (value: unknown) => value is Generator; + var asyncGenerator: (value: unknown) => value is AsyncGenerator; + var nativePromise: (value: unknown) => value is Promise; + var promise: (value: unknown) => value is Promise; + var generatorFunction: (value: unknown) => value is GeneratorFunction; + var asyncGeneratorFunction: (value: unknown) => value is (...args: any[]) => Promise; + var asyncFunction: (value: unknown) => value is (...args: any[]) => Promise; + var boundFunction: (value: unknown) => value is Function; + var regExp: (value: unknown) => value is RegExp; + var date: (value: unknown) => value is Date; + var error: (value: unknown) => value is Error; + var map: (value: unknown) => value is Map; + var set: (value: unknown) => value is Set; + var weakMap: (value: unknown) => value is WeakMap; + var weakSet: (value: unknown) => value is WeakSet; + var int8Array: (value: unknown) => value is Int8Array; + var uint8Array: (value: unknown) => value is Uint8Array; + var uint8ClampedArray: (value: unknown) => value is Uint8ClampedArray; + var int16Array: (value: unknown) => value is Int16Array; + var uint16Array: (value: unknown) => value is Uint16Array; + var int32Array: (value: unknown) => value is Int32Array; + var uint32Array: (value: unknown) => value is Uint32Array; + var float32Array: (value: unknown) => value is Float32Array; + var float64Array: (value: unknown) => value is Float64Array; + var bigInt64Array: (value: unknown) => value is BigInt64Array; + var bigUint64Array: (value: unknown) => value is BigUint64Array; + var arrayBuffer: (value: unknown) => value is ArrayBuffer; + var sharedArrayBuffer: (value: unknown) => value is SharedArrayBuffer; + var dataView: (value: unknown) => value is DataView; + var enumCase: (value: unknown, targetEnum: T) => boolean; + var directInstanceOf: (instance: unknown, class_: Class) => instance is T; + var urlInstance: (value: unknown) => value is URL; + var urlString: (value: unknown) => value is string; + var truthy: (value: false | "" | 0 | 0n | T | null | undefined) => value is T; + var falsy: (value: false | "" | 0 | 0n | T | null | undefined) => value is Falsy; + var nan: (value: unknown) => boolean; + var primitive: (value: unknown) => value is Primitive; + var integer: (value: unknown) => value is number; + var safeInteger: (value: unknown) => value is number; + var plainObject: (value: unknown) => value is Record; + var typedArray: (value: unknown) => value is TypedArray; + var arrayLike: (value: unknown) => value is ArrayLike; + var inRange: (value: number, range: number | number[]) => value is number; + var domElement: (value: unknown) => value is HTMLElement; + var observable: (value: unknown) => value is ObservableLike; + var nodeStream: (value: unknown) => value is NodeStream; + var infinite: (value: unknown) => value is number; + var evenInteger: (value: number) => value is number; + var oddInteger: (value: number) => value is number; + var emptyArray: (value: unknown) => value is never[]; + var nonEmptyArray: (value: unknown) => value is unknown[]; + var emptyString: (value: unknown) => value is ""; + var emptyStringOrWhitespace: (value: unknown) => value is string; + var nonEmptyString: (value: unknown) => value is string; + var nonEmptyStringAndNotWhitespace: (value: unknown) => value is string; + var emptyObject: (value: unknown) => value is Record; + var nonEmptyObject: (value: unknown) => value is Record; + var emptySet: (value: unknown) => value is Set; + var nonEmptySet: (value: unknown) => value is Set; + var emptyMap: (value: unknown) => value is Map; + var nonEmptyMap: (value: unknown) => value is Map; + var propertyKey: (value: unknown) => value is string | number | symbol; + var formData: (value: unknown) => value is FormData; + var urlSearchParams: (value: unknown) => value is URLSearchParams; + var any: (predicate: Predicate | Predicate[], ...values: unknown[]) => boolean; + var all: (predicate: Predicate, ...values: unknown[]) => boolean; +} +export interface ArrayLike { + readonly [index: number]: T; + readonly length: number; +} +export interface NodeStream extends NodeJS.EventEmitter { + pipe(destination: T, options?: { + end?: boolean; + }): T; +} +export declare type Predicate = (value: unknown) => boolean; +export declare const enum AssertionTypeDescription { + class_ = "Class", + numericString = "string with a number", + nullOrUndefined = "null or undefined", + iterable = "Iterable", + asyncIterable = "AsyncIterable", + nativePromise = "native Promise", + urlString = "string with a URL", + truthy = "truthy", + falsy = "falsy", + nan = "NaN", + primitive = "primitive", + integer = "integer", + safeInteger = "integer", + plainObject = "plain object", + arrayLike = "array-like", + typedArray = "TypedArray", + domElement = "HTMLElement", + nodeStream = "Node.js Stream", + infinite = "infinite number", + emptyArray = "empty array", + nonEmptyArray = "non-empty array", + emptyString = "empty string", + emptyStringOrWhitespace = "empty string or whitespace", + nonEmptyString = "non-empty string", + nonEmptyStringAndNotWhitespace = "non-empty string and not whitespace", + emptyObject = "empty object", + nonEmptyObject = "non-empty object", + emptySet = "empty set", + nonEmptySet = "non-empty set", + emptyMap = "empty map", + nonEmptyMap = "non-empty map", + evenInteger = "even integer", + oddInteger = "odd integer", + directInstanceOf = "T", + inRange = "in range", + any = "predicate returns truthy for any value", + all = "predicate returns truthy for all values" +} +interface Assert { + undefined: (value: unknown) => asserts value is undefined; + string: (value: unknown) => asserts value is string; + number: (value: unknown) => asserts value is number; + bigint: (value: unknown) => asserts value is bigint; + function_: (value: unknown) => asserts value is Function; + null_: (value: unknown) => asserts value is null; + class_: (value: unknown) => asserts value is Class; + boolean: (value: unknown) => asserts value is boolean; + symbol: (value: unknown) => asserts value is symbol; + numericString: (value: unknown) => asserts value is string; + array: (value: unknown, assertion?: (element: unknown) => asserts element is T) => asserts value is T[]; + buffer: (value: unknown) => asserts value is Buffer; + blob: (value: unknown) => asserts value is Blob; + nullOrUndefined: (value: unknown) => asserts value is null | undefined; + object: (value: unknown) => asserts value is Record; + iterable: (value: unknown) => asserts value is Iterable; + asyncIterable: (value: unknown) => asserts value is AsyncIterable; + generator: (value: unknown) => asserts value is Generator; + asyncGenerator: (value: unknown) => asserts value is AsyncGenerator; + nativePromise: (value: unknown) => asserts value is Promise; + promise: (value: unknown) => asserts value is Promise; + generatorFunction: (value: unknown) => asserts value is GeneratorFunction; + asyncGeneratorFunction: (value: unknown) => asserts value is AsyncGeneratorFunction; + asyncFunction: (value: unknown) => asserts value is Function; + boundFunction: (value: unknown) => asserts value is Function; + regExp: (value: unknown) => asserts value is RegExp; + date: (value: unknown) => asserts value is Date; + error: (value: unknown) => asserts value is Error; + map: (value: unknown) => asserts value is Map; + set: (value: unknown) => asserts value is Set; + weakMap: (value: unknown) => asserts value is WeakMap; + weakSet: (value: unknown) => asserts value is WeakSet; + int8Array: (value: unknown) => asserts value is Int8Array; + uint8Array: (value: unknown) => asserts value is Uint8Array; + uint8ClampedArray: (value: unknown) => asserts value is Uint8ClampedArray; + int16Array: (value: unknown) => asserts value is Int16Array; + uint16Array: (value: unknown) => asserts value is Uint16Array; + int32Array: (value: unknown) => asserts value is Int32Array; + uint32Array: (value: unknown) => asserts value is Uint32Array; + float32Array: (value: unknown) => asserts value is Float32Array; + float64Array: (value: unknown) => asserts value is Float64Array; + bigInt64Array: (value: unknown) => asserts value is BigInt64Array; + bigUint64Array: (value: unknown) => asserts value is BigUint64Array; + arrayBuffer: (value: unknown) => asserts value is ArrayBuffer; + sharedArrayBuffer: (value: unknown) => asserts value is SharedArrayBuffer; + dataView: (value: unknown) => asserts value is DataView; + enumCase: (value: unknown, targetEnum: T) => asserts value is T[keyof T]; + urlInstance: (value: unknown) => asserts value is URL; + urlString: (value: unknown) => asserts value is string; + truthy: (value: unknown) => asserts value is unknown; + falsy: (value: unknown) => asserts value is unknown; + nan: (value: unknown) => asserts value is unknown; + primitive: (value: unknown) => asserts value is Primitive; + integer: (value: unknown) => asserts value is number; + safeInteger: (value: unknown) => asserts value is number; + plainObject: (value: unknown) => asserts value is Record; + typedArray: (value: unknown) => asserts value is TypedArray; + arrayLike: (value: unknown) => asserts value is ArrayLike; + domElement: (value: unknown) => asserts value is HTMLElement; + observable: (value: unknown) => asserts value is ObservableLike; + nodeStream: (value: unknown) => asserts value is NodeStream; + infinite: (value: unknown) => asserts value is number; + emptyArray: (value: unknown) => asserts value is never[]; + nonEmptyArray: (value: unknown) => asserts value is unknown[]; + emptyString: (value: unknown) => asserts value is ''; + emptyStringOrWhitespace: (value: unknown) => asserts value is string; + nonEmptyString: (value: unknown) => asserts value is string; + nonEmptyStringAndNotWhitespace: (value: unknown) => asserts value is string; + emptyObject: (value: unknown) => asserts value is Record; + nonEmptyObject: (value: unknown) => asserts value is Record; + emptySet: (value: unknown) => asserts value is Set; + nonEmptySet: (value: unknown) => asserts value is Set; + emptyMap: (value: unknown) => asserts value is Map; + nonEmptyMap: (value: unknown) => asserts value is Map; + propertyKey: (value: unknown) => asserts value is PropertyKey; + formData: (value: unknown) => asserts value is FormData; + urlSearchParams: (value: unknown) => asserts value is URLSearchParams; + evenInteger: (value: number) => asserts value is number; + oddInteger: (value: number) => asserts value is number; + directInstanceOf: (instance: unknown, class_: Class) => asserts instance is T; + inRange: (value: number, range: number | number[]) => asserts value is number; + any: (predicate: Predicate | Predicate[], ...values: unknown[]) => void | never; + all: (predicate: Predicate, ...values: unknown[]) => void | never; +} +export declare const assert: Assert; +export default is; +export { Class, TypedArray, ObservableLike, Primitive } from './types'; diff --git a/node_modules/@sindresorhus/is/dist/index.js b/node_modules/@sindresorhus/is/dist/index.js new file mode 100644 index 0000000..a80df87 --- /dev/null +++ b/node_modules/@sindresorhus/is/dist/index.js @@ -0,0 +1,434 @@ +"use strict"; +/// +/// +/// +Object.defineProperty(exports, "__esModule", { value: true }); +const typedArrayTypeNames = [ + 'Int8Array', + 'Uint8Array', + 'Uint8ClampedArray', + 'Int16Array', + 'Uint16Array', + 'Int32Array', + 'Uint32Array', + 'Float32Array', + 'Float64Array', + 'BigInt64Array', + 'BigUint64Array' +]; +function isTypedArrayName(name) { + return typedArrayTypeNames.includes(name); +} +const objectTypeNames = [ + 'Function', + 'Generator', + 'AsyncGenerator', + 'GeneratorFunction', + 'AsyncGeneratorFunction', + 'AsyncFunction', + 'Observable', + 'Array', + 'Buffer', + 'Blob', + 'Object', + 'RegExp', + 'Date', + 'Error', + 'Map', + 'Set', + 'WeakMap', + 'WeakSet', + 'ArrayBuffer', + 'SharedArrayBuffer', + 'DataView', + 'Promise', + 'URL', + 'FormData', + 'URLSearchParams', + 'HTMLElement', + ...typedArrayTypeNames +]; +function isObjectTypeName(name) { + return objectTypeNames.includes(name); +} +const primitiveTypeNames = [ + 'null', + 'undefined', + 'string', + 'number', + 'bigint', + 'boolean', + 'symbol' +]; +function isPrimitiveTypeName(name) { + return primitiveTypeNames.includes(name); +} +// eslint-disable-next-line @typescript-eslint/ban-types +function isOfType(type) { + return (value) => typeof value === type; +} +const { toString } = Object.prototype; +const getObjectType = (value) => { + const objectTypeName = toString.call(value).slice(8, -1); + if (/HTML\w+Element/.test(objectTypeName) && is.domElement(value)) { + return 'HTMLElement'; + } + if (isObjectTypeName(objectTypeName)) { + return objectTypeName; + } + return undefined; +}; +const isObjectOfType = (type) => (value) => getObjectType(value) === type; +function is(value) { + if (value === null) { + return 'null'; + } + switch (typeof value) { + case 'undefined': + return 'undefined'; + case 'string': + return 'string'; + case 'number': + return 'number'; + case 'boolean': + return 'boolean'; + case 'function': + return 'Function'; + case 'bigint': + return 'bigint'; + case 'symbol': + return 'symbol'; + default: + } + if (is.observable(value)) { + return 'Observable'; + } + if (is.array(value)) { + return 'Array'; + } + if (is.buffer(value)) { + return 'Buffer'; + } + const tagType = getObjectType(value); + if (tagType) { + return tagType; + } + if (value instanceof String || value instanceof Boolean || value instanceof Number) { + throw new TypeError('Please don\'t use object wrappers for primitive types'); + } + return 'Object'; +} +is.undefined = isOfType('undefined'); +is.string = isOfType('string'); +const isNumberType = isOfType('number'); +is.number = (value) => isNumberType(value) && !is.nan(value); +is.bigint = isOfType('bigint'); +// eslint-disable-next-line @typescript-eslint/ban-types +is.function_ = isOfType('function'); +is.null_ = (value) => value === null; +is.class_ = (value) => is.function_(value) && value.toString().startsWith('class '); +is.boolean = (value) => value === true || value === false; +is.symbol = isOfType('symbol'); +is.numericString = (value) => is.string(value) && !is.emptyStringOrWhitespace(value) && !Number.isNaN(Number(value)); +is.array = (value, assertion) => { + if (!Array.isArray(value)) { + return false; + } + if (!is.function_(assertion)) { + return true; + } + return value.every(assertion); +}; +is.buffer = (value) => { var _a, _b, _c, _d; return (_d = (_c = (_b = (_a = value) === null || _a === void 0 ? void 0 : _a.constructor) === null || _b === void 0 ? void 0 : _b.isBuffer) === null || _c === void 0 ? void 0 : _c.call(_b, value)) !== null && _d !== void 0 ? _d : false; }; +is.blob = (value) => isObjectOfType('Blob')(value); +is.nullOrUndefined = (value) => is.null_(value) || is.undefined(value); +is.object = (value) => !is.null_(value) && (typeof value === 'object' || is.function_(value)); +is.iterable = (value) => { var _a; return is.function_((_a = value) === null || _a === void 0 ? void 0 : _a[Symbol.iterator]); }; +is.asyncIterable = (value) => { var _a; return is.function_((_a = value) === null || _a === void 0 ? void 0 : _a[Symbol.asyncIterator]); }; +is.generator = (value) => { var _a, _b; return is.iterable(value) && is.function_((_a = value) === null || _a === void 0 ? void 0 : _a.next) && is.function_((_b = value) === null || _b === void 0 ? void 0 : _b.throw); }; +is.asyncGenerator = (value) => is.asyncIterable(value) && is.function_(value.next) && is.function_(value.throw); +is.nativePromise = (value) => isObjectOfType('Promise')(value); +const hasPromiseAPI = (value) => { + var _a, _b; + return is.function_((_a = value) === null || _a === void 0 ? void 0 : _a.then) && + is.function_((_b = value) === null || _b === void 0 ? void 0 : _b.catch); +}; +is.promise = (value) => is.nativePromise(value) || hasPromiseAPI(value); +is.generatorFunction = isObjectOfType('GeneratorFunction'); +is.asyncGeneratorFunction = (value) => getObjectType(value) === 'AsyncGeneratorFunction'; +is.asyncFunction = (value) => getObjectType(value) === 'AsyncFunction'; +// eslint-disable-next-line no-prototype-builtins, @typescript-eslint/ban-types +is.boundFunction = (value) => is.function_(value) && !value.hasOwnProperty('prototype'); +is.regExp = isObjectOfType('RegExp'); +is.date = isObjectOfType('Date'); +is.error = isObjectOfType('Error'); +is.map = (value) => isObjectOfType('Map')(value); +is.set = (value) => isObjectOfType('Set')(value); +is.weakMap = (value) => isObjectOfType('WeakMap')(value); +is.weakSet = (value) => isObjectOfType('WeakSet')(value); +is.int8Array = isObjectOfType('Int8Array'); +is.uint8Array = isObjectOfType('Uint8Array'); +is.uint8ClampedArray = isObjectOfType('Uint8ClampedArray'); +is.int16Array = isObjectOfType('Int16Array'); +is.uint16Array = isObjectOfType('Uint16Array'); +is.int32Array = isObjectOfType('Int32Array'); +is.uint32Array = isObjectOfType('Uint32Array'); +is.float32Array = isObjectOfType('Float32Array'); +is.float64Array = isObjectOfType('Float64Array'); +is.bigInt64Array = isObjectOfType('BigInt64Array'); +is.bigUint64Array = isObjectOfType('BigUint64Array'); +is.arrayBuffer = isObjectOfType('ArrayBuffer'); +is.sharedArrayBuffer = isObjectOfType('SharedArrayBuffer'); +is.dataView = isObjectOfType('DataView'); +is.enumCase = (value, targetEnum) => Object.values(targetEnum).includes(value); +is.directInstanceOf = (instance, class_) => Object.getPrototypeOf(instance) === class_.prototype; +is.urlInstance = (value) => isObjectOfType('URL')(value); +is.urlString = (value) => { + if (!is.string(value)) { + return false; + } + try { + new URL(value); // eslint-disable-line no-new + return true; + } + catch (_a) { + return false; + } +}; +// Example: `is.truthy = (value: unknown): value is (not false | not 0 | not '' | not undefined | not null) => Boolean(value);` +is.truthy = (value) => Boolean(value); +// Example: `is.falsy = (value: unknown): value is (not true | 0 | '' | undefined | null) => Boolean(value);` +is.falsy = (value) => !value; +is.nan = (value) => Number.isNaN(value); +is.primitive = (value) => is.null_(value) || isPrimitiveTypeName(typeof value); +is.integer = (value) => Number.isInteger(value); +is.safeInteger = (value) => Number.isSafeInteger(value); +is.plainObject = (value) => { + // From: https://github.com/sindresorhus/is-plain-obj/blob/main/index.js + if (toString.call(value) !== '[object Object]') { + return false; + } + const prototype = Object.getPrototypeOf(value); + return prototype === null || prototype === Object.getPrototypeOf({}); +}; +is.typedArray = (value) => isTypedArrayName(getObjectType(value)); +const isValidLength = (value) => is.safeInteger(value) && value >= 0; +is.arrayLike = (value) => !is.nullOrUndefined(value) && !is.function_(value) && isValidLength(value.length); +is.inRange = (value, range) => { + if (is.number(range)) { + return value >= Math.min(0, range) && value <= Math.max(range, 0); + } + if (is.array(range) && range.length === 2) { + return value >= Math.min(...range) && value <= Math.max(...range); + } + throw new TypeError(`Invalid range: ${JSON.stringify(range)}`); +}; +const NODE_TYPE_ELEMENT = 1; +const DOM_PROPERTIES_TO_CHECK = [ + 'innerHTML', + 'ownerDocument', + 'style', + 'attributes', + 'nodeValue' +]; +is.domElement = (value) => { + return is.object(value) && + value.nodeType === NODE_TYPE_ELEMENT && + is.string(value.nodeName) && + !is.plainObject(value) && + DOM_PROPERTIES_TO_CHECK.every(property => property in value); +}; +is.observable = (value) => { + var _a, _b, _c, _d; + if (!value) { + return false; + } + // eslint-disable-next-line no-use-extend-native/no-use-extend-native + if (value === ((_b = (_a = value)[Symbol.observable]) === null || _b === void 0 ? void 0 : _b.call(_a))) { + return true; + } + if (value === ((_d = (_c = value)['@@observable']) === null || _d === void 0 ? void 0 : _d.call(_c))) { + return true; + } + return false; +}; +is.nodeStream = (value) => is.object(value) && is.function_(value.pipe) && !is.observable(value); +is.infinite = (value) => value === Infinity || value === -Infinity; +const isAbsoluteMod2 = (remainder) => (value) => is.integer(value) && Math.abs(value % 2) === remainder; +is.evenInteger = isAbsoluteMod2(0); +is.oddInteger = isAbsoluteMod2(1); +is.emptyArray = (value) => is.array(value) && value.length === 0; +is.nonEmptyArray = (value) => is.array(value) && value.length > 0; +is.emptyString = (value) => is.string(value) && value.length === 0; +const isWhiteSpaceString = (value) => is.string(value) && !/\S/.test(value); +is.emptyStringOrWhitespace = (value) => is.emptyString(value) || isWhiteSpaceString(value); +// TODO: Use `not ''` when the `not` operator is available. +is.nonEmptyString = (value) => is.string(value) && value.length > 0; +// TODO: Use `not ''` when the `not` operator is available. +is.nonEmptyStringAndNotWhitespace = (value) => is.string(value) && !is.emptyStringOrWhitespace(value); +is.emptyObject = (value) => is.object(value) && !is.map(value) && !is.set(value) && Object.keys(value).length === 0; +// TODO: Use `not` operator here to remove `Map` and `Set` from type guard: +// - https://github.com/Microsoft/TypeScript/pull/29317 +is.nonEmptyObject = (value) => is.object(value) && !is.map(value) && !is.set(value) && Object.keys(value).length > 0; +is.emptySet = (value) => is.set(value) && value.size === 0; +is.nonEmptySet = (value) => is.set(value) && value.size > 0; +is.emptyMap = (value) => is.map(value) && value.size === 0; +is.nonEmptyMap = (value) => is.map(value) && value.size > 0; +// `PropertyKey` is any value that can be used as an object key (string, number, or symbol) +is.propertyKey = (value) => is.any([is.string, is.number, is.symbol], value); +is.formData = (value) => isObjectOfType('FormData')(value); +is.urlSearchParams = (value) => isObjectOfType('URLSearchParams')(value); +const predicateOnArray = (method, predicate, values) => { + if (!is.function_(predicate)) { + throw new TypeError(`Invalid predicate: ${JSON.stringify(predicate)}`); + } + if (values.length === 0) { + throw new TypeError('Invalid number of values'); + } + return method.call(values, predicate); +}; +is.any = (predicate, ...values) => { + const predicates = is.array(predicate) ? predicate : [predicate]; + return predicates.some(singlePredicate => predicateOnArray(Array.prototype.some, singlePredicate, values)); +}; +is.all = (predicate, ...values) => predicateOnArray(Array.prototype.every, predicate, values); +const assertType = (condition, description, value, options = {}) => { + if (!condition) { + const { multipleValues } = options; + const valuesMessage = multipleValues ? + `received values of types ${[ + ...new Set(value.map(singleValue => `\`${is(singleValue)}\``)) + ].join(', ')}` : + `received value of type \`${is(value)}\``; + throw new TypeError(`Expected value which is \`${description}\`, ${valuesMessage}.`); + } +}; +exports.assert = { + // Unknowns. + undefined: (value) => assertType(is.undefined(value), 'undefined', value), + string: (value) => assertType(is.string(value), 'string', value), + number: (value) => assertType(is.number(value), 'number', value), + bigint: (value) => assertType(is.bigint(value), 'bigint', value), + // eslint-disable-next-line @typescript-eslint/ban-types + function_: (value) => assertType(is.function_(value), 'Function', value), + null_: (value) => assertType(is.null_(value), 'null', value), + class_: (value) => assertType(is.class_(value), "Class" /* class_ */, value), + boolean: (value) => assertType(is.boolean(value), 'boolean', value), + symbol: (value) => assertType(is.symbol(value), 'symbol', value), + numericString: (value) => assertType(is.numericString(value), "string with a number" /* numericString */, value), + array: (value, assertion) => { + const assert = assertType; + assert(is.array(value), 'Array', value); + if (assertion) { + value.forEach(assertion); + } + }, + buffer: (value) => assertType(is.buffer(value), 'Buffer', value), + blob: (value) => assertType(is.blob(value), 'Blob', value), + nullOrUndefined: (value) => assertType(is.nullOrUndefined(value), "null or undefined" /* nullOrUndefined */, value), + object: (value) => assertType(is.object(value), 'Object', value), + iterable: (value) => assertType(is.iterable(value), "Iterable" /* iterable */, value), + asyncIterable: (value) => assertType(is.asyncIterable(value), "AsyncIterable" /* asyncIterable */, value), + generator: (value) => assertType(is.generator(value), 'Generator', value), + asyncGenerator: (value) => assertType(is.asyncGenerator(value), 'AsyncGenerator', value), + nativePromise: (value) => assertType(is.nativePromise(value), "native Promise" /* nativePromise */, value), + promise: (value) => assertType(is.promise(value), 'Promise', value), + generatorFunction: (value) => assertType(is.generatorFunction(value), 'GeneratorFunction', value), + asyncGeneratorFunction: (value) => assertType(is.asyncGeneratorFunction(value), 'AsyncGeneratorFunction', value), + // eslint-disable-next-line @typescript-eslint/ban-types + asyncFunction: (value) => assertType(is.asyncFunction(value), 'AsyncFunction', value), + // eslint-disable-next-line @typescript-eslint/ban-types + boundFunction: (value) => assertType(is.boundFunction(value), 'Function', value), + regExp: (value) => assertType(is.regExp(value), 'RegExp', value), + date: (value) => assertType(is.date(value), 'Date', value), + error: (value) => assertType(is.error(value), 'Error', value), + map: (value) => assertType(is.map(value), 'Map', value), + set: (value) => assertType(is.set(value), 'Set', value), + weakMap: (value) => assertType(is.weakMap(value), 'WeakMap', value), + weakSet: (value) => assertType(is.weakSet(value), 'WeakSet', value), + int8Array: (value) => assertType(is.int8Array(value), 'Int8Array', value), + uint8Array: (value) => assertType(is.uint8Array(value), 'Uint8Array', value), + uint8ClampedArray: (value) => assertType(is.uint8ClampedArray(value), 'Uint8ClampedArray', value), + int16Array: (value) => assertType(is.int16Array(value), 'Int16Array', value), + uint16Array: (value) => assertType(is.uint16Array(value), 'Uint16Array', value), + int32Array: (value) => assertType(is.int32Array(value), 'Int32Array', value), + uint32Array: (value) => assertType(is.uint32Array(value), 'Uint32Array', value), + float32Array: (value) => assertType(is.float32Array(value), 'Float32Array', value), + float64Array: (value) => assertType(is.float64Array(value), 'Float64Array', value), + bigInt64Array: (value) => assertType(is.bigInt64Array(value), 'BigInt64Array', value), + bigUint64Array: (value) => assertType(is.bigUint64Array(value), 'BigUint64Array', value), + arrayBuffer: (value) => assertType(is.arrayBuffer(value), 'ArrayBuffer', value), + sharedArrayBuffer: (value) => assertType(is.sharedArrayBuffer(value), 'SharedArrayBuffer', value), + dataView: (value) => assertType(is.dataView(value), 'DataView', value), + enumCase: (value, targetEnum) => assertType(is.enumCase(value, targetEnum), 'EnumCase', value), + urlInstance: (value) => assertType(is.urlInstance(value), 'URL', value), + urlString: (value) => assertType(is.urlString(value), "string with a URL" /* urlString */, value), + truthy: (value) => assertType(is.truthy(value), "truthy" /* truthy */, value), + falsy: (value) => assertType(is.falsy(value), "falsy" /* falsy */, value), + nan: (value) => assertType(is.nan(value), "NaN" /* nan */, value), + primitive: (value) => assertType(is.primitive(value), "primitive" /* primitive */, value), + integer: (value) => assertType(is.integer(value), "integer" /* integer */, value), + safeInteger: (value) => assertType(is.safeInteger(value), "integer" /* safeInteger */, value), + plainObject: (value) => assertType(is.plainObject(value), "plain object" /* plainObject */, value), + typedArray: (value) => assertType(is.typedArray(value), "TypedArray" /* typedArray */, value), + arrayLike: (value) => assertType(is.arrayLike(value), "array-like" /* arrayLike */, value), + domElement: (value) => assertType(is.domElement(value), "HTMLElement" /* domElement */, value), + observable: (value) => assertType(is.observable(value), 'Observable', value), + nodeStream: (value) => assertType(is.nodeStream(value), "Node.js Stream" /* nodeStream */, value), + infinite: (value) => assertType(is.infinite(value), "infinite number" /* infinite */, value), + emptyArray: (value) => assertType(is.emptyArray(value), "empty array" /* emptyArray */, value), + nonEmptyArray: (value) => assertType(is.nonEmptyArray(value), "non-empty array" /* nonEmptyArray */, value), + emptyString: (value) => assertType(is.emptyString(value), "empty string" /* emptyString */, value), + emptyStringOrWhitespace: (value) => assertType(is.emptyStringOrWhitespace(value), "empty string or whitespace" /* emptyStringOrWhitespace */, value), + nonEmptyString: (value) => assertType(is.nonEmptyString(value), "non-empty string" /* nonEmptyString */, value), + nonEmptyStringAndNotWhitespace: (value) => assertType(is.nonEmptyStringAndNotWhitespace(value), "non-empty string and not whitespace" /* nonEmptyStringAndNotWhitespace */, value), + emptyObject: (value) => assertType(is.emptyObject(value), "empty object" /* emptyObject */, value), + nonEmptyObject: (value) => assertType(is.nonEmptyObject(value), "non-empty object" /* nonEmptyObject */, value), + emptySet: (value) => assertType(is.emptySet(value), "empty set" /* emptySet */, value), + nonEmptySet: (value) => assertType(is.nonEmptySet(value), "non-empty set" /* nonEmptySet */, value), + emptyMap: (value) => assertType(is.emptyMap(value), "empty map" /* emptyMap */, value), + nonEmptyMap: (value) => assertType(is.nonEmptyMap(value), "non-empty map" /* nonEmptyMap */, value), + propertyKey: (value) => assertType(is.propertyKey(value), 'PropertyKey', value), + formData: (value) => assertType(is.formData(value), 'FormData', value), + urlSearchParams: (value) => assertType(is.urlSearchParams(value), 'URLSearchParams', value), + // Numbers. + evenInteger: (value) => assertType(is.evenInteger(value), "even integer" /* evenInteger */, value), + oddInteger: (value) => assertType(is.oddInteger(value), "odd integer" /* oddInteger */, value), + // Two arguments. + directInstanceOf: (instance, class_) => assertType(is.directInstanceOf(instance, class_), "T" /* directInstanceOf */, instance), + inRange: (value, range) => assertType(is.inRange(value, range), "in range" /* inRange */, value), + // Variadic functions. + any: (predicate, ...values) => { + return assertType(is.any(predicate, ...values), "predicate returns truthy for any value" /* any */, values, { multipleValues: true }); + }, + all: (predicate, ...values) => assertType(is.all(predicate, ...values), "predicate returns truthy for all values" /* all */, values, { multipleValues: true }) +}; +// Some few keywords are reserved, but we'll populate them for Node.js users +// See https://github.com/Microsoft/TypeScript/issues/2536 +Object.defineProperties(is, { + class: { + value: is.class_ + }, + function: { + value: is.function_ + }, + null: { + value: is.null_ + } +}); +Object.defineProperties(exports.assert, { + class: { + value: exports.assert.class_ + }, + function: { + value: exports.assert.function_ + }, + null: { + value: exports.assert.null_ + } +}); +exports.default = is; +// For CommonJS default export support +module.exports = is; +module.exports.default = is; +module.exports.assert = exports.assert; diff --git a/node_modules/@sindresorhus/is/dist/types.d.ts b/node_modules/@sindresorhus/is/dist/types.d.ts new file mode 100644 index 0000000..b4fae5d --- /dev/null +++ b/node_modules/@sindresorhus/is/dist/types.d.ts @@ -0,0 +1,25 @@ +/** +Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive). +*/ +export declare type Primitive = null | undefined | string | number | boolean | symbol | bigint; +/** +Matches a [`class` constructor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes). +*/ +export declare type Class = new (...arguments_: Arguments) => T; +/** +Matches any [typed array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray), like `Uint8Array` or `Float64Array`. +*/ +export declare type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array; +declare global { + interface SymbolConstructor { + readonly observable: symbol; + } +} +/** +Matches a value that is like an [Observable](https://github.com/tc39/proposal-observable). +*/ +export interface ObservableLike { + subscribe(observer: (value: unknown) => void): void; + [Symbol.observable](): ObservableLike; +} +export declare type Falsy = false | 0 | 0n | '' | null | undefined; diff --git a/node_modules/@sindresorhus/is/dist/types.js b/node_modules/@sindresorhus/is/dist/types.js new file mode 100644 index 0000000..0930323 --- /dev/null +++ b/node_modules/@sindresorhus/is/dist/types.js @@ -0,0 +1,3 @@ +"use strict"; +// Extracted from https://github.com/sindresorhus/type-fest/blob/78019f42ea888b0cdceb41a4a78163868de57555/index.d.ts +Object.defineProperty(exports, "__esModule", { value: true }); diff --git a/node_modules/@sindresorhus/is/license b/node_modules/@sindresorhus/is/license new file mode 100644 index 0000000..fa7ceba --- /dev/null +++ b/node_modules/@sindresorhus/is/license @@ -0,0 +1,9 @@ +MIT License + +Copyright (c) Sindre Sorhus (https://sindresorhus.com) + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/node_modules/@sindresorhus/is/package.json b/node_modules/@sindresorhus/is/package.json new file mode 100644 index 0000000..8052a87 --- /dev/null +++ b/node_modules/@sindresorhus/is/package.json @@ -0,0 +1,96 @@ +{ + "name": "@sindresorhus/is", + "version": "4.6.0", + "description": "Type check values", + "license": "MIT", + "repository": "sindresorhus/is", + "funding": "https://github.com/sindresorhus/is?sponsor=1", + "author": { + "name": "Sindre Sorhus", + "email": "sindresorhus@gmail.com", + "url": "https://sindresorhus.com" + }, + "main": "dist/index.js", + "engines": { + "node": ">=10" + }, + "scripts": { + "build": "del dist && tsc", + "test": "xo && ava", + "prepare": "npm run build" + }, + "files": [ + "dist" + ], + "keywords": [ + "type", + "types", + "is", + "check", + "checking", + "validate", + "validation", + "utility", + "util", + "typeof", + "instanceof", + "object", + "assert", + "assertion", + "test", + "kind", + "primitive", + "verify", + "compare", + "typescript", + "typeguards", + "types" + ], + "devDependencies": { + "@sindresorhus/tsconfig": "^0.7.0", + "@types/jsdom": "^16.1.0", + "@types/node": "^14.0.13", + "@types/zen-observable": "^0.8.0", + "@typescript-eslint/eslint-plugin": "^2.20.0", + "@typescript-eslint/parser": "^2.20.0", + "ava": "^3.3.0", + "del-cli": "^2.0.0", + "eslint-config-xo-typescript": "^0.26.0", + "jsdom": "^16.0.1", + "rxjs": "^6.4.0", + "tempy": "^0.4.0", + "ts-node": "^8.3.0", + "typescript": "~3.8.2", + "xo": "^0.26.1", + "zen-observable": "^0.8.8" + }, + "types": "dist/index.d.ts", + "sideEffects": false, + "ava": { + "extensions": [ + "ts" + ], + "require": [ + "ts-node/register" + ] + }, + "xo": { + "extends": "xo-typescript", + "extensions": [ + "ts" + ], + "parserOptions": { + "project": "./tsconfig.xo.json" + }, + "globals": [ + "BigInt", + "BigInt64Array", + "BigUint64Array" + ], + "rules": { + "@typescript-eslint/promise-function-async": "off", + "@typescript-eslint/no-empty-function": "off", + "@typescript-eslint/explicit-function-return-type": "off" + } + } +} diff --git a/node_modules/@sindresorhus/is/readme.md b/node_modules/@sindresorhus/is/readme.md new file mode 100644 index 0000000..05a291a --- /dev/null +++ b/node_modules/@sindresorhus/is/readme.md @@ -0,0 +1,669 @@ +# is + +> Type check values + +For example, `is.string('🦄') //=> true` + + + +## Highlights + +- Written in TypeScript +- [Extensive use of type guards](#type-guards) +- [Supports type assertions](#type-assertions) +- [Aware of generic type parameters](#generic-type-parameters) (use with caution) +- Actively maintained +- ![Millions of downloads per week](https://img.shields.io/npm/dw/@sindresorhus/is) + +## Install + +```sh +npm install @sindresorhus/is +``` + +## Usage + +```js +const is = require('@sindresorhus/is'); + +is('🦄'); +//=> 'string' + +is(new Map()); +//=> 'Map' + +is.number(6); +//=> true +``` + +[Assertions](#type-assertions) perform the same type checks, but throw an error if the type does not match. + +```js +const {assert} = require('@sindresorhus/is'); + +assert.string(2); +//=> Error: Expected value which is `string`, received value of type `number`. +``` + +And with TypeScript: + +```ts +import {assert} from '@sindresorhus/is'; + +assert.string(foo); +// `foo` is now typed as a `string`. +``` + +## API + +### is(value) + +Returns the type of `value`. + +Primitives are lowercase and object types are camelcase. + +Example: + +- `'undefined'` +- `'null'` +- `'string'` +- `'symbol'` +- `'Array'` +- `'Function'` +- `'Object'` + +Note: It will throw an error if you try to feed it object-wrapped primitives, as that's a bad practice. For example `new String('foo')`. + +### is.{method} + +All the below methods accept a value and returns a boolean for whether the value is of the desired type. + +#### Primitives + +##### .undefined(value) +##### .null(value) + +**Note:** TypeScript users must use `.null_()` because of a TypeScript naming limitation. + +##### .string(value) +##### .number(value) + +Note: `is.number(NaN)` returns `false`. This intentionally deviates from `typeof` behavior to increase user-friendliness of `is` type checks. + +##### .boolean(value) +##### .symbol(value) +##### .bigint(value) + +#### Built-in types + +##### .array(value, assertion?) + +Returns true if `value` is an array and all of its items match the assertion (if provided). + +```js +is.array(value); // Validate `value` is an array. +is.array(value, is.number); // Validate `value` is an array and all of its items are numbers. +``` + +##### .function(value) + +**Note:** TypeScript users must use `.function_()` because of a TypeScript naming limitation. + +##### .buffer(value) +##### .blob(value) +##### .object(value) + +Keep in mind that [functions are objects too](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions). + +##### .numericString(value) + +Returns `true` for a string that represents a number satisfying `is.number`, for example, `'42'` and `'-8.3'`. + +Note: `'NaN'` returns `false`, but `'Infinity'` and `'-Infinity'` return `true`. + +##### .regExp(value) +##### .date(value) +##### .error(value) +##### .nativePromise(value) +##### .promise(value) + +Returns `true` for any object with a `.then()` and `.catch()` method. Prefer this one over `.nativePromise()` as you usually want to allow userland promise implementations too. + +##### .generator(value) + +Returns `true` for any object that implements its own `.next()` and `.throw()` methods and has a function definition for `Symbol.iterator`. + +##### .generatorFunction(value) + +##### .asyncFunction(value) + +Returns `true` for any `async` function that can be called with the `await` operator. + +```js +is.asyncFunction(async () => {}); +//=> true + +is.asyncFunction(() => {}); +//=> false +``` + +##### .asyncGenerator(value) + +```js +is.asyncGenerator( + (async function * () { + yield 4; + })() +); +//=> true + +is.asyncGenerator( + (function * () { + yield 4; + })() +); +//=> false +``` + +##### .asyncGeneratorFunction(value) + +```js +is.asyncGeneratorFunction(async function * () { + yield 4; +}); +//=> true + +is.asyncGeneratorFunction(function * () { + yield 4; +}); +//=> false +``` + +##### .boundFunction(value) + +Returns `true` for any `bound` function. + +```js +is.boundFunction(() => {}); +//=> true + +is.boundFunction(function () {}.bind(null)); +//=> true + +is.boundFunction(function () {}); +//=> false +``` + +##### .map(value) +##### .set(value) +##### .weakMap(value) +##### .weakSet(value) + +#### Typed arrays + +##### .int8Array(value) +##### .uint8Array(value) +##### .uint8ClampedArray(value) +##### .int16Array(value) +##### .uint16Array(value) +##### .int32Array(value) +##### .uint32Array(value) +##### .float32Array(value) +##### .float64Array(value) +##### .bigInt64Array(value) +##### .bigUint64Array(value) + +#### Structured data + +##### .arrayBuffer(value) +##### .sharedArrayBuffer(value) +##### .dataView(value) + +##### .enumCase(value, enum) + +TypeScript-only. Returns `true` if `value` is a member of `enum`. + +```ts +enum Direction { + Ascending = 'ascending', + Descending = 'descending' +} + +is.enumCase('ascending', Direction); +//=> true + +is.enumCase('other', Direction); +//=> false +``` + +#### Emptiness + +##### .emptyString(value) + +Returns `true` if the value is a `string` and the `.length` is 0. + +##### .emptyStringOrWhitespace(value) + +Returns `true` if `is.emptyString(value)` or if it's a `string` that is all whitespace. + +##### .nonEmptyString(value) + +Returns `true` if the value is a `string` and the `.length` is more than 0. + +##### .nonEmptyStringAndNotWhitespace(value) + +Returns `true` if the value is a `string` that is not empty and not whitespace. + +```js +const values = ['property1', '', null, 'property2', ' ', undefined]; + +values.filter(is.nonEmptyStringAndNotWhitespace); +//=> ['property1', 'property2'] +``` + +##### .emptyArray(value) + +Returns `true` if the value is an `Array` and the `.length` is 0. + +##### .nonEmptyArray(value) + +Returns `true` if the value is an `Array` and the `.length` is more than 0. + +##### .emptyObject(value) + +Returns `true` if the value is an `Object` and `Object.keys(value).length` is 0. + +Please note that `Object.keys` returns only own enumerable properties. Hence something like this can happen: + +```js +const object1 = {}; + +Object.defineProperty(object1, 'property1', { + value: 42, + writable: true, + enumerable: false, + configurable: true +}); + +is.emptyObject(object1); +//=> true +``` + +##### .nonEmptyObject(value) + +Returns `true` if the value is an `Object` and `Object.keys(value).length` is more than 0. + +##### .emptySet(value) + +Returns `true` if the value is a `Set` and the `.size` is 0. + +##### .nonEmptySet(Value) + +Returns `true` if the value is a `Set` and the `.size` is more than 0. + +##### .emptyMap(value) + +Returns `true` if the value is a `Map` and the `.size` is 0. + +##### .nonEmptyMap(value) + +Returns `true` if the value is a `Map` and the `.size` is more than 0. + +#### Miscellaneous + +##### .directInstanceOf(value, class) + +Returns `true` if `value` is a direct instance of `class`. + +```js +is.directInstanceOf(new Error(), Error); +//=> true + +class UnicornError extends Error {} + +is.directInstanceOf(new UnicornError(), Error); +//=> false +``` + +##### .urlInstance(value) + +Returns `true` if `value` is an instance of the [`URL` class](https://developer.mozilla.org/en-US/docs/Web/API/URL). + +```js +const url = new URL('https://example.com'); + +is.urlInstance(url); +//=> true +``` + +##### .urlString(value) + +Returns `true` if `value` is a URL string. + +Note: this only does basic checking using the [`URL` class](https://developer.mozilla.org/en-US/docs/Web/API/URL) constructor. + +```js +const url = 'https://example.com'; + +is.urlString(url); +//=> true + +is.urlString(new URL(url)); +//=> false +``` + +##### .truthy(value) + +Returns `true` for all values that evaluate to true in a boolean context: + +```js +is.truthy('🦄'); +//=> true + +is.truthy(undefined); +//=> false +``` + +##### .falsy(value) + +Returns `true` if `value` is one of: `false`, `0`, `''`, `null`, `undefined`, `NaN`. + +##### .nan(value) +##### .nullOrUndefined(value) +##### .primitive(value) + +JavaScript primitives are as follows: `null`, `undefined`, `string`, `number`, `boolean`, `symbol`. + +##### .integer(value) + +##### .safeInteger(value) + +Returns `true` if `value` is a [safe integer](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isSafeInteger). + +##### .plainObject(value) + +An object is plain if it's created by either `{}`, `new Object()`, or `Object.create(null)`. + +##### .iterable(value) +##### .asyncIterable(value) +##### .class(value) + +Returns `true` for instances created by a class. + +**Note:** TypeScript users must use `.class_()` because of a TypeScript naming limitation. + +##### .typedArray(value) + +##### .arrayLike(value) + +A `value` is array-like if it is not a function and has a `value.length` that is a safe integer greater than or equal to 0. + +```js +is.arrayLike(document.forms); +//=> true + +function foo() { + is.arrayLike(arguments); + //=> true +} +foo(); +``` + +##### .inRange(value, range) + +Check if `value` (number) is in the given `range`. The range is an array of two values, lower bound and upper bound, in no specific order. + +```js +is.inRange(3, [0, 5]); +is.inRange(3, [5, 0]); +is.inRange(0, [-2, 2]); +``` + +##### .inRange(value, upperBound) + +Check if `value` (number) is in the range of `0` to `upperBound`. + +```js +is.inRange(3, 10); +``` + +##### .domElement(value) + +Returns `true` if `value` is a DOM Element. + +##### .nodeStream(value) + +Returns `true` if `value` is a Node.js [stream](https://nodejs.org/api/stream.html). + +```js +const fs = require('fs'); + +is.nodeStream(fs.createReadStream('unicorn.png')); +//=> true +``` + +##### .observable(value) + +Returns `true` if `value` is an `Observable`. + +```js +const {Observable} = require('rxjs'); + +is.observable(new Observable()); +//=> true +``` + +##### .infinite(value) + +Check if `value` is `Infinity` or `-Infinity`. + +##### .evenInteger(value) + +Returns `true` if `value` is an even integer. + +##### .oddInteger(value) + +Returns `true` if `value` is an odd integer. + +##### .propertyKey(value) + +Returns `true` if `value` can be used as an object property key (either `string`, `number`, or `symbol`). + +##### .formData(value) + +Returns `true` if `value` is an instance of the [`FormData` class](https://developer.mozilla.org/en-US/docs/Web/API/FormData). + +```js +const data = new FormData(); + +is.formData(data); +//=> true +``` + +##### .urlSearchParams(value) + +Returns `true` if `value` is an instance of the [`URLSearchParams` class](https://developer.mozilla.org/en-US/docs/Web/API/URLSearchParams). + +```js +const searchParams = new URLSearchParams(); + +is.urlSearchParams(searchParams); +//=> true +``` + +##### .any(predicate | predicate[], ...values) + +Using a single `predicate` argument, returns `true` if **any** of the input `values` returns true in the `predicate`: + +```js +is.any(is.string, {}, true, '🦄'); +//=> true + +is.any(is.boolean, 'unicorns', [], new Map()); +//=> false +``` + +Using an array of `predicate[]`, returns `true` if **any** of the input `values` returns true for **any** of the `predicates` provided in an array: + +```js +is.any([is.string, is.number], {}, true, '🦄'); +//=> true + +is.any([is.boolean, is.number], 'unicorns', [], new Map()); +//=> false +``` + +##### .all(predicate, ...values) + +Returns `true` if **all** of the input `values` returns true in the `predicate`: + +```js +is.all(is.object, {}, new Map(), new Set()); +//=> true + +is.all(is.string, '🦄', [], 'unicorns'); +//=> false +``` + +## Type guards + +When using `is` together with TypeScript, [type guards](http://www.typescriptlang.org/docs/handbook/advanced-types.html#type-guards-and-differentiating-types) are being used extensively to infer the correct type inside if-else statements. + +```ts +import is from '@sindresorhus/is'; + +const padLeft = (value: string, padding: string | number) => { + if (is.number(padding)) { + // `padding` is typed as `number` + return Array(padding + 1).join(' ') + value; + } + + if (is.string(padding)) { + // `padding` is typed as `string` + return padding + value; + } + + throw new TypeError(`Expected 'padding' to be of type 'string' or 'number', got '${is(padding)}'.`); +} + +padLeft('🦄', 3); +//=> ' 🦄' + +padLeft('🦄', '🌈'); +//=> '🌈🦄' +``` + +## Type assertions + +The type guards are also available as [type assertions](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html#assertion-functions), which throw an error for unexpected types. It is a convenient one-line version of the often repetitive "if-not-expected-type-throw" pattern. + +```ts +import {assert} from '@sindresorhus/is'; + +const handleMovieRatingApiResponse = (response: unknown) => { + assert.plainObject(response); + // `response` is now typed as a plain `object` with `unknown` properties. + + assert.number(response.rating); + // `response.rating` is now typed as a `number`. + + assert.string(response.title); + // `response.title` is now typed as a `string`. + + return `${response.title} (${response.rating * 10})`; +}; + +handleMovieRatingApiResponse({rating: 0.87, title: 'The Matrix'}); +//=> 'The Matrix (8.7)' + +// This throws an error. +handleMovieRatingApiResponse({rating: '🦄'}); +``` + +## Generic type parameters + +The type guards and type assertions are aware of [generic type parameters](https://www.typescriptlang.org/docs/handbook/generics.html), such as `Promise` and `Map`. The default is `unknown` for most cases, since `is` cannot check them at runtime. If the generic type is known at compile-time, either implicitly (inferred) or explicitly (provided), `is` propagates the type so it can be used later. + +Use generic type parameters with caution. They are only checked by the TypeScript compiler, and not checked by `is` at runtime. This can lead to unexpected behavior, where the generic type is _assumed_ at compile-time, but actually is something completely different at runtime. It is best to use `unknown` (default) and type-check the value of the generic type parameter at runtime with `is` or `assert`. + +```ts +import {assert} from '@sindresorhus/is'; + +async function badNumberAssumption(input: unknown) { + // Bad assumption about the generic type parameter fools the compile-time type system. + assert.promise(input); + // `input` is a `Promise` but only assumed to be `Promise`. + + const resolved = await input; + // `resolved` is typed as `number` but was not actually checked at runtime. + + // Multiplication will return NaN if the input promise did not actually contain a number. + return 2 * resolved; +} + +async function goodNumberAssertion(input: unknown) { + assert.promise(input); + // `input` is typed as `Promise` + + const resolved = await input; + // `resolved` is typed as `unknown` + + assert.number(resolved); + // `resolved` is typed as `number` + + // Uses runtime checks so only numbers will reach the multiplication. + return 2 * resolved; +} + +badNumberAssumption(Promise.resolve('An unexpected string')); +//=> NaN + +// This correctly throws an error because of the unexpected string value. +goodNumberAssertion(Promise.resolve('An unexpected string')); +``` + +## FAQ + +### Why yet another type checking module? + +There are hundreds of type checking modules on npm, unfortunately, I couldn't find any that fit my needs: + +- Includes both type methods and ability to get the type +- Types of primitives returned as lowercase and object types as camelcase +- Covers all built-ins +- Unsurprising behavior +- Well-maintained +- Comprehensive test suite + +For the ones I found, pick 3 of these. + +The most common mistakes I noticed in these modules was using `instanceof` for type checking, forgetting that functions are objects, and omitting `symbol` as a primitive. + +### Why not just use `instanceof` instead of this package? + +`instanceof` does not work correctly for all types and it does not work across [realms](https://stackoverflow.com/a/49832343/64949). Examples of realms are iframes, windows, web workers, and the `vm` module in Node.js. + +## For enterprise + +Available as part of the Tidelift Subscription. + +The maintainers of @sindresorhus/is and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source dependencies you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use. [Learn more.](https://tidelift.com/subscription/pkg/npm-sindresorhus-is?utm_source=npm-sindresorhus-is&utm_medium=referral&utm_campaign=enterprise&utm_term=repo) + +## Related + +- [ow](https://github.com/sindresorhus/ow) - Function argument validation for humans +- [is-stream](https://github.com/sindresorhus/is-stream) - Check if something is a Node.js stream +- [is-observable](https://github.com/sindresorhus/is-observable) - Check if a value is an Observable +- [file-type](https://github.com/sindresorhus/file-type) - Detect the file type of a Buffer/Uint8Array +- [is-ip](https://github.com/sindresorhus/is-ip) - Check if a string is an IP address +- [is-array-sorted](https://github.com/sindresorhus/is-array-sorted) - Check if an Array is sorted +- [is-error-constructor](https://github.com/sindresorhus/is-error-constructor) - Check if a value is an error constructor +- [is-empty-iterable](https://github.com/sindresorhus/is-empty-iterable) - Check if an Iterable is empty +- [is-blob](https://github.com/sindresorhus/is-blob) - Check if a value is a Blob - File-like object of immutable, raw data +- [has-emoji](https://github.com/sindresorhus/has-emoji) - Check whether a string has any emoji + +## Maintainers + +- [Sindre Sorhus](https://github.com/sindresorhus) +- [Giora Guttsait](https://github.com/gioragutt) +- [Brandon Smith](https://github.com/brandon93s) diff --git a/node_modules/@szmarczak/http-timer/LICENSE b/node_modules/@szmarczak/http-timer/LICENSE new file mode 100644 index 0000000..15ad2e8 --- /dev/null +++ b/node_modules/@szmarczak/http-timer/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2018 Szymon Marczak + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/node_modules/@szmarczak/http-timer/README.md b/node_modules/@szmarczak/http-timer/README.md new file mode 100644 index 0000000..f58e10b --- /dev/null +++ b/node_modules/@szmarczak/http-timer/README.md @@ -0,0 +1,93 @@ +# http-timer +> Timings for HTTP requests + +[![Build Status](https://travis-ci.org/szmarczak/http-timer.svg?branch=master)](https://travis-ci.org/szmarczak/http-timer) +[![Coverage Status](https://coveralls.io/repos/github/szmarczak/http-timer/badge.svg?branch=master)](https://coveralls.io/github/szmarczak/http-timer?branch=master) +[![install size](https://packagephobia.now.sh/badge?p=@szmarczak/http-timer)](https://packagephobia.now.sh/result?p=@szmarczak/http-timer) + +Inspired by the [`request` package](https://github.com/request/request). + +## Installation + +NPM: + +> `npm install @szmarczak/http-timer` + +Yarn: + +> `yarn add @szmarczak/http-timer` + +## Usage +**Note:** +> - The measured events resemble Node.js events, not the kernel ones. +> - Sending a chunk greater than [`highWaterMark`](https://nodejs.org/api/stream.html#stream_new_stream_writable_options) will result in invalid `upload` and `response` timings. You can avoid this by splitting the payload into smaller chunks. + +```js +const https = require('https'); +const timer = require('@szmarczak/http-timer'); + +const request = https.get('https://httpbin.org/anything'); +timer(request); + +request.once('response', response => { + response.resume(); + response.once('end', () => { + console.log(response.timings); // You can use `request.timings` as well + }); +}); + +// { +// start: 1572712180361, +// socket: 1572712180362, +// lookup: 1572712180415, +// connect: 1572712180571, +// upload: 1572712180884, +// response: 1572712181037, +// end: 1572712181039, +// error: undefined, +// abort: undefined, +// phases: { +// wait: 1, +// dns: 53, +// tcp: 156, +// request: 313, +// firstByte: 153, +// download: 2, +// total: 678 +// } +// } +``` + +## API + +### timer(request) + +Returns: `Object` + +**Note**: The time is a `number` representing the milliseconds elapsed since the UNIX epoch. + +- `start` - Time when the request started. +- `socket` - Time when a socket was assigned to the request. +- `lookup` - Time when the DNS lookup finished. +- `connect` - Time when the socket successfully connected. +- `secureConnect` - Time when the socket securely connected. +- `upload` - Time when the request finished uploading. +- `response` - Time when the request fired `response` event. +- `end` - Time when the response fired `end` event. +- `error` - Time when the request fired `error` event. +- `abort` - Time when the request fired `abort` event. +- `phases` + - `wait` - `timings.socket - timings.start` + - `dns` - `timings.lookup - timings.socket` + - `tcp` - `timings.connect - timings.lookup` + - `tls` - `timings.secureConnect - timings.connect` + - `request` - `timings.upload - (timings.secureConnect || timings.connect)` + - `firstByte` - `timings.response - timings.upload` + - `download` - `timings.end - timings.response` + - `total` - `(timings.end || timings.error || timings.abort) - timings.start` + +If something has not been measured yet, it will be `undefined`. + +## License + +MIT diff --git a/node_modules/@szmarczak/http-timer/dist/source/index.d.ts b/node_modules/@szmarczak/http-timer/dist/source/index.d.ts new file mode 100644 index 0000000..2620b4a --- /dev/null +++ b/node_modules/@szmarczak/http-timer/dist/source/index.d.ts @@ -0,0 +1,32 @@ +/// +import { ClientRequest, IncomingMessage } from 'http'; +export interface Timings { + start: number; + socket?: number; + lookup?: number; + connect?: number; + secureConnect?: number; + upload?: number; + response?: number; + end?: number; + error?: number; + abort?: number; + phases: { + wait?: number; + dns?: number; + tcp?: number; + tls?: number; + request?: number; + firstByte?: number; + download?: number; + total?: number; + }; +} +export interface ClientRequestWithTimings extends ClientRequest { + timings?: Timings; +} +export interface IncomingMessageWithTimings extends IncomingMessage { + timings?: Timings; +} +declare const timer: (request: ClientRequestWithTimings) => Timings; +export default timer; diff --git a/node_modules/@szmarczak/http-timer/dist/source/index.js b/node_modules/@szmarczak/http-timer/dist/source/index.js new file mode 100644 index 0000000..6f07245 --- /dev/null +++ b/node_modules/@szmarczak/http-timer/dist/source/index.js @@ -0,0 +1,126 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const defer_to_connect_1 = require("defer-to-connect"); +const util_1 = require("util"); +const nodejsMajorVersion = Number(process.versions.node.split('.')[0]); +const timer = (request) => { + if (request.timings) { + return request.timings; + } + const timings = { + start: Date.now(), + socket: undefined, + lookup: undefined, + connect: undefined, + secureConnect: undefined, + upload: undefined, + response: undefined, + end: undefined, + error: undefined, + abort: undefined, + phases: { + wait: undefined, + dns: undefined, + tcp: undefined, + tls: undefined, + request: undefined, + firstByte: undefined, + download: undefined, + total: undefined + } + }; + request.timings = timings; + const handleError = (origin) => { + const emit = origin.emit.bind(origin); + origin.emit = (event, ...args) => { + // Catches the `error` event + if (event === 'error') { + timings.error = Date.now(); + timings.phases.total = timings.error - timings.start; + origin.emit = emit; + } + // Saves the original behavior + return emit(event, ...args); + }; + }; + handleError(request); + const onAbort = () => { + timings.abort = Date.now(); + // Let the `end` response event be responsible for setting the total phase, + // unless the Node.js major version is >= 13. + if (!timings.response || nodejsMajorVersion >= 13) { + timings.phases.total = Date.now() - timings.start; + } + }; + request.prependOnceListener('abort', onAbort); + const onSocket = (socket) => { + timings.socket = Date.now(); + timings.phases.wait = timings.socket - timings.start; + if (util_1.types.isProxy(socket)) { + return; + } + const lookupListener = () => { + timings.lookup = Date.now(); + timings.phases.dns = timings.lookup - timings.socket; + }; + socket.prependOnceListener('lookup', lookupListener); + defer_to_connect_1.default(socket, { + connect: () => { + timings.connect = Date.now(); + if (timings.lookup === undefined) { + socket.removeListener('lookup', lookupListener); + timings.lookup = timings.connect; + timings.phases.dns = timings.lookup - timings.socket; + } + timings.phases.tcp = timings.connect - timings.lookup; + // This callback is called before flushing any data, + // so we don't need to set `timings.phases.request` here. + }, + secureConnect: () => { + timings.secureConnect = Date.now(); + timings.phases.tls = timings.secureConnect - timings.connect; + } + }); + }; + if (request.socket) { + onSocket(request.socket); + } + else { + request.prependOnceListener('socket', onSocket); + } + const onUpload = () => { + var _a; + timings.upload = Date.now(); + timings.phases.request = timings.upload - ((_a = timings.secureConnect) !== null && _a !== void 0 ? _a : timings.connect); + }; + const writableFinished = () => { + if (typeof request.writableFinished === 'boolean') { + return request.writableFinished; + } + // Node.js doesn't have `request.writableFinished` property + return request.finished && request.outputSize === 0 && (!request.socket || request.socket.writableLength === 0); + }; + if (writableFinished()) { + onUpload(); + } + else { + request.prependOnceListener('finish', onUpload); + } + request.prependOnceListener('response', (response) => { + timings.response = Date.now(); + timings.phases.firstByte = timings.response - timings.upload; + response.timings = timings; + handleError(response); + response.prependOnceListener('end', () => { + timings.end = Date.now(); + timings.phases.download = timings.end - timings.response; + timings.phases.total = timings.end - timings.start; + }); + response.prependOnceListener('aborted', onAbort); + }); + return timings; +}; +exports.default = timer; +// For CommonJS default export support +module.exports = timer; +module.exports.default = timer; diff --git a/node_modules/@szmarczak/http-timer/package.json b/node_modules/@szmarczak/http-timer/package.json new file mode 100644 index 0000000..43a3559 --- /dev/null +++ b/node_modules/@szmarczak/http-timer/package.json @@ -0,0 +1,72 @@ +{ + "name": "@szmarczak/http-timer", + "version": "4.0.6", + "description": "Timings for HTTP requests", + "main": "dist/source", + "engines": { + "node": ">=10" + }, + "scripts": { + "test": "xo && tsc --noEmit && nyc ava", + "build": "del-cli dist && tsc", + "prepare": "npm run build", + "coveralls": "nyc report --reporter=text-lcov | coveralls" + }, + "files": [ + "dist/source" + ], + "keywords": [ + "http", + "https", + "timer", + "timings" + ], + "repository": { + "type": "git", + "url": "git+https://github.com/szmarczak/http-timer.git" + }, + "author": "Szymon Marczak", + "license": "MIT", + "bugs": { + "url": "https://github.com/szmarczak/http-timer/issues" + }, + "homepage": "https://github.com/szmarczak/http-timer#readme", + "dependencies": { + "defer-to-connect": "^2.0.0" + }, + "devDependencies": { + "@ava/typescript": "^2.0.0", + "@sindresorhus/tsconfig": "^1.0.2", + "@types/node": "^16.3.1", + "ava": "^3.15.0", + "coveralls": "^3.1.1", + "del-cli": "^3.0.1", + "http2-wrapper": "^2.0.7", + "nyc": "^15.1.0", + "p-event": "^4.2.0", + "typescript": "^4.3.5", + "xo": "^0.39.1" + }, + "types": "dist/source", + "nyc": { + "extension": [ + ".ts" + ], + "exclude": [ + "**/tests/**" + ] + }, + "xo": { + "rules": { + "@typescript-eslint/no-non-null-assertion": "off" + } + }, + "ava": { + "typescript": { + "compile": false, + "rewritePaths": { + "tests/": "dist/tests/" + } + } + } +} diff --git a/node_modules/@types/cacheable-request/LICENSE b/node_modules/@types/cacheable-request/LICENSE new file mode 100644 index 0000000..9e841e7 --- /dev/null +++ b/node_modules/@types/cacheable-request/LICENSE @@ -0,0 +1,21 @@ + MIT License + + Copyright (c) Microsoft Corporation. + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in all + copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE diff --git a/node_modules/@types/cacheable-request/README.md b/node_modules/@types/cacheable-request/README.md new file mode 100644 index 0000000..e87128e --- /dev/null +++ b/node_modules/@types/cacheable-request/README.md @@ -0,0 +1,16 @@ +# Installation +> `npm install --save @types/cacheable-request` + +# Summary +This package contains type definitions for cacheable-request (https://github.com/lukechilds/cacheable-request#readme). + +# Details +Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/cacheable-request. + +### Additional Details + * Last updated: Wed, 09 Nov 2022 16:32:53 GMT + * Dependencies: [@types/http-cache-semantics](https://npmjs.com/package/@types/http-cache-semantics), [@types/keyv](https://npmjs.com/package/@types/keyv), [@types/node](https://npmjs.com/package/@types/node), [@types/responselike](https://npmjs.com/package/@types/responselike) + * Global values: none + +# Credits +These definitions were written by [BendingBender](https://github.com/BendingBender), and [Paul Melnikow](https://github.com/paulmelnikow). diff --git a/node_modules/@types/cacheable-request/index.d.ts b/node_modules/@types/cacheable-request/index.d.ts new file mode 100644 index 0000000..832f9b9 --- /dev/null +++ b/node_modules/@types/cacheable-request/index.d.ts @@ -0,0 +1,137 @@ +// Type definitions for cacheable-request 6.0 +// Project: https://github.com/lukechilds/cacheable-request#readme +// Definitions by: BendingBender +// Paul Melnikow +// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped +// TypeScript Version: 2.3 + +/// + +import { request, RequestOptions, ClientRequest, ServerResponse } from 'http'; +import { URL } from 'url'; +import { EventEmitter } from 'events'; +import { Store } from 'keyv'; +import { Options as CacheSemanticsOptions } from 'http-cache-semantics'; +import ResponseLike = require('responselike'); + +export = CacheableRequest; + +declare const CacheableRequest: CacheableRequest; + +type RequestFn = typeof request; + +interface CacheableRequest { + new (requestFn: RequestFn, storageAdapter?: string | CacheableRequest.StorageAdapter): ( + opts: string | URL | (RequestOptions & CacheSemanticsOptions), + cb?: (response: ServerResponse | ResponseLike) => void + ) => CacheableRequest.Emitter; + + RequestError: typeof RequestErrorCls; + CacheError: typeof CacheErrorCls; +} + +declare namespace CacheableRequest { + type StorageAdapter = Store; + + interface Options { + /** + * If the cache should be used. Setting this to `false` will completely bypass the cache for the current request. + * @default true + */ + cache?: boolean | undefined; + + /** + * If set to `true` once a cached resource has expired it is deleted and will have to be re-requested. + * + * If set to `false`, after a cached resource's TTL expires it is kept in the cache and will be revalidated + * on the next request with `If-None-Match`/`If-Modified-Since` headers. + * @default false + */ + strictTtl?: boolean | undefined; + + /** + * Limits TTL. The `number` represents milliseconds. + * @default undefined + */ + maxTtl?: number | undefined; + + /** + * When set to `true`, if the DB connection fails we will automatically fallback to a network request. + * DB errors will still be emitted to notify you of the problem even though the request callback may succeed. + * @default false + */ + automaticFailover?: boolean | undefined; + + /** + * Forces refreshing the cache. If the response could be retrieved from the cache, it will perform a + * new request and override the cache instead. + * @default false + */ + forceRefresh?: boolean | undefined; + } + + interface Emitter extends EventEmitter { + addListener(event: 'request', listener: (request: ClientRequest) => void): this; + addListener( + event: 'response', + listener: (response: ServerResponse | ResponseLike) => void + ): this; + addListener(event: 'error', listener: (error: RequestError | CacheError) => void): this; + on(event: 'request', listener: (request: ClientRequest) => void): this; + on(event: 'response', listener: (response: ServerResponse | ResponseLike) => void): this; + on(event: 'error', listener: (error: RequestError | CacheError) => void): this; + once(event: 'request', listener: (request: ClientRequest) => void): this; + once(event: 'response', listener: (response: ServerResponse | ResponseLike) => void): this; + once(event: 'error', listener: (error: RequestError | CacheError) => void): this; + prependListener(event: 'request', listener: (request: ClientRequest) => void): this; + prependListener( + event: 'response', + listener: (response: ServerResponse | ResponseLike) => void + ): this; + prependListener(event: 'error', listener: (error: RequestError | CacheError) => void): this; + prependOnceListener(event: 'request', listener: (request: ClientRequest) => void): this; + prependOnceListener( + event: 'response', + listener: (response: ServerResponse | ResponseLike) => void + ): this; + prependOnceListener( + event: 'error', + listener: (error: RequestError | CacheError) => void + ): this; + removeListener(event: 'request', listener: (request: ClientRequest) => void): this; + removeListener( + event: 'response', + listener: (response: ServerResponse | ResponseLike) => void + ): this; + removeListener(event: 'error', listener: (error: RequestError | CacheError) => void): this; + off(event: 'request', listener: (request: ClientRequest) => void): this; + off(event: 'response', listener: (response: ServerResponse | ResponseLike) => void): this; + off(event: 'error', listener: (error: RequestError | CacheError) => void): this; + removeAllListeners(event?: 'request' | 'response' | 'error'): this; + listeners(event: 'request'): Array<(request: ClientRequest) => void>; + listeners(event: 'response'): Array<(response: ServerResponse | ResponseLike) => void>; + listeners(event: 'error'): Array<(error: RequestError | CacheError) => void>; + rawListeners(event: 'request'): Array<(request: ClientRequest) => void>; + rawListeners(event: 'response'): Array<(response: ServerResponse | ResponseLike) => void>; + rawListeners(event: 'error'): Array<(error: RequestError | CacheError) => void>; + emit(event: 'request', request: ClientRequest): boolean; + emit(event: 'response', response: ServerResponse | ResponseLike): boolean; + emit(event: 'error', error: RequestError | CacheError): boolean; + eventNames(): Array<'request' | 'response' | 'error'>; + listenerCount(type: 'request' | 'response' | 'error'): number; + } + + type RequestError = RequestErrorCls; + type CacheError = CacheErrorCls; +} + +declare class RequestErrorCls extends Error { + readonly name: 'RequestError'; + + constructor(error: Error); +} +declare class CacheErrorCls extends Error { + readonly name: 'CacheError'; + + constructor(error: Error); +} diff --git a/node_modules/@types/cacheable-request/package.json b/node_modules/@types/cacheable-request/package.json new file mode 100644 index 0000000..31742dd --- /dev/null +++ b/node_modules/@types/cacheable-request/package.json @@ -0,0 +1,35 @@ +{ + "name": "@types/cacheable-request", + "version": "6.0.3", + "description": "TypeScript definitions for cacheable-request", + "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/cacheable-request", + "license": "MIT", + "contributors": [ + { + "name": "BendingBender", + "url": "https://github.com/BendingBender", + "githubUsername": "BendingBender" + }, + { + "name": "Paul Melnikow", + "url": "https://github.com/paulmelnikow", + "githubUsername": "paulmelnikow" + } + ], + "main": "", + "types": "index.d.ts", + "repository": { + "type": "git", + "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git", + "directory": "types/cacheable-request" + }, + "scripts": {}, + "dependencies": { + "@types/http-cache-semantics": "*", + "@types/keyv": "^3.1.4", + "@types/node": "*", + "@types/responselike": "^1.0.0" + }, + "typesPublisherContentHash": "9345f1216c9d26f9046880c34f6329b2874405d68cf13d1f1f771fbb4d96549f", + "typeScriptVersion": "4.1" +} \ No newline at end of file diff --git a/node_modules/@types/debug/LICENSE b/node_modules/@types/debug/LICENSE new file mode 100644 index 0000000..9e841e7 --- /dev/null +++ b/node_modules/@types/debug/LICENSE @@ -0,0 +1,21 @@ + MIT License + + Copyright (c) Microsoft Corporation. + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in all + copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE diff --git a/node_modules/@types/debug/README.md b/node_modules/@types/debug/README.md new file mode 100644 index 0000000..c62700a --- /dev/null +++ b/node_modules/@types/debug/README.md @@ -0,0 +1,69 @@ +# Installation +> `npm install --save @types/debug` + +# Summary +This package contains type definitions for debug (https://github.com/debug-js/debug). + +# Details +Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/debug. +## [index.d.ts](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/debug/index.d.ts) +````ts +declare var debug: debug.Debug & { debug: debug.Debug; default: debug.Debug }; + +export = debug; +export as namespace debug; + +declare namespace debug { + interface Debug { + (namespace: string): Debugger; + coerce: (val: any) => any; + disable: () => string; + enable: (namespaces: string) => void; + enabled: (namespaces: string) => boolean; + formatArgs: (this: Debugger, args: any[]) => void; + log: (...args: any[]) => any; + selectColor: (namespace: string) => string | number; + humanize: typeof import("ms"); + + names: string[]; + skips: string[]; + + formatters: Formatters; + + inspectOpts?: { + hideDate?: boolean | number | null; + colors?: boolean | number | null; + depth?: boolean | number | null; + showHidden?: boolean | number | null; + }; + } + + type IDebug = Debug; + + interface Formatters { + [formatter: string]: (v: any) => string; + } + + type IDebugger = Debugger; + + interface Debugger { + (formatter: any, ...args: any[]): void; + + color: string; + diff: number; + enabled: boolean; + log: (...args: any[]) => any; + namespace: string; + destroy: () => boolean; + extend: (namespace: string, delimiter?: string) => Debugger; + } +} + +```` + +### Additional Details + * Last updated: Thu, 19 Mar 2026 06:47:22 GMT + * Dependencies: [@types/ms](https://npmjs.com/package/@types/ms) + +# Credits +These definitions were written by [Seon-Wook Park](https://github.com/swook), [Gal Talmor](https://github.com/galtalmor), [John McLaughlin](https://github.com/zamb3zi), [Brasten Sager](https://github.com/brasten), [Nicolas Penin](https://github.com/npenin), [Kristian Brünn](https://github.com/kristianmitk), and [Caleb Gregory](https://github.com/calebgregory). diff --git a/node_modules/@types/debug/index.d.ts b/node_modules/@types/debug/index.d.ts new file mode 100644 index 0000000..38bef7b --- /dev/null +++ b/node_modules/@types/debug/index.d.ts @@ -0,0 +1,50 @@ +declare var debug: debug.Debug & { debug: debug.Debug; default: debug.Debug }; + +export = debug; +export as namespace debug; + +declare namespace debug { + interface Debug { + (namespace: string): Debugger; + coerce: (val: any) => any; + disable: () => string; + enable: (namespaces: string) => void; + enabled: (namespaces: string) => boolean; + formatArgs: (this: Debugger, args: any[]) => void; + log: (...args: any[]) => any; + selectColor: (namespace: string) => string | number; + humanize: typeof import("ms"); + + names: string[]; + skips: string[]; + + formatters: Formatters; + + inspectOpts?: { + hideDate?: boolean | number | null; + colors?: boolean | number | null; + depth?: boolean | number | null; + showHidden?: boolean | number | null; + }; + } + + type IDebug = Debug; + + interface Formatters { + [formatter: string]: (v: any) => string; + } + + type IDebugger = Debugger; + + interface Debugger { + (formatter: any, ...args: any[]): void; + + color: string; + diff: number; + enabled: boolean; + log: (...args: any[]) => any; + namespace: string; + destroy: () => boolean; + extend: (namespace: string, delimiter?: string) => Debugger; + } +} diff --git a/node_modules/@types/debug/package.json b/node_modules/@types/debug/package.json new file mode 100644 index 0000000..0dacd20 --- /dev/null +++ b/node_modules/@types/debug/package.json @@ -0,0 +1,58 @@ +{ + "name": "@types/debug", + "version": "4.1.13", + "description": "TypeScript definitions for debug", + "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/debug", + "license": "MIT", + "contributors": [ + { + "name": "Seon-Wook Park", + "githubUsername": "swook", + "url": "https://github.com/swook" + }, + { + "name": "Gal Talmor", + "githubUsername": "galtalmor", + "url": "https://github.com/galtalmor" + }, + { + "name": "John McLaughlin", + "githubUsername": "zamb3zi", + "url": "https://github.com/zamb3zi" + }, + { + "name": "Brasten Sager", + "githubUsername": "brasten", + "url": "https://github.com/brasten" + }, + { + "name": "Nicolas Penin", + "githubUsername": "npenin", + "url": "https://github.com/npenin" + }, + { + "name": "Kristian Brünn", + "githubUsername": "kristianmitk", + "url": "https://github.com/kristianmitk" + }, + { + "name": "Caleb Gregory", + "githubUsername": "calebgregory", + "url": "https://github.com/calebgregory" + } + ], + "main": "", + "types": "index.d.ts", + "repository": { + "type": "git", + "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git", + "directory": "types/debug" + }, + "scripts": {}, + "dependencies": { + "@types/ms": "*" + }, + "peerDependencies": {}, + "typesPublisherContentHash": "1c506e100366b85350ff1c28c9cf4cc09e9a07275546bb050993c241c9821cd9", + "typeScriptVersion": "5.2" +} \ No newline at end of file diff --git a/node_modules/@types/fs-extra/LICENSE b/node_modules/@types/fs-extra/LICENSE new file mode 100644 index 0000000..9e841e7 --- /dev/null +++ b/node_modules/@types/fs-extra/LICENSE @@ -0,0 +1,21 @@ + MIT License + + Copyright (c) Microsoft Corporation. + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in all + copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE diff --git a/node_modules/@types/fs-extra/README.md b/node_modules/@types/fs-extra/README.md new file mode 100644 index 0000000..78f2792 --- /dev/null +++ b/node_modules/@types/fs-extra/README.md @@ -0,0 +1,16 @@ +# Installation +> `npm install --save @types/fs-extra` + +# Summary +This package contains type definitions for fs-extra (https://github.com/jprichardson/node-fs-extra). + +# Details +Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/fs-extra. + +### Additional Details + * Last updated: Tue, 21 Sep 2021 19:02:14 GMT + * Dependencies: [@types/node](https://npmjs.com/package/@types/node) + * Global values: none + +# Credits +These definitions were written by [Alan Agius](https://github.com/alan-agius4), [midknight41](https://github.com/midknight41), [Brendan Forster](https://github.com/shiftkey), [Mees van Dijk](https://github.com/mees-), [Justin Rockwood](https://github.com/jrockwood), [Sang Dang](https://github.com/sangdth), [Florian Keller](https://github.com/ffflorian), [Piotr Błażejewicz](https://github.com/peterblazejewicz), and [Tiger Oakes](https://github.com/NotWoods). diff --git a/node_modules/@types/fs-extra/index.d.ts b/node_modules/@types/fs-extra/index.d.ts new file mode 100644 index 0000000..4daa564 --- /dev/null +++ b/node_modules/@types/fs-extra/index.d.ts @@ -0,0 +1,563 @@ +// Type definitions for fs-extra 9.0 +// Project: https://github.com/jprichardson/node-fs-extra +// Definitions by: Alan Agius , +// midknight41 , +// Brendan Forster , +// Mees van Dijk , +// Justin Rockwood , +// Sang Dang , +// Florian Keller +// Piotr Błażejewicz +// Tiger Oakes +// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped +// Minimum TypeScript Version: 3.9 + +/// + +import * as fs from 'fs'; +import Stats = fs.Stats; +import PathLike = fs.PathLike; + +export * from 'fs'; + +export function copy(src: string, dest: string, options?: CopyOptions): Promise; +export function copy(src: string, dest: string, callback: (err: Error) => void): void; +export function copy(src: string, dest: string, options: CopyOptions, callback: (err: Error) => void): void; +export function copySync(src: string, dest: string, options?: CopyOptionsSync): void; + +export function copyFile(src: string, dest: string, flags?: number): Promise; +export function copyFile(src: string, dest: string, callback: (err: Error) => void): void; +export function copyFile(src: string, dest: string, flags: number, callback: (err: Error) => void): void; + +export function move(src: string, dest: string, options?: MoveOptions): Promise; +export function move(src: string, dest: string, callback: (err: Error) => void): void; +export function move(src: string, dest: string, options: MoveOptions, callback: (err: Error) => void): void; +export function moveSync(src: string, dest: string, options?: MoveOptions): void; + +export function createFile(file: string): Promise; +export function createFile(file: string, callback: (err: Error) => void): void; +export function createFileSync(file: string): void; + +export function createSymlink(src: string, dest: string, type: SymlinkType): Promise; +export function createSymlink(src: string, dest: string, type: SymlinkType, callback?: (err: Error) => void): void; +export function createSymlinkSync(src: string, dest: string, type: SymlinkType): void; + +export function ensureDir(path: string, options?: EnsureOptions | number): Promise; +export function ensureDir(path: string, callback?: (err: Error) => void): void; +export function ensureDir(path: string, options?: EnsureOptions | number, callback?: (err: Error) => void): void; +export function ensureDirSync(path: string, options?: EnsureOptions | number): void; + +export function mkdirs(dir: string): Promise; +export function mkdirs(dir: string, callback: (err: Error) => void): void; +export function mkdirp(dir: string): Promise; +export function mkdirp(dir: string, callback: (err: Error) => void): void; +export function mkdirsSync(dir: string): void; +export function mkdirpSync(dir: string): void; + +export function outputFile( + file: string, + data: any, + options?: WriteFileOptions | BufferEncoding | string, +): Promise; +export function outputFile(file: string, data: any, callback: (err: Error) => void): void; +export function outputFile( + file: string, + data: any, + options: WriteFileOptions | string, + callback: (err: Error) => void, +): void; +export function outputFileSync(file: string, data: any, options?: WriteFileOptions | BufferEncoding | string): void; + +export function readJson(file: string, options?: ReadOptions | BufferEncoding | string): Promise; +export function readJson(file: string, callback: (err: Error, jsonObject: any) => void): void; +export function readJson( + file: string, + options: ReadOptions | BufferEncoding | string, + callback: (err: Error, jsonObject: any) => void, +): void; +export function readJSON(file: string, options?: ReadOptions | BufferEncoding | string): Promise; +export function readJSON(file: string, callback: (err: Error, jsonObject: any) => void): void; +export function readJSON( + file: string, + options: ReadOptions | BufferEncoding | string, + callback: (err: Error, jsonObject: any) => void, +): void; + +export function readJsonSync(file: string, options?: ReadOptions | BufferEncoding | string): any; +export function readJSONSync(file: string, options?: ReadOptions | BufferEncoding | string): any; + +export function remove(dir: string, callback: (err: Error) => void): void; +export function remove(dir: string, callback?: (err: Error) => void): Promise; +export function removeSync(dir: string): void; + +export function outputJSON(file: string, data: any, options?: WriteOptions | BufferEncoding | string): Promise; +export function outputJSON( + file: string, + data: any, + options: WriteOptions | BufferEncoding | string, + callback: (err: Error) => void, +): void; +export function outputJSON(file: string, data: any, callback: (err: Error) => void): void; +export function outputJson(file: string, data: any, options?: WriteOptions | BufferEncoding | string): Promise; +export function outputJson( + file: string, + data: any, + options: WriteOptions | BufferEncoding | string, + callback: (err: Error) => void, +): void; +export function outputJson(file: string, data: any, callback: (err: Error) => void): void; +export function outputJsonSync(file: string, data: any, options?: WriteOptions | BufferEncoding | string): void; +export function outputJSONSync(file: string, data: any, options?: WriteOptions | BufferEncoding | string): void; + +export function writeJSON(file: string, object: any, options?: WriteOptions | BufferEncoding | string): Promise; +export function writeJSON(file: string, object: any, callback: (err: Error) => void): void; +export function writeJSON( + file: string, + object: any, + options: WriteOptions | BufferEncoding | string, + callback: (err: Error) => void, +): void; +export function writeJson(file: string, object: any, options?: WriteOptions | BufferEncoding | string): Promise; +export function writeJson(file: string, object: any, callback: (err: Error) => void): void; +export function writeJson( + file: string, + object: any, + options: WriteOptions | BufferEncoding | string, + callback: (err: Error) => void, +): void; + +export function writeJsonSync(file: string, object: any, options?: WriteOptions | BufferEncoding | string): void; +export function writeJSONSync(file: string, object: any, options?: WriteOptions | BufferEncoding | string): void; + +export function ensureFile(path: string): Promise; +export function ensureFile(path: string, callback: (err: Error) => void): void; +export function ensureFileSync(path: string): void; + +export function ensureLink(src: string, dest: string): Promise; +export function ensureLink(src: string, dest: string, callback: (err: Error) => void): void; +// alias for ensureLink +export const createLink: typeof ensureLink; +export function ensureLinkSync(src: string, dest: string): void; +// aliased as +export const createLinkSync: typeof ensureLinkSync; + +export function ensureSymlink(src: string, dest: string, type?: SymlinkType): Promise; +export function ensureSymlink(src: string, dest: string, type: SymlinkType, callback: (err: Error) => void): void; +export function ensureSymlink(src: string, dest: string, callback: (err: Error) => void): void; +export function ensureSymlinkSync(src: string, dest: string, type?: SymlinkType): void; + +export function emptyDir(path: string): Promise; +export function emptyDir(path: string, callback: (err: Error) => void): void; +export const emptydir: typeof emptyDir; + +export function emptyDirSync(path: string): void; +export const emptydirSync: typeof emptyDirSync; + +export function pathExists(path: string): Promise; +export function pathExists(path: string, callback: (err: Error, exists: boolean) => void): void; +export function pathExistsSync(path: string): boolean; + +// fs async methods +// copied from https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/node/v6/index.d.ts + +export function access(path: PathLike, callback: (err: NodeJS.ErrnoException) => void): void; +export function access(path: PathLike, mode: number, callback: (err: NodeJS.ErrnoException) => void): void; +export function access(path: PathLike, mode?: number): Promise; + +export function appendFile( + file: PathLike | number, + data: any, + options: { + encoding?: BufferEncoding | string | undefined; + mode?: number | string | undefined; + flag?: string | undefined; + }, + callback: (err: NodeJS.ErrnoException) => void, +): void; +export function appendFile(file: PathLike | number, data: any, callback: (err: NodeJS.ErrnoException) => void): void; +export function appendFile( + file: PathLike | number, + data: any, + options?: + | { + encoding?: BufferEncoding | string | undefined; + mode?: number | string | undefined; + flag?: string | undefined; + } + | BufferEncoding + | string, +): Promise; + +export function chmod(path: PathLike, mode: Mode, callback: (err: NodeJS.ErrnoException) => void): void; +export function chmod(path: PathLike, mode: Mode): Promise; + +export function chown(path: PathLike, uid: number, gid: number): Promise; +export function chown(path: PathLike, uid: number, gid: number, callback: (err: NodeJS.ErrnoException) => void): void; + +export function close(fd: number, callback: (err: NodeJS.ErrnoException) => void): void; +export function close(fd: number): Promise; + +export function fchmod(fd: number, mode: Mode, callback: (err: NodeJS.ErrnoException) => void): void; +export function fchmod(fd: number, mode: Mode): Promise; + +export function fchown(fd: number, uid: number, gid: number, callback: (err: NodeJS.ErrnoException) => void): void; +export function fchown(fd: number, uid: number, gid: number): Promise; + +export function fdatasync(fd: number, callback: () => void): void; +export function fdatasync(fd: number): Promise; + +export function fstat(fd: number, callback: (err: NodeJS.ErrnoException, stats: Stats) => any): void; +export function fstat(fd: number): Promise; + +export function fsync(fd: number, callback: (err: NodeJS.ErrnoException) => void): void; +export function fsync(fd: number): Promise; + +export function ftruncate(fd: number, callback: (err: NodeJS.ErrnoException) => void): void; +export function ftruncate(fd: number, len: number, callback: (err: NodeJS.ErrnoException) => void): void; +export function ftruncate(fd: number, len?: number): Promise; + +export function futimes(fd: number, atime: number, mtime: number, callback: (err: NodeJS.ErrnoException) => void): void; +export function futimes(fd: number, atime: Date, mtime: Date, callback: (err: NodeJS.ErrnoException) => void): void; +export function futimes(fd: number, atime: number, mtime: number): Promise; +export function futimes(fd: number, atime: Date, mtime: Date): Promise; + +export function lchown(path: PathLike, uid: number, gid: number, callback: (err: NodeJS.ErrnoException) => void): void; +export function lchown(path: PathLike, uid: number, gid: number): Promise; + +export function link(existingPath: PathLike, newPath: PathLike, callback: (err: NodeJS.ErrnoException) => void): void; +export function link(existingPath: PathLike, newPath: PathLike): Promise; + +export function lstat(path: PathLike, callback: (err: NodeJS.ErrnoException, stats: Stats) => any): void; +export function lstat(path: PathLike): Promise; + +/** + * Asynchronous mkdir - creates the directory specified in {path}. Parameter {mode} defaults to 0777. + * + * @param callback No arguments other than a possible exception are given to the completion callback. + */ +export function mkdir(path: PathLike, callback: (err: NodeJS.ErrnoException) => void): void; +/** + * Asynchronous mkdir - creates the directory specified in {path}. Parameter {mode} defaults to 0777. + * + * @param callback No arguments other than a possible exception are given to the completion callback. + */ +export function mkdir( + path: PathLike, + options: Mode | fs.MakeDirectoryOptions | null, + callback: (err: NodeJS.ErrnoException) => void, +): void; +export function mkdir(path: PathLike, options?: Mode | fs.MakeDirectoryOptions | null): Promise; +export function mkdirSync(path: PathLike, options?: Mode | fs.MakeDirectoryOptions | null): void; + +export function open( + path: PathLike, + flags: string | number, + callback: (err: NodeJS.ErrnoException, fd: number) => void, +): void; +export function open( + path: PathLike, + flags: string | number, + mode: Mode, + callback: (err: NodeJS.ErrnoException, fd: number) => void, +): void; +export function open(path: PathLike, flags: string | number, mode?: Mode | null): Promise; + +export function opendir(path: string, cb: (err: NodeJS.ErrnoException | null, dir: fs.Dir) => void): void; +export function opendir( + path: string, + options: fs.OpenDirOptions, + cb: (err: NodeJS.ErrnoException | null, dir: fs.Dir) => void, +): void; +export function opendir(path: string, options?: fs.OpenDirOptions): Promise; + +export function read( + fd: number, + buffer: TBuffer, + offset: number, + length: number, + position: number | null, + callback: (err: NodeJS.ErrnoException, bytesRead: number, buffer: TBuffer) => void, +): void; +export function read( + fd: number, + buffer: TBuffer, + offset: number, + length: number, + position: number | null, +): Promise<{ bytesRead: number; buffer: TBuffer }>; + +export function readFile(file: PathLike | number, callback: (err: NodeJS.ErrnoException, data: Buffer) => void): void; +export function readFile( + file: PathLike | number, + encoding: BufferEncoding | string, + callback: (err: NodeJS.ErrnoException, data: string) => void, +): void; +export function readFile( + file: PathLike | number, + options: { flag?: string | undefined } | { encoding: BufferEncoding | string; flag?: string | undefined }, + callback: (err: NodeJS.ErrnoException, data: Buffer) => void, +): void; +export function readFile( + file: PathLike | number, + options: { flag?: string | undefined } | { encoding: BufferEncoding | string; flag?: string | undefined }, +): Promise; +// tslint:disable-next-line:unified-signatures +export function readFile(file: PathLike | number, encoding: BufferEncoding | string): Promise; +export function readFile(file: PathLike | number): Promise; + +export function readdir(path: PathLike, callback: (err: NodeJS.ErrnoException, files: string[]) => void): void; +export function readdir( + path: PathLike, + options: 'buffer' | { encoding: 'buffer'; withFileTypes?: false | undefined }, +): Promise; +export function readdir( + path: PathLike, + options?: + | { encoding: BufferEncoding | string | null; withFileTypes?: false | undefined } + | BufferEncoding + | string + | null, +): Promise; +export function readdir( + path: PathLike, + options?: { encoding?: BufferEncoding | string | null | undefined; withFileTypes?: false | undefined }, +): Promise; +export function readdir( + path: PathLike, + options: { encoding?: BufferEncoding | string | null | undefined; withFileTypes: true }, +): Promise; + +export function readlink(path: PathLike, callback: (err: NodeJS.ErrnoException, linkString: string) => any): void; +export function readlink(path: PathLike): Promise; + +export function realpath(path: PathLike, callback: (err: NodeJS.ErrnoException, resolvedPath: string) => any): void; +export function realpath( + path: PathLike, + cache: { [path: string]: string }, + callback: (err: NodeJS.ErrnoException, resolvedPath: string) => any, +): void; +export function realpath(path: PathLike, cache?: { [path: string]: string }): Promise; + +/* tslint:disable:unified-signatures */ +export namespace realpath { + const native: { + (path: PathLike, options: { encoding: 'buffer' } | 'buffer'): Promise; + ( + path: PathLike, + options: { encoding: BufferEncoding | string | null } | BufferEncoding | string | undefined | null, + ): Promise; + (path: PathLike, options: { encoding: BufferEncoding | string | null } | string | undefined | null): Promise< + string | Buffer + >; + (path: PathLike): Promise; + } & typeof fs.realpath.native; +} +/* tslint:enable:unified-signatures */ + +export function rename(oldPath: PathLike, newPath: PathLike, callback: (err: NodeJS.ErrnoException) => void): void; +export function rename(oldPath: PathLike, newPath: PathLike): Promise; + +/** + * Asynchronously removes files and directories (modeled on the standard POSIX + * `rm` utility). + * + * Only available in node >= v14.14.0 + */ +export function rm( + path: PathLike, + options?: { + force?: boolean | undefined; + maxRetries?: number | undefined; + recursive?: boolean | undefined; + retryDelay?: number | undefined; + }, +): Promise; + +/** + * Asynchronous rmdir - removes the directory specified in {path} + * + * @param callback No arguments other than a possible exception are given to the completion callback. + */ +export function rmdir(path: PathLike, callback: (err: NodeJS.ErrnoException) => void): void; +export function rmdir(path: PathLike, options?: fs.RmDirOptions): Promise; + +export function stat(path: PathLike, callback: (err: NodeJS.ErrnoException, stats: Stats) => any): void; +export function stat(path: PathLike): Promise; + +export function symlink( + target: PathLike, + path: PathLike, + type: SymlinkType | undefined, + callback: (err: NodeJS.ErrnoException) => void, +): void; +export function symlink(target: PathLike, path: PathLike, callback: (err: NodeJS.ErrnoException) => void): void; +export function symlink(target: PathLike, path: PathLike, type?: SymlinkType): Promise; + +export function truncate(path: PathLike, callback: (err: NodeJS.ErrnoException) => void): void; +export function truncate(path: PathLike, len: number, callback: (err: NodeJS.ErrnoException) => void): void; +export function truncate(path: PathLike, len?: number): Promise; + +/** + * Asynchronous unlink - deletes the file specified in {path} + * + * @param callback No arguments other than a possible exception are given to the completion callback. + */ +export function unlink(path: PathLike, callback: (err: NodeJS.ErrnoException) => void): void; +export function unlink(path: PathLike): Promise; + +export function utimes( + path: PathLike, + atime: number, + mtime: number, + callback: (err: NodeJS.ErrnoException) => void, +): void; +export function utimes(path: PathLike, atime: Date, mtime: Date, callback: (err: NodeJS.ErrnoException) => void): void; +export function utimes(path: PathLike, atime: number, mtime: number): Promise; +export function utimes(path: PathLike, atime: Date, mtime: Date): Promise; + +export function write( + fd: number, + buffer: TBuffer, + offset: number, + length: number, + position: number | null, + callback: (err: NodeJS.ErrnoException, written: number, buffer: TBuffer) => void, +): void; +export function write( + fd: number, + buffer: TBuffer, + offset: number, + length: number, + callback: (err: NodeJS.ErrnoException, written: number, buffer: TBuffer) => void, +): void; +export function write( + fd: number, + data: any, + callback: (err: NodeJS.ErrnoException, written: number, str: string) => void, +): void; +export function write( + fd: number, + data: any, + offset: number, + callback: (err: NodeJS.ErrnoException, written: number, str: string) => void, +): void; +export function write( + fd: number, + data: any, + offset: number, + encoding: BufferEncoding | string, + callback: (err: NodeJS.ErrnoException, written: number, str: string) => void, +): void; +export function write( + fd: number, + buffer: TBuffer, + offset?: number, + length?: number, + position?: number | null, +): Promise<{ bytesWritten: number; buffer: TBuffer }>; +export function write( + fd: number, + data: any, + offset?: number, + encoding?: BufferEncoding | string, +): Promise<{ bytesWritten: number; buffer: string }>; + +export function writeFile(file: PathLike | number, data: any, callback: (err: NodeJS.ErrnoException) => void): void; +export function writeFile( + file: PathLike | number, + data: any, + options?: WriteFileOptions | BufferEncoding | string, +): Promise; +export function writeFile( + file: PathLike | number, + data: any, + options: WriteFileOptions | BufferEncoding | string, + callback: (err: NodeJS.ErrnoException) => void, +): void; + +export function writev( + fd: number, + buffers: NodeJS.ArrayBufferView[], + position: number, + cb: (err: NodeJS.ErrnoException | null, bytesWritten: number, buffers: NodeJS.ArrayBufferView[]) => void, +): void; +export function writev( + fd: number, + buffers: NodeJS.ArrayBufferView[], + cb: (err: NodeJS.ErrnoException | null, bytesWritten: number, buffers: NodeJS.ArrayBufferView[]) => void, +): void; +export function writev(fd: number, buffers: NodeJS.ArrayBufferView[], position?: number): Promise; + +/** + * Asynchronous mkdtemp - Creates a unique temporary directory. Generates six random characters to be appended behind a required prefix to create a unique temporary directory. + * + * @param callback The created folder path is passed as a string to the callback's second parameter. + */ +export function mkdtemp(prefix: string): Promise; +export function mkdtemp(prefix: string, callback: (err: NodeJS.ErrnoException, folder: string) => void): void; + +export interface PathEntry { + path: string; + stats: Stats; +} + +export interface PathEntryStream { + read(): PathEntry | null; +} + +export type CopyFilterSync = (src: string, dest: string) => boolean; +export type CopyFilterAsync = (src: string, dest: string) => Promise; + +export type SymlinkType = 'dir' | 'file' | 'junction'; + +export type Mode = string | number; + +export type ArrayBufferView = NodeJS.TypedArray | DataView; + +export interface CopyOptions { + dereference?: boolean | undefined; + overwrite?: boolean | undefined; + preserveTimestamps?: boolean | undefined; + errorOnExist?: boolean | undefined; + filter?: CopyFilterSync | CopyFilterAsync | undefined; + recursive?: boolean | undefined; +} + +export interface CopyOptionsSync extends CopyOptions { + filter?: CopyFilterSync | undefined; +} + +export interface EnsureOptions { + mode?: number | undefined; +} + +export interface MoveOptions { + overwrite?: boolean | undefined; + limit?: number | undefined; +} + +export interface ReadOptions { + throws?: boolean | undefined; + fs?: object | undefined; + reviver?: any; + encoding?: BufferEncoding | string | undefined; + flag?: string | undefined; +} + +export interface WriteFileOptions { + encoding?: BufferEncoding | string | null | undefined; + flag?: string | undefined; + mode?: number | undefined; +} + +export interface WriteOptions extends WriteFileOptions { + fs?: object | undefined; + replacer?: any; + spaces?: number | string | undefined; + EOL?: string | undefined; +} + +export interface WritevResult { + bytesWritten: number; + buffers: ArrayBufferView[]; +} diff --git a/node_modules/@types/fs-extra/package.json b/node_modules/@types/fs-extra/package.json new file mode 100644 index 0000000..0dc1040 --- /dev/null +++ b/node_modules/@types/fs-extra/package.json @@ -0,0 +1,67 @@ +{ + "name": "@types/fs-extra", + "version": "9.0.13", + "description": "TypeScript definitions for fs-extra", + "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/fs-extra", + "license": "MIT", + "contributors": [ + { + "name": "Alan Agius", + "url": "https://github.com/alan-agius4", + "githubUsername": "alan-agius4" + }, + { + "name": "midknight41", + "url": "https://github.com/midknight41", + "githubUsername": "midknight41" + }, + { + "name": "Brendan Forster", + "url": "https://github.com/shiftkey", + "githubUsername": "shiftkey" + }, + { + "name": "Mees van Dijk", + "url": "https://github.com/mees-", + "githubUsername": "mees-" + }, + { + "name": "Justin Rockwood", + "url": "https://github.com/jrockwood", + "githubUsername": "jrockwood" + }, + { + "name": "Sang Dang", + "url": "https://github.com/sangdth", + "githubUsername": "sangdth" + }, + { + "name": "Florian Keller", + "url": "https://github.com/ffflorian", + "githubUsername": "ffflorian" + }, + { + "name": "Piotr Błażejewicz", + "url": "https://github.com/peterblazejewicz", + "githubUsername": "peterblazejewicz" + }, + { + "name": "Tiger Oakes", + "url": "https://github.com/NotWoods", + "githubUsername": "NotWoods" + } + ], + "main": "", + "types": "index.d.ts", + "repository": { + "type": "git", + "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git", + "directory": "types/fs-extra" + }, + "scripts": {}, + "dependencies": { + "@types/node": "*" + }, + "typesPublisherContentHash": "75e10d16a18d936a50e54414024604aa9484e8345b37c2027921869f254523ee", + "typeScriptVersion": "3.9" +} \ No newline at end of file diff --git a/node_modules/@types/http-cache-semantics/LICENSE b/node_modules/@types/http-cache-semantics/LICENSE new file mode 100644 index 0000000..9e841e7 --- /dev/null +++ b/node_modules/@types/http-cache-semantics/LICENSE @@ -0,0 +1,21 @@ + MIT License + + Copyright (c) Microsoft Corporation. + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in all + copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE diff --git a/node_modules/@types/http-cache-semantics/README.md b/node_modules/@types/http-cache-semantics/README.md new file mode 100644 index 0000000..39943ed --- /dev/null +++ b/node_modules/@types/http-cache-semantics/README.md @@ -0,0 +1,15 @@ +# Installation +> `npm install --save @types/http-cache-semantics` + +# Summary +This package contains type definitions for http-cache-semantics (https://github.com/kornelski/http-cache-semantics#readme). + +# Details +Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/http-cache-semantics. + +### Additional Details + * Last updated: Tue, 27 Jan 2026 09:06:16 GMT + * Dependencies: none + +# Credits +These definitions were written by [BendingBender](https://github.com/BendingBender). diff --git a/node_modules/@types/http-cache-semantics/index.d.ts b/node_modules/@types/http-cache-semantics/index.d.ts new file mode 100644 index 0000000..5b411d1 --- /dev/null +++ b/node_modules/@types/http-cache-semantics/index.d.ts @@ -0,0 +1,251 @@ +export = CachePolicy; + +declare class CachePolicy { + constructor(req: CachePolicy.HttpRequest, res: CachePolicy.HttpResponse, options?: CachePolicy.Options); + + /** + * Returns `true` if the response can be stored in a cache. + * If it's `false` then you MUST NOT store either the request or the response. + */ + storable(): boolean; + + /** + * This is the most important method. Use this method to check whether the cached response is still fresh + * in the context of the new request. + * + * If it returns `true`, then the given `request` matches the original response this cache policy has been + * created with, and the response can be reused without contacting the server. Note that the old response + * can't be returned without being updated, see `responseHeaders()`. + * + * If it returns `false`, then the response may not be matching at all (e.g. it's for a different URL or method), + * or may require to be refreshed first (see `revalidationHeaders()`). + */ + satisfiesWithoutRevalidation(newRequest: CachePolicy.HttpRequest): boolean; + + /** + * Checks if the given request matches this cache entry, and how the cache can be used to satisfy it. Returns an object with: + * + * ``` + * { + * // If defined, you must send a request to the server. + * revalidation: { + * headers: {}, // HTTP headers to use when sending the revalidation response + * // If true, you MUST wait for a response from the server before using the cache + * // If false, this is stale-while-revalidate. The cache is stale, but you can use it while you update it asynchronously. + * synchronous: bool, + * }, + * // If defined, you can use this cached response. + * response: { + * headers: {}, // Updated cached HTTP headers you must use when responding to the client + * }, + * } + * ``` + */ + evaluateRequest(newRequest: CachePolicy.HttpRequest): CachePolicy.EvaluateRequestResult; + + /** + * Returns updated, filtered set of response headers to return to clients receiving the cached response. + * This function is necessary, because proxies MUST always remove hop-by-hop headers (such as `TE` and `Connection`) + * and update response's `Age` to avoid doubling cache time. + * + * @example + * cachedResponse.headers = cachePolicy.responseHeaders(cachedResponse); + */ + responseHeaders(): CachePolicy.Headers; + + /** + * Returns the Date header value from the response or the current time if invalid. + */ + date(): number; + + /** + * Value of the Age header, in seconds, updated for the current time. + * May be fractional. + */ + age(): number; + + /** + * Possibly outdated value of applicable max-age (or heuristic equivalent) in seconds. + * This counts since response's `Date`. + * + * For an up-to-date value, see `timeToLive()`. + * + * Returns the maximum age (freshness lifetime) of the response in seconds. + * @returns {number} The max-age value in seconds. + */ + maxAge(): number; + + /** + * Returns approximate time in milliseconds until the response becomes stale (i.e. not fresh). + * + * After that time (when `timeToLive() <= 0`) the response might not be usable without revalidation. However, + * there are exceptions, e.g. a client can explicitly allow stale responses, so always check with + * `satisfiesWithoutRevalidation()`. + */ + timeToLive(): number; + + /** + * If true, this cache entry is past its expiration date. + * Note that stale cache may be useful sometimes, see `evaluateRequest()`. + */ + stale(): boolean; + + /** + * `policy = CachePolicy.fromObject(obj)` creates an instance from object created by `toObject()`. + */ + static fromObject(obj: CachePolicy.CachePolicyObject): CachePolicy; + + /** + * Chances are you'll want to store the `CachePolicy` object along with the cached response. + * `obj = policy.toObject()` gives a plain JSON-serializable object. + */ + toObject(): CachePolicy.CachePolicyObject; + + /** + * Returns updated, filtered set of request headers to send to the origin server to check if the cached + * response can be reused. These headers allow the origin server to return status 304 indicating the + * response is still fresh. All headers unrelated to caching are passed through as-is. + * + * Use this method when updating cache from the origin server. + * + * @example + * updateRequest.headers = cachePolicy.revalidationHeaders(updateRequest); + */ + revalidationHeaders(newRequest: CachePolicy.HttpRequest): CachePolicy.Headers; + + /** + * Creates new CachePolicy with information combined from the previews response, + * and the new revalidation response. + * + * Returns {policy, modified} where modified is a boolean indicating + * whether the response body has been modified, and old cached body can't be used. + */ + revalidatedPolicy( + revalidationRequest: CachePolicy.HttpRequest, + revalidationResponse?: CachePolicy.HttpResponse, + ): CachePolicy.RevalidationPolicy; +} + +declare namespace CachePolicy { + interface HttpRequest { + url?: string | undefined; + method?: string | undefined; + headers: Headers; + } + + type Request = HttpRequest; + + interface HttpResponse { + status?: number | undefined; + headers: Headers; + } + + type Response = HttpResponse; + + interface Options { + /** + * If `true`, then the response is evaluated from a perspective of a shared cache (i.e. `private` is not + * cacheable and `s-maxage` is respected). If `false`, then the response is evaluated from a perspective + * of a single-user cache (i.e. `private` is cacheable and `s-maxage` is ignored). + * `true` is recommended for HTTP clients. + * @default true + */ + shared?: boolean | undefined; + /** + * A fraction of response's age that is used as a fallback cache duration. The default is 0.1 (10%), + * e.g. if a file hasn't been modified for 100 days, it'll be cached for 100*0.1 = 10 days. + * @default 0.1 + */ + cacheHeuristic?: number | undefined; + /** + * A number of milliseconds to assume as the default time to cache responses with `Cache-Control: immutable`. + * Note that [per RFC](https://httpwg.org/specs/rfc8246.html#the-immutable-cache-control-extension) + * these can become stale, so `max-age` still overrides the default. + * @default 24*3600*1000 (24h) + */ + immutableMinTimeToLive?: number | undefined; + /** + * If `true`, common anti-cache directives will be completely ignored if the non-standard `pre-check` + * and `post-check` directives are present. These two useless directives are most commonly found + * in bad StackOverflow answers and PHP's "session limiter" defaults. + * @default false + */ + ignoreCargoCult?: boolean | undefined; + /** + * If `false`, then server's `Date` header won't be used as the base for `max-age`. This is against the RFC, + * but it's useful if you want to cache responses with very short `max-age`, but your local clock + * is not exactly in sync with the server's. + * @default true + */ + trustServerDate?: boolean | undefined; + } + + interface CachePolicyObject { + v: number; + t: number; + sh: boolean; + ch: number; + imm: number; + st: number; + resh: Headers; + rescc: { [key: string]: string }; + m: string; + u?: string | undefined; + h?: string | undefined; + a: boolean; + reqh: Headers | null; + reqcc: { [key: string]: string }; + } + + interface Headers { + [header: string]: string | string[] | undefined; + } + + interface RevalidationPolicy { + /** + * A new `CachePolicy` with HTTP headers updated from `revalidationResponse`. You can always replace + * the old cached `CachePolicy` with the new one. + */ + policy: CachePolicy; + /** + * Boolean indicating whether the response body has changed. + * + * - If `false`, then a valid 304 Not Modified response has been received, and you can reuse the old + * cached response body. + * - If `true`, you should use new response's body (if present), or make another request to the origin + * server without any conditional headers (i.e. don't use `revalidationHeaders()` this time) to get + * the new resource. + */ + modified: boolean; + matches: boolean; + } + + interface EvaluateRequestRevalidation { + synchronous: boolean; + headers: CachePolicy.Headers; + } + + interface EvaluateRequestHitWithoutRevalidationResult { + response: { + headers: CachePolicy.Headers; + }; + revalidation: undefined; + } + + interface EvaluateRequestHitWithRevalidationResult { + response: { + headers: CachePolicy.Headers; + }; + revalidation: EvaluateRequestRevalidation; + } + + interface EvaluateRequestMissResult { + response: undefined; + revalidation: EvaluateRequestRevalidation; + } + + type EvaluateRequestResult = + | EvaluateRequestHitWithRevalidationResult + | EvaluateRequestHitWithoutRevalidationResult + | EvaluateRequestMissResult; +} diff --git a/node_modules/@types/http-cache-semantics/package.json b/node_modules/@types/http-cache-semantics/package.json new file mode 100644 index 0000000..c11ebfe --- /dev/null +++ b/node_modules/@types/http-cache-semantics/package.json @@ -0,0 +1,26 @@ +{ + "name": "@types/http-cache-semantics", + "version": "4.2.0", + "description": "TypeScript definitions for http-cache-semantics", + "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/http-cache-semantics", + "license": "MIT", + "contributors": [ + { + "name": "BendingBender", + "githubUsername": "BendingBender", + "url": "https://github.com/BendingBender" + } + ], + "main": "", + "types": "index.d.ts", + "repository": { + "type": "git", + "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git", + "directory": "types/http-cache-semantics" + }, + "scripts": {}, + "dependencies": {}, + "peerDependencies": {}, + "typesPublisherContentHash": "f5ae2b8a76a826965b8617b73b86a92dc7b5dd7230a0d6d8e1ecb6139ec75db8", + "typeScriptVersion": "5.2" +} \ No newline at end of file diff --git a/node_modules/@types/keyv/LICENSE b/node_modules/@types/keyv/LICENSE new file mode 100644 index 0000000..9e841e7 --- /dev/null +++ b/node_modules/@types/keyv/LICENSE @@ -0,0 +1,21 @@ + MIT License + + Copyright (c) Microsoft Corporation. + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in all + copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE diff --git a/node_modules/@types/keyv/README.md b/node_modules/@types/keyv/README.md new file mode 100644 index 0000000..8167fcc --- /dev/null +++ b/node_modules/@types/keyv/README.md @@ -0,0 +1,16 @@ +# Installation +> `npm install --save @types/keyv` + +# Summary +This package contains type definitions for keyv (https://github.com/lukechilds/keyv). + +# Details +Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/keyv. + +### Additional Details + * Last updated: Thu, 17 Mar 2022 05:31:42 GMT + * Dependencies: [@types/node](https://npmjs.com/package/@types/node) + * Global values: none + +# Credits +These definitions were written by [AryloYeung](https://github.com/Arylo), and [BendingBender](https://github.com/BendingBender). diff --git a/node_modules/@types/keyv/index.d.ts b/node_modules/@types/keyv/index.d.ts new file mode 100644 index 0000000..adca74d --- /dev/null +++ b/node_modules/@types/keyv/index.d.ts @@ -0,0 +1,90 @@ +// Type definitions for keyv 3.1 +// Project: https://github.com/lukechilds/keyv +// Definitions by: AryloYeung +// BendingBender +// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped +// TypeScript Version: 2.8 + +/// +import { EventEmitter } from 'events'; + +type WithRequiredProperties = T & Required>; + +declare class Keyv extends EventEmitter { + /** + * `this.opts` is an object containing at least the properties listed + * below. However, `Keyv.Options` allows arbitrary properties as well. + * These properties can be specified as the second type parameter to `Keyv`. + */ + opts: WithRequiredProperties< + Keyv.Options, + 'deserialize' | 'namespace' | 'serialize' | 'store' | 'uri' + > & + TOpts; + + /** + * @param opts The options object is also passed through to the storage adapter. Check your storage adapter docs for any extra options. + */ + constructor(opts?: Keyv.Options & TOpts); + /** + * @param uri The connection string URI. + * + * Merged into the options object as options.uri. + * @param opts The options object is also passed through to the storage adapter. Check your storage adapter docs for any extra options. + */ + constructor(uri?: string, opts?: Keyv.Options & TOpts); + + /** Returns the value. */ + get(key: string, options?: { raw?: TRaw }): + Promise<(TRaw extends false + ? TValue + : Keyv.DeserializedData) | undefined>; + /** + * Set a value. + * + * By default keys are persistent. You can set an expiry TTL in milliseconds. + */ + set(key: string, value: TValue, ttl?: number): Promise; + /** + * Deletes an entry. + * + * Returns `true` if the key existed, `false` if not. + */ + delete(key: string): Promise; + /** Delete all entries in the current namespace. */ + clear(): Promise; +} + +declare namespace Keyv { + interface Options { + /** Namespace for the current instance. */ + namespace?: string | undefined; + /** A custom serialization function. */ + serialize?: ((data: DeserializedData) => string) | undefined; + /** A custom deserialization function. */ + deserialize?: ((data: string) => DeserializedData | undefined) | undefined; + /** The connection string URI. */ + uri?: string | undefined; + /** The storage adapter instance to be used by Keyv. */ + store?: Store | undefined; + /** Default TTL. Can be overridden by specififying a TTL on `.set()`. */ + ttl?: number | undefined; + /** Specify an adapter to use. e.g `'redis'` or `'mongodb'`. */ + adapter?: 'redis' | 'mongodb' | 'mongo' | 'sqlite' | 'postgresql' | 'postgres' | 'mysql' | undefined; + + [key: string]: any; + } + + interface DeserializedData { + value: TValue; expires: number | null; + } + + interface Store { + get(key: string): TValue | Promise | undefined; + set(key: string, value: TValue, ttl?: number): any; + delete(key: string): boolean | Promise; + clear(): void | Promise; + } +} + +export = Keyv; diff --git a/node_modules/@types/keyv/package.json b/node_modules/@types/keyv/package.json new file mode 100644 index 0000000..15d4020 --- /dev/null +++ b/node_modules/@types/keyv/package.json @@ -0,0 +1,32 @@ +{ + "name": "@types/keyv", + "version": "3.1.4", + "description": "TypeScript definitions for keyv", + "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/keyv", + "license": "MIT", + "contributors": [ + { + "name": "AryloYeung", + "url": "https://github.com/Arylo", + "githubUsername": "Arylo" + }, + { + "name": "BendingBender", + "url": "https://github.com/BendingBender", + "githubUsername": "BendingBender" + } + ], + "main": "", + "types": "index.d.ts", + "repository": { + "type": "git", + "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git", + "directory": "types/keyv" + }, + "scripts": {}, + "dependencies": { + "@types/node": "*" + }, + "typesPublisherContentHash": "e83393e0860475d12e960cede22532e18e129cf659f31f2a0298a88cb5d02d36", + "typeScriptVersion": "3.9" +} \ No newline at end of file diff --git a/node_modules/@types/ms/LICENSE b/node_modules/@types/ms/LICENSE new file mode 100644 index 0000000..9e841e7 --- /dev/null +++ b/node_modules/@types/ms/LICENSE @@ -0,0 +1,21 @@ + MIT License + + Copyright (c) Microsoft Corporation. + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in all + copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE diff --git a/node_modules/@types/ms/README.md b/node_modules/@types/ms/README.md new file mode 100644 index 0000000..1152869 --- /dev/null +++ b/node_modules/@types/ms/README.md @@ -0,0 +1,82 @@ +# Installation +> `npm install --save @types/ms` + +# Summary +This package contains type definitions for ms (https://github.com/vercel/ms). + +# Details +Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/ms. +## [index.d.ts](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/ms/index.d.ts) +````ts +/** + * Short/Long format for `value`. + * + * @param {Number} value + * @param {{long: boolean}} options + * @return {String} + */ +declare function ms(value: number, options?: { long: boolean }): string; + +/** + * Parse the given `value` and return milliseconds. + * + * @param {ms.StringValue} value + * @return {Number} + */ +declare function ms(value: ms.StringValue): number; + +declare namespace ms { + // Unit, UnitAnyCase, and StringValue are backported from ms@3 + // https://github.com/vercel/ms/blob/8b5923d1d86c84a9f6aba8022d416dcf2361aa8d/src/index.ts + + type Unit = + | "Years" + | "Year" + | "Yrs" + | "Yr" + | "Y" + | "Weeks" + | "Week" + | "W" + | "Days" + | "Day" + | "D" + | "Hours" + | "Hour" + | "Hrs" + | "Hr" + | "H" + | "Minutes" + | "Minute" + | "Mins" + | "Min" + | "M" + | "Seconds" + | "Second" + | "Secs" + | "Sec" + | "s" + | "Milliseconds" + | "Millisecond" + | "Msecs" + | "Msec" + | "Ms"; + + type UnitAnyCase = Unit | Uppercase | Lowercase; + + type StringValue = + | `${number}` + | `${number}${UnitAnyCase}` + | `${number} ${UnitAnyCase}`; +} + +export = ms; + +```` + +### Additional Details + * Last updated: Thu, 16 Jan 2025 21:02:45 GMT + * Dependencies: none + +# Credits +These definitions were written by [Zhiyuan Wang](https://github.com/danny8002). diff --git a/node_modules/@types/ms/index.d.ts b/node_modules/@types/ms/index.d.ts new file mode 100644 index 0000000..b1b1f51 --- /dev/null +++ b/node_modules/@types/ms/index.d.ts @@ -0,0 +1,63 @@ +/** + * Short/Long format for `value`. + * + * @param {Number} value + * @param {{long: boolean}} options + * @return {String} + */ +declare function ms(value: number, options?: { long: boolean }): string; + +/** + * Parse the given `value` and return milliseconds. + * + * @param {ms.StringValue} value + * @return {Number} + */ +declare function ms(value: ms.StringValue): number; + +declare namespace ms { + // Unit, UnitAnyCase, and StringValue are backported from ms@3 + // https://github.com/vercel/ms/blob/8b5923d1d86c84a9f6aba8022d416dcf2361aa8d/src/index.ts + + type Unit = + | "Years" + | "Year" + | "Yrs" + | "Yr" + | "Y" + | "Weeks" + | "Week" + | "W" + | "Days" + | "Day" + | "D" + | "Hours" + | "Hour" + | "Hrs" + | "Hr" + | "H" + | "Minutes" + | "Minute" + | "Mins" + | "Min" + | "M" + | "Seconds" + | "Second" + | "Secs" + | "Sec" + | "s" + | "Milliseconds" + | "Millisecond" + | "Msecs" + | "Msec" + | "Ms"; + + type UnitAnyCase = Unit | Uppercase | Lowercase; + + type StringValue = + | `${number}` + | `${number}${UnitAnyCase}` + | `${number} ${UnitAnyCase}`; +} + +export = ms; diff --git a/node_modules/@types/ms/package.json b/node_modules/@types/ms/package.json new file mode 100644 index 0000000..0f547d0 --- /dev/null +++ b/node_modules/@types/ms/package.json @@ -0,0 +1,26 @@ +{ + "name": "@types/ms", + "version": "2.1.0", + "description": "TypeScript definitions for ms", + "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/ms", + "license": "MIT", + "contributors": [ + { + "name": "Zhiyuan Wang", + "githubUsername": "danny8002", + "url": "https://github.com/danny8002" + } + ], + "main": "", + "types": "index.d.ts", + "repository": { + "type": "git", + "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git", + "directory": "types/ms" + }, + "scripts": {}, + "dependencies": {}, + "peerDependencies": {}, + "typesPublisherContentHash": "2c8651ce1714fdc6bcbc0f262c93a790f1d127fb1c2dc8edbb583decef56fd39", + "typeScriptVersion": "5.0" +} \ No newline at end of file diff --git a/node_modules/@types/node/assert/strict.d.ts b/node_modules/@types/node/assert/strict.d.ts new file mode 100644 index 0000000..4ed7395 --- /dev/null +++ b/node_modules/@types/node/assert/strict.d.ts @@ -0,0 +1,111 @@ +/** + * In strict assertion mode, non-strict methods behave like their corresponding + * strict methods. For example, `assert.deepEqual()` will behave like + * `assert.deepStrictEqual()`. + * + * In strict assertion mode, error messages for objects display a diff. In legacy + * assertion mode, error messages for objects display the objects, often truncated. + * + * To use strict assertion mode: + * + * ```js + * import { strict as assert } from 'node:assert'; + * ``` + * + * ```js + * import assert from 'node:assert/strict'; + * ``` + * + * Example error diff: + * + * ```js + * import { strict as assert } from 'node:assert'; + * + * assert.deepEqual([[[1, 2, 3]], 4, 5], [[[1, 2, '3']], 4, 5]); + * // AssertionError: Expected inputs to be strictly deep-equal: + * // + actual - expected ... Lines skipped + * // + * // [ + * // [ + * // ... + * // 2, + * // + 3 + * // - '3' + * // ], + * // ... + * // 5 + * // ] + * ``` + * + * To deactivate the colors, use the `NO_COLOR` or `NODE_DISABLE_COLORS` + * environment variables. This will also deactivate the colors in the REPL. For + * more on color support in terminal environments, read the tty + * [`getColorDepth()`](https://nodejs.org/docs/latest-v24.x/api/tty.html#writestreamgetcolordepthenv) documentation. + * @since v15.0.0 + * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/assert/strict.js) + */ +declare module "assert/strict" { + import { + Assert, + AssertionError, + AssertionErrorOptions, + AssertOptions, + AssertPredicate, + AssertStrict, + CallTracker, + CallTrackerCall, + CallTrackerReportInformation, + deepStrictEqual, + doesNotMatch, + doesNotReject, + doesNotThrow, + fail, + ifError, + match, + notDeepStrictEqual, + notStrictEqual, + ok, + partialDeepStrictEqual, + rejects, + strictEqual, + throws, + } from "node:assert"; + function strict(value: unknown, message?: string | Error): asserts value; + namespace strict { + export { + Assert, + AssertionError, + AssertionErrorOptions, + AssertOptions, + AssertPredicate, + AssertStrict, + CallTracker, + CallTrackerCall, + CallTrackerReportInformation, + deepStrictEqual, + deepStrictEqual as deepEqual, + doesNotMatch, + doesNotReject, + doesNotThrow, + fail, + ifError, + match, + notDeepStrictEqual, + notDeepStrictEqual as notDeepEqual, + notStrictEqual, + notStrictEqual as notEqual, + ok, + partialDeepStrictEqual, + rejects, + strict, + strictEqual, + strictEqual as equal, + throws, + }; + } + export = strict; +} +declare module "node:assert/strict" { + import strict = require("assert/strict"); + export = strict; +}