WIP: bootstrap and partial real Solana watcher implementation
This commit is contained in:
@@ -0,0 +1,460 @@
|
||||
import { SolanaError, SOLANA_ERROR__CODECS__EXPECTED_FIXED_LENGTH, SOLANA_ERROR__CODECS__EXPECTED_VARIABLE_LENGTH, SOLANA_ERROR__CODECS__ENCODER_DECODER_SIZE_COMPATIBILITY_MISMATCH, SOLANA_ERROR__CODECS__ENCODER_DECODER_FIXED_SIZE_MISMATCH, SOLANA_ERROR__CODECS__ENCODER_DECODER_MAX_SIZE_MISMATCH, SOLANA_ERROR__CODECS__CANNOT_DECODE_EMPTY_BYTE_ARRAY, SOLANA_ERROR__CODECS__INVALID_BYTE_LENGTH, SOLANA_ERROR__CODECS__OFFSET_OUT_OF_RANGE, SOLANA_ERROR__CODECS__EXPECTED_POSITIVE_BYTE_LENGTH, SOLANA_ERROR__CODECS__SENTINEL_MISSING_IN_DECODED_BYTES, SOLANA_ERROR__CODECS__ENCODED_BYTES_MUST_NOT_INCLUDE_SENTINEL } from '@solana/errors';
|
||||
|
||||
// src/add-codec-sentinel.ts
|
||||
|
||||
// src/bytes.ts
|
||||
var mergeBytes = (byteArrays) => {
|
||||
const nonEmptyByteArrays = byteArrays.filter((arr) => arr.length);
|
||||
if (nonEmptyByteArrays.length === 0) {
|
||||
return byteArrays.length ? byteArrays[0] : new Uint8Array();
|
||||
}
|
||||
if (nonEmptyByteArrays.length === 1) {
|
||||
return nonEmptyByteArrays[0];
|
||||
}
|
||||
const totalLength = nonEmptyByteArrays.reduce((total, arr) => total + arr.length, 0);
|
||||
const result = new Uint8Array(totalLength);
|
||||
let offset = 0;
|
||||
nonEmptyByteArrays.forEach((arr) => {
|
||||
result.set(arr, offset);
|
||||
offset += arr.length;
|
||||
});
|
||||
return result;
|
||||
};
|
||||
var padBytes = (bytes, length) => {
|
||||
if (bytes.length >= length) return bytes;
|
||||
const paddedBytes = new Uint8Array(length).fill(0);
|
||||
paddedBytes.set(bytes);
|
||||
return paddedBytes;
|
||||
};
|
||||
var fixBytes = (bytes, length) => padBytes(bytes.length <= length ? bytes : bytes.slice(0, length), length);
|
||||
function containsBytes(data, bytes, offset) {
|
||||
const slice = offset === 0 && data.length === bytes.length ? data : data.slice(offset, offset + bytes.length);
|
||||
if (slice.length !== bytes.length) return false;
|
||||
return bytes.every((b, i) => b === slice[i]);
|
||||
}
|
||||
function getEncodedSize(value, encoder) {
|
||||
return "fixedSize" in encoder ? encoder.fixedSize : encoder.getSizeFromValue(value);
|
||||
}
|
||||
function createEncoder(encoder) {
|
||||
return Object.freeze({
|
||||
...encoder,
|
||||
encode: (value) => {
|
||||
const bytes = new Uint8Array(getEncodedSize(value, encoder));
|
||||
encoder.write(value, bytes, 0);
|
||||
return bytes;
|
||||
}
|
||||
});
|
||||
}
|
||||
function createDecoder(decoder) {
|
||||
return Object.freeze({
|
||||
...decoder,
|
||||
decode: (bytes, offset = 0) => decoder.read(bytes, offset)[0]
|
||||
});
|
||||
}
|
||||
function createCodec(codec) {
|
||||
return Object.freeze({
|
||||
...codec,
|
||||
decode: (bytes, offset = 0) => codec.read(bytes, offset)[0],
|
||||
encode: (value) => {
|
||||
const bytes = new Uint8Array(getEncodedSize(value, codec));
|
||||
codec.write(value, bytes, 0);
|
||||
return bytes;
|
||||
}
|
||||
});
|
||||
}
|
||||
function isFixedSize(codec) {
|
||||
return "fixedSize" in codec && typeof codec.fixedSize === "number";
|
||||
}
|
||||
function assertIsFixedSize(codec) {
|
||||
if (!isFixedSize(codec)) {
|
||||
throw new SolanaError(SOLANA_ERROR__CODECS__EXPECTED_FIXED_LENGTH);
|
||||
}
|
||||
}
|
||||
function isVariableSize(codec) {
|
||||
return !isFixedSize(codec);
|
||||
}
|
||||
function assertIsVariableSize(codec) {
|
||||
if (!isVariableSize(codec)) {
|
||||
throw new SolanaError(SOLANA_ERROR__CODECS__EXPECTED_VARIABLE_LENGTH);
|
||||
}
|
||||
}
|
||||
function combineCodec(encoder, decoder) {
|
||||
if (isFixedSize(encoder) !== isFixedSize(decoder)) {
|
||||
throw new SolanaError(SOLANA_ERROR__CODECS__ENCODER_DECODER_SIZE_COMPATIBILITY_MISMATCH);
|
||||
}
|
||||
if (isFixedSize(encoder) && isFixedSize(decoder) && encoder.fixedSize !== decoder.fixedSize) {
|
||||
throw new SolanaError(SOLANA_ERROR__CODECS__ENCODER_DECODER_FIXED_SIZE_MISMATCH, {
|
||||
decoderFixedSize: decoder.fixedSize,
|
||||
encoderFixedSize: encoder.fixedSize
|
||||
});
|
||||
}
|
||||
if (!isFixedSize(encoder) && !isFixedSize(decoder) && encoder.maxSize !== decoder.maxSize) {
|
||||
throw new SolanaError(SOLANA_ERROR__CODECS__ENCODER_DECODER_MAX_SIZE_MISMATCH, {
|
||||
decoderMaxSize: decoder.maxSize,
|
||||
encoderMaxSize: encoder.maxSize
|
||||
});
|
||||
}
|
||||
return {
|
||||
...decoder,
|
||||
...encoder,
|
||||
decode: decoder.decode,
|
||||
encode: encoder.encode,
|
||||
read: decoder.read,
|
||||
write: encoder.write
|
||||
};
|
||||
}
|
||||
|
||||
// src/add-codec-sentinel.ts
|
||||
function addEncoderSentinel(encoder, sentinel) {
|
||||
const write = (value, bytes, offset) => {
|
||||
const encoderBytes = encoder.encode(value);
|
||||
if (findSentinelIndex(encoderBytes, sentinel) >= 0) {
|
||||
throw new SolanaError(SOLANA_ERROR__CODECS__ENCODED_BYTES_MUST_NOT_INCLUDE_SENTINEL, {
|
||||
encodedBytes: encoderBytes,
|
||||
hexEncodedBytes: hexBytes(encoderBytes),
|
||||
hexSentinel: hexBytes(sentinel),
|
||||
sentinel
|
||||
});
|
||||
}
|
||||
bytes.set(encoderBytes, offset);
|
||||
offset += encoderBytes.length;
|
||||
bytes.set(sentinel, offset);
|
||||
offset += sentinel.length;
|
||||
return offset;
|
||||
};
|
||||
if (isFixedSize(encoder)) {
|
||||
return createEncoder({ ...encoder, fixedSize: encoder.fixedSize + sentinel.length, write });
|
||||
}
|
||||
return createEncoder({
|
||||
...encoder,
|
||||
...encoder.maxSize != null ? { maxSize: encoder.maxSize + sentinel.length } : {},
|
||||
getSizeFromValue: (value) => encoder.getSizeFromValue(value) + sentinel.length,
|
||||
write
|
||||
});
|
||||
}
|
||||
function addDecoderSentinel(decoder, sentinel) {
|
||||
const read = (bytes, offset) => {
|
||||
const candidateBytes = offset === 0 ? bytes : bytes.slice(offset);
|
||||
const sentinelIndex = findSentinelIndex(candidateBytes, sentinel);
|
||||
if (sentinelIndex === -1) {
|
||||
throw new SolanaError(SOLANA_ERROR__CODECS__SENTINEL_MISSING_IN_DECODED_BYTES, {
|
||||
decodedBytes: candidateBytes,
|
||||
hexDecodedBytes: hexBytes(candidateBytes),
|
||||
hexSentinel: hexBytes(sentinel),
|
||||
sentinel
|
||||
});
|
||||
}
|
||||
const preSentinelBytes = candidateBytes.slice(0, sentinelIndex);
|
||||
return [decoder.decode(preSentinelBytes), offset + preSentinelBytes.length + sentinel.length];
|
||||
};
|
||||
if (isFixedSize(decoder)) {
|
||||
return createDecoder({ ...decoder, fixedSize: decoder.fixedSize + sentinel.length, read });
|
||||
}
|
||||
return createDecoder({
|
||||
...decoder,
|
||||
...decoder.maxSize != null ? { maxSize: decoder.maxSize + sentinel.length } : {},
|
||||
read
|
||||
});
|
||||
}
|
||||
function addCodecSentinel(codec, sentinel) {
|
||||
return combineCodec(addEncoderSentinel(codec, sentinel), addDecoderSentinel(codec, sentinel));
|
||||
}
|
||||
function findSentinelIndex(bytes, sentinel) {
|
||||
return bytes.findIndex((byte, index, arr) => {
|
||||
if (sentinel.length === 1) return byte === sentinel[0];
|
||||
return containsBytes(arr, sentinel, index);
|
||||
});
|
||||
}
|
||||
function hexBytes(bytes) {
|
||||
return bytes.reduce((str, byte) => str + byte.toString(16).padStart(2, "0"), "");
|
||||
}
|
||||
function assertByteArrayIsNotEmptyForCodec(codecDescription, bytes, offset = 0) {
|
||||
if (bytes.length - offset <= 0) {
|
||||
throw new SolanaError(SOLANA_ERROR__CODECS__CANNOT_DECODE_EMPTY_BYTE_ARRAY, {
|
||||
codecDescription
|
||||
});
|
||||
}
|
||||
}
|
||||
function assertByteArrayHasEnoughBytesForCodec(codecDescription, expected, bytes, offset = 0) {
|
||||
const bytesLength = bytes.length - offset;
|
||||
if (bytesLength < expected) {
|
||||
throw new SolanaError(SOLANA_ERROR__CODECS__INVALID_BYTE_LENGTH, {
|
||||
bytesLength,
|
||||
codecDescription,
|
||||
expected
|
||||
});
|
||||
}
|
||||
}
|
||||
function assertByteArrayOffsetIsNotOutOfRange(codecDescription, offset, bytesLength) {
|
||||
if (offset < 0 || offset > bytesLength) {
|
||||
throw new SolanaError(SOLANA_ERROR__CODECS__OFFSET_OUT_OF_RANGE, {
|
||||
bytesLength,
|
||||
codecDescription,
|
||||
offset
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
// src/add-codec-size-prefix.ts
|
||||
function addEncoderSizePrefix(encoder, prefix) {
|
||||
const write = (value, bytes, offset) => {
|
||||
const encoderBytes = encoder.encode(value);
|
||||
offset = prefix.write(encoderBytes.length, bytes, offset);
|
||||
bytes.set(encoderBytes, offset);
|
||||
return offset + encoderBytes.length;
|
||||
};
|
||||
if (isFixedSize(prefix) && isFixedSize(encoder)) {
|
||||
return createEncoder({ ...encoder, fixedSize: prefix.fixedSize + encoder.fixedSize, write });
|
||||
}
|
||||
const prefixMaxSize = isFixedSize(prefix) ? prefix.fixedSize : prefix.maxSize ?? null;
|
||||
const encoderMaxSize = isFixedSize(encoder) ? encoder.fixedSize : encoder.maxSize ?? null;
|
||||
const maxSize = prefixMaxSize !== null && encoderMaxSize !== null ? prefixMaxSize + encoderMaxSize : null;
|
||||
return createEncoder({
|
||||
...encoder,
|
||||
...maxSize !== null ? { maxSize } : {},
|
||||
getSizeFromValue: (value) => {
|
||||
const encoderSize = getEncodedSize(value, encoder);
|
||||
return getEncodedSize(encoderSize, prefix) + encoderSize;
|
||||
},
|
||||
write
|
||||
});
|
||||
}
|
||||
function addDecoderSizePrefix(decoder, prefix) {
|
||||
const read = (bytes, offset) => {
|
||||
const [bigintSize, decoderOffset] = prefix.read(bytes, offset);
|
||||
const size = Number(bigintSize);
|
||||
offset = decoderOffset;
|
||||
if (offset > 0 || bytes.length > size) {
|
||||
bytes = bytes.slice(offset, offset + size);
|
||||
}
|
||||
assertByteArrayHasEnoughBytesForCodec("addDecoderSizePrefix", size, bytes);
|
||||
return [decoder.decode(bytes), offset + size];
|
||||
};
|
||||
if (isFixedSize(prefix) && isFixedSize(decoder)) {
|
||||
return createDecoder({ ...decoder, fixedSize: prefix.fixedSize + decoder.fixedSize, read });
|
||||
}
|
||||
const prefixMaxSize = isFixedSize(prefix) ? prefix.fixedSize : prefix.maxSize ?? null;
|
||||
const decoderMaxSize = isFixedSize(decoder) ? decoder.fixedSize : decoder.maxSize ?? null;
|
||||
const maxSize = prefixMaxSize !== null && decoderMaxSize !== null ? prefixMaxSize + decoderMaxSize : null;
|
||||
return createDecoder({ ...decoder, ...maxSize !== null ? { maxSize } : {}, read });
|
||||
}
|
||||
function addCodecSizePrefix(codec, prefix) {
|
||||
return combineCodec(addEncoderSizePrefix(codec, prefix), addDecoderSizePrefix(codec, prefix));
|
||||
}
|
||||
|
||||
// src/fix-codec-size.ts
|
||||
function fixEncoderSize(encoder, fixedBytes) {
|
||||
return createEncoder({
|
||||
fixedSize: fixedBytes,
|
||||
write: (value, bytes, offset) => {
|
||||
const variableByteArray = encoder.encode(value);
|
||||
const fixedByteArray = variableByteArray.length > fixedBytes ? variableByteArray.slice(0, fixedBytes) : variableByteArray;
|
||||
bytes.set(fixedByteArray, offset);
|
||||
return offset + fixedBytes;
|
||||
}
|
||||
});
|
||||
}
|
||||
function fixDecoderSize(decoder, fixedBytes) {
|
||||
return createDecoder({
|
||||
fixedSize: fixedBytes,
|
||||
read: (bytes, offset) => {
|
||||
assertByteArrayHasEnoughBytesForCodec("fixCodecSize", fixedBytes, bytes, offset);
|
||||
if (offset > 0 || bytes.length > fixedBytes) {
|
||||
bytes = bytes.slice(offset, offset + fixedBytes);
|
||||
}
|
||||
if (isFixedSize(decoder)) {
|
||||
bytes = fixBytes(bytes, decoder.fixedSize);
|
||||
}
|
||||
const [value] = decoder.read(bytes, 0);
|
||||
return [value, offset + fixedBytes];
|
||||
}
|
||||
});
|
||||
}
|
||||
function fixCodecSize(codec, fixedBytes) {
|
||||
return combineCodec(fixEncoderSize(codec, fixedBytes), fixDecoderSize(codec, fixedBytes));
|
||||
}
|
||||
|
||||
// src/offset-codec.ts
|
||||
function offsetEncoder(encoder, config) {
|
||||
return createEncoder({
|
||||
...encoder,
|
||||
write: (value, bytes, preOffset) => {
|
||||
const wrapBytes = (offset) => modulo(offset, bytes.length);
|
||||
const newPreOffset = config.preOffset ? config.preOffset({ bytes, preOffset, wrapBytes }) : preOffset;
|
||||
assertByteArrayOffsetIsNotOutOfRange("offsetEncoder", newPreOffset, bytes.length);
|
||||
const postOffset = encoder.write(value, bytes, newPreOffset);
|
||||
const newPostOffset = config.postOffset ? config.postOffset({ bytes, newPreOffset, postOffset, preOffset, wrapBytes }) : postOffset;
|
||||
assertByteArrayOffsetIsNotOutOfRange("offsetEncoder", newPostOffset, bytes.length);
|
||||
return newPostOffset;
|
||||
}
|
||||
});
|
||||
}
|
||||
function offsetDecoder(decoder, config) {
|
||||
return createDecoder({
|
||||
...decoder,
|
||||
read: (bytes, preOffset) => {
|
||||
const wrapBytes = (offset) => modulo(offset, bytes.length);
|
||||
const newPreOffset = config.preOffset ? config.preOffset({ bytes, preOffset, wrapBytes }) : preOffset;
|
||||
assertByteArrayOffsetIsNotOutOfRange("offsetDecoder", newPreOffset, bytes.length);
|
||||
const [value, postOffset] = decoder.read(bytes, newPreOffset);
|
||||
const newPostOffset = config.postOffset ? config.postOffset({ bytes, newPreOffset, postOffset, preOffset, wrapBytes }) : postOffset;
|
||||
assertByteArrayOffsetIsNotOutOfRange("offsetDecoder", newPostOffset, bytes.length);
|
||||
return [value, newPostOffset];
|
||||
}
|
||||
});
|
||||
}
|
||||
function offsetCodec(codec, config) {
|
||||
return combineCodec(offsetEncoder(codec, config), offsetDecoder(codec, config));
|
||||
}
|
||||
function modulo(dividend, divisor) {
|
||||
if (divisor === 0) return 0;
|
||||
return (dividend % divisor + divisor) % divisor;
|
||||
}
|
||||
function resizeEncoder(encoder, resize) {
|
||||
if (isFixedSize(encoder)) {
|
||||
const fixedSize = resize(encoder.fixedSize);
|
||||
if (fixedSize < 0) {
|
||||
throw new SolanaError(SOLANA_ERROR__CODECS__EXPECTED_POSITIVE_BYTE_LENGTH, {
|
||||
bytesLength: fixedSize,
|
||||
codecDescription: "resizeEncoder"
|
||||
});
|
||||
}
|
||||
return createEncoder({ ...encoder, fixedSize });
|
||||
}
|
||||
return createEncoder({
|
||||
...encoder,
|
||||
getSizeFromValue: (value) => {
|
||||
const newSize = resize(encoder.getSizeFromValue(value));
|
||||
if (newSize < 0) {
|
||||
throw new SolanaError(SOLANA_ERROR__CODECS__EXPECTED_POSITIVE_BYTE_LENGTH, {
|
||||
bytesLength: newSize,
|
||||
codecDescription: "resizeEncoder"
|
||||
});
|
||||
}
|
||||
return newSize;
|
||||
}
|
||||
});
|
||||
}
|
||||
function resizeDecoder(decoder, resize) {
|
||||
if (isFixedSize(decoder)) {
|
||||
const fixedSize = resize(decoder.fixedSize);
|
||||
if (fixedSize < 0) {
|
||||
throw new SolanaError(SOLANA_ERROR__CODECS__EXPECTED_POSITIVE_BYTE_LENGTH, {
|
||||
bytesLength: fixedSize,
|
||||
codecDescription: "resizeDecoder"
|
||||
});
|
||||
}
|
||||
return createDecoder({ ...decoder, fixedSize });
|
||||
}
|
||||
return decoder;
|
||||
}
|
||||
function resizeCodec(codec, resize) {
|
||||
return combineCodec(resizeEncoder(codec, resize), resizeDecoder(codec, resize));
|
||||
}
|
||||
|
||||
// src/pad-codec.ts
|
||||
function padLeftEncoder(encoder, offset) {
|
||||
return offsetEncoder(
|
||||
resizeEncoder(encoder, (size) => size + offset),
|
||||
{ preOffset: ({ preOffset }) => preOffset + offset }
|
||||
);
|
||||
}
|
||||
function padRightEncoder(encoder, offset) {
|
||||
return offsetEncoder(
|
||||
resizeEncoder(encoder, (size) => size + offset),
|
||||
{ postOffset: ({ postOffset }) => postOffset + offset }
|
||||
);
|
||||
}
|
||||
function padLeftDecoder(decoder, offset) {
|
||||
return offsetDecoder(
|
||||
resizeDecoder(decoder, (size) => size + offset),
|
||||
{ preOffset: ({ preOffset }) => preOffset + offset }
|
||||
);
|
||||
}
|
||||
function padRightDecoder(decoder, offset) {
|
||||
return offsetDecoder(
|
||||
resizeDecoder(decoder, (size) => size + offset),
|
||||
{ postOffset: ({ postOffset }) => postOffset + offset }
|
||||
);
|
||||
}
|
||||
function padLeftCodec(codec, offset) {
|
||||
return combineCodec(padLeftEncoder(codec, offset), padLeftDecoder(codec, offset));
|
||||
}
|
||||
function padRightCodec(codec, offset) {
|
||||
return combineCodec(padRightEncoder(codec, offset), padRightDecoder(codec, offset));
|
||||
}
|
||||
|
||||
// src/reverse-codec.ts
|
||||
function copySourceToTargetInReverse(source, target_WILL_MUTATE, sourceOffset, sourceLength, targetOffset = 0) {
|
||||
while (sourceOffset < --sourceLength) {
|
||||
const leftValue = source[sourceOffset];
|
||||
target_WILL_MUTATE[sourceOffset + targetOffset] = source[sourceLength];
|
||||
target_WILL_MUTATE[sourceLength + targetOffset] = leftValue;
|
||||
sourceOffset++;
|
||||
}
|
||||
if (sourceOffset === sourceLength) {
|
||||
target_WILL_MUTATE[sourceOffset + targetOffset] = source[sourceOffset];
|
||||
}
|
||||
}
|
||||
function reverseEncoder(encoder) {
|
||||
assertIsFixedSize(encoder);
|
||||
return createEncoder({
|
||||
...encoder,
|
||||
write: (value, bytes, offset) => {
|
||||
const newOffset = encoder.write(value, bytes, offset);
|
||||
copySourceToTargetInReverse(
|
||||
bytes,
|
||||
bytes,
|
||||
offset,
|
||||
offset + encoder.fixedSize
|
||||
);
|
||||
return newOffset;
|
||||
}
|
||||
});
|
||||
}
|
||||
function reverseDecoder(decoder) {
|
||||
assertIsFixedSize(decoder);
|
||||
return createDecoder({
|
||||
...decoder,
|
||||
read: (bytes, offset) => {
|
||||
const reversedBytes = bytes.slice();
|
||||
copySourceToTargetInReverse(
|
||||
bytes,
|
||||
reversedBytes,
|
||||
offset,
|
||||
offset + decoder.fixedSize
|
||||
);
|
||||
return decoder.read(reversedBytes, offset);
|
||||
}
|
||||
});
|
||||
}
|
||||
function reverseCodec(codec) {
|
||||
return combineCodec(reverseEncoder(codec), reverseDecoder(codec));
|
||||
}
|
||||
|
||||
// src/transform-codec.ts
|
||||
function transformEncoder(encoder, unmap) {
|
||||
return createEncoder({
|
||||
...isVariableSize(encoder) ? { ...encoder, getSizeFromValue: (value) => encoder.getSizeFromValue(unmap(value)) } : encoder,
|
||||
write: (value, bytes, offset) => encoder.write(unmap(value), bytes, offset)
|
||||
});
|
||||
}
|
||||
function transformDecoder(decoder, map) {
|
||||
return createDecoder({
|
||||
...decoder,
|
||||
read: (bytes, offset) => {
|
||||
const [value, newOffset] = decoder.read(bytes, offset);
|
||||
return [map(value, bytes, offset), newOffset];
|
||||
}
|
||||
});
|
||||
}
|
||||
function transformCodec(codec, unmap, map) {
|
||||
return createCodec({
|
||||
...transformEncoder(codec, unmap),
|
||||
read: map ? transformDecoder(codec, map).read : codec.read
|
||||
});
|
||||
}
|
||||
|
||||
export { addCodecSentinel, addCodecSizePrefix, addDecoderSentinel, addDecoderSizePrefix, addEncoderSentinel, addEncoderSizePrefix, assertByteArrayHasEnoughBytesForCodec, assertByteArrayIsNotEmptyForCodec, assertByteArrayOffsetIsNotOutOfRange, assertIsFixedSize, assertIsVariableSize, combineCodec, containsBytes, createCodec, createDecoder, createEncoder, fixBytes, fixCodecSize, fixDecoderSize, fixEncoderSize, getEncodedSize, isFixedSize, isVariableSize, mergeBytes, offsetCodec, offsetDecoder, offsetEncoder, padBytes, padLeftCodec, padLeftDecoder, padLeftEncoder, padRightCodec, padRightDecoder, padRightEncoder, resizeCodec, resizeDecoder, resizeEncoder, reverseCodec, reverseDecoder, reverseEncoder, transformCodec, transformDecoder, transformEncoder };
|
||||
//# sourceMappingURL=index.node.mjs.map
|
||||
//# sourceMappingURL=index.node.mjs.map
|
||||
@@ -0,0 +1,174 @@
|
||||
import { AST } from './ast.js';
|
||||
export type Platform = 'aix' | 'android' | 'darwin' | 'freebsd' | 'haiku' | 'linux' | 'openbsd' | 'sunos' | 'win32' | 'cygwin' | 'netbsd';
|
||||
export interface MinimatchOptions {
|
||||
/** do not expand `{x,y}` style braces */
|
||||
nobrace?: boolean;
|
||||
/** do not treat patterns starting with `#` as a comment */
|
||||
nocomment?: boolean;
|
||||
/** do not treat patterns starting with `!` as a negation */
|
||||
nonegate?: boolean;
|
||||
/** print LOTS of debugging output */
|
||||
debug?: boolean;
|
||||
/** treat `**` the same as `*` */
|
||||
noglobstar?: boolean;
|
||||
/** do not expand extglobs like `+(a|b)` */
|
||||
noext?: boolean;
|
||||
/** return the pattern if nothing matches */
|
||||
nonull?: boolean;
|
||||
/** treat `\\` as a path separator, not an escape character */
|
||||
windowsPathsNoEscape?: boolean;
|
||||
/**
|
||||
* inverse of {@link MinimatchOptions.windowsPathsNoEscape}
|
||||
* @deprecated
|
||||
*/
|
||||
allowWindowsEscape?: boolean;
|
||||
/**
|
||||
* Compare a partial path to a pattern. As long as the parts
|
||||
* of the path that are present are not contradicted by the
|
||||
* pattern, it will be treated as a match. This is useful in
|
||||
* applications where you're walking through a folder structure,
|
||||
* and don't yet have the full path, but want to ensure that you
|
||||
* do not walk down paths that can never be a match.
|
||||
*/
|
||||
partial?: boolean;
|
||||
/** allow matches that start with `.` even if the pattern does not */
|
||||
dot?: boolean;
|
||||
/** ignore case */
|
||||
nocase?: boolean;
|
||||
/** ignore case only in wildcard patterns */
|
||||
nocaseMagicOnly?: boolean;
|
||||
/** consider braces to be "magic" for the purpose of `hasMagic` */
|
||||
magicalBraces?: boolean;
|
||||
/**
|
||||
* If set, then patterns without slashes will be matched
|
||||
* against the basename of the path if it contains slashes.
|
||||
* For example, `a?b` would match the path `/xyz/123/acb`, but
|
||||
* not `/xyz/acb/123`.
|
||||
*/
|
||||
matchBase?: boolean;
|
||||
/** invert the results of negated matches */
|
||||
flipNegate?: boolean;
|
||||
/** do not collapse multiple `/` into a single `/` */
|
||||
preserveMultipleSlashes?: boolean;
|
||||
/**
|
||||
* A number indicating the level of optimization that should be done
|
||||
* to the pattern prior to parsing and using it for matches.
|
||||
*/
|
||||
optimizationLevel?: number;
|
||||
/** operating system platform */
|
||||
platform?: Platform;
|
||||
/**
|
||||
* When a pattern starts with a UNC path or drive letter, and in
|
||||
* `nocase:true` mode, do not convert the root portions of the
|
||||
* pattern into a case-insensitive regular expression, and instead
|
||||
* leave them as strings.
|
||||
*
|
||||
* This is the default when the platform is `win32` and
|
||||
* `nocase:true` is set.
|
||||
*/
|
||||
windowsNoMagicRoot?: boolean;
|
||||
/**
|
||||
* max number of `{...}` patterns to expand. Default 100_000.
|
||||
*/
|
||||
braceExpandMax?: number;
|
||||
/**
|
||||
* Max number of non-adjacent `**` patterns to recursively walk down.
|
||||
*
|
||||
* The default of 200 is almost certainly high enough for most purposes,
|
||||
* and can handle absurdly excessive patterns.
|
||||
*/
|
||||
maxGlobstarRecursion?: number;
|
||||
/**
|
||||
* Max depth to traverse for nested extglobs like `*(a|b|c)`
|
||||
*
|
||||
* Default is 2, which is quite low, but any higher value
|
||||
* swiftly results in punishing performance impacts. Note
|
||||
* that this is *not* relevant when the globstar types can
|
||||
* be safely coalesced into a single set.
|
||||
*
|
||||
* For example, `*(a|@(b|c)|d)` would be flattened into
|
||||
* `*(a|b|c|d)`. Thus, many common extglobs will retain good
|
||||
* performance and never hit this limit, even if they are
|
||||
* excessively deep and complicated.
|
||||
*
|
||||
* If the limit is hit, then the extglob characters are simply
|
||||
* not parsed, and the pattern effectively switches into
|
||||
* `noextglob: true` mode for the contents of that nested
|
||||
* sub-pattern. This will typically _not_ result in a match,
|
||||
* but is considered a valid trade-off for security and
|
||||
* performance.
|
||||
*/
|
||||
maxExtglobRecursion?: number;
|
||||
}
|
||||
export declare const minimatch: {
|
||||
(p: string, pattern: string, options?: MinimatchOptions): boolean;
|
||||
sep: Sep;
|
||||
GLOBSTAR: typeof GLOBSTAR;
|
||||
filter: (pattern: string, options?: MinimatchOptions) => (p: string) => boolean;
|
||||
defaults: (def: MinimatchOptions) => typeof minimatch;
|
||||
braceExpand: (pattern: string, options?: MinimatchOptions) => string[];
|
||||
makeRe: (pattern: string, options?: MinimatchOptions) => false | MMRegExp;
|
||||
match: (list: string[], pattern: string, options?: MinimatchOptions) => string[];
|
||||
AST: typeof AST;
|
||||
Minimatch: typeof Minimatch;
|
||||
escape: (s: string, { windowsPathsNoEscape, magicalBraces, }?: Pick<MinimatchOptions, "windowsPathsNoEscape" | "magicalBraces">) => string;
|
||||
unescape: (s: string, { windowsPathsNoEscape, magicalBraces, }?: Pick<MinimatchOptions, "windowsPathsNoEscape" | "magicalBraces">) => string;
|
||||
};
|
||||
export type Sep = '\\' | '/';
|
||||
export declare const sep: Sep;
|
||||
export declare const GLOBSTAR: unique symbol;
|
||||
export declare const filter: (pattern: string, options?: MinimatchOptions) => (p: string) => boolean;
|
||||
export declare const defaults: (def: MinimatchOptions) => typeof minimatch;
|
||||
export declare const braceExpand: (pattern: string, options?: MinimatchOptions) => string[];
|
||||
export declare const makeRe: (pattern: string, options?: MinimatchOptions) => false | MMRegExp;
|
||||
export declare const match: (list: string[], pattern: string, options?: MinimatchOptions) => string[];
|
||||
export type MMRegExp = RegExp & {
|
||||
_src?: string;
|
||||
_glob?: string;
|
||||
};
|
||||
export type ParseReturnFiltered = string | MMRegExp | typeof GLOBSTAR;
|
||||
export type ParseReturn = ParseReturnFiltered | false;
|
||||
export declare class Minimatch {
|
||||
#private;
|
||||
options: MinimatchOptions;
|
||||
set: ParseReturnFiltered[][];
|
||||
pattern: string;
|
||||
windowsPathsNoEscape: boolean;
|
||||
nonegate: boolean;
|
||||
negate: boolean;
|
||||
comment: boolean;
|
||||
empty: boolean;
|
||||
preserveMultipleSlashes: boolean;
|
||||
partial: boolean;
|
||||
globSet: string[];
|
||||
globParts: string[][];
|
||||
nocase: boolean;
|
||||
isWindows: boolean;
|
||||
platform: Platform;
|
||||
windowsNoMagicRoot: boolean;
|
||||
maxGlobstarRecursion: number;
|
||||
regexp: false | null | MMRegExp;
|
||||
constructor(pattern: string, options?: MinimatchOptions);
|
||||
hasMagic(): boolean;
|
||||
debug(..._: unknown[]): void;
|
||||
make(): void;
|
||||
preprocess(globParts: string[][]): string[][];
|
||||
adjascentGlobstarOptimize(globParts: string[][]): string[][];
|
||||
levelOneOptimize(globParts: string[][]): string[][];
|
||||
levelTwoFileOptimize(parts: string | string[]): string[];
|
||||
firstPhasePreProcess(globParts: string[][]): string[][];
|
||||
secondPhasePreProcess(globParts: string[][]): string[][];
|
||||
partsMatch(a: string[], b: string[], emptyGSMatch?: boolean): false | string[];
|
||||
parseNegate(): void;
|
||||
matchOne(file: string[], pattern: ParseReturn[], partial?: boolean): boolean;
|
||||
braceExpand(): string[];
|
||||
parse(pattern: string): ParseReturn;
|
||||
makeRe(): false | MMRegExp;
|
||||
slashSplit(p: string): string[];
|
||||
match(f: string, partial?: boolean): boolean;
|
||||
static defaults(def: MinimatchOptions): typeof Minimatch;
|
||||
}
|
||||
export { AST } from './ast.js';
|
||||
export { escape } from './escape.js';
|
||||
export { unescape } from './unescape.js';
|
||||
//# sourceMappingURL=index.d.ts.map
|
||||
@@ -0,0 +1,3 @@
|
||||
import * as z from "../v4/mini/external.js";
|
||||
export * from "../v4/mini/external.js";
|
||||
export { z };
|
||||
@@ -0,0 +1,67 @@
|
||||
'use strict'
|
||||
|
||||
const bench = require('fastbench')
|
||||
const pino = require('../../')
|
||||
|
||||
const base = pino(pino.destination('/dev/null'))
|
||||
const baseCl = pino({
|
||||
customLevels: { foo: 31 }
|
||||
}, pino.destination('/dev/null'))
|
||||
const child = base.child({})
|
||||
const childCl = base.child({
|
||||
customLevels: { foo: 31 }
|
||||
})
|
||||
const childOfBaseCl = baseCl.child({})
|
||||
|
||||
const max = 100
|
||||
|
||||
const run = bench([
|
||||
function benchPinoNoCustomLevel (cb) {
|
||||
for (var i = 0; i < max; i++) {
|
||||
base.info({ hello: 'world' })
|
||||
}
|
||||
setImmediate(cb)
|
||||
},
|
||||
function benchPinoCustomLevel (cb) {
|
||||
for (var i = 0; i < max; i++) {
|
||||
baseCl.foo({ hello: 'world' })
|
||||
}
|
||||
setImmediate(cb)
|
||||
},
|
||||
function benchChildNoCustomLevel (cb) {
|
||||
for (var i = 0; i < max; i++) {
|
||||
child.info({ hello: 'world' })
|
||||
}
|
||||
setImmediate(cb)
|
||||
},
|
||||
function benchPinoChildCustomLevel (cb) {
|
||||
for (var i = 0; i < max; i++) {
|
||||
childCl.foo({ hello: 'world' })
|
||||
}
|
||||
setImmediate(cb)
|
||||
},
|
||||
function benchPinoChildInheritedCustomLevel (cb) {
|
||||
for (var i = 0; i < max; i++) {
|
||||
childOfBaseCl.foo({ hello: 'world' })
|
||||
}
|
||||
setImmediate(cb)
|
||||
},
|
||||
function benchPinoChildCreation (cb) {
|
||||
const child = base.child({})
|
||||
for (var i = 0; i < max; i++) {
|
||||
child.info({ hello: 'world' })
|
||||
}
|
||||
setImmediate(cb)
|
||||
},
|
||||
function benchPinoChildCreationCustomLevel (cb) {
|
||||
const child = base.child({
|
||||
customLevels: { foo: 31 }
|
||||
})
|
||||
for (var i = 0; i < max; i++) {
|
||||
child.foo({ hello: 'world' })
|
||||
}
|
||||
setImmediate(cb)
|
||||
}
|
||||
], 10000)
|
||||
|
||||
run(run)
|
||||
@@ -0,0 +1,13 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.TSEnumNameDefinition = void 0;
|
||||
const DefinitionBase_1 = require("./DefinitionBase");
|
||||
const DefinitionType_1 = require("./DefinitionType");
|
||||
class TSEnumNameDefinition extends DefinitionBase_1.DefinitionBase {
|
||||
isTypeDefinition = true;
|
||||
isVariableDefinition = true;
|
||||
constructor(name, node) {
|
||||
super(DefinitionType_1.DefinitionType.TSEnumName, name, node, null);
|
||||
}
|
||||
}
|
||||
exports.TSEnumNameDefinition = TSEnumNameDefinition;
|
||||
@@ -0,0 +1,4 @@
|
||||
import * as ts from 'typescript';
|
||||
type ImportClausePhaseModifier = 'defer' | 'type' | null;
|
||||
export declare function getImportClausePhaseModifier(node: ts.ImportClause | null | undefined): ImportClausePhaseModifier;
|
||||
export {};
|
||||
@@ -0,0 +1,5 @@
|
||||
export type MessageIds = 'unsafeArgument' | 'unsafeArraySpread' | 'unsafeSpread' | 'unsafeTupleSpread';
|
||||
declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<MessageIds, [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
export default _default;
|
||||
@@ -0,0 +1,60 @@
|
||||
declare namespace list {
|
||||
type List = {
|
||||
/**
|
||||
* Safely splits comma-separated values (such as those for `transition-*`
|
||||
* and `background` properties).
|
||||
*
|
||||
* ```js
|
||||
* Once (root, { list }) {
|
||||
* list.comma('black, linear-gradient(white, black)')
|
||||
* //=> ['black', 'linear-gradient(white, black)']
|
||||
* }
|
||||
* ```
|
||||
*
|
||||
* @param str Comma-separated values.
|
||||
* @return Split values.
|
||||
*/
|
||||
comma(str: string): string[]
|
||||
|
||||
default: List
|
||||
|
||||
/**
|
||||
* Safely splits space-separated values (such as those for `background`,
|
||||
* `border-radius`, and other shorthand properties).
|
||||
*
|
||||
* ```js
|
||||
* Once (root, { list }) {
|
||||
* list.space('1px calc(10% + 1px)') //=> ['1px', 'calc(10% + 1px)']
|
||||
* }
|
||||
* ```
|
||||
*
|
||||
* @param str Space-separated values.
|
||||
* @return Split values.
|
||||
*/
|
||||
space(str: string): string[]
|
||||
|
||||
/**
|
||||
* Safely splits values.
|
||||
*
|
||||
* ```js
|
||||
* Once (root, { list }) {
|
||||
* list.split('1px calc(10% + 1px)', [' ', '\n', '\t']) //=> ['1px', 'calc(10% + 1px)']
|
||||
* }
|
||||
* ```
|
||||
*
|
||||
* @param string separated values.
|
||||
* @param separators array of separators.
|
||||
* @param last boolean indicator.
|
||||
* @return Split values.
|
||||
*/
|
||||
split(
|
||||
string: string,
|
||||
separators: readonly string[],
|
||||
last: boolean
|
||||
): string[]
|
||||
}
|
||||
}
|
||||
|
||||
declare let list: list.List
|
||||
|
||||
export = list
|
||||
@@ -0,0 +1,26 @@
|
||||
'use strict';
|
||||
|
||||
const https = require('https');
|
||||
const utils = require('../utils');
|
||||
|
||||
/**
|
||||
* Constructor for a Jayson HTTPS server
|
||||
* @class ServerHttps
|
||||
* @extends require('https').Server
|
||||
* @param {Server} server Server instance
|
||||
* @param {Object} [options] Options for this instance
|
||||
* @return {ServerHttps}
|
||||
*/
|
||||
const ServerHttps = function(server, options) {
|
||||
if(!(this instanceof ServerHttps)) {
|
||||
return new ServerHttps(server, options);
|
||||
}
|
||||
|
||||
this.options = utils.merge(server.options, options || {});
|
||||
|
||||
const listener = utils.getHttpListener(this, server);
|
||||
https.Server.call(this, this.options, listener);
|
||||
};
|
||||
require('util').inherits(ServerHttps, https.Server);
|
||||
|
||||
module.exports = ServerHttps;
|
||||
@@ -0,0 +1,7 @@
|
||||
import { EvaluatedModules } from 'vite/module-runner';
|
||||
|
||||
declare class VitestEvaluatedModules extends EvaluatedModules {
|
||||
getModuleSourceMapById(id: string): any;
|
||||
}
|
||||
|
||||
export { VitestEvaluatedModules as V };
|
||||
@@ -0,0 +1,14 @@
|
||||
export type ObjectLike<T = unknown> = Record<string, T>;
|
||||
/**
|
||||
* Check if the variable contains an object strictly rejecting arrays
|
||||
* @returns `true` if obj is an object
|
||||
*/
|
||||
export declare function isObjectNotArray(obj: unknown): obj is ObjectLike;
|
||||
/**
|
||||
* Pure function - doesn't mutate either parameter!
|
||||
* Merges two objects together deeply, overwriting the properties in first with the properties in second
|
||||
* @param first The first object
|
||||
* @param second The second object
|
||||
* @returns a new object
|
||||
*/
|
||||
export declare function deepMerge(first?: ObjectLike, second?: ObjectLike): Record<string, unknown>;
|
||||
@@ -0,0 +1,51 @@
|
||||
/*! *****************************************************************************
|
||||
Copyright (c) Microsoft Corporation. All rights reserved.
|
||||
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
|
||||
this file except in compliance with the License. You may obtain a copy of the
|
||||
License at http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
||||
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
|
||||
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
|
||||
MERCHANTABILITY OR NON-INFRINGEMENT.
|
||||
|
||||
See the Apache Version 2.0 License for specific language governing permissions
|
||||
and limitations under the License.
|
||||
***************************************************************************** */
|
||||
|
||||
|
||||
/// <reference lib="es2015.symbol" />
|
||||
/// <reference lib="es2015.iterable" />
|
||||
|
||||
interface SymbolConstructor {
|
||||
/**
|
||||
* A method that returns the default async iterator for an object. Called by the semantics of
|
||||
* the for-await-of statement.
|
||||
*/
|
||||
readonly asyncIterator: unique symbol;
|
||||
}
|
||||
|
||||
interface AsyncIterator<T, TReturn = any, TNext = any> {
|
||||
// NOTE: 'next' is defined using a tuple to ensure we report the correct assignability errors in all places.
|
||||
next(...[value]: [] | [TNext]): Promise<IteratorResult<T, TReturn>>;
|
||||
return?(value?: TReturn | PromiseLike<TReturn>): Promise<IteratorResult<T, TReturn>>;
|
||||
throw?(e?: any): Promise<IteratorResult<T, TReturn>>;
|
||||
}
|
||||
|
||||
interface AsyncIterable<T, TReturn = any, TNext = any> {
|
||||
[Symbol.asyncIterator](): AsyncIterator<T, TReturn, TNext>;
|
||||
}
|
||||
|
||||
/**
|
||||
* Describes a user-defined {@link AsyncIterator} that is also async iterable.
|
||||
*/
|
||||
interface AsyncIterableIterator<T, TReturn = any, TNext = any> extends AsyncIterator<T, TReturn, TNext> {
|
||||
[Symbol.asyncIterator](): AsyncIterableIterator<T, TReturn, TNext>;
|
||||
}
|
||||
|
||||
/**
|
||||
* Describes an {@link AsyncIterator} produced by the runtime that inherits from the intrinsic `AsyncIterator.prototype`.
|
||||
*/
|
||||
interface AsyncIteratorObject<T, TReturn = unknown, TNext = unknown> extends AsyncIterator<T, TReturn, TNext> {
|
||||
[Symbol.asyncIterator](): AsyncIteratorObject<T, TReturn, TNext>;
|
||||
}
|
||||
@@ -0,0 +1,12 @@
|
||||
'use strict'
|
||||
|
||||
const fs = require('node:fs')
|
||||
const { once } = require('node:events')
|
||||
|
||||
async function run (opts) {
|
||||
const stream = fs.createWriteStream(opts.destination)
|
||||
await once(stream, 'open')
|
||||
return stream
|
||||
}
|
||||
|
||||
module.exports = run
|
||||
@@ -0,0 +1,734 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.Class = exports.BIGINT_FORMAT_RANGES = exports.NUMBER_FORMAT_RANGES = exports.primitiveTypes = exports.propertyKeyTypes = exports.getParsedType = exports.allowsEval = exports.captureStackTrace = void 0;
|
||||
exports.assertEqual = assertEqual;
|
||||
exports.assertNotEqual = assertNotEqual;
|
||||
exports.assertIs = assertIs;
|
||||
exports.assertNever = assertNever;
|
||||
exports.assert = assert;
|
||||
exports.getEnumValues = getEnumValues;
|
||||
exports.joinValues = joinValues;
|
||||
exports.jsonStringifyReplacer = jsonStringifyReplacer;
|
||||
exports.cached = cached;
|
||||
exports.nullish = nullish;
|
||||
exports.cleanRegex = cleanRegex;
|
||||
exports.floatSafeRemainder = floatSafeRemainder;
|
||||
exports.defineLazy = defineLazy;
|
||||
exports.objectClone = objectClone;
|
||||
exports.assignProp = assignProp;
|
||||
exports.mergeDefs = mergeDefs;
|
||||
exports.cloneDef = cloneDef;
|
||||
exports.getElementAtPath = getElementAtPath;
|
||||
exports.promiseAllObject = promiseAllObject;
|
||||
exports.randomString = randomString;
|
||||
exports.esc = esc;
|
||||
exports.slugify = slugify;
|
||||
exports.isObject = isObject;
|
||||
exports.isPlainObject = isPlainObject;
|
||||
exports.shallowClone = shallowClone;
|
||||
exports.numKeys = numKeys;
|
||||
exports.escapeRegex = escapeRegex;
|
||||
exports.clone = clone;
|
||||
exports.normalizeParams = normalizeParams;
|
||||
exports.createTransparentProxy = createTransparentProxy;
|
||||
exports.stringifyPrimitive = stringifyPrimitive;
|
||||
exports.optionalKeys = optionalKeys;
|
||||
exports.pick = pick;
|
||||
exports.omit = omit;
|
||||
exports.extend = extend;
|
||||
exports.safeExtend = safeExtend;
|
||||
exports.merge = merge;
|
||||
exports.partial = partial;
|
||||
exports.required = required;
|
||||
exports.aborted = aborted;
|
||||
exports.explicitlyAborted = explicitlyAborted;
|
||||
exports.prefixIssues = prefixIssues;
|
||||
exports.unwrapMessage = unwrapMessage;
|
||||
exports.finalizeIssue = finalizeIssue;
|
||||
exports.getSizableOrigin = getSizableOrigin;
|
||||
exports.getLengthableOrigin = getLengthableOrigin;
|
||||
exports.parsedType = parsedType;
|
||||
exports.issue = issue;
|
||||
exports.cleanEnum = cleanEnum;
|
||||
exports.base64ToUint8Array = base64ToUint8Array;
|
||||
exports.uint8ArrayToBase64 = uint8ArrayToBase64;
|
||||
exports.base64urlToUint8Array = base64urlToUint8Array;
|
||||
exports.uint8ArrayToBase64url = uint8ArrayToBase64url;
|
||||
exports.hexToUint8Array = hexToUint8Array;
|
||||
exports.uint8ArrayToHex = uint8ArrayToHex;
|
||||
const core_js_1 = require("./core.cjs");
|
||||
// functions
|
||||
function assertEqual(val) {
|
||||
return val;
|
||||
}
|
||||
function assertNotEqual(val) {
|
||||
return val;
|
||||
}
|
||||
function assertIs(_arg) { }
|
||||
function assertNever(_x) {
|
||||
throw new Error("Unexpected value in exhaustive check");
|
||||
}
|
||||
function assert(_) { }
|
||||
function getEnumValues(entries) {
|
||||
const numericValues = Object.values(entries).filter((v) => typeof v === "number");
|
||||
const values = Object.entries(entries)
|
||||
.filter(([k, _]) => numericValues.indexOf(+k) === -1)
|
||||
.map(([_, v]) => v);
|
||||
return values;
|
||||
}
|
||||
function joinValues(array, separator = "|") {
|
||||
return array.map((val) => stringifyPrimitive(val)).join(separator);
|
||||
}
|
||||
function jsonStringifyReplacer(_, value) {
|
||||
if (typeof value === "bigint")
|
||||
return value.toString();
|
||||
return value;
|
||||
}
|
||||
function cached(getter) {
|
||||
const set = false;
|
||||
return {
|
||||
get value() {
|
||||
if (!set) {
|
||||
const value = getter();
|
||||
Object.defineProperty(this, "value", { value });
|
||||
return value;
|
||||
}
|
||||
throw new Error("cached value already set");
|
||||
},
|
||||
};
|
||||
}
|
||||
function nullish(input) {
|
||||
return input === null || input === undefined;
|
||||
}
|
||||
function cleanRegex(source) {
|
||||
const start = source.startsWith("^") ? 1 : 0;
|
||||
const end = source.endsWith("$") ? source.length - 1 : source.length;
|
||||
return source.slice(start, end);
|
||||
}
|
||||
function floatSafeRemainder(val, step) {
|
||||
const ratio = val / step;
|
||||
const roundedRatio = Math.round(ratio);
|
||||
// Use a relative epsilon scaled to the magnitude of the result
|
||||
const tolerance = Number.EPSILON * Math.max(Math.abs(ratio), 1);
|
||||
if (Math.abs(ratio - roundedRatio) < tolerance)
|
||||
return 0;
|
||||
return ratio - roundedRatio;
|
||||
}
|
||||
const EVALUATING = /* @__PURE__*/ Symbol("evaluating");
|
||||
function defineLazy(object, key, getter) {
|
||||
let value = undefined;
|
||||
Object.defineProperty(object, key, {
|
||||
get() {
|
||||
if (value === EVALUATING) {
|
||||
// Circular reference detected, return undefined to break the cycle
|
||||
return undefined;
|
||||
}
|
||||
if (value === undefined) {
|
||||
value = EVALUATING;
|
||||
value = getter();
|
||||
}
|
||||
return value;
|
||||
},
|
||||
set(v) {
|
||||
Object.defineProperty(object, key, {
|
||||
value: v,
|
||||
// configurable: true,
|
||||
});
|
||||
// object[key] = v;
|
||||
},
|
||||
configurable: true,
|
||||
});
|
||||
}
|
||||
function objectClone(obj) {
|
||||
return Object.create(Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj));
|
||||
}
|
||||
function assignProp(target, prop, value) {
|
||||
Object.defineProperty(target, prop, {
|
||||
value,
|
||||
writable: true,
|
||||
enumerable: true,
|
||||
configurable: true,
|
||||
});
|
||||
}
|
||||
function mergeDefs(...defs) {
|
||||
const mergedDescriptors = {};
|
||||
for (const def of defs) {
|
||||
const descriptors = Object.getOwnPropertyDescriptors(def);
|
||||
Object.assign(mergedDescriptors, descriptors);
|
||||
}
|
||||
return Object.defineProperties({}, mergedDescriptors);
|
||||
}
|
||||
function cloneDef(schema) {
|
||||
return mergeDefs(schema._zod.def);
|
||||
}
|
||||
function getElementAtPath(obj, path) {
|
||||
if (!path)
|
||||
return obj;
|
||||
return path.reduce((acc, key) => acc?.[key], obj);
|
||||
}
|
||||
function promiseAllObject(promisesObj) {
|
||||
const keys = Object.keys(promisesObj);
|
||||
const promises = keys.map((key) => promisesObj[key]);
|
||||
return Promise.all(promises).then((results) => {
|
||||
const resolvedObj = {};
|
||||
for (let i = 0; i < keys.length; i++) {
|
||||
resolvedObj[keys[i]] = results[i];
|
||||
}
|
||||
return resolvedObj;
|
||||
});
|
||||
}
|
||||
function randomString(length = 10) {
|
||||
const chars = "abcdefghijklmnopqrstuvwxyz";
|
||||
let str = "";
|
||||
for (let i = 0; i < length; i++) {
|
||||
str += chars[Math.floor(Math.random() * chars.length)];
|
||||
}
|
||||
return str;
|
||||
}
|
||||
function esc(str) {
|
||||
return JSON.stringify(str);
|
||||
}
|
||||
function slugify(input) {
|
||||
return input
|
||||
.toLowerCase()
|
||||
.trim()
|
||||
.replace(/[^\w\s-]/g, "")
|
||||
.replace(/[\s_-]+/g, "-")
|
||||
.replace(/^-+|-+$/g, "");
|
||||
}
|
||||
exports.captureStackTrace = ("captureStackTrace" in Error ? Error.captureStackTrace : (..._args) => { });
|
||||
function isObject(data) {
|
||||
return typeof data === "object" && data !== null && !Array.isArray(data);
|
||||
}
|
||||
exports.allowsEval = cached(() => {
|
||||
// Skip the probe under `jitless`: strict CSPs report the caught `new Function`
|
||||
// as a `securitypolicyviolation` even though the throw is swallowed.
|
||||
if (core_js_1.globalConfig.jitless) {
|
||||
return false;
|
||||
}
|
||||
// @ts-ignore
|
||||
if (typeof navigator !== "undefined" && navigator?.userAgent?.includes("Cloudflare")) {
|
||||
return false;
|
||||
}
|
||||
try {
|
||||
const F = Function;
|
||||
new F("");
|
||||
return true;
|
||||
}
|
||||
catch (_) {
|
||||
return false;
|
||||
}
|
||||
});
|
||||
function isPlainObject(o) {
|
||||
if (isObject(o) === false)
|
||||
return false;
|
||||
// modified constructor
|
||||
const ctor = o.constructor;
|
||||
if (ctor === undefined)
|
||||
return true;
|
||||
if (typeof ctor !== "function")
|
||||
return true;
|
||||
// modified prototype
|
||||
const prot = ctor.prototype;
|
||||
if (isObject(prot) === false)
|
||||
return false;
|
||||
// ctor doesn't have static `isPrototypeOf`
|
||||
if (Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf") === false) {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
function shallowClone(o) {
|
||||
if (isPlainObject(o))
|
||||
return { ...o };
|
||||
if (Array.isArray(o))
|
||||
return [...o];
|
||||
if (o instanceof Map)
|
||||
return new Map(o);
|
||||
if (o instanceof Set)
|
||||
return new Set(o);
|
||||
return o;
|
||||
}
|
||||
function numKeys(data) {
|
||||
let keyCount = 0;
|
||||
for (const key in data) {
|
||||
if (Object.prototype.hasOwnProperty.call(data, key)) {
|
||||
keyCount++;
|
||||
}
|
||||
}
|
||||
return keyCount;
|
||||
}
|
||||
const getParsedType = (data) => {
|
||||
const t = typeof data;
|
||||
switch (t) {
|
||||
case "undefined":
|
||||
return "undefined";
|
||||
case "string":
|
||||
return "string";
|
||||
case "number":
|
||||
return Number.isNaN(data) ? "nan" : "number";
|
||||
case "boolean":
|
||||
return "boolean";
|
||||
case "function":
|
||||
return "function";
|
||||
case "bigint":
|
||||
return "bigint";
|
||||
case "symbol":
|
||||
return "symbol";
|
||||
case "object":
|
||||
if (Array.isArray(data)) {
|
||||
return "array";
|
||||
}
|
||||
if (data === null) {
|
||||
return "null";
|
||||
}
|
||||
if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") {
|
||||
return "promise";
|
||||
}
|
||||
if (typeof Map !== "undefined" && data instanceof Map) {
|
||||
return "map";
|
||||
}
|
||||
if (typeof Set !== "undefined" && data instanceof Set) {
|
||||
return "set";
|
||||
}
|
||||
if (typeof Date !== "undefined" && data instanceof Date) {
|
||||
return "date";
|
||||
}
|
||||
// @ts-ignore
|
||||
if (typeof File !== "undefined" && data instanceof File) {
|
||||
return "file";
|
||||
}
|
||||
return "object";
|
||||
default:
|
||||
throw new Error(`Unknown data type: ${t}`);
|
||||
}
|
||||
};
|
||||
exports.getParsedType = getParsedType;
|
||||
exports.propertyKeyTypes = new Set(["string", "number", "symbol"]);
|
||||
exports.primitiveTypes = new Set([
|
||||
"string",
|
||||
"number",
|
||||
"bigint",
|
||||
"boolean",
|
||||
"symbol",
|
||||
"undefined",
|
||||
]);
|
||||
function escapeRegex(str) {
|
||||
return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
|
||||
}
|
||||
// zod-specific utils
|
||||
function clone(inst, def, params) {
|
||||
const cl = new inst._zod.constr(def ?? inst._zod.def);
|
||||
if (!def || params?.parent)
|
||||
cl._zod.parent = inst;
|
||||
return cl;
|
||||
}
|
||||
function normalizeParams(_params) {
|
||||
const params = _params;
|
||||
if (!params)
|
||||
return {};
|
||||
if (typeof params === "string")
|
||||
return { error: () => params };
|
||||
if (params?.message !== undefined) {
|
||||
if (params?.error !== undefined)
|
||||
throw new Error("Cannot specify both `message` and `error` params");
|
||||
params.error = params.message;
|
||||
}
|
||||
delete params.message;
|
||||
if (typeof params.error === "string")
|
||||
return { ...params, error: () => params.error };
|
||||
return params;
|
||||
}
|
||||
function createTransparentProxy(getter) {
|
||||
let target;
|
||||
return new Proxy({}, {
|
||||
get(_, prop, receiver) {
|
||||
target ?? (target = getter());
|
||||
return Reflect.get(target, prop, receiver);
|
||||
},
|
||||
set(_, prop, value, receiver) {
|
||||
target ?? (target = getter());
|
||||
return Reflect.set(target, prop, value, receiver);
|
||||
},
|
||||
has(_, prop) {
|
||||
target ?? (target = getter());
|
||||
return Reflect.has(target, prop);
|
||||
},
|
||||
deleteProperty(_, prop) {
|
||||
target ?? (target = getter());
|
||||
return Reflect.deleteProperty(target, prop);
|
||||
},
|
||||
ownKeys(_) {
|
||||
target ?? (target = getter());
|
||||
return Reflect.ownKeys(target);
|
||||
},
|
||||
getOwnPropertyDescriptor(_, prop) {
|
||||
target ?? (target = getter());
|
||||
return Reflect.getOwnPropertyDescriptor(target, prop);
|
||||
},
|
||||
defineProperty(_, prop, descriptor) {
|
||||
target ?? (target = getter());
|
||||
return Reflect.defineProperty(target, prop, descriptor);
|
||||
},
|
||||
});
|
||||
}
|
||||
function stringifyPrimitive(value) {
|
||||
if (typeof value === "bigint")
|
||||
return value.toString() + "n";
|
||||
if (typeof value === "string")
|
||||
return `"${value}"`;
|
||||
return `${value}`;
|
||||
}
|
||||
function optionalKeys(shape) {
|
||||
return Object.keys(shape).filter((k) => {
|
||||
return shape[k]._zod.optin === "optional" && shape[k]._zod.optout === "optional";
|
||||
});
|
||||
}
|
||||
exports.NUMBER_FORMAT_RANGES = {
|
||||
safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
|
||||
int32: [-2147483648, 2147483647],
|
||||
uint32: [0, 4294967295],
|
||||
float32: [-3.4028234663852886e38, 3.4028234663852886e38],
|
||||
float64: [-Number.MAX_VALUE, Number.MAX_VALUE],
|
||||
};
|
||||
exports.BIGINT_FORMAT_RANGES = {
|
||||
int64: [/* @__PURE__*/ BigInt("-9223372036854775808"), /* @__PURE__*/ BigInt("9223372036854775807")],
|
||||
uint64: [/* @__PURE__*/ BigInt(0), /* @__PURE__*/ BigInt("18446744073709551615")],
|
||||
};
|
||||
function pick(schema, mask) {
|
||||
const currDef = schema._zod.def;
|
||||
const checks = currDef.checks;
|
||||
const hasChecks = checks && checks.length > 0;
|
||||
if (hasChecks) {
|
||||
throw new Error(".pick() cannot be used on object schemas containing refinements");
|
||||
}
|
||||
const def = mergeDefs(schema._zod.def, {
|
||||
get shape() {
|
||||
const newShape = {};
|
||||
for (const key in mask) {
|
||||
if (!(key in currDef.shape)) {
|
||||
throw new Error(`Unrecognized key: "${key}"`);
|
||||
}
|
||||
if (!mask[key])
|
||||
continue;
|
||||
newShape[key] = currDef.shape[key];
|
||||
}
|
||||
assignProp(this, "shape", newShape); // self-caching
|
||||
return newShape;
|
||||
},
|
||||
checks: [],
|
||||
});
|
||||
return clone(schema, def);
|
||||
}
|
||||
function omit(schema, mask) {
|
||||
const currDef = schema._zod.def;
|
||||
const checks = currDef.checks;
|
||||
const hasChecks = checks && checks.length > 0;
|
||||
if (hasChecks) {
|
||||
throw new Error(".omit() cannot be used on object schemas containing refinements");
|
||||
}
|
||||
const def = mergeDefs(schema._zod.def, {
|
||||
get shape() {
|
||||
const newShape = { ...schema._zod.def.shape };
|
||||
for (const key in mask) {
|
||||
if (!(key in currDef.shape)) {
|
||||
throw new Error(`Unrecognized key: "${key}"`);
|
||||
}
|
||||
if (!mask[key])
|
||||
continue;
|
||||
delete newShape[key];
|
||||
}
|
||||
assignProp(this, "shape", newShape); // self-caching
|
||||
return newShape;
|
||||
},
|
||||
checks: [],
|
||||
});
|
||||
return clone(schema, def);
|
||||
}
|
||||
function extend(schema, shape) {
|
||||
if (!isPlainObject(shape)) {
|
||||
throw new Error("Invalid input to extend: expected a plain object");
|
||||
}
|
||||
const checks = schema._zod.def.checks;
|
||||
const hasChecks = checks && checks.length > 0;
|
||||
if (hasChecks) {
|
||||
// Only throw if new shape overlaps with existing shape
|
||||
// Use getOwnPropertyDescriptor to check key existence without accessing values
|
||||
const existingShape = schema._zod.def.shape;
|
||||
for (const key in shape) {
|
||||
if (Object.getOwnPropertyDescriptor(existingShape, key) !== undefined) {
|
||||
throw new Error("Cannot overwrite keys on object schemas containing refinements. Use `.safeExtend()` instead.");
|
||||
}
|
||||
}
|
||||
}
|
||||
const def = mergeDefs(schema._zod.def, {
|
||||
get shape() {
|
||||
const _shape = { ...schema._zod.def.shape, ...shape };
|
||||
assignProp(this, "shape", _shape); // self-caching
|
||||
return _shape;
|
||||
},
|
||||
});
|
||||
return clone(schema, def);
|
||||
}
|
||||
function safeExtend(schema, shape) {
|
||||
if (!isPlainObject(shape)) {
|
||||
throw new Error("Invalid input to safeExtend: expected a plain object");
|
||||
}
|
||||
const def = mergeDefs(schema._zod.def, {
|
||||
get shape() {
|
||||
const _shape = { ...schema._zod.def.shape, ...shape };
|
||||
assignProp(this, "shape", _shape); // self-caching
|
||||
return _shape;
|
||||
},
|
||||
});
|
||||
return clone(schema, def);
|
||||
}
|
||||
function merge(a, b) {
|
||||
if (a._zod.def.checks?.length) {
|
||||
throw new Error(".merge() cannot be used on object schemas containing refinements. Use .safeExtend() instead.");
|
||||
}
|
||||
const def = mergeDefs(a._zod.def, {
|
||||
get shape() {
|
||||
const _shape = { ...a._zod.def.shape, ...b._zod.def.shape };
|
||||
assignProp(this, "shape", _shape); // self-caching
|
||||
return _shape;
|
||||
},
|
||||
get catchall() {
|
||||
return b._zod.def.catchall;
|
||||
},
|
||||
checks: b._zod.def.checks ?? [],
|
||||
});
|
||||
return clone(a, def);
|
||||
}
|
||||
function partial(Class, schema, mask) {
|
||||
const currDef = schema._zod.def;
|
||||
const checks = currDef.checks;
|
||||
const hasChecks = checks && checks.length > 0;
|
||||
if (hasChecks) {
|
||||
throw new Error(".partial() cannot be used on object schemas containing refinements");
|
||||
}
|
||||
const def = mergeDefs(schema._zod.def, {
|
||||
get shape() {
|
||||
const oldShape = schema._zod.def.shape;
|
||||
const shape = { ...oldShape };
|
||||
if (mask) {
|
||||
for (const key in mask) {
|
||||
if (!(key in oldShape)) {
|
||||
throw new Error(`Unrecognized key: "${key}"`);
|
||||
}
|
||||
if (!mask[key])
|
||||
continue;
|
||||
// if (oldShape[key]!._zod.optin === "optional") continue;
|
||||
shape[key] = Class
|
||||
? new Class({
|
||||
type: "optional",
|
||||
innerType: oldShape[key],
|
||||
})
|
||||
: oldShape[key];
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (const key in oldShape) {
|
||||
// if (oldShape[key]!._zod.optin === "optional") continue;
|
||||
shape[key] = Class
|
||||
? new Class({
|
||||
type: "optional",
|
||||
innerType: oldShape[key],
|
||||
})
|
||||
: oldShape[key];
|
||||
}
|
||||
}
|
||||
assignProp(this, "shape", shape); // self-caching
|
||||
return shape;
|
||||
},
|
||||
checks: [],
|
||||
});
|
||||
return clone(schema, def);
|
||||
}
|
||||
function required(Class, schema, mask) {
|
||||
const def = mergeDefs(schema._zod.def, {
|
||||
get shape() {
|
||||
const oldShape = schema._zod.def.shape;
|
||||
const shape = { ...oldShape };
|
||||
if (mask) {
|
||||
for (const key in mask) {
|
||||
if (!(key in shape)) {
|
||||
throw new Error(`Unrecognized key: "${key}"`);
|
||||
}
|
||||
if (!mask[key])
|
||||
continue;
|
||||
// overwrite with non-optional
|
||||
shape[key] = new Class({
|
||||
type: "nonoptional",
|
||||
innerType: oldShape[key],
|
||||
});
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (const key in oldShape) {
|
||||
// overwrite with non-optional
|
||||
shape[key] = new Class({
|
||||
type: "nonoptional",
|
||||
innerType: oldShape[key],
|
||||
});
|
||||
}
|
||||
}
|
||||
assignProp(this, "shape", shape); // self-caching
|
||||
return shape;
|
||||
},
|
||||
});
|
||||
return clone(schema, def);
|
||||
}
|
||||
// invalid_type | too_big | too_small | invalid_format | not_multiple_of | unrecognized_keys | invalid_union | invalid_key | invalid_element | invalid_value | custom
|
||||
function aborted(x, startIndex = 0) {
|
||||
if (x.aborted === true)
|
||||
return true;
|
||||
for (let i = startIndex; i < x.issues.length; i++) {
|
||||
if (x.issues[i]?.continue !== true) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
// Checks for explicit abort (continue === false), as opposed to implicit abort (continue === undefined).
|
||||
// Used to respect `abort: true` in .refine() even for checks that have a `when` function.
|
||||
function explicitlyAborted(x, startIndex = 0) {
|
||||
if (x.aborted === true)
|
||||
return true;
|
||||
for (let i = startIndex; i < x.issues.length; i++) {
|
||||
if (x.issues[i]?.continue === false) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
function prefixIssues(path, issues) {
|
||||
return issues.map((iss) => {
|
||||
var _a;
|
||||
(_a = iss).path ?? (_a.path = []);
|
||||
iss.path.unshift(path);
|
||||
return iss;
|
||||
});
|
||||
}
|
||||
function unwrapMessage(message) {
|
||||
return typeof message === "string" ? message : message?.message;
|
||||
}
|
||||
function finalizeIssue(iss, ctx, config) {
|
||||
const message = iss.message
|
||||
? iss.message
|
||||
: (unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ??
|
||||
unwrapMessage(ctx?.error?.(iss)) ??
|
||||
unwrapMessage(config.customError?.(iss)) ??
|
||||
unwrapMessage(config.localeError?.(iss)) ??
|
||||
"Invalid input");
|
||||
const { inst: _inst, continue: _continue, input: _input, ...rest } = iss;
|
||||
rest.path ?? (rest.path = []);
|
||||
rest.message = message;
|
||||
if (ctx?.reportInput) {
|
||||
rest.input = _input;
|
||||
}
|
||||
return rest;
|
||||
}
|
||||
function getSizableOrigin(input) {
|
||||
if (input instanceof Set)
|
||||
return "set";
|
||||
if (input instanceof Map)
|
||||
return "map";
|
||||
// @ts-ignore
|
||||
if (input instanceof File)
|
||||
return "file";
|
||||
return "unknown";
|
||||
}
|
||||
function getLengthableOrigin(input) {
|
||||
if (Array.isArray(input))
|
||||
return "array";
|
||||
if (typeof input === "string")
|
||||
return "string";
|
||||
return "unknown";
|
||||
}
|
||||
function parsedType(data) {
|
||||
const t = typeof data;
|
||||
switch (t) {
|
||||
case "number": {
|
||||
return Number.isNaN(data) ? "nan" : "number";
|
||||
}
|
||||
case "object": {
|
||||
if (data === null) {
|
||||
return "null";
|
||||
}
|
||||
if (Array.isArray(data)) {
|
||||
return "array";
|
||||
}
|
||||
const obj = data;
|
||||
if (obj && Object.getPrototypeOf(obj) !== Object.prototype && "constructor" in obj && obj.constructor) {
|
||||
return obj.constructor.name;
|
||||
}
|
||||
}
|
||||
}
|
||||
return t;
|
||||
}
|
||||
function issue(...args) {
|
||||
const [iss, input, inst] = args;
|
||||
if (typeof iss === "string") {
|
||||
return {
|
||||
message: iss,
|
||||
code: "custom",
|
||||
input,
|
||||
inst,
|
||||
};
|
||||
}
|
||||
return { ...iss };
|
||||
}
|
||||
function cleanEnum(obj) {
|
||||
return Object.entries(obj)
|
||||
.filter(([k, _]) => {
|
||||
// return true if NaN, meaning it's not a number, thus a string key
|
||||
return Number.isNaN(Number.parseInt(k, 10));
|
||||
})
|
||||
.map((el) => el[1]);
|
||||
}
|
||||
// Codec utility functions
|
||||
function base64ToUint8Array(base64) {
|
||||
const binaryString = atob(base64);
|
||||
const bytes = new Uint8Array(binaryString.length);
|
||||
for (let i = 0; i < binaryString.length; i++) {
|
||||
bytes[i] = binaryString.charCodeAt(i);
|
||||
}
|
||||
return bytes;
|
||||
}
|
||||
function uint8ArrayToBase64(bytes) {
|
||||
let binaryString = "";
|
||||
for (let i = 0; i < bytes.length; i++) {
|
||||
binaryString += String.fromCharCode(bytes[i]);
|
||||
}
|
||||
return btoa(binaryString);
|
||||
}
|
||||
function base64urlToUint8Array(base64url) {
|
||||
const base64 = base64url.replace(/-/g, "+").replace(/_/g, "/");
|
||||
const padding = "=".repeat((4 - (base64.length % 4)) % 4);
|
||||
return base64ToUint8Array(base64 + padding);
|
||||
}
|
||||
function uint8ArrayToBase64url(bytes) {
|
||||
return uint8ArrayToBase64(bytes).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
|
||||
}
|
||||
function hexToUint8Array(hex) {
|
||||
const cleanHex = hex.replace(/^0x/, "");
|
||||
if (cleanHex.length % 2 !== 0) {
|
||||
throw new Error("Invalid hex string length");
|
||||
}
|
||||
const bytes = new Uint8Array(cleanHex.length / 2);
|
||||
for (let i = 0; i < cleanHex.length; i += 2) {
|
||||
bytes[i / 2] = Number.parseInt(cleanHex.slice(i, i + 2), 16);
|
||||
}
|
||||
return bytes;
|
||||
}
|
||||
function uint8ArrayToHex(bytes) {
|
||||
return Array.from(bytes)
|
||||
.map((b) => b.toString(16).padStart(2, "0"))
|
||||
.join("");
|
||||
}
|
||||
// instanceof
|
||||
class Class {
|
||||
constructor(..._args) { }
|
||||
}
|
||||
exports.Class = Class;
|
||||
@@ -0,0 +1,26 @@
|
||||
"use strict";
|
||||
// THIS CODE WAS AUTOMATICALLY GENERATED
|
||||
// DO NOT EDIT THIS CODE BY HAND
|
||||
// RUN THE FOLLOWING COMMAND FROM THE WORKSPACE ROOT TO REGENERATE:
|
||||
// npx nx generate-lib repo
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.es2025 = void 0;
|
||||
const es2024_1 = require("./es2024");
|
||||
const es2025_collection_1 = require("./es2025.collection");
|
||||
const es2025_float16_1 = require("./es2025.float16");
|
||||
const es2025_intl_1 = require("./es2025.intl");
|
||||
const es2025_iterator_1 = require("./es2025.iterator");
|
||||
const es2025_promise_1 = require("./es2025.promise");
|
||||
const es2025_regexp_1 = require("./es2025.regexp");
|
||||
exports.es2025 = {
|
||||
libs: [
|
||||
es2024_1.es2024,
|
||||
es2025_collection_1.es2025_collection,
|
||||
es2025_float16_1.es2025_float16,
|
||||
es2025_intl_1.es2025_intl,
|
||||
es2025_iterator_1.es2025_iterator,
|
||||
es2025_promise_1.es2025_promise,
|
||||
es2025_regexp_1.es2025_regexp,
|
||||
],
|
||||
variables: [],
|
||||
};
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,16 @@
|
||||
var test = require('tape');
|
||||
var equal = require('../');
|
||||
|
||||
test('NaN and 0 values', function (t) {
|
||||
t.ok(equal(NaN, NaN));
|
||||
t.notOk(equal(0, NaN));
|
||||
t.ok(equal(0, 0));
|
||||
t.notOk(equal(0, 1));
|
||||
t.end();
|
||||
});
|
||||
|
||||
|
||||
test('nested NaN values', function (t) {
|
||||
t.ok(equal([ NaN, 1, NaN ], [ NaN, 1, NaN ]));
|
||||
t.end();
|
||||
});
|
||||
@@ -0,0 +1,34 @@
|
||||
'use strict';
|
||||
|
||||
var parse = require('../');
|
||||
var test = require('tape');
|
||||
|
||||
test('flag boolean true (default all --args to boolean)', function (t) {
|
||||
var argv = parse(['moo', '--honk', 'cow'], {
|
||||
boolean: true,
|
||||
});
|
||||
|
||||
t.deepEqual(argv, {
|
||||
honk: true,
|
||||
_: ['moo', 'cow'],
|
||||
});
|
||||
|
||||
t.deepEqual(typeof argv.honk, 'boolean');
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('flag boolean true only affects double hyphen arguments without equals signs', function (t) {
|
||||
var argv = parse(['moo', '--honk', 'cow', '-p', '55', '--tacos=good'], {
|
||||
boolean: true,
|
||||
});
|
||||
|
||||
t.deepEqual(argv, {
|
||||
honk: true,
|
||||
tacos: 'good',
|
||||
p: 55,
|
||||
_: ['moo', 'cow'],
|
||||
});
|
||||
|
||||
t.deepEqual(typeof argv.honk, 'boolean');
|
||||
t.end();
|
||||
});
|
||||
@@ -0,0 +1 @@
|
||||
var i=Object.defineProperty;var a=(t,r)=>i(t,"name",{value:r,configurable:!0});import s from"node:repl";import{transform as f}from"esbuild";const p=a(t=>{const{eval:r}=t,n=a(async function(e,c,o,l){try{e=(await f(e,{sourcefile:o,loader:"ts",tsconfigRaw:{compilerOptions:{preserveValueImports:!0}},define:{require:"global.require"}})).code}catch{}return r.call(this,e,c,o,l)},"preEval");t.eval=n},"patchEval"),{start:u}=s;s.start=function(){const t=Reflect.apply(u,this,arguments);return p(t),t};
|
||||
@@ -0,0 +1,32 @@
|
||||
var test = require('tape');
|
||||
var stringify = require('../');
|
||||
|
||||
test('simple object', function (t) {
|
||||
t.plan(1);
|
||||
var obj = { c: 6, b: [4,5], a: 3, z: null };
|
||||
t.equal(stringify(obj), '{"a":3,"b":[4,5],"c":6,"z":null}');
|
||||
});
|
||||
|
||||
test('object with undefined', function (t) {
|
||||
t.plan(1);
|
||||
var obj = { a: 3, z: undefined };
|
||||
t.equal(stringify(obj), '{"a":3}');
|
||||
});
|
||||
|
||||
test('array with undefined', function (t) {
|
||||
t.plan(1);
|
||||
var obj = [4, undefined, 6];
|
||||
t.equal(stringify(obj), '[4,null,6]');
|
||||
});
|
||||
|
||||
test('object with empty string', function (t) {
|
||||
t.plan(1);
|
||||
var obj = { a: 3, z: '' };
|
||||
t.equal(stringify(obj), '{"a":3,"z":""}');
|
||||
});
|
||||
|
||||
test('array with empty string', function (t) {
|
||||
t.plan(1);
|
||||
var obj = [4, '', 6];
|
||||
t.equal(stringify(obj), '[4,"",6]');
|
||||
});
|
||||
@@ -0,0 +1,136 @@
|
||||
"use strict";
|
||||
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
|
||||
if (k2 === undefined) k2 = k;
|
||||
var desc = Object.getOwnPropertyDescriptor(m, k);
|
||||
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
|
||||
desc = { enumerable: true, get: function() { return m[k]; } };
|
||||
}
|
||||
Object.defineProperty(o, k2, desc);
|
||||
}) : (function(o, m, k, k2) {
|
||||
if (k2 === undefined) k2 = k;
|
||||
o[k2] = m[k];
|
||||
}));
|
||||
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
|
||||
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
||||
}) : function(o, v) {
|
||||
o["default"] = v;
|
||||
});
|
||||
var __importStar = (this && this.__importStar) || function (mod) {
|
||||
if (mod && mod.__esModule) return mod;
|
||||
var result = {};
|
||||
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
|
||||
__setModuleDefault(result, mod);
|
||||
return result;
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.default = default_1;
|
||||
const util = __importStar(require("../core/util.cjs"));
|
||||
const error = () => {
|
||||
const Sizable = {
|
||||
string: { unit: "znakov", verb: "imeti" },
|
||||
file: { unit: "bajtov", verb: "imeti" },
|
||||
array: { unit: "elementov", verb: "imeti" },
|
||||
set: { unit: "elementov", verb: "imeti" },
|
||||
};
|
||||
function getSizing(origin) {
|
||||
return Sizable[origin] ?? null;
|
||||
}
|
||||
const FormatDictionary = {
|
||||
regex: "vnos",
|
||||
email: "e-poštni naslov",
|
||||
url: "URL",
|
||||
emoji: "emoji",
|
||||
uuid: "UUID",
|
||||
uuidv4: "UUIDv4",
|
||||
uuidv6: "UUIDv6",
|
||||
nanoid: "nanoid",
|
||||
guid: "GUID",
|
||||
cuid: "cuid",
|
||||
cuid2: "cuid2",
|
||||
ulid: "ULID",
|
||||
xid: "XID",
|
||||
ksuid: "KSUID",
|
||||
datetime: "ISO datum in čas",
|
||||
date: "ISO datum",
|
||||
time: "ISO čas",
|
||||
duration: "ISO trajanje",
|
||||
ipv4: "IPv4 naslov",
|
||||
ipv6: "IPv6 naslov",
|
||||
cidrv4: "obseg IPv4",
|
||||
cidrv6: "obseg IPv6",
|
||||
base64: "base64 kodiran niz",
|
||||
base64url: "base64url kodiran niz",
|
||||
json_string: "JSON niz",
|
||||
e164: "E.164 številka",
|
||||
jwt: "JWT",
|
||||
template_literal: "vnos",
|
||||
};
|
||||
const TypeDictionary = {
|
||||
nan: "NaN",
|
||||
number: "število",
|
||||
array: "tabela",
|
||||
};
|
||||
return (issue) => {
|
||||
switch (issue.code) {
|
||||
case "invalid_type": {
|
||||
const expected = TypeDictionary[issue.expected] ?? issue.expected;
|
||||
const receivedType = util.parsedType(issue.input);
|
||||
const received = TypeDictionary[receivedType] ?? receivedType;
|
||||
if (/^[A-Z]/.test(issue.expected)) {
|
||||
return `Neveljaven vnos: pričakovano instanceof ${issue.expected}, prejeto ${received}`;
|
||||
}
|
||||
return `Neveljaven vnos: pričakovano ${expected}, prejeto ${received}`;
|
||||
}
|
||||
case "invalid_value":
|
||||
if (issue.values.length === 1)
|
||||
return `Neveljaven vnos: pričakovano ${util.stringifyPrimitive(issue.values[0])}`;
|
||||
return `Neveljavna možnost: pričakovano eno izmed ${util.joinValues(issue.values, "|")}`;
|
||||
case "too_big": {
|
||||
const adj = issue.inclusive ? "<=" : "<";
|
||||
const sizing = getSizing(issue.origin);
|
||||
if (sizing)
|
||||
return `Preveliko: pričakovano, da bo ${issue.origin ?? "vrednost"} imelo ${adj}${issue.maximum.toString()} ${sizing.unit ?? "elementov"}`;
|
||||
return `Preveliko: pričakovano, da bo ${issue.origin ?? "vrednost"} ${adj}${issue.maximum.toString()}`;
|
||||
}
|
||||
case "too_small": {
|
||||
const adj = issue.inclusive ? ">=" : ">";
|
||||
const sizing = getSizing(issue.origin);
|
||||
if (sizing) {
|
||||
return `Premajhno: pričakovano, da bo ${issue.origin} imelo ${adj}${issue.minimum.toString()} ${sizing.unit}`;
|
||||
}
|
||||
return `Premajhno: pričakovano, da bo ${issue.origin} ${adj}${issue.minimum.toString()}`;
|
||||
}
|
||||
case "invalid_format": {
|
||||
const _issue = issue;
|
||||
if (_issue.format === "starts_with") {
|
||||
return `Neveljaven niz: mora se začeti z "${_issue.prefix}"`;
|
||||
}
|
||||
if (_issue.format === "ends_with")
|
||||
return `Neveljaven niz: mora se končati z "${_issue.suffix}"`;
|
||||
if (_issue.format === "includes")
|
||||
return `Neveljaven niz: mora vsebovati "${_issue.includes}"`;
|
||||
if (_issue.format === "regex")
|
||||
return `Neveljaven niz: mora ustrezati vzorcu ${_issue.pattern}`;
|
||||
return `Neveljaven ${FormatDictionary[_issue.format] ?? issue.format}`;
|
||||
}
|
||||
case "not_multiple_of":
|
||||
return `Neveljavno število: mora biti večkratnik ${issue.divisor}`;
|
||||
case "unrecognized_keys":
|
||||
return `Neprepoznan${issue.keys.length > 1 ? "i ključi" : " ključ"}: ${util.joinValues(issue.keys, ", ")}`;
|
||||
case "invalid_key":
|
||||
return `Neveljaven ključ v ${issue.origin}`;
|
||||
case "invalid_union":
|
||||
return "Neveljaven vnos";
|
||||
case "invalid_element":
|
||||
return `Neveljavna vrednost v ${issue.origin}`;
|
||||
default:
|
||||
return "Neveljaven vnos";
|
||||
}
|
||||
};
|
||||
};
|
||||
function default_1() {
|
||||
return {
|
||||
localeError: error(),
|
||||
};
|
||||
}
|
||||
module.exports = exports.default;
|
||||
@@ -0,0 +1,391 @@
|
||||
import net = require('net');
|
||||
import tls = require('tls');
|
||||
import https = require('https');
|
||||
import http = require('http');
|
||||
import events = require('events');
|
||||
import Stream = require('stream');
|
||||
import WebSocket = require('isomorphic-ws');
|
||||
import * as connect from 'connect';
|
||||
|
||||
type ConstructorOf<Proto, CtorArgs extends any[]> = {
|
||||
(...args: CtorArgs): Proto;
|
||||
new(...args: CtorArgs): Proto;
|
||||
prototype: Proto;
|
||||
}
|
||||
|
||||
export interface UtilsJSONParseOptions {
|
||||
reviver?: Function;
|
||||
}
|
||||
|
||||
export interface UtilsJSONStringifyOptions {
|
||||
replacer?: Function;
|
||||
}
|
||||
|
||||
export interface GenerateRequestOptions {
|
||||
version?: number;
|
||||
notificationIdNull?: boolean;
|
||||
generator?: IDGenerator;
|
||||
}
|
||||
|
||||
export declare class Utils {
|
||||
|
||||
static request(method: string, params: RequestParamsLike, options?: GenerateRequestOptions): JSONRPCRequest;
|
||||
static request(method: string, params: RequestParamsLike, id?: JSONRPCIDLike | null | undefined, options?: GenerateRequestOptions): JSONRPCRequest;
|
||||
|
||||
static response(error: JSONRPCError | undefined | null, result: JSONRPCResultLike | undefined | null, id: JSONRPCIDLike | null | undefined, version?: number): JSONRPCVersionTwoResponse;
|
||||
static response(error: JSONRPCError | undefined | null, result: JSONRPCResultLike | undefined | null, id: JSONRPCIDLike | null | undefined, version:2): JSONRPCVersionTwoResponse;
|
||||
static response(error: JSONRPCError | undefined | null, result: JSONRPCResultLike | undefined | null, id: JSONRPCIDLike | null | undefined, version:1): JSONRPCVersionOneResponse;
|
||||
|
||||
static generateId(): string;
|
||||
|
||||
static merge(...objs: object[]): object;
|
||||
|
||||
static parseStream(stream:Stream, options:UtilsJSONParseOptions, onRequest: (err?:Error, data?:any) => void): void;
|
||||
|
||||
static parseBody(stream:Stream, options:UtilsJSONParseOptions, callback: (err?:Error, obj?:any) => void): void;
|
||||
|
||||
static getHttpListener(self:http.Server, server:Server): Function;
|
||||
|
||||
static isContentType(request:http.IncomingMessage, typ:string): boolean;
|
||||
|
||||
static isMethod(request:http.IncomingMessage, method:string): boolean;
|
||||
|
||||
static walk(obj:object, key:string, fn: (key:string, value:any) => any): object;
|
||||
|
||||
static once<T extends (...args: any[]) => any>(fn: T): T;
|
||||
|
||||
static isPlainObject(obj: any): boolean;
|
||||
|
||||
static toArray(obj: any): Array<any>;
|
||||
|
||||
static toPlainObject(obj: any): object;
|
||||
|
||||
static pick(obj: object, keys: string[]): object;
|
||||
|
||||
static JSON: UtilsJSON;
|
||||
|
||||
static Request: UtilsRequest;
|
||||
|
||||
static Response: UtilsResponse;
|
||||
|
||||
}
|
||||
|
||||
// lowercase Utils
|
||||
export declare class utils extends Utils {
|
||||
}
|
||||
|
||||
type UtilsJSON = {
|
||||
parse(str:string, options:UtilsJSONParseOptions | null | undefined, callback: (err?:Error, obj?:object) => void):void;
|
||||
stringify(obj:object, options:UtilsJSONStringifyOptions | null | undefined, callback: (err?:Error, str?:string) => void):void;
|
||||
}
|
||||
|
||||
type UtilsRequest = {
|
||||
isBatch(request:any): boolean;
|
||||
isNotification(request:any): boolean;
|
||||
isValidVersionTwoRequest(request:any): boolean;
|
||||
isValidVersionOneRequest(request:any): boolean;
|
||||
isValidRequest(request:any, version?:number): boolean;
|
||||
}
|
||||
|
||||
type UtilsResponse = {
|
||||
isValidError(error:any, version?:number): boolean;
|
||||
isValidResponse(response:any, version?:number): boolean;
|
||||
}
|
||||
|
||||
export type RequestParamsLike = Array<any> | object | undefined;
|
||||
|
||||
export interface JSONRPCError {
|
||||
code: number;
|
||||
message: string;
|
||||
data?: object;
|
||||
}
|
||||
|
||||
export type JSONRPCErrorLike = Error | JSONRPCError;
|
||||
|
||||
export interface JSONRPCVersionOneRequest {
|
||||
method: string;
|
||||
params: Array<any>;
|
||||
id: JSONRPCIDLike;
|
||||
}
|
||||
|
||||
export interface JSONRPCVersionTwoRequest {
|
||||
jsonrpc: string;
|
||||
method: string;
|
||||
params: RequestParamsLike;
|
||||
id?: JSONRPCIDLike | null;
|
||||
}
|
||||
|
||||
export interface JSONRPCVersionOneResponseWithResult {
|
||||
result: any;
|
||||
error: null;
|
||||
id: any;
|
||||
}
|
||||
|
||||
export interface JSONRPCVersionOneResponseWithError {
|
||||
result: null;
|
||||
error: object;
|
||||
id: any;
|
||||
}
|
||||
|
||||
export type JSONRPCVersionOneResponse = JSONRPCVersionOneResponseWithError | JSONRPCVersionOneResponseWithResult;
|
||||
|
||||
export interface JSONRPCVersionTwoResponseWithResult {
|
||||
jsonrpc: string;
|
||||
result: any;
|
||||
id: JSONRPCIDLike | null;
|
||||
}
|
||||
|
||||
export interface JSONRPCVersionTwoResponseWithError {
|
||||
jsonrpc: string;
|
||||
error: JSONRPCError;
|
||||
id: JSONRPCIDLike | null;
|
||||
}
|
||||
|
||||
export type JSONRPCVersionTwoResponse = JSONRPCVersionTwoResponseWithResult | JSONRPCVersionTwoResponseWithError;
|
||||
|
||||
export type JSONRPCResponseWithError = JSONRPCVersionOneResponseWithError | JSONRPCVersionTwoResponseWithError;
|
||||
export type JSONRPCResponseWithResult = JSONRPCVersionOneResponseWithResult | JSONRPCVersionTwoResponseWithResult;
|
||||
export type JSONRPCResponse = JSONRPCVersionOneResponse | JSONRPCVersionTwoResponse;
|
||||
|
||||
export type JSONRPCIDLike = number | string;
|
||||
|
||||
export type JSONRPCRequest = JSONRPCVersionOneRequest | JSONRPCVersionTwoRequest;
|
||||
|
||||
export type JSONRPCRequestLike = JSONRPCRequest | string;
|
||||
|
||||
export type JSONRPCResultLike = any;
|
||||
|
||||
export interface JSONRPCCallbackTypePlain {
|
||||
(err?: JSONRPCErrorLike | null, result?: JSONRPCResultLike): void
|
||||
}
|
||||
|
||||
export interface JSONRPCCallbackTypeSugared {
|
||||
(err?: Error | null, error?: JSONRPCErrorLike, result?: JSONRPCResultLike): void
|
||||
}
|
||||
|
||||
type JSONRPCCallbackType = JSONRPCCallbackTypePlain | JSONRPCCallbackTypeSugared;
|
||||
|
||||
export interface JSONRPCCallbackTypeBatchPlain {
|
||||
(err: JSONRPCErrorLike, results?: Array<JSONRPCResultLike>): void
|
||||
}
|
||||
|
||||
export interface JSONRPCCallbackTypeBatchSugared {
|
||||
(err: Error, errors?: Array<JSONRPCErrorLike>, results?: Array<JSONRPCResultLike>): void
|
||||
}
|
||||
|
||||
type JSONRPCCallbackTypeBatch = JSONRPCCallbackTypeBatchPlain | JSONRPCCallbackTypeBatchSugared;
|
||||
|
||||
export interface MethodHandler {
|
||||
(this:Server, args:RequestParamsLike, callback:JSONRPCCallbackTypePlain): Promise<JSONRPCResultLike> | void;
|
||||
}
|
||||
|
||||
export interface MethodHandlerContext {
|
||||
(this:Server, args:RequestParamsLike, context:object, callback:JSONRPCCallbackTypePlain): Promise<JSONRPCResultLike> | void;
|
||||
}
|
||||
|
||||
export type MethodHandlerType = MethodHandlerContext | MethodHandler;
|
||||
|
||||
export type MethodOptionsParamsLike = Array<any> | Object | object;
|
||||
|
||||
export interface MethodOptions {
|
||||
handler?: MethodHandlerType;
|
||||
useContext?: boolean;
|
||||
params?: MethodOptionsParamsLike;
|
||||
}
|
||||
|
||||
export type MethodExecuteCallbackType = {
|
||||
(err?: Error | null, result?: JSONRPCResultLike): void
|
||||
}
|
||||
|
||||
type MethodConstructor= ConstructorOf<Method, [options: MethodOptions] | [handler?: MethodHandlerType, options?: MethodOptions]>;
|
||||
|
||||
export interface Method {
|
||||
getHandler(): MethodHandlerType;
|
||||
setHandler(handler: MethodHandlerType): void;
|
||||
execute(server: Server, requestParams: RequestParamsLike, callback: MethodExecuteCallbackType): any | Promise<any>;
|
||||
execute(server: Server, requestParams: RequestParamsLike, context:object, callback: MethodExecuteCallbackType): any | Promise<any>;
|
||||
}
|
||||
|
||||
export declare const Method: MethodConstructor;
|
||||
|
||||
// lowercase Method
|
||||
export type method = Method;
|
||||
export declare const method: MethodConstructor;
|
||||
|
||||
export type MethodLike = Function | Method | Client;
|
||||
|
||||
export type ServerRouterFunction = (this: Server, method: string, params: RequestParamsLike) => MethodLike;
|
||||
|
||||
export interface ServerOptions {
|
||||
useContext?: boolean;
|
||||
params?: MethodOptionsParamsLike;
|
||||
version?: number;
|
||||
reviver?: JSONParseReviver;
|
||||
replacer?: JSONStringifyReplacer;
|
||||
encoding?: string;
|
||||
router?: ServerRouterFunction;
|
||||
methodConstructor?: Function;
|
||||
maxBatchLength?: number;
|
||||
}
|
||||
|
||||
export type ServerCallCallbackType = {
|
||||
(err?: JSONRPCResponseWithError | null, result?: JSONRPCResponseWithResult): void
|
||||
}
|
||||
|
||||
export interface MethodMap { [methodName:string]: Method }
|
||||
|
||||
type ServerConstructor = ConstructorOf<Server, [methods?: { [methodName: string]: MethodLike }, options?: ServerOptions]> & {
|
||||
errors: {[errorName: string]: number};
|
||||
errorMessages: {[errorMessage: string]: string};
|
||||
interfaces: {[interfaces: string]: Function};
|
||||
}
|
||||
|
||||
export interface Server extends events.EventEmitter {
|
||||
_methods: MethodMap;
|
||||
options: ServerOptions;
|
||||
errorMessages: {[errorMessage: string]: string};
|
||||
|
||||
http(options?: HttpServerOptions): HttpServer;
|
||||
https(options?: HttpsServerOptions): HttpsServer;
|
||||
tcp(options?: TcpServerOptions): TcpServer;
|
||||
tls(options?: TlsServerOptions): TlsServer;
|
||||
websocket(options?: WebsocketServerOptions): WebsocketServer;
|
||||
middleware(options?: MiddlewareServerOptions): connect.HandleFunction;
|
||||
|
||||
method(name: string, definition: MethodLike): void;
|
||||
methods(methods: {[methodName: string]: MethodLike}): void;
|
||||
hasMethod(name: string): boolean;
|
||||
removeMethod(name: string): void;
|
||||
getMethod(name: string): MethodLike;
|
||||
error(code?: number, message?: string, data?: object): JSONRPCError;
|
||||
call(request: JSONRPCRequestLike | Array<JSONRPCRequestLike>, originalCallback?: ServerCallCallbackType): void;
|
||||
call(request: JSONRPCRequestLike | Array<JSONRPCRequestLike>, context: object, originalCallback?: ServerCallCallbackType): void;
|
||||
callp(request: JSONRPCRequestLike | Array<JSONRPCRequestLike>, context?: object): Promise<JSONRPCResultLike>;
|
||||
}
|
||||
|
||||
export declare const Server: ServerConstructor;
|
||||
|
||||
// lowercase Server
|
||||
export type server = Server;
|
||||
export declare const server: ServerConstructor;
|
||||
|
||||
export interface MiddlewareServerOptions extends ServerOptions {
|
||||
end?: boolean;
|
||||
}
|
||||
|
||||
export interface HttpServerOptions extends ServerOptions {
|
||||
}
|
||||
|
||||
declare class HttpServer extends http.Server {
|
||||
constructor(server: Server, options?: HttpServerOptions);
|
||||
}
|
||||
|
||||
export interface HttpsServerOptions extends ServerOptions, https.ServerOptions {
|
||||
}
|
||||
|
||||
declare class HttpsServer extends https.Server {
|
||||
constructor(server: Server, options?: HttpsServerOptions);
|
||||
}
|
||||
|
||||
export interface TcpServerOptions extends ServerOptions {
|
||||
}
|
||||
|
||||
declare class TcpServer extends net.Server {
|
||||
constructor(server: Server, options?: TcpServerOptions);
|
||||
}
|
||||
|
||||
export interface TlsServerOptions extends tls.TlsOptions {
|
||||
}
|
||||
|
||||
declare class TlsServer extends tls.Server {
|
||||
constructor(server: Server, options?: TlsServerOptions);
|
||||
}
|
||||
|
||||
export interface WebsocketServerOptions extends ServerOptions, WebSocket.ServerOptions {
|
||||
wss?: WebSocket.Server;
|
||||
}
|
||||
|
||||
declare class WebsocketServer {
|
||||
constructor(server: Server, options?: WebsocketServerOptions);
|
||||
}
|
||||
|
||||
type JSONParseReviver = (key: string, value: any) => any;
|
||||
type JSONStringifyReplacer = (key: string, value: any) => any;
|
||||
|
||||
type IDGenerator = () => JSONRPCIDLike;
|
||||
|
||||
export interface ClientOptions {
|
||||
version?: number;
|
||||
reviver?: JSONParseReviver;
|
||||
replacer?: JSONStringifyReplacer;
|
||||
generator?: IDGenerator;
|
||||
notificationIdNull?: boolean;
|
||||
}
|
||||
|
||||
export interface HttpClientOptions extends ClientOptions, http.RequestOptions {
|
||||
}
|
||||
|
||||
declare class HttpClient extends Client {
|
||||
constructor(options?: HttpClientOptions);
|
||||
}
|
||||
|
||||
export interface TlsClientOptions extends ClientOptions, tls.ConnectionOptions {
|
||||
}
|
||||
|
||||
declare class TlsClient extends Client {
|
||||
constructor(options?: TlsClientOptions);
|
||||
}
|
||||
|
||||
export interface TcpClientOptions extends ClientOptions, net.TcpSocketConnectOpts {
|
||||
}
|
||||
|
||||
declare class TcpClient extends Client {
|
||||
constructor(options?: TcpClientOptions);
|
||||
}
|
||||
|
||||
export interface HttpsClientOptions extends ClientOptions, https.RequestOptions {
|
||||
}
|
||||
|
||||
declare class HttpsClient extends Client {
|
||||
constructor(options?: HttpsClientOptions);
|
||||
}
|
||||
|
||||
export interface WebsocketClientOptions extends ClientOptions {
|
||||
url?: string;
|
||||
ws?: WebSocket;
|
||||
timeout?: number;
|
||||
}
|
||||
|
||||
declare class WebsocketClient extends Client {
|
||||
constructor(options?: WebsocketClientOptions);
|
||||
}
|
||||
|
||||
export type BrowserClientCallServerFunction = (request: string) => Promise<string>;
|
||||
|
||||
declare class BrowserClient {
|
||||
constructor(callServer: BrowserClientCallServerFunction, options?: ClientOptions);
|
||||
request(method: string, params: RequestParamsLike, id: JSONRPCIDLike | undefined, shouldCall: false): JSONRPCRequest;
|
||||
request(method: string, params: RequestParamsLike, id?: JSONRPCIDLike): Promise<JSONRPCResultLike>;
|
||||
request(method: Array<JSONRPCRequestLike>): Promise<JSONRPCResultLike>;
|
||||
}
|
||||
|
||||
type ClientConstructor = ConstructorOf<Client, [options: ClientOptions] | [server: Server, options?: ClientOptions]> & {
|
||||
http(options?: HttpClientOptions): HttpClient;
|
||||
https(options?: HttpsClientOptions): HttpsClient;
|
||||
tcp(options?: TcpClientOptions): TcpClient;
|
||||
tls(options?: TlsClientOptions): TlsClient;
|
||||
websocket(options?: WebsocketClientOptions): WebsocketClient;
|
||||
browser(callServer: BrowserClientCallServerFunction, options?: ClientOptions): BrowserClient;
|
||||
}
|
||||
|
||||
export interface Client extends events.EventEmitter {
|
||||
request(method:string, params:RequestParamsLike, id:JSONRPCIDLike | undefined, shouldCall:false): JSONRPCRequest;
|
||||
request(method:string, params:RequestParamsLike, id?:JSONRPCIDLike): Promise<JSONRPCResultLike>;
|
||||
request(method: Array<JSONRPCRequestLike>): Promise<JSONRPCResultLike>;
|
||||
}
|
||||
|
||||
export declare const Client: ClientConstructor;
|
||||
|
||||
// lowercase Client
|
||||
export type client = Client;
|
||||
export declare const client: ClientConstructor;
|
||||
@@ -0,0 +1,462 @@
|
||||
declare module "node:buffer" {
|
||||
global {
|
||||
interface BufferConstructor {
|
||||
// see ../buffer.d.ts for implementation shared with all TypeScript versions
|
||||
|
||||
/**
|
||||
* Allocates a new buffer containing the given {str}.
|
||||
*
|
||||
* @param str String to store in buffer.
|
||||
* @param encoding encoding to use, optional. Default is 'utf8'
|
||||
* @deprecated since v10.0.0 - Use `Buffer.from(string[, encoding])` instead.
|
||||
*/
|
||||
new(str: string, encoding?: BufferEncoding): Buffer;
|
||||
/**
|
||||
* Allocates a new buffer of {size} octets.
|
||||
*
|
||||
* @param size count of octets to allocate.
|
||||
* @deprecated since v10.0.0 - Use `Buffer.alloc()` instead (also see `Buffer.allocUnsafe()`).
|
||||
*/
|
||||
new(size: number): Buffer;
|
||||
/**
|
||||
* Allocates a new buffer containing the given {array} of octets.
|
||||
*
|
||||
* @param array The octets to store.
|
||||
* @deprecated since v10.0.0 - Use `Buffer.from(array)` instead.
|
||||
*/
|
||||
new(array: ArrayLike<number>): Buffer;
|
||||
/**
|
||||
* Produces a Buffer backed by the same allocated memory as
|
||||
* the given {ArrayBuffer}/{SharedArrayBuffer}.
|
||||
*
|
||||
* @param arrayBuffer The ArrayBuffer with which to share memory.
|
||||
* @deprecated since v10.0.0 - Use `Buffer.from(arrayBuffer[, byteOffset[, length]])` instead.
|
||||
*/
|
||||
new(arrayBuffer: ArrayBufferLike): Buffer;
|
||||
/**
|
||||
* Allocates a new `Buffer` using an `array` of bytes in the range `0` – `255`.
|
||||
* Array entries outside that range will be truncated to fit into it.
|
||||
*
|
||||
* ```js
|
||||
* import { Buffer } from 'node:buffer';
|
||||
*
|
||||
* // Creates a new Buffer containing the UTF-8 bytes of the string 'buffer'.
|
||||
* const buf = Buffer.from([0x62, 0x75, 0x66, 0x66, 0x65, 0x72]);
|
||||
* ```
|
||||
*
|
||||
* If `array` is an `Array`-like object (that is, one with a `length` property of
|
||||
* type `number`), it is treated as if it is an array, unless it is a `Buffer` or
|
||||
* a `Uint8Array`. This means all other `TypedArray` variants get treated as an
|
||||
* `Array`. To create a `Buffer` from the bytes backing a `TypedArray`, use
|
||||
* `Buffer.copyBytesFrom()`.
|
||||
*
|
||||
* A `TypeError` will be thrown if `array` is not an `Array` or another type
|
||||
* appropriate for `Buffer.from()` variants.
|
||||
*
|
||||
* `Buffer.from(array)` and `Buffer.from(string)` may also use the internal
|
||||
* `Buffer` pool like `Buffer.allocUnsafe()` does.
|
||||
* @since v5.10.0
|
||||
*/
|
||||
from(array: WithImplicitCoercion<ArrayLike<number>>): Buffer;
|
||||
/**
|
||||
* This creates a view of the `ArrayBuffer` without copying the underlying
|
||||
* memory. For example, when passed a reference to the `.buffer` property of a
|
||||
* `TypedArray` instance, the newly created `Buffer` will share the same
|
||||
* allocated memory as the `TypedArray`'s underlying `ArrayBuffer`.
|
||||
*
|
||||
* ```js
|
||||
* import { Buffer } from 'node:buffer';
|
||||
*
|
||||
* const arr = new Uint16Array(2);
|
||||
*
|
||||
* arr[0] = 5000;
|
||||
* arr[1] = 4000;
|
||||
*
|
||||
* // Shares memory with `arr`.
|
||||
* const buf = Buffer.from(arr.buffer);
|
||||
*
|
||||
* console.log(buf);
|
||||
* // Prints: <Buffer 88 13 a0 0f>
|
||||
*
|
||||
* // Changing the original Uint16Array changes the Buffer also.
|
||||
* arr[1] = 6000;
|
||||
*
|
||||
* console.log(buf);
|
||||
* // Prints: <Buffer 88 13 70 17>
|
||||
* ```
|
||||
*
|
||||
* The optional `byteOffset` and `length` arguments specify a memory range within
|
||||
* the `arrayBuffer` that will be shared by the `Buffer`.
|
||||
*
|
||||
* ```js
|
||||
* import { Buffer } from 'node:buffer';
|
||||
*
|
||||
* const ab = new ArrayBuffer(10);
|
||||
* const buf = Buffer.from(ab, 0, 2);
|
||||
*
|
||||
* console.log(buf.length);
|
||||
* // Prints: 2
|
||||
* ```
|
||||
*
|
||||
* A `TypeError` will be thrown if `arrayBuffer` is not an `ArrayBuffer` or a
|
||||
* `SharedArrayBuffer` or another type appropriate for `Buffer.from()`
|
||||
* variants.
|
||||
*
|
||||
* It is important to remember that a backing `ArrayBuffer` can cover a range
|
||||
* of memory that extends beyond the bounds of a `TypedArray` view. A new
|
||||
* `Buffer` created using the `buffer` property of a `TypedArray` may extend
|
||||
* beyond the range of the `TypedArray`:
|
||||
*
|
||||
* ```js
|
||||
* import { Buffer } from 'node:buffer';
|
||||
*
|
||||
* const arrA = Uint8Array.from([0x63, 0x64, 0x65, 0x66]); // 4 elements
|
||||
* const arrB = new Uint8Array(arrA.buffer, 1, 2); // 2 elements
|
||||
* console.log(arrA.buffer === arrB.buffer); // true
|
||||
*
|
||||
* const buf = Buffer.from(arrB.buffer);
|
||||
* console.log(buf);
|
||||
* // Prints: <Buffer 63 64 65 66>
|
||||
* ```
|
||||
* @since v5.10.0
|
||||
* @param arrayBuffer An `ArrayBuffer`, `SharedArrayBuffer`, for example the
|
||||
* `.buffer` property of a `TypedArray`.
|
||||
* @param byteOffset Index of first byte to expose. **Default:** `0`.
|
||||
* @param length Number of bytes to expose. **Default:**
|
||||
* `arrayBuffer.byteLength - byteOffset`.
|
||||
*/
|
||||
from(
|
||||
arrayBuffer: WithImplicitCoercion<ArrayBufferLike>,
|
||||
byteOffset?: number,
|
||||
length?: number,
|
||||
): Buffer;
|
||||
/**
|
||||
* Creates a new `Buffer` containing `string`. The `encoding` parameter identifies
|
||||
* the character encoding to be used when converting `string` into bytes.
|
||||
*
|
||||
* ```js
|
||||
* import { Buffer } from 'node:buffer';
|
||||
*
|
||||
* const buf1 = Buffer.from('this is a tést');
|
||||
* const buf2 = Buffer.from('7468697320697320612074c3a97374', 'hex');
|
||||
*
|
||||
* console.log(buf1.toString());
|
||||
* // Prints: this is a tést
|
||||
* console.log(buf2.toString());
|
||||
* // Prints: this is a tést
|
||||
* console.log(buf1.toString('latin1'));
|
||||
* // Prints: this is a tést
|
||||
* ```
|
||||
*
|
||||
* A `TypeError` will be thrown if `string` is not a string or another type
|
||||
* appropriate for `Buffer.from()` variants.
|
||||
*
|
||||
* `Buffer.from(string)` may also use the internal `Buffer` pool like
|
||||
* `Buffer.allocUnsafe()` does.
|
||||
* @since v5.10.0
|
||||
* @param string A string to encode.
|
||||
* @param encoding The encoding of `string`. **Default:** `'utf8'`.
|
||||
*/
|
||||
from(string: WithImplicitCoercion<string>, encoding?: BufferEncoding): Buffer;
|
||||
from(arrayOrString: WithImplicitCoercion<ArrayLike<number> | string>): Buffer;
|
||||
/**
|
||||
* Creates a new Buffer using the passed {data}
|
||||
* @param values to create a new Buffer
|
||||
*/
|
||||
of(...items: number[]): Buffer;
|
||||
/**
|
||||
* Returns a new `Buffer` which is the result of concatenating all the `Buffer` instances in the `list` together.
|
||||
*
|
||||
* If the list has no items, or if the `totalLength` is 0, then a new zero-length `Buffer` is returned.
|
||||
*
|
||||
* If `totalLength` is not provided, it is calculated from the `Buffer` instances
|
||||
* in `list` by adding their lengths.
|
||||
*
|
||||
* If `totalLength` is provided, it must be an unsigned integer. If the
|
||||
* combined length of the `Buffer`s in `list` exceeds `totalLength`, the result is
|
||||
* truncated to `totalLength`.
|
||||
*
|
||||
* ```js
|
||||
* import { Buffer } from 'node:buffer';
|
||||
*
|
||||
* // Create a single `Buffer` from a list of three `Buffer` instances.
|
||||
*
|
||||
* const buf1 = Buffer.alloc(10);
|
||||
* const buf2 = Buffer.alloc(14);
|
||||
* const buf3 = Buffer.alloc(18);
|
||||
* const totalLength = buf1.length + buf2.length + buf3.length;
|
||||
*
|
||||
* console.log(totalLength);
|
||||
* // Prints: 42
|
||||
*
|
||||
* const bufA = Buffer.concat([buf1, buf2, buf3], totalLength);
|
||||
*
|
||||
* console.log(bufA);
|
||||
* // Prints: <Buffer 00 00 00 00 ...>
|
||||
* console.log(bufA.length);
|
||||
* // Prints: 42
|
||||
* ```
|
||||
*
|
||||
* `Buffer.concat()` may also use the internal `Buffer` pool like `Buffer.allocUnsafe()` does.
|
||||
* @since v0.7.11
|
||||
* @param list List of `Buffer` or {@link Uint8Array} instances to concatenate.
|
||||
* @param totalLength Total length of the `Buffer` instances in `list` when concatenated.
|
||||
*/
|
||||
concat(list: readonly Uint8Array[], totalLength?: number): Buffer;
|
||||
/**
|
||||
* Copies the underlying memory of `view` into a new `Buffer`.
|
||||
*
|
||||
* ```js
|
||||
* const u16 = new Uint16Array([0, 0xffff]);
|
||||
* const buf = Buffer.copyBytesFrom(u16, 1, 1);
|
||||
* u16[1] = 0;
|
||||
* console.log(buf.length); // 2
|
||||
* console.log(buf[0]); // 255
|
||||
* console.log(buf[1]); // 255
|
||||
* ```
|
||||
* @since v19.8.0
|
||||
* @param view The {TypedArray} to copy.
|
||||
* @param [offset=0] The starting offset within `view`.
|
||||
* @param [length=view.length - offset] The number of elements from `view` to copy.
|
||||
*/
|
||||
copyBytesFrom(view: NodeJS.TypedArray, offset?: number, length?: number): Buffer;
|
||||
/**
|
||||
* Allocates a new `Buffer` of `size` bytes. If `fill` is `undefined`, the`Buffer` will be zero-filled.
|
||||
*
|
||||
* ```js
|
||||
* import { Buffer } from 'node:buffer';
|
||||
*
|
||||
* const buf = Buffer.alloc(5);
|
||||
*
|
||||
* console.log(buf);
|
||||
* // Prints: <Buffer 00 00 00 00 00>
|
||||
* ```
|
||||
*
|
||||
* If `size` is larger than {@link constants.MAX_LENGTH} or smaller than 0, `ERR_OUT_OF_RANGE` is thrown.
|
||||
*
|
||||
* If `fill` is specified, the allocated `Buffer` will be initialized by calling `buf.fill(fill)`.
|
||||
*
|
||||
* ```js
|
||||
* import { Buffer } from 'node:buffer';
|
||||
*
|
||||
* const buf = Buffer.alloc(5, 'a');
|
||||
*
|
||||
* console.log(buf);
|
||||
* // Prints: <Buffer 61 61 61 61 61>
|
||||
* ```
|
||||
*
|
||||
* If both `fill` and `encoding` are specified, the allocated `Buffer` will be
|
||||
* initialized by calling `buf.fill(fill, encoding)`.
|
||||
*
|
||||
* ```js
|
||||
* import { Buffer } from 'node:buffer';
|
||||
*
|
||||
* const buf = Buffer.alloc(11, 'aGVsbG8gd29ybGQ=', 'base64');
|
||||
*
|
||||
* console.log(buf);
|
||||
* // Prints: <Buffer 68 65 6c 6c 6f 20 77 6f 72 6c 64>
|
||||
* ```
|
||||
*
|
||||
* Calling `Buffer.alloc()` can be measurably slower than the alternative `Buffer.allocUnsafe()` but ensures that the newly created `Buffer` instance
|
||||
* contents will never contain sensitive data from previous allocations, including
|
||||
* data that might not have been allocated for `Buffer`s.
|
||||
*
|
||||
* A `TypeError` will be thrown if `size` is not a number.
|
||||
* @since v5.10.0
|
||||
* @param size The desired length of the new `Buffer`.
|
||||
* @param [fill=0] A value to pre-fill the new `Buffer` with.
|
||||
* @param [encoding='utf8'] If `fill` is a string, this is its encoding.
|
||||
*/
|
||||
alloc(size: number, fill?: string | Uint8Array | number, encoding?: BufferEncoding): Buffer;
|
||||
/**
|
||||
* Allocates a new `Buffer` of `size` bytes. If `size` is larger than {@link constants.MAX_LENGTH} or smaller than 0, `ERR_OUT_OF_RANGE` is thrown.
|
||||
*
|
||||
* The underlying memory for `Buffer` instances created in this way is _not_
|
||||
* _initialized_. The contents of the newly created `Buffer` are unknown and _may contain sensitive data_. Use `Buffer.alloc()` instead to initialize`Buffer` instances with zeroes.
|
||||
*
|
||||
* ```js
|
||||
* import { Buffer } from 'node:buffer';
|
||||
*
|
||||
* const buf = Buffer.allocUnsafe(10);
|
||||
*
|
||||
* console.log(buf);
|
||||
* // Prints (contents may vary): <Buffer a0 8b 28 3f 01 00 00 00 50 32>
|
||||
*
|
||||
* buf.fill(0);
|
||||
*
|
||||
* console.log(buf);
|
||||
* // Prints: <Buffer 00 00 00 00 00 00 00 00 00 00>
|
||||
* ```
|
||||
*
|
||||
* A `TypeError` will be thrown if `size` is not a number.
|
||||
*
|
||||
* The `Buffer` module pre-allocates an internal `Buffer` instance of
|
||||
* size `Buffer.poolSize` that is used as a pool for the fast allocation of new `Buffer` instances created using `Buffer.allocUnsafe()`, `Buffer.from(array)`,
|
||||
* and `Buffer.concat()` only when `size` is less than `Buffer.poolSize >>> 1` (floor of `Buffer.poolSize` divided by two).
|
||||
*
|
||||
* Use of this pre-allocated internal memory pool is a key difference between
|
||||
* calling `Buffer.alloc(size, fill)` vs. `Buffer.allocUnsafe(size).fill(fill)`.
|
||||
* Specifically, `Buffer.alloc(size, fill)` will _never_ use the internal `Buffer`pool, while `Buffer.allocUnsafe(size).fill(fill)`_will_ use the internal`Buffer` pool if `size` is less
|
||||
* than or equal to half `Buffer.poolSize`. The
|
||||
* difference is subtle but can be important when an application requires the
|
||||
* additional performance that `Buffer.allocUnsafe()` provides.
|
||||
* @since v5.10.0
|
||||
* @param size The desired length of the new `Buffer`.
|
||||
*/
|
||||
allocUnsafe(size: number): Buffer;
|
||||
/**
|
||||
* Allocates a new `Buffer` of `size` bytes. If `size` is larger than {@link constants.MAX_LENGTH} or smaller than 0, `ERR_OUT_OF_RANGE` is thrown. A zero-length `Buffer` is created if
|
||||
* `size` is 0.
|
||||
*
|
||||
* The underlying memory for `Buffer` instances created in this way is _not_
|
||||
* _initialized_. The contents of the newly created `Buffer` are unknown and _may contain sensitive data_. Use `buf.fill(0)` to initialize
|
||||
* such `Buffer` instances with zeroes.
|
||||
*
|
||||
* When using `Buffer.allocUnsafe()` to allocate new `Buffer` instances,
|
||||
* allocations under 4 KiB are sliced from a single pre-allocated `Buffer`. This
|
||||
* allows applications to avoid the garbage collection overhead of creating many
|
||||
* individually allocated `Buffer` instances. This approach improves both
|
||||
* performance and memory usage by eliminating the need to track and clean up as
|
||||
* many individual `ArrayBuffer` objects.
|
||||
*
|
||||
* However, in the case where a developer may need to retain a small chunk of
|
||||
* memory from a pool for an indeterminate amount of time, it may be appropriate
|
||||
* to create an un-pooled `Buffer` instance using `Buffer.allocUnsafeSlow()` and
|
||||
* then copying out the relevant bits.
|
||||
*
|
||||
* ```js
|
||||
* import { Buffer } from 'node:buffer';
|
||||
*
|
||||
* // Need to keep around a few small chunks of memory.
|
||||
* const store = [];
|
||||
*
|
||||
* socket.on('readable', () => {
|
||||
* let data;
|
||||
* while (null !== (data = readable.read())) {
|
||||
* // Allocate for retained data.
|
||||
* const sb = Buffer.allocUnsafeSlow(10);
|
||||
*
|
||||
* // Copy the data into the new allocation.
|
||||
* data.copy(sb, 0, 0, 10);
|
||||
*
|
||||
* store.push(sb);
|
||||
* }
|
||||
* });
|
||||
* ```
|
||||
*
|
||||
* A `TypeError` will be thrown if `size` is not a number.
|
||||
* @since v5.12.0
|
||||
* @param size The desired length of the new `Buffer`.
|
||||
*/
|
||||
allocUnsafeSlow(size: number): Buffer;
|
||||
}
|
||||
interface Buffer extends Uint8Array {
|
||||
// see ../buffer.d.ts for implementation shared with all TypeScript versions
|
||||
|
||||
/**
|
||||
* Returns a new `Buffer` that references the same memory as the original, but
|
||||
* offset and cropped by the `start` and `end` indices.
|
||||
*
|
||||
* This method is not compatible with the `Uint8Array.prototype.slice()`,
|
||||
* which is a superclass of `Buffer`. To copy the slice, use`Uint8Array.prototype.slice()`.
|
||||
*
|
||||
* ```js
|
||||
* import { Buffer } from 'node:buffer';
|
||||
*
|
||||
* const buf = Buffer.from('buffer');
|
||||
*
|
||||
* const copiedBuf = Uint8Array.prototype.slice.call(buf);
|
||||
* copiedBuf[0]++;
|
||||
* console.log(copiedBuf.toString());
|
||||
* // Prints: cuffer
|
||||
*
|
||||
* console.log(buf.toString());
|
||||
* // Prints: buffer
|
||||
*
|
||||
* // With buf.slice(), the original buffer is modified.
|
||||
* const notReallyCopiedBuf = buf.slice();
|
||||
* notReallyCopiedBuf[0]++;
|
||||
* console.log(notReallyCopiedBuf.toString());
|
||||
* // Prints: cuffer
|
||||
* console.log(buf.toString());
|
||||
* // Also prints: cuffer (!)
|
||||
* ```
|
||||
* @since v0.3.0
|
||||
* @deprecated Use `subarray` instead.
|
||||
* @param [start=0] Where the new `Buffer` will start.
|
||||
* @param [end=buf.length] Where the new `Buffer` will end (not inclusive).
|
||||
*/
|
||||
slice(start?: number, end?: number): Buffer;
|
||||
/**
|
||||
* Returns a new `Buffer` that references the same memory as the original, but
|
||||
* offset and cropped by the `start` and `end` indices.
|
||||
*
|
||||
* Specifying `end` greater than `buf.length` will return the same result as
|
||||
* that of `end` equal to `buf.length`.
|
||||
*
|
||||
* This method is inherited from [`TypedArray.prototype.subarray()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/subarray).
|
||||
*
|
||||
* Modifying the new `Buffer` slice will modify the memory in the original `Buffer`because the allocated memory of the two objects overlap.
|
||||
*
|
||||
* ```js
|
||||
* import { Buffer } from 'node:buffer';
|
||||
*
|
||||
* // Create a `Buffer` with the ASCII alphabet, take a slice, and modify one byte
|
||||
* // from the original `Buffer`.
|
||||
*
|
||||
* const buf1 = Buffer.allocUnsafe(26);
|
||||
*
|
||||
* for (let i = 0; i < 26; i++) {
|
||||
* // 97 is the decimal ASCII value for 'a'.
|
||||
* buf1[i] = i + 97;
|
||||
* }
|
||||
*
|
||||
* const buf2 = buf1.subarray(0, 3);
|
||||
*
|
||||
* console.log(buf2.toString('ascii', 0, buf2.length));
|
||||
* // Prints: abc
|
||||
*
|
||||
* buf1[0] = 33;
|
||||
*
|
||||
* console.log(buf2.toString('ascii', 0, buf2.length));
|
||||
* // Prints: !bc
|
||||
* ```
|
||||
*
|
||||
* Specifying negative indexes causes the slice to be generated relative to the
|
||||
* end of `buf` rather than the beginning.
|
||||
*
|
||||
* ```js
|
||||
* import { Buffer } from 'node:buffer';
|
||||
*
|
||||
* const buf = Buffer.from('buffer');
|
||||
*
|
||||
* console.log(buf.subarray(-6, -1).toString());
|
||||
* // Prints: buffe
|
||||
* // (Equivalent to buf.subarray(0, 5).)
|
||||
*
|
||||
* console.log(buf.subarray(-6, -2).toString());
|
||||
* // Prints: buff
|
||||
* // (Equivalent to buf.subarray(0, 4).)
|
||||
*
|
||||
* console.log(buf.subarray(-5, -2).toString());
|
||||
* // Prints: uff
|
||||
* // (Equivalent to buf.subarray(1, 4).)
|
||||
* ```
|
||||
* @since v3.0.0
|
||||
* @param [start=0] Where the new `Buffer` will start.
|
||||
* @param [end=buf.length] Where the new `Buffer` will end (not inclusive).
|
||||
*/
|
||||
subarray(start?: number, end?: number): Buffer;
|
||||
}
|
||||
/**
|
||||
* @deprecated This is intended for internal use, and will be removed once `@types/node` no longer supports
|
||||
* TypeScript versions earlier than 5.7.
|
||||
*/
|
||||
type NonSharedBuffer = Buffer;
|
||||
/**
|
||||
* @deprecated This is intended for internal use, and will be removed once `@types/node` no longer supports
|
||||
* TypeScript versions earlier than 5.7.
|
||||
*/
|
||||
type AllowSharedBuffer = Buffer;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,5 @@
|
||||
function _assertClassBrand(e, t, n) {
|
||||
if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n;
|
||||
throw new TypeError("Private element is not present on this object");
|
||||
}
|
||||
export { _assertClassBrand as default };
|
||||
@@ -0,0 +1 @@
|
||||
export * from './dist/runners.js'
|
||||
@@ -0,0 +1,155 @@
|
||||
self.Flatted = (function (exports) {
|
||||
'use strict';
|
||||
|
||||
function _typeof(o) {
|
||||
"@babel/helpers - typeof";
|
||||
|
||||
return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
|
||||
return typeof o;
|
||||
} : function (o) {
|
||||
return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
|
||||
}, _typeof(o);
|
||||
}
|
||||
|
||||
/// <reference types="../types/index.d.ts" />
|
||||
|
||||
// (c) 2020-present Andrea Giammarchi
|
||||
|
||||
var $parse = JSON.parse,
|
||||
$stringify = JSON.stringify;
|
||||
var keys = Object.keys;
|
||||
var Primitive = String; // it could be Number
|
||||
var primitive = 'string'; // it could be 'number'
|
||||
|
||||
var ignore = {};
|
||||
var object = 'object';
|
||||
var noop = function noop(_, value) {
|
||||
return value;
|
||||
};
|
||||
var primitives = function primitives(value) {
|
||||
return value instanceof Primitive ? Primitive(value) : value;
|
||||
};
|
||||
var Primitives = function Primitives(_, value) {
|
||||
return _typeof(value) === primitive ? new Primitive(value) : value;
|
||||
};
|
||||
var resolver = function resolver(input, lazy, parsed, $) {
|
||||
return function (output) {
|
||||
for (var ke = keys(output), length = ke.length, y = 0; y < length; y++) {
|
||||
var k = ke[y];
|
||||
var value = output[k];
|
||||
if (value instanceof Primitive) {
|
||||
var tmp = input[+value];
|
||||
if (_typeof(tmp) === object && !parsed.has(tmp)) {
|
||||
parsed.add(tmp);
|
||||
output[k] = ignore;
|
||||
lazy.push({
|
||||
o: output,
|
||||
k: k,
|
||||
r: tmp
|
||||
});
|
||||
} else output[k] = $.call(output, k, tmp);
|
||||
} else if (output[k] !== ignore) output[k] = $.call(output, k, value);
|
||||
}
|
||||
return output;
|
||||
};
|
||||
};
|
||||
var set = function set(known, input, value) {
|
||||
var index = Primitive(input.push(value) - 1);
|
||||
known.set(value, index);
|
||||
return index;
|
||||
};
|
||||
|
||||
/**
|
||||
* Converts a specialized flatted string into a JS value.
|
||||
* @param {string} text
|
||||
* @param {(this: any, key: string, value: any) => any} [reviver]
|
||||
* @returns {any}
|
||||
*/
|
||||
var parse = function parse(text, reviver) {
|
||||
var input = $parse(text, Primitives).map(primitives);
|
||||
var $ = reviver || noop;
|
||||
var value = input[0];
|
||||
if (_typeof(value) === object && value) {
|
||||
var lazy = [];
|
||||
var revive = resolver(input, lazy, new Set(), $);
|
||||
value = revive(value);
|
||||
var i = 0;
|
||||
while (i < lazy.length) {
|
||||
// it could be a lazy.shift() but that's costly
|
||||
var _lazy$i = lazy[i++],
|
||||
o = _lazy$i.o,
|
||||
k = _lazy$i.k,
|
||||
r = _lazy$i.r;
|
||||
o[k] = $.call(o, k, revive(r));
|
||||
}
|
||||
}
|
||||
return $.call({
|
||||
'': value
|
||||
}, '', value);
|
||||
};
|
||||
|
||||
/**
|
||||
* Converts a JS value into a specialized flatted string.
|
||||
* @param {any} value
|
||||
* @param {((this: any, key: string, value: any) => any) | (string | number)[] | null | undefined} [replacer]
|
||||
* @param {string | number | undefined} [space]
|
||||
* @returns {string}
|
||||
*/
|
||||
var stringify = function stringify(value, replacer, space) {
|
||||
var $ = replacer && _typeof(replacer) === object ? function (k, v) {
|
||||
return k === '' || -1 < replacer.indexOf(k) ? v : void 0;
|
||||
} : replacer || noop;
|
||||
var known = new Map();
|
||||
var input = [];
|
||||
var output = [];
|
||||
var i = +set(known, input, $.call({
|
||||
'': value
|
||||
}, '', value));
|
||||
var firstRun = !i;
|
||||
while (i < input.length) {
|
||||
firstRun = true;
|
||||
output[i] = $stringify(input[i++], replace, space);
|
||||
}
|
||||
return '[' + output.join(',') + ']';
|
||||
function replace(key, value) {
|
||||
if (firstRun) {
|
||||
firstRun = !firstRun;
|
||||
return value;
|
||||
}
|
||||
var after = $.call(this, key, value);
|
||||
switch (_typeof(after)) {
|
||||
case object:
|
||||
if (after === null) return after;
|
||||
case primitive:
|
||||
return known.get(after) || set(known, input, after);
|
||||
}
|
||||
return after;
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Converts a generic value into a JSON serializable object without losing recursion.
|
||||
* @param {any} value
|
||||
* @returns {any}
|
||||
*/
|
||||
var toJSON = function toJSON(value) {
|
||||
return $parse(stringify(value));
|
||||
};
|
||||
|
||||
/**
|
||||
* Converts a previously serialized object with recursion into a recursive one.
|
||||
* @param {any} value
|
||||
* @returns {any}
|
||||
*/
|
||||
var fromJSON = function fromJSON(value) {
|
||||
return parse($stringify(value));
|
||||
};
|
||||
|
||||
exports.fromJSON = fromJSON;
|
||||
exports.parse = parse;
|
||||
exports.stringify = stringify;
|
||||
exports.toJSON = toJSON;
|
||||
|
||||
return exports;
|
||||
|
||||
})({});
|
||||
@@ -0,0 +1,2 @@
|
||||
import type { LibDefinition } from '../variable';
|
||||
export declare const esnext_asynciterable: LibDefinition;
|
||||
Reference in New Issue
Block a user