WIP: bootstrap and partial real Solana watcher implementation
This commit is contained in:
@@ -0,0 +1,16 @@
|
||||
"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.es2021_promise = void 0;
|
||||
const base_config_1 = require("./base-config");
|
||||
exports.es2021_promise = {
|
||||
libs: [],
|
||||
variables: [
|
||||
['AggregateError', base_config_1.TYPE_VALUE],
|
||||
['AggregateErrorConstructor', base_config_1.TYPE],
|
||||
['PromiseConstructor', base_config_1.TYPE],
|
||||
],
|
||||
};
|
||||
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"p256.js","sourceRoot":"","sources":["src/p256.ts"],"names":[],"mappings":";;;AAMA,uCAAuD;AACvD,sEAAsE;AACzD,QAAA,IAAI,GAAiB,cAAK,CAAC;AACxC,sEAAsE;AACzD,QAAA,SAAS,GAAiB,cAAK,CAAC;AAC7C,6EAA6E;AAChE,QAAA,WAAW,GAAsC,CAAC,GAAG,EAAE,CAAC,qBAAW,CAAC,WAAW,CAAC,EAAE,CAAC;AAChG,6EAA6E;AAChE,QAAA,aAAa,GAAsC,CAAC,GAAG,EAAE,CAAC,qBAAW,CAAC,aAAa,CAAC,EAAE,CAAC"}
|
||||
@@ -0,0 +1,3 @@
|
||||
export { AST_NODE_TYPES, AST_TOKEN_TYPES, TSESTree, } from '@typescript-eslint/types';
|
||||
export type { NodeWithParent } from '@typescript-eslint/types';
|
||||
export type { ParserServices, ParserServicesWithoutTypeInformation, ParserServicesWithTypeInformation, } from '@typescript-eslint/typescript-estree';
|
||||
@@ -0,0 +1,5 @@
|
||||
const file11 = require("./file11.js")
|
||||
|
||||
module.exports = function () {
|
||||
file11()
|
||||
}
|
||||
@@ -0,0 +1,9 @@
|
||||
import { _ as _array_with_holes } from "./_array_with_holes.js";
|
||||
import { _ as _iterable_to_array_limit } from "./_iterable_to_array_limit.js";
|
||||
import { _ as _non_iterable_rest } from "./_non_iterable_rest.js";
|
||||
import { _ as _unsupported_iterable_to_array } from "./_unsupported_iterable_to_array.js";
|
||||
|
||||
function _sliced_to_array(arr, i) {
|
||||
return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
|
||||
}
|
||||
export { _sliced_to_array as _ };
|
||||
@@ -0,0 +1,39 @@
|
||||
// Copyright 2017 Lovell Fuller and others.
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
|
||||
'use strict';
|
||||
|
||||
const interpreterPath = (elf) => {
|
||||
if (elf.length < 64) {
|
||||
return null;
|
||||
}
|
||||
if (elf.readUInt32BE(0) !== 0x7F454C46) {
|
||||
// Unexpected magic bytes
|
||||
return null;
|
||||
}
|
||||
if (elf.readUInt8(4) !== 2) {
|
||||
// Not a 64-bit ELF
|
||||
return null;
|
||||
}
|
||||
if (elf.readUInt8(5) !== 1) {
|
||||
// Not little-endian
|
||||
return null;
|
||||
}
|
||||
const offset = elf.readUInt32LE(32);
|
||||
const size = elf.readUInt16LE(54);
|
||||
const count = elf.readUInt16LE(56);
|
||||
for (let i = 0; i < count; i++) {
|
||||
const headerOffset = offset + (i * size);
|
||||
const type = elf.readUInt32LE(headerOffset);
|
||||
if (type === 3) {
|
||||
const fileOffset = elf.readUInt32LE(headerOffset + 8);
|
||||
const fileSize = elf.readUInt32LE(headerOffset + 32);
|
||||
return elf.subarray(fileOffset, fileOffset + fileSize).toString().replace(/\0.*$/g, '');
|
||||
}
|
||||
}
|
||||
return null;
|
||||
};
|
||||
|
||||
module.exports = {
|
||||
interpreterPath
|
||||
};
|
||||
@@ -0,0 +1,122 @@
|
||||
/**
|
||||
* PBKDF (RFC 2898). Can be used to create a key from password and salt.
|
||||
* @module
|
||||
*/
|
||||
import { hmac } from './hmac.ts';
|
||||
// prettier-ignore
|
||||
import {
|
||||
ahash, anumber,
|
||||
asyncLoop, checkOpts, clean, createView, Hash, kdfInputToBytes,
|
||||
type CHash,
|
||||
type KDFInput
|
||||
} from './utils.ts';
|
||||
|
||||
export type Pbkdf2Opt = {
|
||||
c: number; // Iterations
|
||||
dkLen?: number; // Desired key length in bytes (Intended output length in octets of the derived key
|
||||
asyncTick?: number; // Maximum time in ms for which async function can block execution
|
||||
};
|
||||
// Common prologue and epilogue for sync/async functions
|
||||
function pbkdf2Init(hash: CHash, _password: KDFInput, _salt: KDFInput, _opts: Pbkdf2Opt) {
|
||||
ahash(hash);
|
||||
const opts = checkOpts({ dkLen: 32, asyncTick: 10 }, _opts);
|
||||
const { c, dkLen, asyncTick } = opts;
|
||||
anumber(c);
|
||||
anumber(dkLen);
|
||||
anumber(asyncTick);
|
||||
if (c < 1) throw new Error('iterations (c) should be >= 1');
|
||||
const password = kdfInputToBytes(_password);
|
||||
const salt = kdfInputToBytes(_salt);
|
||||
// DK = PBKDF2(PRF, Password, Salt, c, dkLen);
|
||||
const DK = new Uint8Array(dkLen);
|
||||
// U1 = PRF(Password, Salt + INT_32_BE(i))
|
||||
const PRF = hmac.create(hash, password);
|
||||
const PRFSalt = PRF._cloneInto().update(salt);
|
||||
return { c, dkLen, asyncTick, DK, PRF, PRFSalt };
|
||||
}
|
||||
|
||||
function pbkdf2Output<T extends Hash<T>>(
|
||||
PRF: Hash<T>,
|
||||
PRFSalt: Hash<T>,
|
||||
DK: Uint8Array,
|
||||
prfW: Hash<T>,
|
||||
u: Uint8Array
|
||||
) {
|
||||
PRF.destroy();
|
||||
PRFSalt.destroy();
|
||||
if (prfW) prfW.destroy();
|
||||
clean(u);
|
||||
return DK;
|
||||
}
|
||||
|
||||
/**
|
||||
* PBKDF2-HMAC: RFC 2898 key derivation function
|
||||
* @param hash - hash function that would be used e.g. sha256
|
||||
* @param password - password from which a derived key is generated
|
||||
* @param salt - cryptographic salt
|
||||
* @param opts - {c, dkLen} where c is work factor and dkLen is output message size
|
||||
* @example
|
||||
* const key = pbkdf2(sha256, 'password', 'salt', { dkLen: 32, c: Math.pow(2, 18) });
|
||||
*/
|
||||
export function pbkdf2(
|
||||
hash: CHash,
|
||||
password: KDFInput,
|
||||
salt: KDFInput,
|
||||
opts: Pbkdf2Opt
|
||||
): Uint8Array {
|
||||
const { c, dkLen, DK, PRF, PRFSalt } = pbkdf2Init(hash, password, salt, opts);
|
||||
let prfW: any; // Working copy
|
||||
const arr = new Uint8Array(4);
|
||||
const view = createView(arr);
|
||||
const u = new Uint8Array(PRF.outputLen);
|
||||
// DK = T1 + T2 + ⋯ + Tdklen/hlen
|
||||
for (let ti = 1, pos = 0; pos < dkLen; ti++, pos += PRF.outputLen) {
|
||||
// Ti = F(Password, Salt, c, i)
|
||||
const Ti = DK.subarray(pos, pos + PRF.outputLen);
|
||||
view.setInt32(0, ti, false);
|
||||
// F(Password, Salt, c, i) = U1 ^ U2 ^ ⋯ ^ Uc
|
||||
// U1 = PRF(Password, Salt + INT_32_BE(i))
|
||||
(prfW = PRFSalt._cloneInto(prfW)).update(arr).digestInto(u);
|
||||
Ti.set(u.subarray(0, Ti.length));
|
||||
for (let ui = 1; ui < c; ui++) {
|
||||
// Uc = PRF(Password, Uc−1)
|
||||
PRF._cloneInto(prfW).update(u).digestInto(u);
|
||||
for (let i = 0; i < Ti.length; i++) Ti[i] ^= u[i];
|
||||
}
|
||||
}
|
||||
return pbkdf2Output(PRF, PRFSalt, DK, prfW, u);
|
||||
}
|
||||
|
||||
/**
|
||||
* PBKDF2-HMAC: RFC 2898 key derivation function. Async version.
|
||||
* @example
|
||||
* await pbkdf2Async(sha256, 'password', 'salt', { dkLen: 32, c: 500_000 });
|
||||
*/
|
||||
export async function pbkdf2Async(
|
||||
hash: CHash,
|
||||
password: KDFInput,
|
||||
salt: KDFInput,
|
||||
opts: Pbkdf2Opt
|
||||
): Promise<Uint8Array> {
|
||||
const { c, dkLen, asyncTick, DK, PRF, PRFSalt } = pbkdf2Init(hash, password, salt, opts);
|
||||
let prfW: any; // Working copy
|
||||
const arr = new Uint8Array(4);
|
||||
const view = createView(arr);
|
||||
const u = new Uint8Array(PRF.outputLen);
|
||||
// DK = T1 + T2 + ⋯ + Tdklen/hlen
|
||||
for (let ti = 1, pos = 0; pos < dkLen; ti++, pos += PRF.outputLen) {
|
||||
// Ti = F(Password, Salt, c, i)
|
||||
const Ti = DK.subarray(pos, pos + PRF.outputLen);
|
||||
view.setInt32(0, ti, false);
|
||||
// F(Password, Salt, c, i) = U1 ^ U2 ^ ⋯ ^ Uc
|
||||
// U1 = PRF(Password, Salt + INT_32_BE(i))
|
||||
(prfW = PRFSalt._cloneInto(prfW)).update(arr).digestInto(u);
|
||||
Ti.set(u.subarray(0, Ti.length));
|
||||
await asyncLoop(c - 1, asyncTick, () => {
|
||||
// Uc = PRF(Password, Uc−1)
|
||||
PRF._cloneInto(prfW).update(u).digestInto(u);
|
||||
for (let i = 0; i < Ti.length; i++) Ti[i] ^= u[i];
|
||||
});
|
||||
}
|
||||
return pbkdf2Output(PRF, PRFSalt, DK, prfW, u);
|
||||
}
|
||||
@@ -0,0 +1,21 @@
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2021 Matteo Collina
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
||||
@@ -0,0 +1,5 @@
|
||||
import setPrototypeOf from "./setPrototypeOf.js";
|
||||
function _inheritsLoose(t, o) {
|
||||
t.prototype = Object.create(o.prototype), t.prototype.constructor = t, setPrototypeOf(t, o);
|
||||
}
|
||||
export { _inheritsLoose as default };
|
||||
@@ -0,0 +1,24 @@
|
||||
|
||||
var test = require('tape')
|
||||
var printf = require('pff')
|
||||
var getTypeParser = require('../').getTypeParser
|
||||
var types = require('./types')
|
||||
|
||||
test('types', function (t) {
|
||||
Object.keys(types).forEach(function (typeName) {
|
||||
var type = types[typeName]
|
||||
t.test(typeName, function (t) {
|
||||
var parser = getTypeParser(type.id, type.format)
|
||||
type.tests.forEach(function (tests) {
|
||||
var input = tests[0]
|
||||
var expected = tests[1]
|
||||
var result = parser(input)
|
||||
if (typeof expected === 'function') {
|
||||
return expected(t, result)
|
||||
}
|
||||
t.equal(result, expected)
|
||||
})
|
||||
t.end()
|
||||
})
|
||||
})
|
||||
})
|
||||
@@ -0,0 +1,16 @@
|
||||
[![Build status][ci image]][ci]
|
||||
|
||||
64-bit big-endian signed integer-to-string conversion designed for [pg][].
|
||||
|
||||
```js
|
||||
const readInt8 = require('pg-int8');
|
||||
|
||||
readInt8(Buffer.from([0, 1, 2, 3, 4, 5, 6, 7]))
|
||||
// '283686952306183'
|
||||
```
|
||||
|
||||
|
||||
[pg]: https://github.com/brianc/node-postgres
|
||||
|
||||
[ci]: https://travis-ci.org/charmander/pg-int8
|
||||
[ci image]: https://api.travis-ci.org/charmander/pg-int8.svg
|
||||
@@ -0,0 +1 @@
|
||||
export { _ as default } from "../esm/_class_call_check.js";
|
||||
@@ -0,0 +1,20 @@
|
||||
declare namespace PostgresInterval {
|
||||
export interface IPostgresInterval {
|
||||
years?: number;
|
||||
months?: number;
|
||||
days?: number;
|
||||
hours?: number;
|
||||
minutes?: number;
|
||||
seconds?: number;
|
||||
milliseconds?: number;
|
||||
|
||||
toPostgres(): string;
|
||||
|
||||
toISO(): string;
|
||||
toISOString(): string;
|
||||
}
|
||||
}
|
||||
|
||||
declare function PostgresInterval(raw: string): PostgresInterval.IPostgresInterval;
|
||||
|
||||
export = PostgresInterval;
|
||||
@@ -0,0 +1,101 @@
|
||||
const maxDistance = 3;
|
||||
|
||||
function editDistance(a, b) {
|
||||
// https://en.wikipedia.org/wiki/Damerau–Levenshtein_distance
|
||||
// Calculating optimal string alignment distance, no substring is edited more than once.
|
||||
// (Simple implementation.)
|
||||
|
||||
// Quick early exit, return worst case.
|
||||
if (Math.abs(a.length - b.length) > maxDistance)
|
||||
return Math.max(a.length, b.length);
|
||||
|
||||
// distance between prefix substrings of a and b
|
||||
const d = [];
|
||||
|
||||
// pure deletions turn a into empty string
|
||||
for (let i = 0; i <= a.length; i++) {
|
||||
d[i] = [i];
|
||||
}
|
||||
// pure insertions turn empty string into b
|
||||
for (let j = 0; j <= b.length; j++) {
|
||||
d[0][j] = j;
|
||||
}
|
||||
|
||||
// fill matrix
|
||||
for (let j = 1; j <= b.length; j++) {
|
||||
for (let i = 1; i <= a.length; i++) {
|
||||
let cost = 1;
|
||||
if (a[i - 1] === b[j - 1]) {
|
||||
cost = 0;
|
||||
} else {
|
||||
cost = 1;
|
||||
}
|
||||
d[i][j] = Math.min(
|
||||
d[i - 1][j] + 1, // deletion
|
||||
d[i][j - 1] + 1, // insertion
|
||||
d[i - 1][j - 1] + cost, // substitution
|
||||
);
|
||||
// transposition
|
||||
if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
|
||||
d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return d[a.length][b.length];
|
||||
}
|
||||
|
||||
/**
|
||||
* Find close matches, restricted to same number of edits.
|
||||
*
|
||||
* @param {string} word
|
||||
* @param {string[]} candidates
|
||||
* @returns {string}
|
||||
*/
|
||||
|
||||
function suggestSimilar(word, candidates) {
|
||||
if (!candidates || candidates.length === 0) return '';
|
||||
// remove possible duplicates
|
||||
candidates = Array.from(new Set(candidates));
|
||||
|
||||
const searchingOptions = word.startsWith('--');
|
||||
if (searchingOptions) {
|
||||
word = word.slice(2);
|
||||
candidates = candidates.map((candidate) => candidate.slice(2));
|
||||
}
|
||||
|
||||
let similar = [];
|
||||
let bestDistance = maxDistance;
|
||||
const minSimilarity = 0.4;
|
||||
candidates.forEach((candidate) => {
|
||||
if (candidate.length <= 1) return; // no one character guesses
|
||||
|
||||
const distance = editDistance(word, candidate);
|
||||
const length = Math.max(word.length, candidate.length);
|
||||
const similarity = (length - distance) / length;
|
||||
if (similarity > minSimilarity) {
|
||||
if (distance < bestDistance) {
|
||||
// better edit distance, throw away previous worse matches
|
||||
bestDistance = distance;
|
||||
similar = [candidate];
|
||||
} else if (distance === bestDistance) {
|
||||
similar.push(candidate);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
similar.sort((a, b) => a.localeCompare(b));
|
||||
if (searchingOptions) {
|
||||
similar = similar.map((candidate) => `--${candidate}`);
|
||||
}
|
||||
|
||||
if (similar.length > 1) {
|
||||
return `\n(Did you mean one of ${similar.join(', ')}?)`;
|
||||
}
|
||||
if (similar.length === 1) {
|
||||
return `\n(Did you mean ${similar[0]}?)`;
|
||||
}
|
||||
return '';
|
||||
}
|
||||
|
||||
exports.suggestSimilar = suggestSimilar;
|
||||
@@ -0,0 +1,14 @@
|
||||
export * from './clear-caches';
|
||||
export * from './create-program/getScriptKind';
|
||||
export { getCanonicalFileName } from './create-program/shared';
|
||||
export { createProgramFromConfigFile as createProgram } from './create-program/useProvidedPrograms';
|
||||
export * from './getModifiers';
|
||||
export { TSError } from './node-utils';
|
||||
export { type AST, parse, parseAndGenerateServices, type ParseAndGenerateServicesResult, } from './parser';
|
||||
export type { ParserServices, ParserServicesWithoutTypeInformation, ParserServicesWithTypeInformation, TSESTreeOptions, } from './parser-options';
|
||||
export { addCandidateTSConfigRootDir, clearCandidateTSConfigRootDirs, } from './parseSettings/candidateTSConfigRootDirs';
|
||||
export { simpleTraverse } from './simple-traverse';
|
||||
export * from './ts-estree';
|
||||
export { typescriptVersionIsAtLeast } from './version-check';
|
||||
export { version } from './version';
|
||||
export { withoutProjectParserOptions } from './withoutProjectParserOptions';
|
||||
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"msgpack.d.ts","sourceRoot":"","sources":["../../../src/api/node/msgpack.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,iBAAiB,MAAO,CAAC;AACtC,eAAO,MAAM,YAAY,MAAO,CAAC;AACjC,eAAO,MAAM,aAAa,MAAO,CAAC;AAClC,eAAO,MAAM,aAAa,MAAO,CAAC;AAClC,eAAO,MAAM,aAAa,MAAO,CAAC;AAIlC,uEAAuE;AACvE,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAIjD;AAED,6EAA6E;AAC7E,wBAAgB,cAAc,CAAC,GAAG,EAAE,UAAU,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAkBhF;AAKD,qBAAa,aAAa;IACtB,OAAO,CAAC,GAAG,CAAa;IACxB,OAAO,CAAC,IAAI,CAAW;IACvB,OAAO,CAAC,GAAG,CAAS;gBAER,WAAW,SAAM;IAM7B,OAAO,CAAC,MAAM;IAWd,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAmBtC,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAwB9B,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IA4B9B,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI;IAK/B,MAAM,IAAI,UAAU;CAGvB;AAED,qBAAa,aAAa;IACtB,OAAO,CAAC,GAAG,CAAa;IACxB,OAAO,CAAC,IAAI,CAAW;IACvB,OAAO,CAAC,GAAG,CAAS;gBAER,IAAI,EAAE,UAAU,EAAE,MAAM,SAAI;IAMxC,eAAe,IAAI,MAAM;IAgBzB,QAAQ,IAAI,MAAM;IAiBlB,UAAU,IAAI,MAAM;IAyBpB,QAAQ,IAAI,OAAO;CAMtB"}
|
||||
@@ -0,0 +1,94 @@
|
||||
/*! *****************************************************************************
|
||||
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="es2024.collection" />
|
||||
|
||||
interface ReadonlySetLike<T> {
|
||||
/**
|
||||
* Despite its name, returns an iterator of the values in the set-like.
|
||||
*/
|
||||
keys(): Iterator<T>;
|
||||
/**
|
||||
* @returns a boolean indicating whether an element with the specified value exists in the set-like or not.
|
||||
*/
|
||||
has(value: T): boolean;
|
||||
/**
|
||||
* @returns the number of (unique) elements in the set-like.
|
||||
*/
|
||||
readonly size: number;
|
||||
}
|
||||
|
||||
interface Set<T> {
|
||||
/**
|
||||
* @returns a new Set containing all the elements in this Set and also all the elements in the argument.
|
||||
*/
|
||||
union<U>(other: ReadonlySetLike<U>): Set<T | U>;
|
||||
/**
|
||||
* @returns a new Set containing all the elements which are both in this Set and in the argument.
|
||||
*/
|
||||
intersection<U>(other: ReadonlySetLike<U>): Set<T & U>;
|
||||
/**
|
||||
* @returns a new Set containing all the elements in this Set which are not also in the argument.
|
||||
*/
|
||||
difference<U>(other: ReadonlySetLike<U>): Set<T>;
|
||||
/**
|
||||
* @returns a new Set containing all the elements which are in either this Set or in the argument, but not in both.
|
||||
*/
|
||||
symmetricDifference<U>(other: ReadonlySetLike<U>): Set<T | U>;
|
||||
/**
|
||||
* @returns a boolean indicating whether all the elements in this Set are also in the argument.
|
||||
*/
|
||||
isSubsetOf(other: ReadonlySetLike<unknown>): boolean;
|
||||
/**
|
||||
* @returns a boolean indicating whether all the elements in the argument are also in this Set.
|
||||
*/
|
||||
isSupersetOf(other: ReadonlySetLike<unknown>): boolean;
|
||||
/**
|
||||
* @returns a boolean indicating whether this Set has no elements in common with the argument.
|
||||
*/
|
||||
isDisjointFrom(other: ReadonlySetLike<unknown>): boolean;
|
||||
}
|
||||
|
||||
interface ReadonlySet<T> {
|
||||
/**
|
||||
* @returns a new Set containing all the elements in this Set and also all the elements in the argument.
|
||||
*/
|
||||
union<U>(other: ReadonlySetLike<U>): Set<T | U>;
|
||||
/**
|
||||
* @returns a new Set containing all the elements which are both in this Set and in the argument.
|
||||
*/
|
||||
intersection<U>(other: ReadonlySetLike<U>): Set<T & U>;
|
||||
/**
|
||||
* @returns a new Set containing all the elements in this Set which are not also in the argument.
|
||||
*/
|
||||
difference<U>(other: ReadonlySetLike<U>): Set<T>;
|
||||
/**
|
||||
* @returns a new Set containing all the elements which are in either this Set or in the argument, but not in both.
|
||||
*/
|
||||
symmetricDifference<U>(other: ReadonlySetLike<U>): Set<T | U>;
|
||||
/**
|
||||
* @returns a boolean indicating whether all the elements in this Set are also in the argument.
|
||||
*/
|
||||
isSubsetOf(other: ReadonlySetLike<unknown>): boolean;
|
||||
/**
|
||||
* @returns a boolean indicating whether all the elements in the argument are also in this Set.
|
||||
*/
|
||||
isSupersetOf(other: ReadonlySetLike<unknown>): boolean;
|
||||
/**
|
||||
* @returns a boolean indicating whether this Set has no elements in common with the argument.
|
||||
*/
|
||||
isDisjointFrom(other: ReadonlySetLike<unknown>): boolean;
|
||||
}
|
||||
@@ -0,0 +1,53 @@
|
||||
import { Hash, type CHash, type CHashXO, type HashXOF, type Input } from './utils.ts';
|
||||
/** `keccakf1600` internal function, additionally allows to adjust round count. */
|
||||
export declare function keccakP(s: Uint32Array, rounds?: number): void;
|
||||
/** Keccak sponge function. */
|
||||
export declare class Keccak extends Hash<Keccak> implements HashXOF<Keccak> {
|
||||
protected state: Uint8Array;
|
||||
protected pos: number;
|
||||
protected posOut: number;
|
||||
protected finished: boolean;
|
||||
protected state32: Uint32Array;
|
||||
protected destroyed: boolean;
|
||||
blockLen: number;
|
||||
suffix: number;
|
||||
outputLen: number;
|
||||
protected enableXOF: boolean;
|
||||
protected rounds: number;
|
||||
constructor(blockLen: number, suffix: number, outputLen: number, enableXOF?: boolean, rounds?: number);
|
||||
clone(): Keccak;
|
||||
protected keccak(): void;
|
||||
update(data: Input): this;
|
||||
protected finish(): void;
|
||||
protected writeInto(out: Uint8Array): Uint8Array;
|
||||
xofInto(out: Uint8Array): Uint8Array;
|
||||
xof(bytes: number): Uint8Array;
|
||||
digestInto(out: Uint8Array): Uint8Array;
|
||||
digest(): Uint8Array;
|
||||
destroy(): void;
|
||||
_cloneInto(to?: Keccak): Keccak;
|
||||
}
|
||||
/** SHA3-224 hash function. */
|
||||
export declare const sha3_224: CHash;
|
||||
/** SHA3-256 hash function. Different from keccak-256. */
|
||||
export declare const sha3_256: CHash;
|
||||
/** SHA3-384 hash function. */
|
||||
export declare const sha3_384: CHash;
|
||||
/** SHA3-512 hash function. */
|
||||
export declare const sha3_512: CHash;
|
||||
/** keccak-224 hash function. */
|
||||
export declare const keccak_224: CHash;
|
||||
/** keccak-256 hash function. Different from SHA3-256. */
|
||||
export declare const keccak_256: CHash;
|
||||
/** keccak-384 hash function. */
|
||||
export declare const keccak_384: CHash;
|
||||
/** keccak-512 hash function. */
|
||||
export declare const keccak_512: CHash;
|
||||
export type ShakeOpts = {
|
||||
dkLen?: number;
|
||||
};
|
||||
/** SHAKE128 XOF with 128-bit security. */
|
||||
export declare const shake128: CHashXO;
|
||||
/** SHAKE256 XOF with 256-bit security. */
|
||||
export declare const shake256: CHashXO;
|
||||
//# sourceMappingURL=sha3.d.ts.map
|
||||
@@ -0,0 +1,270 @@
|
||||
'use strict'
|
||||
|
||||
const SINGLE_QUOTE = "'".charCodeAt(0)
|
||||
const DOUBLE_QUOTE = '"'.charCodeAt(0)
|
||||
const BACKSLASH = '\\'.charCodeAt(0)
|
||||
const SLASH = '/'.charCodeAt(0)
|
||||
const NEWLINE = '\n'.charCodeAt(0)
|
||||
const SPACE = ' '.charCodeAt(0)
|
||||
const FEED = '\f'.charCodeAt(0)
|
||||
const TAB = '\t'.charCodeAt(0)
|
||||
const CR = '\r'.charCodeAt(0)
|
||||
const OPEN_SQUARE = '['.charCodeAt(0)
|
||||
const CLOSE_SQUARE = ']'.charCodeAt(0)
|
||||
const OPEN_PARENTHESES = '('.charCodeAt(0)
|
||||
const CLOSE_PARENTHESES = ')'.charCodeAt(0)
|
||||
const OPEN_CURLY = '{'.charCodeAt(0)
|
||||
const CLOSE_CURLY = '}'.charCodeAt(0)
|
||||
const SEMICOLON = ';'.charCodeAt(0)
|
||||
const ASTERISK = '*'.charCodeAt(0)
|
||||
const COLON = ':'.charCodeAt(0)
|
||||
const AT = '@'.charCodeAt(0)
|
||||
|
||||
const RE_AT_END = /[\t\n\f\r "#'()/;[\\\]{}]/g
|
||||
const RE_WORD_END = /[\t\n\f\r !"#'():;@[\\\]{}]|\/(?=\*)/g
|
||||
const RE_BAD_BRACKET = /.[\r\n"'(/\\]/
|
||||
const RE_HEX_ESCAPE = /[\da-f]/i
|
||||
|
||||
module.exports = function tokenizer(input, options = {}) {
|
||||
let css = input.css.valueOf()
|
||||
let ignore = options.ignoreErrors
|
||||
|
||||
let code, content, escape, next, quote
|
||||
let currentToken, escaped, escapePos, n, prev
|
||||
|
||||
let length = css.length
|
||||
let pos = 0
|
||||
let buffer = []
|
||||
let returned = []
|
||||
let lastBadParen = -1
|
||||
|
||||
function position() {
|
||||
return pos
|
||||
}
|
||||
|
||||
function unclosed(what) {
|
||||
throw input.error('Unclosed ' + what, pos)
|
||||
}
|
||||
|
||||
function endOfFile() {
|
||||
return returned.length === 0 && pos >= length
|
||||
}
|
||||
|
||||
function nextToken(opts) {
|
||||
if (returned.length) return returned.pop()
|
||||
if (pos >= length) return
|
||||
|
||||
let ignoreUnclosed = opts ? opts.ignoreUnclosed : false
|
||||
|
||||
code = css.charCodeAt(pos)
|
||||
|
||||
switch (code) {
|
||||
case NEWLINE:
|
||||
case SPACE:
|
||||
case TAB:
|
||||
case CR:
|
||||
case FEED: {
|
||||
next = pos
|
||||
do {
|
||||
next += 1
|
||||
code = css.charCodeAt(next)
|
||||
} while (
|
||||
code === SPACE ||
|
||||
code === NEWLINE ||
|
||||
code === TAB ||
|
||||
code === CR ||
|
||||
code === FEED
|
||||
)
|
||||
|
||||
currentToken = ['space', css.slice(pos, next)]
|
||||
pos = next - 1
|
||||
break
|
||||
}
|
||||
|
||||
case OPEN_SQUARE:
|
||||
case CLOSE_SQUARE:
|
||||
case OPEN_CURLY:
|
||||
case CLOSE_CURLY:
|
||||
case COLON:
|
||||
case SEMICOLON:
|
||||
case CLOSE_PARENTHESES: {
|
||||
let controlChar = String.fromCharCode(code)
|
||||
currentToken = [controlChar, controlChar, pos]
|
||||
break
|
||||
}
|
||||
|
||||
case OPEN_PARENTHESES: {
|
||||
prev = buffer.length ? buffer.pop()[1] : ''
|
||||
n = css.charCodeAt(pos + 1)
|
||||
if (
|
||||
prev === 'url' &&
|
||||
n !== SINGLE_QUOTE &&
|
||||
n !== DOUBLE_QUOTE &&
|
||||
n !== SPACE &&
|
||||
n !== NEWLINE &&
|
||||
n !== TAB &&
|
||||
n !== FEED &&
|
||||
n !== CR
|
||||
) {
|
||||
next = pos
|
||||
do {
|
||||
escaped = false
|
||||
next = css.indexOf(')', next + 1)
|
||||
if (next === -1) {
|
||||
if (ignore || ignoreUnclosed) {
|
||||
next = pos
|
||||
break
|
||||
} else {
|
||||
unclosed('bracket')
|
||||
}
|
||||
}
|
||||
escapePos = next
|
||||
while (css.charCodeAt(escapePos - 1) === BACKSLASH) {
|
||||
escapePos -= 1
|
||||
escaped = !escaped
|
||||
}
|
||||
} while (escaped)
|
||||
|
||||
currentToken = ['brackets', css.slice(pos, next + 1), pos, next]
|
||||
|
||||
pos = next
|
||||
} else if (pos <= lastBadParen) {
|
||||
currentToken = ['(', '(', pos]
|
||||
} else {
|
||||
next = css.indexOf(')', pos + 1)
|
||||
content = css.slice(pos, next + 1)
|
||||
|
||||
if (next === -1 || RE_BAD_BRACKET.test(content)) {
|
||||
lastBadParen = next === -1 ? length : next
|
||||
currentToken = ['(', '(', pos]
|
||||
} else {
|
||||
currentToken = ['brackets', content, pos, next]
|
||||
pos = next
|
||||
}
|
||||
}
|
||||
|
||||
break
|
||||
}
|
||||
|
||||
case SINGLE_QUOTE:
|
||||
case DOUBLE_QUOTE: {
|
||||
quote = code === SINGLE_QUOTE ? "'" : '"'
|
||||
next = pos
|
||||
do {
|
||||
escaped = false
|
||||
next = css.indexOf(quote, next + 1)
|
||||
if (next === -1) {
|
||||
if (ignore || ignoreUnclosed) {
|
||||
next = pos + 1
|
||||
break
|
||||
} else {
|
||||
unclosed('string')
|
||||
}
|
||||
}
|
||||
escapePos = next
|
||||
while (css.charCodeAt(escapePos - 1) === BACKSLASH) {
|
||||
escapePos -= 1
|
||||
escaped = !escaped
|
||||
}
|
||||
} while (escaped)
|
||||
|
||||
currentToken = ['string', css.slice(pos, next + 1), pos, next]
|
||||
pos = next
|
||||
break
|
||||
}
|
||||
|
||||
case AT: {
|
||||
RE_AT_END.lastIndex = pos + 1
|
||||
RE_AT_END.test(css)
|
||||
if (RE_AT_END.lastIndex === 0) {
|
||||
next = css.length - 1
|
||||
} else {
|
||||
next = RE_AT_END.lastIndex - 2
|
||||
}
|
||||
|
||||
currentToken = ['at-word', css.slice(pos, next + 1), pos, next]
|
||||
|
||||
pos = next
|
||||
break
|
||||
}
|
||||
|
||||
case BACKSLASH: {
|
||||
next = pos
|
||||
escape = true
|
||||
while (css.charCodeAt(next + 1) === BACKSLASH) {
|
||||
next += 1
|
||||
escape = !escape
|
||||
}
|
||||
code = css.charCodeAt(next + 1)
|
||||
if (
|
||||
escape &&
|
||||
code !== SLASH &&
|
||||
code !== SPACE &&
|
||||
code !== NEWLINE &&
|
||||
code !== TAB &&
|
||||
code !== CR &&
|
||||
code !== FEED
|
||||
) {
|
||||
next += 1
|
||||
if (RE_HEX_ESCAPE.test(css.charAt(next))) {
|
||||
while (RE_HEX_ESCAPE.test(css.charAt(next + 1))) {
|
||||
next += 1
|
||||
}
|
||||
if (css.charCodeAt(next + 1) === SPACE) {
|
||||
next += 1
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
currentToken = ['word', css.slice(pos, next + 1), pos, next]
|
||||
|
||||
pos = next
|
||||
break
|
||||
}
|
||||
|
||||
default: {
|
||||
if (code === SLASH && css.charCodeAt(pos + 1) === ASTERISK) {
|
||||
next = css.indexOf('*/', pos + 2) + 1
|
||||
if (next === 0) {
|
||||
if (ignore || ignoreUnclosed) {
|
||||
next = css.length
|
||||
} else {
|
||||
unclosed('comment')
|
||||
}
|
||||
}
|
||||
|
||||
currentToken = ['comment', css.slice(pos, next + 1), pos, next]
|
||||
pos = next
|
||||
} else {
|
||||
RE_WORD_END.lastIndex = pos + 1
|
||||
RE_WORD_END.test(css)
|
||||
if (RE_WORD_END.lastIndex === 0) {
|
||||
next = css.length - 1
|
||||
} else {
|
||||
next = RE_WORD_END.lastIndex - 2
|
||||
}
|
||||
|
||||
currentToken = ['word', css.slice(pos, next + 1), pos, next]
|
||||
buffer.push(currentToken)
|
||||
pos = next
|
||||
}
|
||||
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
pos++
|
||||
return currentToken
|
||||
}
|
||||
|
||||
function back(token) {
|
||||
returned.push(token)
|
||||
}
|
||||
|
||||
return {
|
||||
back,
|
||||
endOfFile,
|
||||
nextToken,
|
||||
position
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,40 @@
|
||||
humanize-ms
|
||||
---------------
|
||||
|
||||
[![NPM version][npm-image]][npm-url]
|
||||
[![build status][travis-image]][travis-url]
|
||||
[![Test coverage][coveralls-image]][coveralls-url]
|
||||
[![Gittip][gittip-image]][gittip-url]
|
||||
[![David deps][david-image]][david-url]
|
||||
|
||||
[npm-image]: https://img.shields.io/npm/v/humanize-ms.svg?style=flat
|
||||
[npm-url]: https://npmjs.org/package/humanize-ms
|
||||
[travis-image]: https://img.shields.io/travis/node-modules/humanize-ms.svg?style=flat
|
||||
[travis-url]: https://travis-ci.org/node-modules/humanize-ms
|
||||
[coveralls-image]: https://img.shields.io/coveralls/node-modules/humanize-ms.svg?style=flat
|
||||
[coveralls-url]: https://coveralls.io/r/node-modules/humanize-ms?branch=master
|
||||
[gittip-image]: https://img.shields.io/gittip/dead-horse.svg?style=flat
|
||||
[gittip-url]: https://www.gittip.com/dead-horse/
|
||||
[david-image]: https://img.shields.io/david/node-modules/humanize-ms.svg?style=flat
|
||||
[david-url]: https://david-dm.org/node-modules/humanize-ms
|
||||
|
||||
transform humanize time to ms
|
||||
|
||||
## Installation
|
||||
|
||||
```bash
|
||||
$ npm install humanize-ms
|
||||
```
|
||||
|
||||
## Examples
|
||||
|
||||
```js
|
||||
var ms = require('humanize-ms');
|
||||
|
||||
ms('1s') // 1000
|
||||
ms(1000) // 1000
|
||||
```
|
||||
|
||||
### License
|
||||
|
||||
MIT
|
||||
@@ -0,0 +1,35 @@
|
||||
import { R as RequiredProperty } from '../../types-Cxp8y2TL.js';
|
||||
|
||||
type RegisterOptions = {
|
||||
namespace?: string;
|
||||
};
|
||||
type Unregister = () => void;
|
||||
type ScopedRequire = (id: string, fromFile: string | URL) => any;
|
||||
type ScopedResolve = (id: string, fromFile: string | URL, resolveOptions?: {
|
||||
paths?: string[] | undefined;
|
||||
}) => string;
|
||||
type NamespacedUnregister = Unregister & {
|
||||
require: ScopedRequire;
|
||||
resolve: ScopedResolve;
|
||||
unregister: Unregister;
|
||||
};
|
||||
type Register = {
|
||||
(options: RequiredProperty<RegisterOptions, 'namespace'>): NamespacedUnregister;
|
||||
(options?: RegisterOptions): Unregister;
|
||||
};
|
||||
declare const register: Register;
|
||||
|
||||
declare const tsxRequire: {
|
||||
(id: string, fromFile: string | URL): any;
|
||||
resolve: {
|
||||
(id: string, fromFile: string | URL, options?: {
|
||||
paths?: string[] | undefined;
|
||||
}): string;
|
||||
paths: (request: string) => string[] | null;
|
||||
};
|
||||
main: NodeJS.Module | undefined;
|
||||
extensions: NodeJS.RequireExtensions;
|
||||
cache: NodeJS.Dict<NodeJS.Module>;
|
||||
};
|
||||
|
||||
export { register, tsxRequire as require };
|
||||
@@ -0,0 +1,144 @@
|
||||
import { getSafeTimers } from '@vitest/utils/timers';
|
||||
import { c as createBirpc } from './index.Chj8NDwU.js';
|
||||
import { g as getWorkerState } from './utils.BX5Fg8C4.js';
|
||||
|
||||
/* Ported from https://github.com/boblauer/MockDate/blob/master/src/mockdate.ts */
|
||||
/*
|
||||
The MIT License (MIT)
|
||||
|
||||
Copyright (c) 2014 Bob Lauer
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
||||
*/
|
||||
const RealDate = Date;
|
||||
let now = null;
|
||||
class MockDate extends RealDate {
|
||||
constructor(y, m, d, h, M, s, ms) {
|
||||
super();
|
||||
let date;
|
||||
switch (arguments.length) {
|
||||
case 0:
|
||||
if (now !== null) date = new RealDate(now.valueOf());
|
||||
else date = new RealDate();
|
||||
break;
|
||||
case 1:
|
||||
date = new RealDate(y);
|
||||
break;
|
||||
default:
|
||||
d = typeof d === "undefined" ? 1 : d;
|
||||
h = h || 0;
|
||||
M = M || 0;
|
||||
s = s || 0;
|
||||
ms = ms || 0;
|
||||
date = new RealDate(y, m, d, h, M, s, ms);
|
||||
break;
|
||||
}
|
||||
Object.setPrototypeOf(date, MockDate.prototype);
|
||||
return date;
|
||||
}
|
||||
}
|
||||
MockDate.UTC = RealDate.UTC;
|
||||
MockDate.now = function() {
|
||||
return new MockDate().valueOf();
|
||||
};
|
||||
MockDate.parse = function(dateString) {
|
||||
return RealDate.parse(dateString);
|
||||
};
|
||||
MockDate.toString = function() {
|
||||
return RealDate.toString();
|
||||
};
|
||||
function mockDate(date) {
|
||||
const dateObj = new RealDate(date.valueOf());
|
||||
if (Number.isNaN(dateObj.getTime())) throw new TypeError(`mockdate: The time set is an invalid date: ${date}`);
|
||||
// @ts-expect-error global
|
||||
globalThis.Date = MockDate;
|
||||
now = dateObj.valueOf();
|
||||
}
|
||||
function resetDate() {
|
||||
globalThis.Date = RealDate;
|
||||
}
|
||||
|
||||
const { get } = Reflect;
|
||||
function withSafeTimers(fn) {
|
||||
const { setTimeout, clearTimeout, nextTick, setImmediate, clearImmediate } = getSafeTimers();
|
||||
const currentSetTimeout = globalThis.setTimeout;
|
||||
const currentClearTimeout = globalThis.clearTimeout;
|
||||
const currentSetImmediate = globalThis.setImmediate;
|
||||
const currentClearImmediate = globalThis.clearImmediate;
|
||||
const currentNextTick = globalThis.process?.nextTick;
|
||||
try {
|
||||
globalThis.setTimeout = setTimeout;
|
||||
globalThis.clearTimeout = clearTimeout;
|
||||
if (setImmediate) globalThis.setImmediate = setImmediate;
|
||||
if (clearImmediate) globalThis.clearImmediate = clearImmediate;
|
||||
if (globalThis.process && nextTick) globalThis.process.nextTick = nextTick;
|
||||
return fn();
|
||||
} finally {
|
||||
globalThis.setTimeout = currentSetTimeout;
|
||||
globalThis.clearTimeout = currentClearTimeout;
|
||||
globalThis.setImmediate = currentSetImmediate;
|
||||
globalThis.clearImmediate = currentClearImmediate;
|
||||
if (globalThis.process && nextTick) nextTick(() => {
|
||||
globalThis.process.nextTick = currentNextTick;
|
||||
});
|
||||
}
|
||||
}
|
||||
const promises = /* @__PURE__ */ new Set();
|
||||
async function rpcDone() {
|
||||
if (!promises.size) return;
|
||||
const awaitable = Array.from(promises);
|
||||
return Promise.all(awaitable);
|
||||
}
|
||||
const onCancelCallbacks = [];
|
||||
function onCancel(callback) {
|
||||
onCancelCallbacks.push(callback);
|
||||
}
|
||||
function createRuntimeRpc(options) {
|
||||
return createSafeRpc(createBirpc({ async onCancel(reason) {
|
||||
await Promise.all(onCancelCallbacks.map((fn) => fn(reason)));
|
||||
} }, {
|
||||
eventNames: ["onCancel"],
|
||||
timeout: -1,
|
||||
...options
|
||||
}));
|
||||
}
|
||||
function createSafeRpc(rpc) {
|
||||
return new Proxy(rpc, { get(target, p, handler) {
|
||||
// keep $rejectPendingCalls as sync function
|
||||
if (p === "$rejectPendingCalls") return rpc.$rejectPendingCalls;
|
||||
const sendCall = get(target, p, handler);
|
||||
const safeSendCall = (...args) => withSafeTimers(async () => {
|
||||
const result = sendCall(...args);
|
||||
promises.add(result);
|
||||
try {
|
||||
return await result;
|
||||
} finally {
|
||||
promises.delete(result);
|
||||
}
|
||||
});
|
||||
safeSendCall.asEvent = sendCall.asEvent;
|
||||
return safeSendCall;
|
||||
} });
|
||||
}
|
||||
function rpc() {
|
||||
const { rpc } = getWorkerState();
|
||||
return rpc;
|
||||
}
|
||||
|
||||
export { RealDate as R, rpcDone as a, resetDate as b, createRuntimeRpc as c, mockDate as m, onCancel as o, rpc as r };
|
||||
@@ -0,0 +1,56 @@
|
||||
'use strict';
|
||||
module.exports = function generate_const(it, $keyword, $ruleType) {
|
||||
var out = ' ';
|
||||
var $lvl = it.level;
|
||||
var $dataLvl = it.dataLevel;
|
||||
var $schema = it.schema[$keyword];
|
||||
var $schemaPath = it.schemaPath + it.util.getProperty($keyword);
|
||||
var $errSchemaPath = it.errSchemaPath + '/' + $keyword;
|
||||
var $breakOnError = !it.opts.allErrors;
|
||||
var $data = 'data' + ($dataLvl || '');
|
||||
var $valid = 'valid' + $lvl;
|
||||
var $isData = it.opts.$data && $schema && $schema.$data,
|
||||
$schemaValue;
|
||||
if ($isData) {
|
||||
out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; ';
|
||||
$schemaValue = 'schema' + $lvl;
|
||||
} else {
|
||||
$schemaValue = $schema;
|
||||
}
|
||||
if (!$isData) {
|
||||
out += ' var schema' + ($lvl) + ' = validate.schema' + ($schemaPath) + ';';
|
||||
}
|
||||
out += 'var ' + ($valid) + ' = equal(' + ($data) + ', schema' + ($lvl) + '); if (!' + ($valid) + ') { ';
|
||||
var $$outStack = $$outStack || [];
|
||||
$$outStack.push(out);
|
||||
out = ''; /* istanbul ignore else */
|
||||
if (it.createErrors !== false) {
|
||||
out += ' { keyword: \'' + ('const') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { allowedValue: schema' + ($lvl) + ' } ';
|
||||
if (it.opts.messages !== false) {
|
||||
out += ' , message: \'should be equal to constant\' ';
|
||||
}
|
||||
if (it.opts.verbose) {
|
||||
out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';
|
||||
}
|
||||
out += ' } ';
|
||||
} else {
|
||||
out += ' {} ';
|
||||
}
|
||||
var __err = out;
|
||||
out = $$outStack.pop();
|
||||
if (!it.compositeRule && $breakOnError) {
|
||||
/* istanbul ignore if */
|
||||
if (it.async) {
|
||||
out += ' throw new ValidationError([' + (__err) + ']); ';
|
||||
} else {
|
||||
out += ' validate.errors = [' + (__err) + ']; return false; ';
|
||||
}
|
||||
} else {
|
||||
out += ' var err = ' + (__err) + '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';
|
||||
}
|
||||
out += ' }';
|
||||
if ($breakOnError) {
|
||||
out += ' else { ';
|
||||
}
|
||||
return out;
|
||||
}
|
||||
@@ -0,0 +1,96 @@
|
||||
import { File as WebFile } from "@web-std/file";
|
||||
|
||||
import { afterEach, beforeEach, expect, expectTypeOf, test } from "vitest";
|
||||
|
||||
import * as z from "zod/v4";
|
||||
|
||||
const minCheck = z.file().min(5);
|
||||
const maxCheck = z.file().max(8);
|
||||
const mimeCheck = z.file().mime(["text/plain", "application/json"]);
|
||||
|
||||
const originalFile = global.File;
|
||||
beforeEach(async () => {
|
||||
if (!globalThis.File) globalThis.File = WebFile;
|
||||
});
|
||||
afterEach(() => {
|
||||
if (globalThis.File !== originalFile) {
|
||||
globalThis.File = originalFile;
|
||||
}
|
||||
});
|
||||
|
||||
test("passing validations", () => {
|
||||
minCheck.safeParse(new File(["12345"], "test.txt"));
|
||||
maxCheck.safeParse(new File(["12345678"], "test.txt"));
|
||||
mimeCheck.safeParse(new File([""], "test.csv", { type: "text/plain" }));
|
||||
expect(() => mimeCheck.parse(new File([""], "test.txt"))).toThrow();
|
||||
expect(() => mimeCheck.parse(new File([""], "test.txt", { type: "text/csv" }))).toThrow();
|
||||
});
|
||||
|
||||
test("types", () => {
|
||||
expectTypeOf(z.file().parse(new File([], "test.txt"))).toEqualTypeOf(new File([], "test.txt"));
|
||||
});
|
||||
|
||||
test("failing validations", () => {
|
||||
expect(minCheck.safeParse(new File(["1234"], "test.txt"))).toMatchInlineSnapshot(`
|
||||
{
|
||||
"error": [ZodError: [
|
||||
{
|
||||
"origin": "file",
|
||||
"code": "too_small",
|
||||
"minimum": 5,
|
||||
"inclusive": true,
|
||||
"path": [],
|
||||
"message": "Too small: expected file to have >=5 bytes"
|
||||
}
|
||||
]],
|
||||
"success": false,
|
||||
}
|
||||
`);
|
||||
expect(maxCheck.safeParse(new File(["123456789"], "test.txt"))).toMatchInlineSnapshot(`
|
||||
{
|
||||
"error": [ZodError: [
|
||||
{
|
||||
"origin": "file",
|
||||
"code": "too_big",
|
||||
"maximum": 8,
|
||||
"inclusive": true,
|
||||
"path": [],
|
||||
"message": "Too big: expected file to have <=8 bytes"
|
||||
}
|
||||
]],
|
||||
"success": false,
|
||||
}
|
||||
`);
|
||||
expect(mimeCheck.safeParse(new File([""], "test.csv"))).toMatchInlineSnapshot(`
|
||||
{
|
||||
"error": [ZodError: [
|
||||
{
|
||||
"code": "invalid_value",
|
||||
"values": [
|
||||
"text/plain",
|
||||
"application/json"
|
||||
],
|
||||
"path": [],
|
||||
"message": "Invalid option: expected one of \\"text/plain\\"|\\"application/json\\""
|
||||
}
|
||||
]],
|
||||
"success": false,
|
||||
}
|
||||
`);
|
||||
expect(mimeCheck.safeParse(new File([""], "test.csv", { type: "text/csv" }))).toMatchInlineSnapshot(`
|
||||
{
|
||||
"error": [ZodError: [
|
||||
{
|
||||
"code": "invalid_value",
|
||||
"values": [
|
||||
"text/plain",
|
||||
"application/json"
|
||||
],
|
||||
"path": [],
|
||||
"message": "Invalid option: expected one of \\"text/plain\\"|\\"application/json\\""
|
||||
}
|
||||
]],
|
||||
"success": false,
|
||||
}
|
||||
`);
|
||||
});
|
||||
@@ -0,0 +1,12 @@
|
||||
"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.esnext_promise = void 0;
|
||||
const base_config_1 = require("./base-config");
|
||||
exports.esnext_promise = {
|
||||
libs: [],
|
||||
variables: [['PromiseConstructor', base_config_1.TYPE]],
|
||||
};
|
||||
@@ -0,0 +1,16 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.getValueOfLiteralType = void 0;
|
||||
const valueIsPseudoBigInt = (value) => {
|
||||
return typeof value === 'object';
|
||||
};
|
||||
const pseudoBigIntToBigInt = (value) => {
|
||||
return BigInt((value.negative ? '-' : '') + value.base10Value);
|
||||
};
|
||||
const getValueOfLiteralType = (type) => {
|
||||
if (valueIsPseudoBigInt(type.value)) {
|
||||
return pseudoBigIntToBigInt(type.value);
|
||||
}
|
||||
return type.value;
|
||||
};
|
||||
exports.getValueOfLiteralType = getValueOfLiteralType;
|
||||
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"_md.d.ts","sourceRoot":"","sources":["src/_md.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,KAAK,KAAK,EAAE,IAAI,EAAwD,MAAM,YAAY,CAAC;AAEpG,gGAAgG;AAChG,wBAAgB,YAAY,CAC1B,IAAI,EAAE,QAAQ,EACd,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,OAAO,GACZ,IAAI,CAUN;AAED,wBAAwB;AACxB,wBAAgB,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAE3D;AAED,yDAAyD;AACzD,wBAAgB,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAE3D;AAED;;;GAGG;AACH,8BAAsB,MAAM,CAAC,CAAC,SAAS,MAAM,CAAC,CAAC,CAAC,CAAE,SAAQ,IAAI,CAAC,CAAC,CAAC;IAC/D,SAAS,CAAC,QAAQ,CAAC,OAAO,CAAC,GAAG,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAC/D,SAAS,CAAC,QAAQ,CAAC,GAAG,IAAI,MAAM,EAAE;IAClC,SAAS,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI;IAC/C,QAAQ,CAAC,OAAO,IAAI,IAAI;IACxB,SAAS,CAAC,QAAQ,CAAC,UAAU,IAAI,IAAI;IAErC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAGvB,SAAS,CAAC,MAAM,EAAE,UAAU,CAAC;IAC7B,SAAS,CAAC,IAAI,EAAE,QAAQ,CAAC;IACzB,SAAS,CAAC,QAAQ,UAAS;IAC3B,SAAS,CAAC,MAAM,SAAK;IACrB,SAAS,CAAC,GAAG,SAAK;IAClB,SAAS,CAAC,SAAS,UAAS;gBAEhB,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO;IASjF,MAAM,CAAC,IAAI,EAAE,KAAK,GAAG,IAAI;IA0BzB,UAAU,CAAC,GAAG,EAAE,UAAU,GAAG,IAAI;IAkCjC,MAAM,IAAI,UAAU;IAOpB,UAAU,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC;IAWrB,KAAK,IAAI,CAAC;CAGX;AAED;;;GAGG;AAEH,4EAA4E;AAC5E,eAAO,MAAM,SAAS,EAAE,WAEtB,CAAC;AAEH,8EAA8E;AAC9E,eAAO,MAAM,SAAS,EAAE,WAEtB,CAAC;AAEH,6EAA6E;AAC7E,eAAO,MAAM,SAAS,EAAE,WAGtB,CAAC;AAEH,4EAA4E;AAC5E,eAAO,MAAM,SAAS,EAAE,WAGtB,CAAC"}
|
||||
Reference in New Issue
Block a user