WIP: bootstrap and partial real Solana watcher implementation
This commit is contained in:
@@ -0,0 +1 @@
|
||||
const{parse:t,stringify:e}=JSON,{keys:n}=Object,o=String,r="string",s={},c="object",l=(t,e)=>e,f=t=>t instanceof o?o(t):t,i=(t,e)=>typeof e===r?new o(e):e,a=(t,e,n)=>{const r=o(e.push(n)-1);return t.set(n,r),r},u=(e,r)=>{const a=t(e,i).map(f),u=r||l;let p=a[0];if(typeof p===c&&p){const t=[],e=((t,e,r,l)=>f=>{for(let i=n(f),{length:a}=i,u=0;u<a;u++){const n=i[u],a=f[n];if(a instanceof o){const o=t[+a];typeof o!==c||r.has(o)?f[n]=l.call(f,n,o):(r.add(o),f[n]=s,e.push({o:f,k:n,r:o}))}else f[n]!==s&&(f[n]=l.call(f,n,a))}return f})(a,t,new Set,u);p=e(p);let r=0;for(;r<t.length;){const{o:n,k:o,r:s}=t[r++];n[o]=u.call(n,o,e(s))}}return u.call({"":p},"",p)},p=(t,n,o)=>{const s=n&&typeof n===c?(t,e)=>""===t||-1<n.indexOf(t)?e:void 0:n||l,f=new Map,i=[],u=[];let p=+a(f,i,s.call({"":t},"",t)),h=!p;for(;p<i.length;)h=!0,u[p]=e(i[p++],g,o);return"["+u.join(",")+"]";function g(t,e){if(h)return h=!h,e;const n=s.call(this,t,e);switch(typeof n){case c:if(null===n)return n;case r:return f.get(n)||a(f,i,n)}return n}},h=e=>t(p(e)),g=t=>u(e(t));export{g as fromJSON,u as parse,p as stringify,h as toJSON};
|
||||
@@ -0,0 +1,15 @@
|
||||
ISC License
|
||||
|
||||
Copyright (c) 2018-2020, Andrea Giammarchi, @WebReflection
|
||||
|
||||
Permission to use, copy, modify, and/or distribute this software for any
|
||||
purpose with or without fee is hereby granted, provided that the above
|
||||
copyright notice and this permission notice appear in all copies.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
|
||||
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
|
||||
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
|
||||
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
|
||||
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
|
||||
OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
||||
PERFORMANCE OF THIS SOFTWARE.
|
||||
@@ -0,0 +1,59 @@
|
||||
export {};
|
||||
|
||||
import { InternalEventTargetEventProperties } from "node:events";
|
||||
|
||||
type _AbortController = typeof globalThis extends { onmessage: any } ? {} : AbortController;
|
||||
interface AbortController {
|
||||
readonly signal: AbortSignal;
|
||||
abort(reason?: any): void;
|
||||
}
|
||||
|
||||
interface AbortSignalEventMap {
|
||||
"abort": Event;
|
||||
}
|
||||
|
||||
type _AbortSignal = typeof globalThis extends { onmessage: any } ? {} : AbortSignal;
|
||||
interface AbortSignal extends EventTarget, InternalEventTargetEventProperties<AbortSignalEventMap> {
|
||||
readonly aborted: boolean;
|
||||
readonly reason: any;
|
||||
throwIfAborted(): void;
|
||||
addEventListener<K extends keyof AbortSignalEventMap>(
|
||||
type: K,
|
||||
listener: (ev: AbortSignalEventMap[K]) => void,
|
||||
options?: AddEventListenerOptions | boolean,
|
||||
): void;
|
||||
addEventListener(
|
||||
type: string,
|
||||
listener: EventListener | EventListenerObject,
|
||||
options?: AddEventListenerOptions | boolean,
|
||||
): void;
|
||||
removeEventListener<K extends keyof AbortSignalEventMap>(
|
||||
type: K,
|
||||
listener: (ev: AbortSignalEventMap[K]) => void,
|
||||
options?: EventListenerOptions | boolean,
|
||||
): void;
|
||||
removeEventListener(
|
||||
type: string,
|
||||
listener: EventListener | EventListenerObject,
|
||||
options?: EventListenerOptions | boolean,
|
||||
): void;
|
||||
}
|
||||
|
||||
declare global {
|
||||
interface AbortController extends _AbortController {}
|
||||
var AbortController: typeof globalThis extends { onmessage: any; AbortController: infer T } ? T
|
||||
: {
|
||||
prototype: AbortController;
|
||||
new(): AbortController;
|
||||
};
|
||||
|
||||
interface AbortSignal extends _AbortSignal {}
|
||||
var AbortSignal: typeof globalThis extends { onmessage: any; AbortSignal: infer T } ? T
|
||||
: {
|
||||
prototype: AbortSignal;
|
||||
new(): AbortSignal;
|
||||
abort(reason?: any): AbortSignal;
|
||||
any(signals: AbortSignal[]): AbortSignal;
|
||||
timeout(milliseconds: number): AbortSignal;
|
||||
};
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,23 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.sha224 = exports.SHA224 = exports.sha256 = exports.SHA256 = void 0;
|
||||
/**
|
||||
* SHA2-256 a.k.a. sha256. In JS, it is the fastest hash, even faster than Blake3.
|
||||
*
|
||||
* To break sha256 using birthday attack, attackers need to try 2^128 hashes.
|
||||
* BTC network is doing 2^70 hashes/sec (2^95 hashes/year) as per 2025.
|
||||
*
|
||||
* Check out [FIPS 180-4](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf).
|
||||
* @module
|
||||
* @deprecated
|
||||
*/
|
||||
const sha2_ts_1 = require("./sha2.js");
|
||||
/** @deprecated Use import from `noble/hashes/sha2` module */
|
||||
exports.SHA256 = sha2_ts_1.SHA256;
|
||||
/** @deprecated Use import from `noble/hashes/sha2` module */
|
||||
exports.sha256 = sha2_ts_1.sha256;
|
||||
/** @deprecated Use import from `noble/hashes/sha2` module */
|
||||
exports.SHA224 = sha2_ts_1.SHA224;
|
||||
/** @deprecated Use import from `noble/hashes/sha2` module */
|
||||
exports.sha224 = sha2_ts_1.sha224;
|
||||
//# sourceMappingURL=sha256.js.map
|
||||
@@ -0,0 +1,125 @@
|
||||
/**
|
||||
* @fileoverview Helper class to aid in constructing fix commands.
|
||||
* @author Alan Pierce
|
||||
*/
|
||||
"use strict";
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Typedefs
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* @import { SourceRange } from "@eslint/core";
|
||||
*/
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Requirements
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
const astUtils = require("./ast-utils");
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Public Interface
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* A helper class to combine fix options into a fix command. Currently, it
|
||||
* exposes some "retain" methods that extend the range of the text being
|
||||
* replaced so that other fixes won't touch that region in the same pass.
|
||||
*/
|
||||
class FixTracker {
|
||||
/**
|
||||
* Create a new FixTracker.
|
||||
* @param {ruleFixer} fixer A ruleFixer instance.
|
||||
* @param {SourceCode} sourceCode A SourceCode object for the current code.
|
||||
*/
|
||||
constructor(fixer, sourceCode) {
|
||||
this.fixer = fixer;
|
||||
this.sourceCode = sourceCode;
|
||||
this.retainedRange = null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Mark the given range as "retained", meaning that other fixes may not
|
||||
* may not modify this region in the same pass.
|
||||
* @param {SourceRange} range The range to retain.
|
||||
* @returns {FixTracker} The same RuleFixer, for chained calls.
|
||||
*/
|
||||
retainRange(range) {
|
||||
this.retainedRange = range;
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Given a node, find the function containing it (or the entire program) and
|
||||
* mark it as retained, meaning that other fixes may not modify it in this
|
||||
* pass. This is useful for avoiding conflicts in fixes that modify control
|
||||
* flow.
|
||||
* @param {ASTNode} node The node to use as a starting point.
|
||||
* @returns {FixTracker} The same RuleFixer, for chained calls.
|
||||
*/
|
||||
retainEnclosingFunction(node) {
|
||||
const functionNode = astUtils.getUpperFunction(node);
|
||||
|
||||
return this.retainRange(
|
||||
functionNode ? functionNode.range : this.sourceCode.ast.range,
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Given a node or token, find the token before and afterward, and mark that
|
||||
* range as retained, meaning that other fixes may not modify it in this
|
||||
* pass. This is useful for avoiding conflicts in fixes that make a small
|
||||
* change to the code where the AST should not be changed.
|
||||
* @param {ASTNode|Token} nodeOrToken The node or token to use as a starting
|
||||
* point. The token to the left and right are use in the range.
|
||||
* @returns {FixTracker} The same RuleFixer, for chained calls.
|
||||
*/
|
||||
retainSurroundingTokens(nodeOrToken) {
|
||||
const tokenBefore =
|
||||
this.sourceCode.getTokenBefore(nodeOrToken) || nodeOrToken;
|
||||
const tokenAfter =
|
||||
this.sourceCode.getTokenAfter(nodeOrToken) || nodeOrToken;
|
||||
|
||||
return this.retainRange([tokenBefore.range[0], tokenAfter.range[1]]);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a fix command that replaces the given range with the given text,
|
||||
* accounting for any retained ranges.
|
||||
* @param {SourceRange} range The range to remove in the fix.
|
||||
* @param {string} text The text to insert in place of the range.
|
||||
* @returns {Object} The fix command.
|
||||
*/
|
||||
replaceTextRange(range, text) {
|
||||
let actualRange;
|
||||
|
||||
if (this.retainedRange) {
|
||||
actualRange = [
|
||||
Math.min(this.retainedRange[0], range[0]),
|
||||
Math.max(this.retainedRange[1], range[1]),
|
||||
];
|
||||
} else {
|
||||
actualRange = range;
|
||||
}
|
||||
|
||||
return this.fixer.replaceTextRange(
|
||||
actualRange,
|
||||
this.sourceCode.text.slice(actualRange[0], range[0]) +
|
||||
text +
|
||||
this.sourceCode.text.slice(range[1], actualRange[1]),
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a fix command that removes the given node or token, accounting for
|
||||
* any retained ranges.
|
||||
* @param {ASTNode|Token} nodeOrToken The node or token to remove.
|
||||
* @returns {Object} The fix command.
|
||||
*/
|
||||
remove(nodeOrToken) {
|
||||
return this.replaceTextRange(nodeOrToken.range, "");
|
||||
}
|
||||
}
|
||||
|
||||
module.exports = FixTracker;
|
||||
@@ -0,0 +1,2 @@
|
||||
import type { LibDefinition } from '../variable';
|
||||
export declare const webworker_importscripts: LibDefinition;
|
||||
@@ -0,0 +1,7 @@
|
||||
var classApplyDescriptorGet = require("./classApplyDescriptorGet.js");
|
||||
var assertClassBrand = require("./assertClassBrand.js");
|
||||
var classCheckPrivateStaticFieldDescriptor = require("./classCheckPrivateStaticFieldDescriptor.js");
|
||||
function _classStaticPrivateFieldSpecGet(t, s, r) {
|
||||
return assertClassBrand(s, t), classCheckPrivateStaticFieldDescriptor(r, "get"), classApplyDescriptorGet(t, r);
|
||||
}
|
||||
module.exports = _classStaticPrivateFieldSpecGet, module.exports.__esModule = true, module.exports["default"] = module.exports;
|
||||
@@ -0,0 +1,781 @@
|
||||
/**
|
||||
* bls12-381 is pairing-friendly Barreto-Lynn-Scott elliptic curve construction allowing to:
|
||||
|
||||
* Construct zk-SNARKs at the ~120-bit security, as per [Barbulescu-Duquesne 2017](https://hal.science/hal-01534101/file/main.pdf)
|
||||
* Efficiently verify N aggregate signatures with 1 pairing and N ec additions:
|
||||
the Boneh-Lynn-Shacham signature scheme is orders of magnitude more efficient than Schnorr
|
||||
|
||||
BLS can mean 2 different things:
|
||||
|
||||
* Barreto-Lynn-Scott: BLS12, a Pairing Friendly Elliptic Curve
|
||||
* Boneh-Lynn-Shacham: A Signature Scheme.
|
||||
|
||||
### Summary
|
||||
|
||||
1. BLS Relies on expensive bilinear pairing
|
||||
2. Secret Keys: 32 bytes
|
||||
3. Public Keys: 48 OR 96 bytes - big-endian x coordinate of point on G1 OR G2 curve
|
||||
4. Signatures: 96 OR 48 bytes - big-endian x coordinate of point on G2 OR G1 curve
|
||||
5. The 12 stands for the Embedding degree.
|
||||
|
||||
Modes of operation:
|
||||
|
||||
* Long signatures: 48-byte keys + 96-byte sigs (G1 keys + G2 sigs).
|
||||
* Short signatures: 96-byte keys + 48-byte sigs (G2 keys + G1 sigs).
|
||||
|
||||
### Formulas
|
||||
|
||||
- `P = pk x G` - public keys
|
||||
- `S = pk x H(m)` - signing, uses hash-to-curve on m
|
||||
- `e(P, H(m)) == e(G, S)` - verification using pairings
|
||||
- `e(G, S) = e(G, SUM(n)(Si)) = MUL(n)(e(G, Si))` - signature aggregation
|
||||
|
||||
### Curves
|
||||
|
||||
G1 is ordinary elliptic curve. G2 is extension field curve, think "over complex numbers".
|
||||
|
||||
- G1: y² = x³ + 4
|
||||
- G2: y² = x³ + 4(u + 1) where u = √−1; r-order subgroup of E'(Fp²), M-type twist
|
||||
|
||||
### Towers
|
||||
|
||||
Pairing G1 + G2 produces element in Fp₁₂, 12-degree polynomial.
|
||||
Fp₁₂ is usually implemented using tower of lower-degree polynomials for speed.
|
||||
|
||||
- Fp₁₂ = Fp₆² => Fp₂³
|
||||
- Fp(u) / (u² - β) where β = -1
|
||||
- Fp₂(v) / (v³ - ξ) where ξ = u + 1
|
||||
- Fp₆(w) / (w² - γ) where γ = v
|
||||
- Fp²[u] = Fp/u²+1
|
||||
- Fp⁶[v] = Fp²/v³-1-u
|
||||
- Fp¹²[w] = Fp⁶/w²-v
|
||||
|
||||
### Params
|
||||
|
||||
* Embedding degree (k): 12
|
||||
* Seed is sometimes named x or t
|
||||
* t = -15132376222941642752
|
||||
* p = (t-1)² * (t⁴-t²+1)/3 + t
|
||||
* r = t⁴-t²+1
|
||||
* Ate loop size: X
|
||||
|
||||
To verify curve parameters, see
|
||||
[pairing-friendly-curves spec](https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-pairing-friendly-curves-11).
|
||||
Basic math is done over finite fields over p.
|
||||
More complicated math is done over polynominal extension fields.
|
||||
|
||||
### Compatibility and notes
|
||||
1. It is compatible with Algorand, Chia, Dfinity, Ethereum, Filecoin, ZEC.
|
||||
Filecoin uses little endian byte arrays for secret keys - make sure to reverse byte order.
|
||||
2. Make sure to correctly select mode: "long signature" or "short signature".
|
||||
3. Compatible with specs:
|
||||
RFC 9380,
|
||||
[cfrg-pairing-friendly-curves-11](https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-pairing-friendly-curves-11),
|
||||
[cfrg-bls-signature-05](https://datatracker.ietf.org/doc/draft-irtf-cfrg-bls-signature/).
|
||||
|
||||
*
|
||||
* @module
|
||||
*/
|
||||
/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
|
||||
import { sha256 } from '@noble/hashes/sha2.js';
|
||||
import { bls, type CurveFn } from './abstract/bls.ts';
|
||||
import { Field, type IField } from './abstract/modular.ts';
|
||||
import {
|
||||
abytes,
|
||||
bitLen,
|
||||
bitMask,
|
||||
bytesToHex,
|
||||
bytesToNumberBE,
|
||||
concatBytes,
|
||||
ensureBytes,
|
||||
numberToBytesBE,
|
||||
type Hex,
|
||||
} from './utils.ts';
|
||||
// Types
|
||||
import { isogenyMap } from './abstract/hash-to-curve.ts';
|
||||
import type { BigintTuple, Fp, Fp12, Fp2, Fp6 } from './abstract/tower.ts';
|
||||
import { psiFrobenius, tower12 } from './abstract/tower.ts';
|
||||
import {
|
||||
mapToCurveSimpleSWU,
|
||||
type AffinePoint,
|
||||
type WeierstrassOpts,
|
||||
type WeierstrassPoint,
|
||||
type WeierstrassPointCons,
|
||||
} from './abstract/weierstrass.ts';
|
||||
|
||||
// Be friendly to bad ECMAScript parsers by not using bigint literals
|
||||
// prettier-ignore
|
||||
const _0n = BigInt(0), _1n = BigInt(1), _2n = BigInt(2), _3n = BigInt(3), _4n = BigInt(4);
|
||||
|
||||
// To verify math:
|
||||
// https://tools.ietf.org/html/draft-irtf-cfrg-pairing-friendly-curves-11
|
||||
|
||||
// The BLS parameter x (seed) for BLS12-381. NOTE: it is negative!
|
||||
// x = -2^63 - 2^62 - 2^60 - 2^57 - 2^48 - 2^16
|
||||
const BLS_X = BigInt('0xd201000000010000');
|
||||
// t = x (called differently in different places)
|
||||
// const t = -BLS_X;
|
||||
const BLS_X_LEN = bitLen(BLS_X);
|
||||
|
||||
// a=0, b=4
|
||||
// P is characteristic of field Fp, in which curve calculations are done.
|
||||
// p = (t-1)² * (t⁴-t²+1)/3 + t
|
||||
// bls12_381_Fp = (t-1n)**2n * (t**4n - t**2n + 1n) / 3n + t
|
||||
// r*h is curve order, amount of points on curve,
|
||||
// where r is order of prime subgroup and h is cofactor.
|
||||
// r = t⁴-t²+1
|
||||
// r = (t**4n - t**2n + 1n)
|
||||
// cofactor h of G1: (t - 1)²/3
|
||||
// cofactorG1 = (t-1n)**2n/3n
|
||||
// x = 3685416753713387016781088315183077757961620795782546409894578378688607592378376318836054947676345821548104185464507
|
||||
// y = 1339506544944476473020471379941921221584933875938349620426543736416511423956333506472724655353366534992391756441569
|
||||
const bls12_381_CURVE_G1: WeierstrassOpts<bigint> = {
|
||||
p: BigInt(
|
||||
'0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaab'
|
||||
),
|
||||
n: BigInt('0x73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001'),
|
||||
h: BigInt('0x396c8c005555e1568c00aaab0000aaab'),
|
||||
a: _0n,
|
||||
b: _4n,
|
||||
Gx: BigInt(
|
||||
'0x17f1d3a73197d7942695638c4fa9ac0fc3688c4f9774b905a14e3a3f171bac586c55e83ff97a1aeffb3af00adb22c6bb'
|
||||
),
|
||||
Gy: BigInt(
|
||||
'0x08b3f481e3aaa0f1a09e30ed741d8ae4fcf5e095d5d00af600db18cb2c04b3edd03cc744a2888ae40caa232946c5e7e1'
|
||||
),
|
||||
};
|
||||
|
||||
// CURVE FIELDS
|
||||
export const bls12_381_Fr: IField<bigint> = Field(bls12_381_CURVE_G1.n, {
|
||||
modFromBytes: true,
|
||||
isLE: true,
|
||||
});
|
||||
const { Fp, Fp2, Fp6, Fp12 } = tower12({
|
||||
ORDER: bls12_381_CURVE_G1.p,
|
||||
X_LEN: BLS_X_LEN,
|
||||
// Finite extension field over irreducible polynominal.
|
||||
// Fp(u) / (u² - β) where β = -1
|
||||
FP2_NONRESIDUE: [_1n, _1n],
|
||||
Fp2mulByB: ({ c0, c1 }) => {
|
||||
const t0 = Fp.mul(c0, _4n); // 4 * c0
|
||||
const t1 = Fp.mul(c1, _4n); // 4 * c1
|
||||
// (T0-T1) + (T0+T1)*i
|
||||
return { c0: Fp.sub(t0, t1), c1: Fp.add(t0, t1) };
|
||||
},
|
||||
Fp12finalExponentiate: (num) => {
|
||||
const x = BLS_X;
|
||||
// this^(q⁶) / this
|
||||
const t0 = Fp12.div(Fp12.frobeniusMap(num, 6), num);
|
||||
// t0^(q²) * t0
|
||||
const t1 = Fp12.mul(Fp12.frobeniusMap(t0, 2), t0);
|
||||
const t2 = Fp12.conjugate(Fp12._cyclotomicExp(t1, x));
|
||||
const t3 = Fp12.mul(Fp12.conjugate(Fp12._cyclotomicSquare(t1)), t2);
|
||||
const t4 = Fp12.conjugate(Fp12._cyclotomicExp(t3, x));
|
||||
const t5 = Fp12.conjugate(Fp12._cyclotomicExp(t4, x));
|
||||
const t6 = Fp12.mul(Fp12.conjugate(Fp12._cyclotomicExp(t5, x)), Fp12._cyclotomicSquare(t2));
|
||||
const t7 = Fp12.conjugate(Fp12._cyclotomicExp(t6, x));
|
||||
const t2_t5_pow_q2 = Fp12.frobeniusMap(Fp12.mul(t2, t5), 2);
|
||||
const t4_t1_pow_q3 = Fp12.frobeniusMap(Fp12.mul(t4, t1), 3);
|
||||
const t6_t1c_pow_q1 = Fp12.frobeniusMap(Fp12.mul(t6, Fp12.conjugate(t1)), 1);
|
||||
const t7_t3c_t1 = Fp12.mul(Fp12.mul(t7, Fp12.conjugate(t3)), t1);
|
||||
// (t2 * t5)^(q²) * (t4 * t1)^(q³) * (t6 * t1.conj)^(q^1) * t7 * t3.conj * t1
|
||||
return Fp12.mul(Fp12.mul(Fp12.mul(t2_t5_pow_q2, t4_t1_pow_q3), t6_t1c_pow_q1), t7_t3c_t1);
|
||||
},
|
||||
});
|
||||
|
||||
// GLV endomorphism Ψ(P), for fast cofactor clearing
|
||||
const { G2psi, G2psi2 } = psiFrobenius(Fp, Fp2, Fp2.div(Fp2.ONE, Fp2.NONRESIDUE)); // 1/(u+1)
|
||||
|
||||
/**
|
||||
* Default hash_to_field / hash-to-curve for BLS.
|
||||
* m: 1 for G1, 2 for G2
|
||||
* k: target security level in bits
|
||||
* hash: any function, e.g. BBS+ uses BLAKE2: see [github](https://github.com/hyperledger/aries-framework-go/issues/2247).
|
||||
* Parameter values come from [section 8.8.2 of RFC 9380](https://www.rfc-editor.org/rfc/rfc9380#section-8.8.2).
|
||||
*/
|
||||
const htfDefaults = Object.freeze({
|
||||
DST: 'BLS_SIG_BLS12381G2_XMD:SHA-256_SSWU_RO_NUL_',
|
||||
encodeDST: 'BLS_SIG_BLS12381G2_XMD:SHA-256_SSWU_RO_NUL_',
|
||||
p: Fp.ORDER,
|
||||
m: 2,
|
||||
k: 128,
|
||||
expand: 'xmd',
|
||||
hash: sha256,
|
||||
});
|
||||
|
||||
// a=0, b=4
|
||||
// cofactor h of G2
|
||||
// (t^8 - 4t^7 + 5t^6 - 4t^4 + 6t^3 - 4t^2 - 4t + 13)/9
|
||||
// cofactorG2 = (t**8n - 4n*t**7n + 5n*t**6n - 4n*t**4n + 6n*t**3n - 4n*t**2n - 4n*t+13n)/9n
|
||||
// x = 3059144344244213709971259814753781636986470325476647558659373206291635324768958432433509563104347017837885763365758*u + 352701069587466618187139116011060144890029952792775240219908644239793785735715026873347600343865175952761926303160
|
||||
// y = 927553665492332455747201965776037880757740193453592970025027978793976877002675564980949289727957565575433344219582*u + 1985150602287291935568054521177171638300868978215655730859378665066344726373823718423869104263333984641494340347905
|
||||
const bls12_381_CURVE_G2 = {
|
||||
p: Fp2.ORDER,
|
||||
n: bls12_381_CURVE_G1.n,
|
||||
h: BigInt(
|
||||
'0x5d543a95414e7f1091d50792876a202cd91de4547085abaa68a205b2e5a7ddfa628f1cb4d9e82ef21537e293a6691ae1616ec6e786f0c70cf1c38e31c7238e5'
|
||||
),
|
||||
a: Fp2.ZERO,
|
||||
b: Fp2.fromBigTuple([_4n, _4n]),
|
||||
Gx: Fp2.fromBigTuple([
|
||||
BigInt(
|
||||
'0x024aa2b2f08f0a91260805272dc51051c6e47ad4fa403b02b4510b647ae3d1770bac0326a805bbefd48056c8c121bdb8'
|
||||
),
|
||||
BigInt(
|
||||
'0x13e02b6052719f607dacd3a088274f65596bd0d09920b61ab5da61bbdc7f5049334cf11213945d57e5ac7d055d042b7e'
|
||||
),
|
||||
]),
|
||||
Gy: Fp2.fromBigTuple([
|
||||
BigInt(
|
||||
'0x0ce5d527727d6e118cc9cdc6da2e351aadfd9baa8cbdd3a76d429a695160d12c923ac9cc3baca289e193548608b82801'
|
||||
),
|
||||
BigInt(
|
||||
'0x0606c4a02ea734cc32acd2b02bc28b99cb3e287e85a763af267492ab572e99ab3f370d275cec1da1aaa9075ff05f79be'
|
||||
),
|
||||
]),
|
||||
};
|
||||
|
||||
// Encoding utils
|
||||
// Compressed point of infinity
|
||||
// Set compressed & point-at-infinity bits
|
||||
const COMPZERO = setMask(Fp.toBytes(_0n), { infinity: true, compressed: true });
|
||||
|
||||
function parseMask(bytes: Uint8Array) {
|
||||
// Copy, so we can remove mask data. It will be removed also later, when Fp.create will call modulo.
|
||||
bytes = bytes.slice();
|
||||
const mask = bytes[0] & 0b1110_0000;
|
||||
const compressed = !!((mask >> 7) & 1); // compression bit (0b1000_0000)
|
||||
const infinity = !!((mask >> 6) & 1); // point at infinity bit (0b0100_0000)
|
||||
const sort = !!((mask >> 5) & 1); // sort bit (0b0010_0000)
|
||||
bytes[0] &= 0b0001_1111; // clear mask (zero first 3 bits)
|
||||
return { compressed, infinity, sort, value: bytes };
|
||||
}
|
||||
|
||||
function setMask(
|
||||
bytes: Uint8Array,
|
||||
mask: { compressed?: boolean; infinity?: boolean; sort?: boolean }
|
||||
) {
|
||||
if (bytes[0] & 0b1110_0000) throw new Error('setMask: non-empty mask');
|
||||
if (mask.compressed) bytes[0] |= 0b1000_0000;
|
||||
if (mask.infinity) bytes[0] |= 0b0100_0000;
|
||||
if (mask.sort) bytes[0] |= 0b0010_0000;
|
||||
return bytes;
|
||||
}
|
||||
|
||||
function pointG1ToBytes(
|
||||
_c: WeierstrassPointCons<Fp>,
|
||||
point: WeierstrassPoint<Fp>,
|
||||
isComp: boolean
|
||||
) {
|
||||
const { BYTES: L, ORDER: P } = Fp;
|
||||
const is0 = point.is0();
|
||||
const { x, y } = point.toAffine();
|
||||
if (isComp) {
|
||||
if (is0) return COMPZERO.slice();
|
||||
const sort = Boolean((y * _2n) / P);
|
||||
return setMask(numberToBytesBE(x, L), { compressed: true, sort });
|
||||
} else {
|
||||
if (is0) {
|
||||
return concatBytes(Uint8Array.of(0x40), new Uint8Array(2 * L - 1));
|
||||
} else {
|
||||
return concatBytes(numberToBytesBE(x, L), numberToBytesBE(y, L));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function signatureG1ToBytes(point: WeierstrassPoint<Fp>) {
|
||||
point.assertValidity();
|
||||
const { BYTES: L, ORDER: P } = Fp;
|
||||
const { x, y } = point.toAffine();
|
||||
if (point.is0()) return COMPZERO.slice();
|
||||
const sort = Boolean((y * _2n) / P);
|
||||
return setMask(numberToBytesBE(x, L), { compressed: true, sort });
|
||||
}
|
||||
|
||||
function pointG1FromBytes(bytes: Uint8Array): AffinePoint<Fp> {
|
||||
const { compressed, infinity, sort, value } = parseMask(bytes);
|
||||
const { BYTES: L, ORDER: P } = Fp;
|
||||
if (value.length === 48 && compressed) {
|
||||
const compressedValue = bytesToNumberBE(value);
|
||||
// Zero
|
||||
const x = Fp.create(compressedValue & bitMask(Fp.BITS));
|
||||
if (infinity) {
|
||||
if (x !== _0n) throw new Error('invalid G1 point: non-empty, at infinity, with compression');
|
||||
return { x: _0n, y: _0n };
|
||||
}
|
||||
const right = Fp.add(Fp.pow(x, _3n), Fp.create(bls12_381_CURVE_G1.b)); // y² = x³ + b
|
||||
let y = Fp.sqrt(right);
|
||||
if (!y) throw new Error('invalid G1 point: compressed point');
|
||||
if ((y * _2n) / P !== BigInt(sort)) y = Fp.neg(y);
|
||||
return { x: Fp.create(x), y: Fp.create(y) };
|
||||
} else if (value.length === 96 && !compressed) {
|
||||
// Check if the infinity flag is set
|
||||
const x = bytesToNumberBE(value.subarray(0, L));
|
||||
const y = bytesToNumberBE(value.subarray(L));
|
||||
if (infinity) {
|
||||
if (x !== _0n || y !== _0n) throw new Error('G1: non-empty point at infinity');
|
||||
return bls12_381.G1.Point.ZERO.toAffine();
|
||||
}
|
||||
return { x: Fp.create(x), y: Fp.create(y) };
|
||||
} else {
|
||||
throw new Error('invalid G1 point: expected 48/96 bytes');
|
||||
}
|
||||
}
|
||||
|
||||
function signatureG1FromBytes(hex: Hex): WeierstrassPoint<Fp> {
|
||||
const { infinity, sort, value } = parseMask(ensureBytes('signatureHex', hex, 48));
|
||||
const P = Fp.ORDER;
|
||||
const Point = bls12_381.G1.Point;
|
||||
const compressedValue = bytesToNumberBE(value);
|
||||
// Zero
|
||||
if (infinity) return Point.ZERO;
|
||||
const x = Fp.create(compressedValue & bitMask(Fp.BITS));
|
||||
const right = Fp.add(Fp.pow(x, _3n), Fp.create(bls12_381_CURVE_G1.b)); // y² = x³ + b
|
||||
let y = Fp.sqrt(right);
|
||||
if (!y) throw new Error('invalid G1 point: compressed');
|
||||
const aflag = BigInt(sort);
|
||||
if ((y * _2n) / P !== aflag) y = Fp.neg(y);
|
||||
const point = Point.fromAffine({ x, y });
|
||||
point.assertValidity();
|
||||
return point;
|
||||
}
|
||||
|
||||
function pointG2ToBytes(
|
||||
_c: WeierstrassPointCons<Fp2>,
|
||||
point: WeierstrassPoint<Fp2>,
|
||||
isComp: boolean
|
||||
) {
|
||||
const { BYTES: L, ORDER: P } = Fp;
|
||||
const is0 = point.is0();
|
||||
const { x, y } = point.toAffine();
|
||||
if (isComp) {
|
||||
if (is0) return concatBytes(COMPZERO, numberToBytesBE(_0n, L));
|
||||
const flag = Boolean(y.c1 === _0n ? (y.c0 * _2n) / P : (y.c1 * _2n) / P);
|
||||
return concatBytes(
|
||||
setMask(numberToBytesBE(x.c1, L), { compressed: true, sort: flag }),
|
||||
numberToBytesBE(x.c0, L)
|
||||
);
|
||||
} else {
|
||||
if (is0) return concatBytes(Uint8Array.of(0x40), new Uint8Array(4 * L - 1));
|
||||
const { re: x0, im: x1 } = Fp2.reim(x);
|
||||
const { re: y0, im: y1 } = Fp2.reim(y);
|
||||
return concatBytes(
|
||||
numberToBytesBE(x1, L),
|
||||
numberToBytesBE(x0, L),
|
||||
numberToBytesBE(y1, L),
|
||||
numberToBytesBE(y0, L)
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
function signatureG2ToBytes(point: WeierstrassPoint<Fp2>) {
|
||||
point.assertValidity();
|
||||
const { BYTES: L } = Fp;
|
||||
if (point.is0()) return concatBytes(COMPZERO, numberToBytesBE(_0n, L));
|
||||
const { x, y } = point.toAffine();
|
||||
const { re: x0, im: x1 } = Fp2.reim(x);
|
||||
const { re: y0, im: y1 } = Fp2.reim(y);
|
||||
const tmp = y1 > _0n ? y1 * _2n : y0 * _2n;
|
||||
const sort = Boolean((tmp / Fp.ORDER) & _1n);
|
||||
const z2 = x0;
|
||||
return concatBytes(
|
||||
setMask(numberToBytesBE(x1, L), { sort, compressed: true }),
|
||||
numberToBytesBE(z2, L)
|
||||
);
|
||||
}
|
||||
|
||||
function pointG2FromBytes(bytes: Uint8Array): AffinePoint<Fp2> {
|
||||
const { BYTES: L, ORDER: P } = Fp;
|
||||
const { compressed, infinity, sort, value } = parseMask(bytes);
|
||||
if (
|
||||
(!compressed && !infinity && sort) || // 00100000
|
||||
(!compressed && infinity && sort) || // 01100000
|
||||
(sort && infinity && compressed) // 11100000
|
||||
) {
|
||||
throw new Error('invalid encoding flag: ' + (bytes[0] & 0b1110_0000));
|
||||
}
|
||||
const slc = (b: Uint8Array, from: number, to?: number) => bytesToNumberBE(b.slice(from, to));
|
||||
if (value.length === 96 && compressed) {
|
||||
if (infinity) {
|
||||
// check that all bytes are 0
|
||||
if (value.reduce((p, c) => (p !== 0 ? c + 1 : c), 0) > 0) {
|
||||
throw new Error('invalid G2 point: compressed');
|
||||
}
|
||||
return { x: Fp2.ZERO, y: Fp2.ZERO };
|
||||
}
|
||||
const x_1 = slc(value, 0, L);
|
||||
const x_0 = slc(value, L, 2 * L);
|
||||
const x = Fp2.create({ c0: Fp.create(x_0), c1: Fp.create(x_1) });
|
||||
const right = Fp2.add(Fp2.pow(x, _3n), bls12_381_CURVE_G2.b); // y² = x³ + 4 * (u+1) = x³ + b
|
||||
let y = Fp2.sqrt(right);
|
||||
const Y_bit = y.c1 === _0n ? (y.c0 * _2n) / P : (y.c1 * _2n) / P ? _1n : _0n;
|
||||
y = sort && Y_bit > 0 ? y : Fp2.neg(y);
|
||||
return { x, y };
|
||||
} else if (value.length === 192 && !compressed) {
|
||||
if (infinity) {
|
||||
if (value.reduce((p, c) => (p !== 0 ? c + 1 : c), 0) > 0) {
|
||||
throw new Error('invalid G2 point: uncompressed');
|
||||
}
|
||||
return { x: Fp2.ZERO, y: Fp2.ZERO };
|
||||
}
|
||||
const x1 = slc(value, 0 * L, 1 * L);
|
||||
const x0 = slc(value, 1 * L, 2 * L);
|
||||
const y1 = slc(value, 2 * L, 3 * L);
|
||||
const y0 = slc(value, 3 * L, 4 * L);
|
||||
return { x: Fp2.fromBigTuple([x0, x1]), y: Fp2.fromBigTuple([y0, y1]) };
|
||||
} else {
|
||||
throw new Error('invalid G2 point: expected 96/192 bytes');
|
||||
}
|
||||
}
|
||||
|
||||
function signatureG2FromBytes(hex: Hex) {
|
||||
const { ORDER: P } = Fp;
|
||||
// TODO: Optimize, it's very slow because of sqrt.
|
||||
const { infinity, sort, value } = parseMask(ensureBytes('signatureHex', hex));
|
||||
const Point = bls12_381.G2.Point;
|
||||
const half = value.length / 2;
|
||||
if (half !== 48 && half !== 96)
|
||||
throw new Error('invalid compressed signature length, expected 96/192 bytes');
|
||||
const z1 = bytesToNumberBE(value.slice(0, half));
|
||||
const z2 = bytesToNumberBE(value.slice(half));
|
||||
// Indicates the infinity point
|
||||
if (infinity) return Point.ZERO;
|
||||
const x1 = Fp.create(z1 & bitMask(Fp.BITS));
|
||||
const x2 = Fp.create(z2);
|
||||
const x = Fp2.create({ c0: x2, c1: x1 });
|
||||
const y2 = Fp2.add(Fp2.pow(x, _3n), bls12_381_CURVE_G2.b); // y² = x³ + 4
|
||||
// The slow part
|
||||
let y = Fp2.sqrt(y2);
|
||||
if (!y) throw new Error('Failed to find a square root');
|
||||
|
||||
// Choose the y whose leftmost bit of the imaginary part is equal to the a_flag1
|
||||
// If y1 happens to be zero, then use the bit of y0
|
||||
const { re: y0, im: y1 } = Fp2.reim(y);
|
||||
const aflag1 = BigInt(sort);
|
||||
const isGreater = y1 > _0n && (y1 * _2n) / P !== aflag1;
|
||||
const is0 = y1 === _0n && (y0 * _2n) / P !== aflag1;
|
||||
if (isGreater || is0) y = Fp2.neg(y);
|
||||
const point = Point.fromAffine({ x, y });
|
||||
point.assertValidity();
|
||||
return point;
|
||||
}
|
||||
|
||||
/**
|
||||
* bls12-381 pairing-friendly curve.
|
||||
* @example
|
||||
* import { bls12_381 as bls } from '@noble/curves/bls12-381';
|
||||
* // G1 keys, G2 signatures
|
||||
* const privateKey = '67d53f170b908cabb9eb326c3c337762d59289a8fec79f7bc9254b584b73265c';
|
||||
* const message = '64726e3da8';
|
||||
* const publicKey = bls.getPublicKey(privateKey);
|
||||
* const signature = bls.sign(message, privateKey);
|
||||
* const isValid = bls.verify(signature, message, publicKey);
|
||||
*/
|
||||
export const bls12_381: CurveFn = bls({
|
||||
// Fields
|
||||
fields: {
|
||||
Fp,
|
||||
Fp2,
|
||||
Fp6,
|
||||
Fp12,
|
||||
Fr: bls12_381_Fr,
|
||||
},
|
||||
// G1: y² = x³ + 4
|
||||
G1: {
|
||||
...bls12_381_CURVE_G1,
|
||||
Fp,
|
||||
htfDefaults: { ...htfDefaults, m: 1, DST: 'BLS_SIG_BLS12381G1_XMD:SHA-256_SSWU_RO_NUL_' },
|
||||
wrapPrivateKey: true,
|
||||
allowInfinityPoint: true,
|
||||
// Checks is the point resides in prime-order subgroup.
|
||||
// point.isTorsionFree() should return true for valid points
|
||||
// It returns false for shitty points.
|
||||
// https://eprint.iacr.org/2021/1130.pdf
|
||||
isTorsionFree: (c, point): boolean => {
|
||||
// GLV endomorphism ψ(P)
|
||||
const beta = BigInt(
|
||||
'0x5f19672fdf76ce51ba69c6076a0f77eaddb3a93be6f89688de17d813620a00022e01fffffffefffe'
|
||||
);
|
||||
const phi = new c(Fp.mul(point.X, beta), point.Y, point.Z);
|
||||
// TODO: unroll
|
||||
const xP = point.multiplyUnsafe(BLS_X).negate(); // [x]P
|
||||
const u2P = xP.multiplyUnsafe(BLS_X); // [u2]P
|
||||
return u2P.equals(phi);
|
||||
},
|
||||
// Clear cofactor of G1
|
||||
// https://eprint.iacr.org/2019/403
|
||||
clearCofactor: (_c, point) => {
|
||||
// return this.multiplyUnsafe(CURVE.h);
|
||||
return point.multiplyUnsafe(BLS_X).add(point); // x*P + P
|
||||
},
|
||||
mapToCurve: mapToG1,
|
||||
fromBytes: pointG1FromBytes,
|
||||
toBytes: pointG1ToBytes,
|
||||
ShortSignature: {
|
||||
fromBytes(bytes: Uint8Array) {
|
||||
abytes(bytes);
|
||||
return signatureG1FromBytes(bytes);
|
||||
},
|
||||
fromHex(hex: Hex): WeierstrassPoint<Fp> {
|
||||
return signatureG1FromBytes(hex);
|
||||
},
|
||||
toBytes(point: WeierstrassPoint<Fp>) {
|
||||
return signatureG1ToBytes(point);
|
||||
},
|
||||
toRawBytes(point: WeierstrassPoint<Fp>) {
|
||||
return signatureG1ToBytes(point);
|
||||
},
|
||||
toHex(point: WeierstrassPoint<Fp>) {
|
||||
return bytesToHex(signatureG1ToBytes(point));
|
||||
},
|
||||
},
|
||||
},
|
||||
G2: {
|
||||
...bls12_381_CURVE_G2,
|
||||
Fp: Fp2,
|
||||
// https://datatracker.ietf.org/doc/html/rfc9380#name-clearing-the-cofactor
|
||||
// https://datatracker.ietf.org/doc/html/rfc9380#name-cofactor-clearing-for-bls12
|
||||
hEff: BigInt(
|
||||
'0xbc69f08f2ee75b3584c6a0ea91b352888e2a8e9145ad7689986ff031508ffe1329c2f178731db956d82bf015d1212b02ec0ec69d7477c1ae954cbc06689f6a359894c0adebbf6b4e8020005aaa95551'
|
||||
),
|
||||
htfDefaults: { ...htfDefaults },
|
||||
wrapPrivateKey: true,
|
||||
allowInfinityPoint: true,
|
||||
mapToCurve: mapToG2,
|
||||
// Checks is the point resides in prime-order subgroup.
|
||||
// point.isTorsionFree() should return true for valid points
|
||||
// It returns false for shitty points.
|
||||
// https://eprint.iacr.org/2021/1130.pdf
|
||||
// Older version: https://eprint.iacr.org/2019/814.pdf
|
||||
isTorsionFree: (c, P): boolean => {
|
||||
return P.multiplyUnsafe(BLS_X).negate().equals(G2psi(c, P)); // ψ(P) == [u](P)
|
||||
},
|
||||
// Maps the point into the prime-order subgroup G2.
|
||||
// clear_cofactor_bls12381_g2 from RFC 9380.
|
||||
// https://eprint.iacr.org/2017/419.pdf
|
||||
// prettier-ignore
|
||||
clearCofactor: (c, P) => {
|
||||
const x = BLS_X;
|
||||
let t1 = P.multiplyUnsafe(x).negate(); // [-x]P
|
||||
let t2 = G2psi(c, P); // Ψ(P)
|
||||
let t3 = P.double(); // 2P
|
||||
t3 = G2psi2(c, t3); // Ψ²(2P)
|
||||
t3 = t3.subtract(t2); // Ψ²(2P) - Ψ(P)
|
||||
t2 = t1.add(t2); // [-x]P + Ψ(P)
|
||||
t2 = t2.multiplyUnsafe(x).negate(); // [x²]P - [x]Ψ(P)
|
||||
t3 = t3.add(t2); // Ψ²(2P) - Ψ(P) + [x²]P - [x]Ψ(P)
|
||||
t3 = t3.subtract(t1); // Ψ²(2P) - Ψ(P) + [x²]P - [x]Ψ(P) + [x]P
|
||||
const Q = t3.subtract(P); // Ψ²(2P) - Ψ(P) + [x²]P - [x]Ψ(P) + [x]P - 1P
|
||||
return Q; // [x²-x-1]P + [x-1]Ψ(P) + Ψ²(2P)
|
||||
},
|
||||
fromBytes: pointG2FromBytes,
|
||||
toBytes: pointG2ToBytes,
|
||||
Signature: {
|
||||
fromBytes(bytes: Uint8Array): WeierstrassPoint<Fp2> {
|
||||
abytes(bytes);
|
||||
return signatureG2FromBytes(bytes);
|
||||
},
|
||||
fromHex(hex: Hex): WeierstrassPoint<Fp2> {
|
||||
return signatureG2FromBytes(hex);
|
||||
},
|
||||
toBytes(point: WeierstrassPoint<Fp2>) {
|
||||
return signatureG2ToBytes(point);
|
||||
},
|
||||
toRawBytes(point: WeierstrassPoint<Fp2>) {
|
||||
return signatureG2ToBytes(point);
|
||||
},
|
||||
toHex(point: WeierstrassPoint<Fp2>) {
|
||||
return bytesToHex(signatureG2ToBytes(point));
|
||||
},
|
||||
},
|
||||
},
|
||||
params: {
|
||||
ateLoopSize: BLS_X, // The BLS parameter x for BLS12-381
|
||||
r: bls12_381_CURVE_G1.n, // order; z⁴ − z² + 1; CURVE.n from other curves
|
||||
xNegative: true,
|
||||
twistType: 'multiplicative',
|
||||
},
|
||||
htfDefaults,
|
||||
hash: sha256,
|
||||
});
|
||||
|
||||
// 3-isogeny map from E' to E https://www.rfc-editor.org/rfc/rfc9380#appendix-E.3
|
||||
const isogenyMapG2 = isogenyMap(
|
||||
Fp2,
|
||||
[
|
||||
// xNum
|
||||
[
|
||||
[
|
||||
'0x5c759507e8e333ebb5b7a9a47d7ed8532c52d39fd3a042a88b58423c50ae15d5c2638e343d9c71c6238aaaaaaaa97d6',
|
||||
'0x5c759507e8e333ebb5b7a9a47d7ed8532c52d39fd3a042a88b58423c50ae15d5c2638e343d9c71c6238aaaaaaaa97d6',
|
||||
],
|
||||
[
|
||||
'0x0',
|
||||
'0x11560bf17baa99bc32126fced787c88f984f87adf7ae0c7f9a208c6b4f20a4181472aaa9cb8d555526a9ffffffffc71a',
|
||||
],
|
||||
[
|
||||
'0x11560bf17baa99bc32126fced787c88f984f87adf7ae0c7f9a208c6b4f20a4181472aaa9cb8d555526a9ffffffffc71e',
|
||||
'0x8ab05f8bdd54cde190937e76bc3e447cc27c3d6fbd7063fcd104635a790520c0a395554e5c6aaaa9354ffffffffe38d',
|
||||
],
|
||||
[
|
||||
'0x171d6541fa38ccfaed6dea691f5fb614cb14b4e7f4e810aa22d6108f142b85757098e38d0f671c7188e2aaaaaaaa5ed1',
|
||||
'0x0',
|
||||
],
|
||||
],
|
||||
// xDen
|
||||
[
|
||||
[
|
||||
'0x0',
|
||||
'0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaa63',
|
||||
],
|
||||
[
|
||||
'0xc',
|
||||
'0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaa9f',
|
||||
],
|
||||
['0x1', '0x0'], // LAST 1
|
||||
],
|
||||
// yNum
|
||||
[
|
||||
[
|
||||
'0x1530477c7ab4113b59a4c18b076d11930f7da5d4a07f649bf54439d87d27e500fc8c25ebf8c92f6812cfc71c71c6d706',
|
||||
'0x1530477c7ab4113b59a4c18b076d11930f7da5d4a07f649bf54439d87d27e500fc8c25ebf8c92f6812cfc71c71c6d706',
|
||||
],
|
||||
[
|
||||
'0x0',
|
||||
'0x5c759507e8e333ebb5b7a9a47d7ed8532c52d39fd3a042a88b58423c50ae15d5c2638e343d9c71c6238aaaaaaaa97be',
|
||||
],
|
||||
[
|
||||
'0x11560bf17baa99bc32126fced787c88f984f87adf7ae0c7f9a208c6b4f20a4181472aaa9cb8d555526a9ffffffffc71c',
|
||||
'0x8ab05f8bdd54cde190937e76bc3e447cc27c3d6fbd7063fcd104635a790520c0a395554e5c6aaaa9354ffffffffe38f',
|
||||
],
|
||||
[
|
||||
'0x124c9ad43b6cf79bfbf7043de3811ad0761b0f37a1e26286b0e977c69aa274524e79097a56dc4bd9e1b371c71c718b10',
|
||||
'0x0',
|
||||
],
|
||||
],
|
||||
// yDen
|
||||
[
|
||||
[
|
||||
'0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffa8fb',
|
||||
'0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffa8fb',
|
||||
],
|
||||
[
|
||||
'0x0',
|
||||
'0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffa9d3',
|
||||
],
|
||||
[
|
||||
'0x12',
|
||||
'0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaa99',
|
||||
],
|
||||
['0x1', '0x0'], // LAST 1
|
||||
],
|
||||
].map((i) => i.map((pair) => Fp2.fromBigTuple(pair.map(BigInt) as BigintTuple))) as [
|
||||
Fp2[],
|
||||
Fp2[],
|
||||
Fp2[],
|
||||
Fp2[],
|
||||
]
|
||||
);
|
||||
// 11-isogeny map from E' to E
|
||||
const isogenyMapG1 = isogenyMap(
|
||||
Fp,
|
||||
[
|
||||
// xNum
|
||||
[
|
||||
'0x11a05f2b1e833340b809101dd99815856b303e88a2d7005ff2627b56cdb4e2c85610c2d5f2e62d6eaeac1662734649b7',
|
||||
'0x17294ed3e943ab2f0588bab22147a81c7c17e75b2f6a8417f565e33c70d1e86b4838f2a6f318c356e834eef1b3cb83bb',
|
||||
'0xd54005db97678ec1d1048c5d10a9a1bce032473295983e56878e501ec68e25c958c3e3d2a09729fe0179f9dac9edcb0',
|
||||
'0x1778e7166fcc6db74e0609d307e55412d7f5e4656a8dbf25f1b33289f1b330835336e25ce3107193c5b388641d9b6861',
|
||||
'0xe99726a3199f4436642b4b3e4118e5499db995a1257fb3f086eeb65982fac18985a286f301e77c451154ce9ac8895d9',
|
||||
'0x1630c3250d7313ff01d1201bf7a74ab5db3cb17dd952799b9ed3ab9097e68f90a0870d2dcae73d19cd13c1c66f652983',
|
||||
'0xd6ed6553fe44d296a3726c38ae652bfb11586264f0f8ce19008e218f9c86b2a8da25128c1052ecaddd7f225a139ed84',
|
||||
'0x17b81e7701abdbe2e8743884d1117e53356de5ab275b4db1a682c62ef0f2753339b7c8f8c8f475af9ccb5618e3f0c88e',
|
||||
'0x80d3cf1f9a78fc47b90b33563be990dc43b756ce79f5574a2c596c928c5d1de4fa295f296b74e956d71986a8497e317',
|
||||
'0x169b1f8e1bcfa7c42e0c37515d138f22dd2ecb803a0c5c99676314baf4bb1b7fa3190b2edc0327797f241067be390c9e',
|
||||
'0x10321da079ce07e272d8ec09d2565b0dfa7dccdde6787f96d50af36003b14866f69b771f8c285decca67df3f1605fb7b',
|
||||
'0x6e08c248e260e70bd1e962381edee3d31d79d7e22c837bc23c0bf1bc24c6b68c24b1b80b64d391fa9c8ba2e8ba2d229',
|
||||
],
|
||||
// xDen
|
||||
[
|
||||
'0x8ca8d548cff19ae18b2e62f4bd3fa6f01d5ef4ba35b48ba9c9588617fc8ac62b558d681be343df8993cf9fa40d21b1c',
|
||||
'0x12561a5deb559c4348b4711298e536367041e8ca0cf0800c0126c2588c48bf5713daa8846cb026e9e5c8276ec82b3bff',
|
||||
'0xb2962fe57a3225e8137e629bff2991f6f89416f5a718cd1fca64e00b11aceacd6a3d0967c94fedcfcc239ba5cb83e19',
|
||||
'0x3425581a58ae2fec83aafef7c40eb545b08243f16b1655154cca8abc28d6fd04976d5243eecf5c4130de8938dc62cd8',
|
||||
'0x13a8e162022914a80a6f1d5f43e7a07dffdfc759a12062bb8d6b44e833b306da9bd29ba81f35781d539d395b3532a21e',
|
||||
'0xe7355f8e4e667b955390f7f0506c6e9395735e9ce9cad4d0a43bcef24b8982f7400d24bc4228f11c02df9a29f6304a5',
|
||||
'0x772caacf16936190f3e0c63e0596721570f5799af53a1894e2e073062aede9cea73b3538f0de06cec2574496ee84a3a',
|
||||
'0x14a7ac2a9d64a8b230b3f5b074cf01996e7f63c21bca68a81996e1cdf9822c580fa5b9489d11e2d311f7d99bbdcc5a5e',
|
||||
'0xa10ecf6ada54f825e920b3dafc7a3cce07f8d1d7161366b74100da67f39883503826692abba43704776ec3a79a1d641',
|
||||
'0x95fc13ab9e92ad4476d6e3eb3a56680f682b4ee96f7d03776df533978f31c1593174e4b4b7865002d6384d168ecdd0a',
|
||||
'0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001', // LAST 1
|
||||
],
|
||||
// yNum
|
||||
[
|
||||
'0x90d97c81ba24ee0259d1f094980dcfa11ad138e48a869522b52af6c956543d3cd0c7aee9b3ba3c2be9845719707bb33',
|
||||
'0x134996a104ee5811d51036d776fb46831223e96c254f383d0f906343eb67ad34d6c56711962fa8bfe097e75a2e41c696',
|
||||
'0xcc786baa966e66f4a384c86a3b49942552e2d658a31ce2c344be4b91400da7d26d521628b00523b8dfe240c72de1f6',
|
||||
'0x1f86376e8981c217898751ad8746757d42aa7b90eeb791c09e4a3ec03251cf9de405aba9ec61deca6355c77b0e5f4cb',
|
||||
'0x8cc03fdefe0ff135caf4fe2a21529c4195536fbe3ce50b879833fd221351adc2ee7f8dc099040a841b6daecf2e8fedb',
|
||||
'0x16603fca40634b6a2211e11db8f0a6a074a7d0d4afadb7bd76505c3d3ad5544e203f6326c95a807299b23ab13633a5f0',
|
||||
'0x4ab0b9bcfac1bbcb2c977d027796b3ce75bb8ca2be184cb5231413c4d634f3747a87ac2460f415ec961f8855fe9d6f2',
|
||||
'0x987c8d5333ab86fde9926bd2ca6c674170a05bfe3bdd81ffd038da6c26c842642f64550fedfe935a15e4ca31870fb29',
|
||||
'0x9fc4018bd96684be88c9e221e4da1bb8f3abd16679dc26c1e8b6e6a1f20cabe69d65201c78607a360370e577bdba587',
|
||||
'0xe1bba7a1186bdb5223abde7ada14a23c42a0ca7915af6fe06985e7ed1e4d43b9b3f7055dd4eba6f2bafaaebca731c30',
|
||||
'0x19713e47937cd1be0dfd0b8f1d43fb93cd2fcbcb6caf493fd1183e416389e61031bf3a5cce3fbafce813711ad011c132',
|
||||
'0x18b46a908f36f6deb918c143fed2edcc523559b8aaf0c2462e6bfe7f911f643249d9cdf41b44d606ce07c8a4d0074d8e',
|
||||
'0xb182cac101b9399d155096004f53f447aa7b12a3426b08ec02710e807b4633f06c851c1919211f20d4c04f00b971ef8',
|
||||
'0x245a394ad1eca9b72fc00ae7be315dc757b3b080d4c158013e6632d3c40659cc6cf90ad1c232a6442d9d3f5db980133',
|
||||
'0x5c129645e44cf1102a159f748c4a3fc5e673d81d7e86568d9ab0f5d396a7ce46ba1049b6579afb7866b1e715475224b',
|
||||
'0x15e6be4e990f03ce4ea50b3b42df2eb5cb181d8f84965a3957add4fa95af01b2b665027efec01c7704b456be69c8b604',
|
||||
],
|
||||
// yDen
|
||||
[
|
||||
'0x16112c4c3a9c98b252181140fad0eae9601a6de578980be6eec3232b5be72e7a07f3688ef60c206d01479253b03663c1',
|
||||
'0x1962d75c2381201e1a0cbd6c43c348b885c84ff731c4d59ca4a10356f453e01f78a4260763529e3532f6102c2e49a03d',
|
||||
'0x58df3306640da276faaae7d6e8eb15778c4855551ae7f310c35a5dd279cd2eca6757cd636f96f891e2538b53dbf67f2',
|
||||
'0x16b7d288798e5395f20d23bf89edb4d1d115c5dbddbcd30e123da489e726af41727364f2c28297ada8d26d98445f5416',
|
||||
'0xbe0e079545f43e4b00cc912f8228ddcc6d19c9f0f69bbb0542eda0fc9dec916a20b15dc0fd2ededda39142311a5001d',
|
||||
'0x8d9e5297186db2d9fb266eaac783182b70152c65550d881c5ecd87b6f0f5a6449f38db9dfa9cce202c6477faaf9b7ac',
|
||||
'0x166007c08a99db2fc3ba8734ace9824b5eecfdfa8d0cf8ef5dd365bc400a0051d5fa9c01a58b1fb93d1a1399126a775c',
|
||||
'0x16a3ef08be3ea7ea03bcddfabba6ff6ee5a4375efa1f4fd7feb34fd206357132b920f5b00801dee460ee415a15812ed9',
|
||||
'0x1866c8ed336c61231a1be54fd1d74cc4f9fb0ce4c6af5920abc5750c4bf39b4852cfe2f7bb9248836b233d9d55535d4a',
|
||||
'0x167a55cda70a6e1cea820597d94a84903216f763e13d87bb5308592e7ea7d4fbc7385ea3d529b35e346ef48bb8913f55',
|
||||
'0x4d2f259eea405bd48f010a01ad2911d9c6dd039bb61a6290e591b36e636a5c871a5c29f4f83060400f8b49cba8f6aa8',
|
||||
'0xaccbb67481d033ff5852c1e48c50c477f94ff8aefce42d28c0f9a88cea7913516f968986f7ebbea9684b529e2561092',
|
||||
'0xad6b9514c767fe3c3613144b45f1496543346d98adf02267d5ceef9a00d9b8693000763e3b90ac11e99b138573345cc',
|
||||
'0x2660400eb2e4f3b628bdd0d53cd76f2bf565b94e72927c1cb748df27942480e420517bd8714cc80d1fadc1326ed06f7',
|
||||
'0xe0fa1d816ddc03e6b24255e0d7819c171c40f65e273b853324efcd6356caa205ca2f570f13497804415473a1d634b8f',
|
||||
'0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001', // LAST 1
|
||||
],
|
||||
].map((i) => i.map((j) => BigInt(j))) as [Fp[], Fp[], Fp[], Fp[]]
|
||||
);
|
||||
|
||||
// Optimized SWU Map - Fp to G1
|
||||
const G1_SWU = mapToCurveSimpleSWU(Fp, {
|
||||
A: Fp.create(
|
||||
BigInt(
|
||||
'0x144698a3b8e9433d693a02c96d4982b0ea985383ee66a8d8e8981aefd881ac98936f8da0e0f97f5cf428082d584c1d'
|
||||
)
|
||||
),
|
||||
B: Fp.create(
|
||||
BigInt(
|
||||
'0x12e2908d11688030018b12e8753eee3b2016c1f0f24f4070a0b9c14fcef35ef55a23215a316ceaa5d1cc48e98e172be0'
|
||||
)
|
||||
),
|
||||
Z: Fp.create(BigInt(11)),
|
||||
});
|
||||
// SWU Map - Fp2 to G2': y² = x³ + 240i * x + 1012 + 1012i
|
||||
const G2_SWU = mapToCurveSimpleSWU(Fp2, {
|
||||
A: Fp2.create({ c0: Fp.create(_0n), c1: Fp.create(BigInt(240)) }), // A' = 240 * I
|
||||
B: Fp2.create({ c0: Fp.create(BigInt(1012)), c1: Fp.create(BigInt(1012)) }), // B' = 1012 * (1 + I)
|
||||
Z: Fp2.create({ c0: Fp.create(BigInt(-2)), c1: Fp.create(BigInt(-1)) }), // Z: -(2 + I)
|
||||
});
|
||||
|
||||
function mapToG1(scalars: bigint[]) {
|
||||
const { x, y } = G1_SWU(Fp.create(scalars[0]));
|
||||
return isogenyMapG1(x, y);
|
||||
}
|
||||
function mapToG2(scalars: bigint[]) {
|
||||
const { x, y } = G2_SWU(Fp2.fromBigTuple(scalars as BigintTuple));
|
||||
return isogenyMapG2(x, y);
|
||||
}
|
||||
@@ -0,0 +1,669 @@
|
||||
/**
|
||||
* @fileoverview Rule to flag constant comparisons and logical expressions that always/never short circuit
|
||||
* @author Jordan Eldredge <https://jordaneldredge.com>
|
||||
*/
|
||||
|
||||
"use strict";
|
||||
|
||||
const {
|
||||
isNullLiteral,
|
||||
isConstant,
|
||||
isReferenceToGlobalVariable,
|
||||
isLogicalAssignmentOperator,
|
||||
ECMASCRIPT_GLOBALS,
|
||||
} = require("./utils/ast-utils");
|
||||
|
||||
const NUMERIC_OR_STRING_BINARY_OPERATORS = new Set([
|
||||
"+",
|
||||
"-",
|
||||
"*",
|
||||
"/",
|
||||
"%",
|
||||
"|",
|
||||
"^",
|
||||
"&",
|
||||
"**",
|
||||
"<<",
|
||||
">>",
|
||||
">>>",
|
||||
]);
|
||||
|
||||
const RELATIONAL_OPERATORS = new Set(["<", "<=", ">", ">="]);
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Helpers
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Checks whether or not a node is `null` or `undefined`. Similar to the one
|
||||
* found in ast-utils.js, but this one correctly handles the edge case that
|
||||
* `undefined` has been redefined.
|
||||
* @param {Scope} scope Scope in which the expression was found.
|
||||
* @param {ASTNode} node A node to check.
|
||||
* @returns {boolean} Whether or not the node is a `null` or `undefined`.
|
||||
* @public
|
||||
*/
|
||||
function isNullOrUndefined(scope, node) {
|
||||
return (
|
||||
isNullLiteral(node) ||
|
||||
(node.type === "Identifier" &&
|
||||
node.name === "undefined" &&
|
||||
isReferenceToGlobalVariable(scope, node)) ||
|
||||
(node.type === "UnaryExpression" && node.operator === "void")
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Test if an AST node has a statically knowable constant nullishness. Meaning,
|
||||
* it will always resolve to a constant value of either: `null`, `undefined`
|
||||
* or not `null` _or_ `undefined`. An expression that can vary between those
|
||||
* three states at runtime would return `false`.
|
||||
* @param {Scope} scope The scope in which the node was found.
|
||||
* @param {ASTNode} node The AST node being tested.
|
||||
* @param {boolean} nonNullish if `true` then nullish values are not considered constant.
|
||||
* @returns {boolean} Does `node` have constant nullishness?
|
||||
*/
|
||||
function hasConstantNullishness(scope, node, nonNullish) {
|
||||
if (nonNullish && isNullOrUndefined(scope, node)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
switch (node.type) {
|
||||
case "ObjectExpression": // Objects are never nullish
|
||||
case "ArrayExpression": // Arrays are never nullish
|
||||
case "ArrowFunctionExpression": // Functions never nullish
|
||||
case "FunctionExpression": // Functions are never nullish
|
||||
case "ClassExpression": // Classes are never nullish
|
||||
case "NewExpression": // Objects are never nullish
|
||||
case "Literal": // Nullish, or non-nullish, literals never change
|
||||
case "TemplateLiteral": // A string is never nullish
|
||||
case "UpdateExpression": // Numbers are never nullish
|
||||
case "BinaryExpression": // Numbers, strings, or booleans are never nullish
|
||||
return true;
|
||||
case "CallExpression": {
|
||||
if (node.callee.type !== "Identifier") {
|
||||
return false;
|
||||
}
|
||||
const functionName = node.callee.name;
|
||||
|
||||
return (
|
||||
(functionName === "Boolean" ||
|
||||
functionName === "String" ||
|
||||
functionName === "Number" ||
|
||||
functionName === "Symbol" ||
|
||||
functionName === "BigInt") &&
|
||||
isReferenceToGlobalVariable(scope, node.callee)
|
||||
);
|
||||
}
|
||||
case "LogicalExpression": {
|
||||
return (
|
||||
node.operator === "??" &&
|
||||
hasConstantNullishness(scope, node.right, true)
|
||||
);
|
||||
}
|
||||
case "AssignmentExpression":
|
||||
if (node.operator === "=") {
|
||||
return hasConstantNullishness(scope, node.right, nonNullish);
|
||||
}
|
||||
|
||||
/*
|
||||
* Handling short-circuiting assignment operators would require
|
||||
* walking the scope. We won't attempt that (for now...) /
|
||||
*/
|
||||
if (isLogicalAssignmentOperator(node.operator)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
/*
|
||||
* The remaining assignment expressions all result in a numeric or
|
||||
* string (non-nullish) value:
|
||||
* "+=", "-=", "*=", "/=", "%=", "<<=", ">>=", ">>>=", "|=", "^=", "&="
|
||||
*/
|
||||
|
||||
return true;
|
||||
case "UnaryExpression":
|
||||
/*
|
||||
* "void" Always returns `undefined`
|
||||
* "typeof" All types are strings, and thus non-nullish
|
||||
* "!" Boolean is never nullish
|
||||
* "delete" Returns a boolean, which is never nullish
|
||||
* Math operators always return numbers or strings, neither of which
|
||||
* are non-nullish "+", "-", "~"
|
||||
*/
|
||||
|
||||
return true;
|
||||
case "SequenceExpression": {
|
||||
const last = node.expressions.at(-1);
|
||||
|
||||
return hasConstantNullishness(scope, last, nonNullish);
|
||||
}
|
||||
case "Identifier":
|
||||
return (
|
||||
node.name === "undefined" &&
|
||||
isReferenceToGlobalVariable(scope, node)
|
||||
);
|
||||
case "JSXElement": // ESLint has a policy of not assuming any specific JSX behavior.
|
||||
case "JSXFragment":
|
||||
return false;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Test if an AST node is a boolean value that never changes. Specifically we
|
||||
* test for:
|
||||
* 1. Literal booleans (`true` or `false`)
|
||||
* 2. Unary `!` expressions with a constant value
|
||||
* 3. Constant booleans created via the `Boolean` global function
|
||||
* @param {Scope} scope The scope in which the node was found.
|
||||
* @param {ASTNode} node The node to test
|
||||
* @returns {boolean} Is `node` guaranteed to be a boolean?
|
||||
*/
|
||||
function isStaticBoolean(scope, node) {
|
||||
switch (node.type) {
|
||||
case "Literal":
|
||||
return typeof node.value === "boolean";
|
||||
case "CallExpression":
|
||||
return (
|
||||
node.callee.type === "Identifier" &&
|
||||
node.callee.name === "Boolean" &&
|
||||
isReferenceToGlobalVariable(scope, node.callee) &&
|
||||
(node.arguments.length === 0 ||
|
||||
isConstant(scope, node.arguments[0], true))
|
||||
);
|
||||
case "UnaryExpression":
|
||||
return (
|
||||
node.operator === "!" && isConstant(scope, node.argument, true)
|
||||
);
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Test if an AST node will always give the same result when compared to a
|
||||
* boolean value. Note that comparison to boolean values is different than
|
||||
* truthiness.
|
||||
* https://262.ecma-international.org/5.1/#sec-11.9.3
|
||||
*
|
||||
* JavaScript `==` operator works by converting the boolean to `1` (true) or
|
||||
* `+0` (false) and then checks the values `==` equality to that number.
|
||||
* @param {Scope} scope The scope in which node was found.
|
||||
* @param {ASTNode} node The node to test.
|
||||
* @returns {boolean} Will `node` always coerce to the same boolean value?
|
||||
*/
|
||||
function hasConstantLooseBooleanComparison(scope, node) {
|
||||
switch (node.type) {
|
||||
case "ObjectExpression":
|
||||
case "ClassExpression":
|
||||
/**
|
||||
* In theory objects like:
|
||||
*
|
||||
* `{toString: () => a}`
|
||||
* `{valueOf: () => a}`
|
||||
*
|
||||
* Or a classes like:
|
||||
*
|
||||
* `class { static toString() { return a } }`
|
||||
* `class { static valueOf() { return a } }`
|
||||
*
|
||||
* Are not constant verifiably when `inBooleanPosition` is
|
||||
* false, but it's an edge case we've opted not to handle.
|
||||
*/
|
||||
return true;
|
||||
case "ArrayExpression": {
|
||||
const nonSpreadElements = node.elements.filter(
|
||||
e =>
|
||||
// Elements can be `null` in sparse arrays: `[,,]`;
|
||||
e !== null && e.type !== "SpreadElement",
|
||||
);
|
||||
|
||||
/*
|
||||
* Possible future direction if needed: We could check if the
|
||||
* single value would result in variable boolean comparison.
|
||||
* For now we will err on the side of caution since `[x]` could
|
||||
* evaluate to `[0]` or `[1]`.
|
||||
*/
|
||||
return node.elements.length === 0 || nonSpreadElements.length > 1;
|
||||
}
|
||||
case "ArrowFunctionExpression":
|
||||
case "FunctionExpression":
|
||||
return true;
|
||||
case "UnaryExpression":
|
||||
if (
|
||||
node.operator === "void" || // Always returns `undefined`
|
||||
node.operator === "typeof" // All `typeof` strings, when coerced to number, are not 0 or 1.
|
||||
) {
|
||||
return true;
|
||||
}
|
||||
if (node.operator === "!") {
|
||||
return isConstant(scope, node.argument, true);
|
||||
}
|
||||
|
||||
/*
|
||||
* We won't try to reason about +, -, ~, or delete
|
||||
* In theory, for the mathematical operators, we could look at the
|
||||
* argument and try to determine if it coerces to a constant numeric
|
||||
* value.
|
||||
*/
|
||||
return false;
|
||||
case "NewExpression": // Objects might have custom `.valueOf` or `.toString`.
|
||||
return false;
|
||||
case "CallExpression": {
|
||||
if (
|
||||
node.callee.type === "Identifier" &&
|
||||
node.callee.name === "Boolean" &&
|
||||
isReferenceToGlobalVariable(scope, node.callee)
|
||||
) {
|
||||
return (
|
||||
node.arguments.length === 0 ||
|
||||
isConstant(scope, node.arguments[0], true)
|
||||
);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
case "Literal": // True or false, literals never change
|
||||
return true;
|
||||
case "Identifier":
|
||||
return (
|
||||
node.name === "undefined" &&
|
||||
isReferenceToGlobalVariable(scope, node)
|
||||
);
|
||||
case "TemplateLiteral":
|
||||
/*
|
||||
* In theory we could try to check if the quasi are sufficient to
|
||||
* prove that the expression will always be true, but it would be
|
||||
* tricky to get right. For example: `000.${foo}000`
|
||||
*/
|
||||
return node.expressions.length === 0;
|
||||
case "AssignmentExpression":
|
||||
if (node.operator === "=") {
|
||||
return hasConstantLooseBooleanComparison(scope, node.right);
|
||||
}
|
||||
|
||||
/*
|
||||
* Handling short-circuiting assignment operators would require
|
||||
* walking the scope. We won't attempt that (for now...)
|
||||
*
|
||||
* The remaining assignment expressions all result in a numeric or
|
||||
* string (non-nullish) values which could be truthy or falsy:
|
||||
* "+=", "-=", "*=", "/=", "%=", "<<=", ">>=", ">>>=", "|=", "^=", "&="
|
||||
*/
|
||||
return false;
|
||||
case "SequenceExpression": {
|
||||
const last = node.expressions.at(-1);
|
||||
|
||||
return hasConstantLooseBooleanComparison(scope, last);
|
||||
}
|
||||
case "JSXElement": // ESLint has a policy of not assuming any specific JSX behavior.
|
||||
case "JSXFragment":
|
||||
return false;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Test if an AST node will always give the same result when _strictly_ compared
|
||||
* to a boolean value. This can happen if the expression can never be boolean, or
|
||||
* if it is always the same boolean value.
|
||||
* @param {Scope} scope The scope in which the node was found.
|
||||
* @param {ASTNode} node The node to test
|
||||
* @returns {boolean} Will `node` always give the same result when compared to a
|
||||
* static boolean value?
|
||||
*/
|
||||
function hasConstantStrictBooleanComparison(scope, node) {
|
||||
switch (node.type) {
|
||||
case "ObjectExpression": // Objects are not booleans
|
||||
case "ArrayExpression": // Arrays are not booleans
|
||||
case "ArrowFunctionExpression": // Functions are not booleans
|
||||
case "FunctionExpression":
|
||||
case "ClassExpression": // Classes are not booleans
|
||||
case "NewExpression": // Objects are not booleans
|
||||
case "TemplateLiteral": // Strings are not booleans
|
||||
case "Literal": // True, false, or not boolean, literals never change.
|
||||
case "UpdateExpression": // Numbers are not booleans
|
||||
return true;
|
||||
case "BinaryExpression":
|
||||
return NUMERIC_OR_STRING_BINARY_OPERATORS.has(node.operator);
|
||||
case "UnaryExpression": {
|
||||
if (node.operator === "delete") {
|
||||
return false;
|
||||
}
|
||||
if (node.operator === "!") {
|
||||
return isConstant(scope, node.argument, true);
|
||||
}
|
||||
|
||||
/*
|
||||
* The remaining operators return either strings or numbers, neither
|
||||
* of which are boolean.
|
||||
*/
|
||||
return true;
|
||||
}
|
||||
case "SequenceExpression": {
|
||||
const last = node.expressions.at(-1);
|
||||
|
||||
return hasConstantStrictBooleanComparison(scope, last);
|
||||
}
|
||||
case "Identifier":
|
||||
return (
|
||||
node.name === "undefined" &&
|
||||
isReferenceToGlobalVariable(scope, node)
|
||||
);
|
||||
case "AssignmentExpression":
|
||||
if (node.operator === "=") {
|
||||
return hasConstantStrictBooleanComparison(scope, node.right);
|
||||
}
|
||||
|
||||
/*
|
||||
* Handling short-circuiting assignment operators would require
|
||||
* walking the scope. We won't attempt that (for now...)
|
||||
*/
|
||||
if (isLogicalAssignmentOperator(node.operator)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
/*
|
||||
* The remaining assignment expressions all result in either a number
|
||||
* or a string, neither of which can ever be boolean.
|
||||
*/
|
||||
return true;
|
||||
case "CallExpression": {
|
||||
if (node.callee.type !== "Identifier") {
|
||||
return false;
|
||||
}
|
||||
const functionName = node.callee.name;
|
||||
|
||||
if (
|
||||
(functionName === "String" ||
|
||||
functionName === "Number" ||
|
||||
functionName === "BigInt" ||
|
||||
functionName === "Symbol") &&
|
||||
isReferenceToGlobalVariable(scope, node.callee)
|
||||
) {
|
||||
return true;
|
||||
}
|
||||
if (
|
||||
functionName === "Boolean" &&
|
||||
isReferenceToGlobalVariable(scope, node.callee)
|
||||
) {
|
||||
return (
|
||||
node.arguments.length === 0 ||
|
||||
isConstant(scope, node.arguments[0], true)
|
||||
);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
case "JSXElement": // ESLint has a policy of not assuming any specific JSX behavior.
|
||||
case "JSXFragment":
|
||||
return false;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Test if an AST node will always result in a newly constructed object
|
||||
* @param {Scope} scope The scope in which the node was found.
|
||||
* @param {ASTNode} node The node to test
|
||||
* @returns {boolean} Will `node` always be new?
|
||||
*/
|
||||
function isAlwaysNew(scope, node) {
|
||||
switch (node.type) {
|
||||
case "ObjectExpression":
|
||||
case "ArrayExpression":
|
||||
case "ArrowFunctionExpression":
|
||||
case "FunctionExpression":
|
||||
case "ClassExpression":
|
||||
return true;
|
||||
case "NewExpression": {
|
||||
if (node.callee.type !== "Identifier") {
|
||||
return false;
|
||||
}
|
||||
|
||||
/*
|
||||
* All the built-in constructors are always new, but
|
||||
* user-defined constructors could return a sentinel
|
||||
* object.
|
||||
*
|
||||
* Catching these is especially useful for primitive constructors
|
||||
* which return boxed values, a surprising gotcha' in JavaScript.
|
||||
*/
|
||||
return (
|
||||
Object.hasOwn(ECMASCRIPT_GLOBALS, node.callee.name) &&
|
||||
isReferenceToGlobalVariable(scope, node.callee)
|
||||
);
|
||||
}
|
||||
case "Literal":
|
||||
// Regular expressions are objects, and thus always new
|
||||
return typeof node.regex === "object";
|
||||
case "SequenceExpression": {
|
||||
const last = node.expressions.at(-1);
|
||||
|
||||
return isAlwaysNew(scope, last);
|
||||
}
|
||||
case "AssignmentExpression":
|
||||
if (node.operator === "=") {
|
||||
return isAlwaysNew(scope, node.right);
|
||||
}
|
||||
return false;
|
||||
case "ConditionalExpression":
|
||||
return (
|
||||
isAlwaysNew(scope, node.consequent) &&
|
||||
isAlwaysNew(scope, node.alternate)
|
||||
);
|
||||
case "JSXElement": // ESLint has a policy of not assuming any specific JSX behavior.
|
||||
case "JSXFragment":
|
||||
return false;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if one operand will cause the result to be constant.
|
||||
* @param {Scope} scope Scope in which the expression was found.
|
||||
* @param {ASTNode} a One side of the expression
|
||||
* @param {ASTNode} b The other side of the expression
|
||||
* @param {string} operator The binary expression operator
|
||||
* @returns {ASTNode | null} The node which will cause the expression to have a constant result.
|
||||
*/
|
||||
function findBinaryExpressionConstantOperand(scope, a, b, operator) {
|
||||
if (operator === "==" || operator === "!=") {
|
||||
if (
|
||||
(isNullOrUndefined(scope, a) &&
|
||||
hasConstantNullishness(scope, b, false)) ||
|
||||
(isStaticBoolean(scope, a) &&
|
||||
hasConstantLooseBooleanComparison(scope, b))
|
||||
) {
|
||||
return b;
|
||||
}
|
||||
} else if (operator === "===" || operator === "!==") {
|
||||
if (
|
||||
(isNullOrUndefined(scope, a) &&
|
||||
hasConstantNullishness(scope, b, false)) ||
|
||||
(isStaticBoolean(scope, a) &&
|
||||
hasConstantStrictBooleanComparison(scope, b))
|
||||
) {
|
||||
return b;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if a node is a statically knowable literal.
|
||||
* @param {Scope} scope The scope in which the node was found.
|
||||
* @param {ASTNode} node The node to test.
|
||||
* @returns {boolean} `true` if the node is a literal.
|
||||
*/
|
||||
function isStaticLiteral(scope, node) {
|
||||
switch (node.type) {
|
||||
case "Literal":
|
||||
return true;
|
||||
case "UnaryExpression":
|
||||
return (
|
||||
["-", "+", "~"].includes(node.operator) &&
|
||||
node.argument.type === "Literal"
|
||||
);
|
||||
case "Identifier":
|
||||
return (
|
||||
node.name === "undefined" &&
|
||||
isReferenceToGlobalVariable(scope, node)
|
||||
);
|
||||
case "TemplateLiteral":
|
||||
return node.expressions.length === 0;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Rule Definition
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/** @type {import('../types').Rule.RuleModule} */
|
||||
module.exports = {
|
||||
meta: {
|
||||
type: "problem",
|
||||
docs: {
|
||||
description:
|
||||
"Disallow expressions where the operation doesn't affect the value",
|
||||
recommended: true,
|
||||
url: "https://eslint.org/docs/latest/rules/no-constant-binary-expression",
|
||||
},
|
||||
defaultOptions: [
|
||||
{
|
||||
checkRelationalComparisons: false,
|
||||
},
|
||||
],
|
||||
schema: [
|
||||
{
|
||||
type: "object",
|
||||
properties: {
|
||||
checkRelationalComparisons: {
|
||||
type: "boolean",
|
||||
},
|
||||
},
|
||||
additionalProperties: false,
|
||||
},
|
||||
],
|
||||
messages: {
|
||||
constantBinaryOperand:
|
||||
"Unexpected constant binary expression. Compares constantly with the {{otherSide}}-hand side of the `{{operator}}`.",
|
||||
constantShortCircuit:
|
||||
"Unexpected constant {{property}} on the left-hand side of a `{{operator}}` expression.",
|
||||
alwaysNew:
|
||||
"Unexpected comparison to newly constructed object. These two values can never be equal.",
|
||||
bothAlwaysNew:
|
||||
"Unexpected comparison of two newly constructed objects. These two values can never be equal.",
|
||||
constantRelationalComparison:
|
||||
"Unexpected constant relational comparison. Both sides of the `{{operator}}` are literal values.",
|
||||
},
|
||||
},
|
||||
|
||||
create(context) {
|
||||
const sourceCode = context.sourceCode;
|
||||
const { checkRelationalComparisons } = context.options[0];
|
||||
|
||||
return {
|
||||
LogicalExpression(node) {
|
||||
const { operator, left } = node;
|
||||
const scope = sourceCode.getScope(node);
|
||||
|
||||
if (
|
||||
(operator === "&&" || operator === "||") &&
|
||||
isConstant(scope, left, true)
|
||||
) {
|
||||
context.report({
|
||||
node: left,
|
||||
messageId: "constantShortCircuit",
|
||||
data: { property: "truthiness", operator },
|
||||
});
|
||||
} else if (
|
||||
operator === "??" &&
|
||||
hasConstantNullishness(scope, left, false)
|
||||
) {
|
||||
context.report({
|
||||
node: left,
|
||||
messageId: "constantShortCircuit",
|
||||
data: { property: "nullishness", operator },
|
||||
});
|
||||
}
|
||||
},
|
||||
BinaryExpression(node) {
|
||||
const scope = sourceCode.getScope(node);
|
||||
const { right, left, operator } = node;
|
||||
const rightConstantOperand =
|
||||
findBinaryExpressionConstantOperand(
|
||||
scope,
|
||||
left,
|
||||
right,
|
||||
operator,
|
||||
);
|
||||
const leftConstantOperand = findBinaryExpressionConstantOperand(
|
||||
scope,
|
||||
right,
|
||||
left,
|
||||
operator,
|
||||
);
|
||||
|
||||
if (rightConstantOperand) {
|
||||
context.report({
|
||||
node: rightConstantOperand,
|
||||
messageId: "constantBinaryOperand",
|
||||
data: { operator, otherSide: "left" },
|
||||
});
|
||||
} else if (leftConstantOperand) {
|
||||
context.report({
|
||||
node: leftConstantOperand,
|
||||
messageId: "constantBinaryOperand",
|
||||
data: { operator, otherSide: "right" },
|
||||
});
|
||||
} else if (operator === "===" || operator === "!==") {
|
||||
if (isAlwaysNew(scope, left)) {
|
||||
context.report({ node: left, messageId: "alwaysNew" });
|
||||
} else if (isAlwaysNew(scope, right)) {
|
||||
context.report({ node: right, messageId: "alwaysNew" });
|
||||
}
|
||||
} else if (operator === "==" || operator === "!=") {
|
||||
/*
|
||||
* If both sides are "new", then both sides are objects and
|
||||
* therefore they will be compared by reference even with `==`
|
||||
* equality.
|
||||
*/
|
||||
if (isAlwaysNew(scope, left) && isAlwaysNew(scope, right)) {
|
||||
context.report({
|
||||
node: left,
|
||||
messageId: "bothAlwaysNew",
|
||||
});
|
||||
}
|
||||
} else if (
|
||||
checkRelationalComparisons &&
|
||||
RELATIONAL_OPERATORS.has(operator)
|
||||
) {
|
||||
if (
|
||||
isStaticLiteral(scope, left) &&
|
||||
isStaticLiteral(scope, right)
|
||||
) {
|
||||
context.report({
|
||||
node,
|
||||
messageId: "constantRelationalComparison",
|
||||
data: { operator },
|
||||
});
|
||||
}
|
||||
}
|
||||
},
|
||||
|
||||
/*
|
||||
* In theory we could handle short-circuiting assignment operators,
|
||||
* for some constant values, but that would require walking the
|
||||
* scope to find the value of the variable being assigned. This is
|
||||
* dependent on https://github.com/eslint/eslint/issues/13776
|
||||
*
|
||||
* AssignmentExpression() {},
|
||||
*/
|
||||
};
|
||||
},
|
||||
};
|
||||
@@ -0,0 +1,59 @@
|
||||
/**
|
||||
* @fileoverview A rule to disallow negated left operands of the `in` operator
|
||||
* @author Michael Ficarra
|
||||
* @deprecated in ESLint v3.3.0
|
||||
*/
|
||||
|
||||
"use strict";
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Rule Definition
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/** @type {import('../types').Rule.RuleModule} */
|
||||
module.exports = {
|
||||
meta: {
|
||||
type: "problem",
|
||||
|
||||
docs: {
|
||||
description:
|
||||
"Disallow negating the left operand in `in` expressions",
|
||||
recommended: false,
|
||||
url: "https://eslint.org/docs/latest/rules/no-negated-in-lhs",
|
||||
},
|
||||
|
||||
deprecated: {
|
||||
message: "Renamed rule.",
|
||||
url: "https://eslint.org/blog/2016/08/eslint-v3.3.0-released/#deprecated-rules",
|
||||
deprecatedSince: "3.3.0",
|
||||
availableUntil: "11.0.0",
|
||||
replacedBy: [
|
||||
{
|
||||
rule: {
|
||||
name: "no-unsafe-negation",
|
||||
url: "https://eslint.org/docs/rules/no-unsafe-negation",
|
||||
},
|
||||
},
|
||||
],
|
||||
},
|
||||
schema: [],
|
||||
|
||||
messages: {
|
||||
negatedLHS: "The 'in' expression's left operand is negated.",
|
||||
},
|
||||
},
|
||||
|
||||
create(context) {
|
||||
return {
|
||||
BinaryExpression(node) {
|
||||
if (
|
||||
node.operator === "in" &&
|
||||
node.left.type === "UnaryExpression" &&
|
||||
node.left.operator === "!"
|
||||
) {
|
||||
context.report({ node, messageId: "negatedLHS" });
|
||||
}
|
||||
},
|
||||
};
|
||||
},
|
||||
};
|
||||
@@ -0,0 +1,13 @@
|
||||
var toPropertyKey = require("./toPropertyKey.js");
|
||||
function _defineProperties(e, r) {
|
||||
for (var t = 0; t < r.length; t++) {
|
||||
var o = r[t];
|
||||
o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, toPropertyKey(o.key), o);
|
||||
}
|
||||
}
|
||||
function _createClass(e, r, t) {
|
||||
return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", {
|
||||
writable: !1
|
||||
}), e;
|
||||
}
|
||||
module.exports = _createClass, module.exports.__esModule = true, module.exports["default"] = module.exports;
|
||||
@@ -0,0 +1,99 @@
|
||||
'use strict'
|
||||
|
||||
const { test } = require('node:test')
|
||||
const { createWarning, createDeprecation } = require('..')
|
||||
|
||||
process.removeAllListeners('warning')
|
||||
|
||||
test('Create warning with zero parameter', t => {
|
||||
t.plan(3)
|
||||
|
||||
const warnItem = createWarning({
|
||||
name: 'TestWarning',
|
||||
code: 'CODE',
|
||||
message: 'Not available'
|
||||
})
|
||||
t.assert.deepStrictEqual(warnItem.name, 'TestWarning')
|
||||
t.assert.deepStrictEqual(warnItem.message, 'Not available')
|
||||
t.assert.deepStrictEqual(warnItem.code, 'CODE')
|
||||
})
|
||||
|
||||
test('Create error with 1 parameter', t => {
|
||||
t.plan(3)
|
||||
|
||||
const warnItem = createWarning({
|
||||
name: 'TestWarning',
|
||||
code: 'CODE',
|
||||
message: 'hey %s'
|
||||
})
|
||||
t.assert.deepStrictEqual(warnItem.name, 'TestWarning')
|
||||
t.assert.deepStrictEqual(warnItem.format('alice'), 'hey alice')
|
||||
t.assert.deepStrictEqual(warnItem.code, 'CODE')
|
||||
})
|
||||
|
||||
test('Create error with 2 parameters', t => {
|
||||
t.plan(3)
|
||||
|
||||
const warnItem = createWarning({
|
||||
name: 'TestWarning',
|
||||
code: 'CODE',
|
||||
message: 'hey %s, I like your %s'
|
||||
})
|
||||
t.assert.deepStrictEqual(warnItem.name, 'TestWarning')
|
||||
t.assert.deepStrictEqual(warnItem.format('alice', 'attitude'), 'hey alice, I like your attitude')
|
||||
t.assert.deepStrictEqual(warnItem.code, 'CODE')
|
||||
})
|
||||
|
||||
test('Create error with 3 parameters', t => {
|
||||
t.plan(3)
|
||||
|
||||
const warnItem = createWarning({
|
||||
name: 'TestWarning',
|
||||
code: 'CODE',
|
||||
message: 'hey %s, I like your %s %s'
|
||||
})
|
||||
t.assert.deepStrictEqual(warnItem.name, 'TestWarning')
|
||||
t.assert.deepStrictEqual(warnItem.format('alice', 'attitude', 'see you'), 'hey alice, I like your attitude see you')
|
||||
t.assert.deepStrictEqual(warnItem.code, 'CODE')
|
||||
})
|
||||
|
||||
test('Creates a deprecation warning', t => {
|
||||
t.plan(3)
|
||||
|
||||
const deprecationItem = createDeprecation({
|
||||
name: 'DeprecationWarning',
|
||||
code: 'CODE',
|
||||
message: 'hello %s'
|
||||
})
|
||||
t.assert.deepStrictEqual(deprecationItem.name, 'DeprecationWarning')
|
||||
t.assert.deepStrictEqual(deprecationItem.format('world'), 'hello world')
|
||||
t.assert.deepStrictEqual(deprecationItem.code, 'CODE')
|
||||
})
|
||||
|
||||
test('Should throw when error code has no name', t => {
|
||||
t.plan(1)
|
||||
t.assert.throws(() => createWarning(), new Error('Warning name must not be empty'))
|
||||
})
|
||||
|
||||
test('Should throw when error has no code', t => {
|
||||
t.plan(1)
|
||||
t.assert.throws(() => createWarning({ name: 'name' }), new Error('Warning code must not be empty'))
|
||||
})
|
||||
|
||||
test('Should throw when error has no message', t => {
|
||||
t.plan(1)
|
||||
t.assert.throws(() => createWarning({
|
||||
name: 'name',
|
||||
code: 'code'
|
||||
}), new Error('Warning message must not be empty'))
|
||||
})
|
||||
|
||||
test('Cannot set unlimited other than boolean', t => {
|
||||
t.plan(1)
|
||||
t.assert.throws(() => createWarning({
|
||||
name: 'name',
|
||||
code: 'code',
|
||||
message: 'message',
|
||||
unlimited: 'unlimited'
|
||||
}), new Error('Warning opts.unlimited must be a boolean'))
|
||||
})
|
||||
@@ -0,0 +1,114 @@
|
||||
/**
|
||||
* Pure JS replacement for @typescript/libsyncrpc.
|
||||
*
|
||||
* Spawns a child process and communicates with it synchronously over
|
||||
* stdin/stdout pipes using the same MessagePack-based tuple protocol:
|
||||
* [MessageType (u8), method (bin), payload (bin)]
|
||||
*
|
||||
* Synchronous I/O is achieved by calling fs.readSync / fs.writeSync
|
||||
* directly on the pipe file descriptors obtained from the spawned
|
||||
* ChildProcess.
|
||||
*/
|
||||
/**
|
||||
* SyncRpcChannel – drop-in replacement for the native libsyncrpc class.
|
||||
*
|
||||
* API surface intentionally matches the original:
|
||||
* - constructor(exe, args)
|
||||
* - requestSync(method, payload): string
|
||||
* - requestBinarySync(method, payload): Uint8Array
|
||||
* - registerCallback(name, cb)
|
||||
* - close()
|
||||
*
|
||||
* The protocol is unversioned; both sides (this JS channel and the Go
|
||||
* child process) must be built from the same tree.
|
||||
*
|
||||
* This class is **not** thread-safe. All calls must originate from a
|
||||
* single thread — do not share an instance across worker threads.
|
||||
*/
|
||||
export declare class SyncRpcChannel {
|
||||
private child;
|
||||
private readFd;
|
||||
private writeFd;
|
||||
private pipeFd;
|
||||
private callbacks;
|
||||
private methodBufCache;
|
||||
private readonly collectTiming;
|
||||
lastBytesSent: number;
|
||||
lastBytesReceived: number;
|
||||
private _msgType;
|
||||
private _msgName;
|
||||
private _msgPayload;
|
||||
private headerBuf;
|
||||
private readBuf;
|
||||
private readBufPos;
|
||||
private readBufLen;
|
||||
private writeBuf;
|
||||
constructor(exe: string, args: string[], collectTiming?: boolean);
|
||||
/**
|
||||
* Send a request and synchronously wait for the response (string).
|
||||
* Handles Call (callback) messages from the child inline.
|
||||
*/
|
||||
requestSync(method: string, payload: string): string;
|
||||
/**
|
||||
* Send a request and synchronously wait for the response (binary).
|
||||
* Handles Call (callback) messages from the child inline.
|
||||
*/
|
||||
requestBinarySync(method: string, payload: Uint8Array): Uint8Array;
|
||||
/** Register a string→string callback that the child may invoke. */
|
||||
registerCallback(name: string, callback: (name: string, payload: string) => string): void;
|
||||
/** Kill the child process and release resources. */
|
||||
close(): void;
|
||||
private ensureOpen;
|
||||
private getMethodBuf;
|
||||
private requestBytesSync;
|
||||
/**
|
||||
* Handle an incoming MSG_CALL from the child process.
|
||||
*
|
||||
* After sending the error response back to the child, this method
|
||||
* intentionally re-throws to abort the caller's request loop.
|
||||
* A failed callback is treated as unrecoverable to match the
|
||||
* behavior of the native libsyncrpc addon.
|
||||
*/
|
||||
private handleCall;
|
||||
/**
|
||||
* Write a complete [type, name, payload] tuple in as few writeSync
|
||||
* calls as possible. For messages that fit in the pre-allocated
|
||||
* write buffer (64 KB), everything is assembled and sent in a single
|
||||
* syscall. Larger messages use two syscalls: one for the header
|
||||
* portion and one for the payload data.
|
||||
*/
|
||||
private writeTuple;
|
||||
/**
|
||||
* Read a [type, name, payload] tuple into instance fields
|
||||
* (_msgType, _msgName, _msgPayload) to avoid allocating a
|
||||
* short-lived 3-element array on every call.
|
||||
*/
|
||||
private readTuple;
|
||||
/**
|
||||
* Read a MessagePack bin field.
|
||||
*/
|
||||
private readBin;
|
||||
/** Build an EOF error with the child's exit code/signal if available. */
|
||||
private eofError;
|
||||
/** Read a single byte from the buffered read-ahead. */
|
||||
private readByte;
|
||||
private readExact;
|
||||
/**
|
||||
* Fill the internal read-ahead buffer from the pipe fd.
|
||||
* Retries on EAGAIN for non-blocking mode compatibility.
|
||||
*/
|
||||
private fillReadBuffer;
|
||||
/**
|
||||
* Synchronously read exactly `length` bytes into `buffer`.
|
||||
* Serves from the internal read-ahead buffer first; for large reads
|
||||
* that exceed the buffer size, reads directly from the fd to avoid
|
||||
* an extra copy.
|
||||
*/
|
||||
private readExactInto;
|
||||
/**
|
||||
* Synchronously write all bytes from `data` (up to `length`).
|
||||
* Retries on EAGAIN.
|
||||
*/
|
||||
private writeAllBuf;
|
||||
}
|
||||
//# sourceMappingURL=syncChannel.d.ts.map
|
||||
@@ -0,0 +1,448 @@
|
||||
declare const rules: {
|
||||
'adjacent-overload-signatures': import("@typescript-eslint/utils/ts-eslint").RuleModule<"adjacentSignature", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'array-type': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./array-type").MessageIds, import("./array-type").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'await-thenable': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./await-thenable").MessageId, [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'ban-ts-comment': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./ban-ts-comment").MessageIds, import("./ban-ts-comment").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'ban-tslint-comment': import("@typescript-eslint/utils/ts-eslint").RuleModule<"commentDetected", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'class-literal-property-style': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./class-literal-property-style").MessageIds, import("./class-literal-property-style").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'class-methods-use-this': import("@typescript-eslint/utils/ts-eslint").RuleModule<"missingThis", import("./class-methods-use-this").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'consistent-generic-constructors': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./consistent-generic-constructors").MessageIds, import("./consistent-generic-constructors").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'consistent-indexed-object-style': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./consistent-indexed-object-style").MessageIds, import("./consistent-indexed-object-style").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'consistent-return': import("@typescript-eslint/utils/ts-eslint").RuleModule<"missingReturn" | "missingReturnValue" | "unexpectedReturnValue", [({
|
||||
treatUndefinedAsUnspecified?: boolean;
|
||||
} | undefined)?], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'consistent-type-assertions': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./consistent-type-assertions").MessageIds, import("./consistent-type-assertions").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'consistent-type-definitions': import("@typescript-eslint/utils/ts-eslint").RuleModule<"interfaceOverType" | "typeOverInterface", [string], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'consistent-type-exports': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./consistent-type-exports").MessageIds, import("./consistent-type-exports").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'consistent-type-imports': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./consistent-type-imports").MessageIds, import("./consistent-type-imports").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'default-param-last': import("@typescript-eslint/utils/ts-eslint").RuleModule<"shouldBeLast", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'dot-notation': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useBrackets" | "useDot", [{
|
||||
allowIndexSignaturePropertyAccess?: boolean;
|
||||
allowKeywords?: boolean;
|
||||
allowPattern?: string;
|
||||
allowPrivateClassPropertyAccess?: boolean;
|
||||
allowProtectedClassPropertyAccess?: boolean;
|
||||
}], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'explicit-function-return-type': import("@typescript-eslint/utils/ts-eslint").RuleModule<"missingReturnType", import("./explicit-function-return-type").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'explicit-member-accessibility': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./explicit-member-accessibility").MessageIds, import("./explicit-member-accessibility").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'explicit-module-boundary-types': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./explicit-module-boundary-types").MessageIds, import("./explicit-module-boundary-types").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'init-declarations': import("@typescript-eslint/utils/ts-eslint").RuleModule<"initialized" | "notInitialized", ["always" | "never", ({
|
||||
ignoreForLoopInit?: boolean;
|
||||
} | undefined)?], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'max-params': import("@typescript-eslint/utils/ts-eslint").RuleModule<"exceed", ({
|
||||
countVoidThis?: boolean;
|
||||
max: number;
|
||||
} | {
|
||||
countVoidThis?: boolean;
|
||||
maximum: number;
|
||||
})[], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'member-ordering': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./member-ordering").MessageIds, import("./member-ordering").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'method-signature-style': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./method-signature-style").MessageIds, import("./method-signature-style").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'naming-convention': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./naming-convention").MessageIds, import("./naming-convention").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-array-constructor': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useLiteral", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-array-delete': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-array-delete").MessageId, [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-base-to-string': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-base-to-string").MessageIds, import("./no-base-to-string").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-confusing-non-null-assertion': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-confusing-non-null-assertion").MessageId, [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-confusing-void-expression': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-confusing-void-expression").MessageId, import("./no-confusing-void-expression").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-deprecated': import("@typescript-eslint/utils/ts-eslint").RuleModule<"deprecated" | "deprecatedWithReason", [{
|
||||
allow?: import("@typescript-eslint/type-utils").TypeOrValueSpecifier[];
|
||||
}], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-dupe-class-members': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unexpected", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-duplicate-enum-values': import("@typescript-eslint/utils/ts-eslint").RuleModule<"duplicateValue", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-duplicate-type-constituents': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-duplicate-type-constituents").MessageIds, import("./no-duplicate-type-constituents").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-dynamic-delete': import("@typescript-eslint/utils/ts-eslint").RuleModule<"dynamicDelete", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-empty-function': import("@typescript-eslint/utils/ts-eslint").RuleModule<"suggestComment" | "unexpected", [{
|
||||
allow?: string[];
|
||||
}], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-empty-interface': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-empty-interface").MessageIds, import("./no-empty-interface").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-empty-object-type': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-empty-object-type").MessageIds, import("./no-empty-object-type").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-explicit-any': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-explicit-any").MessageIds, import("./no-explicit-any").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-extra-non-null-assertion': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noExtraNonNullAssertion", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-extraneous-class': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-extraneous-class").MessageIds, import("./no-extraneous-class").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-floating-promises': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-floating-promises").MessageId, import("./no-floating-promises").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-for-in-array': import("@typescript-eslint/utils/ts-eslint").RuleModule<"forInViolation", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-implied-eval': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noFunctionConstructor" | "noImpliedEvalError", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-import-type-side-effects': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useTopLevelQualifier", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-inferrable-types': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noInferrableType", import("./no-inferrable-types").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-invalid-this': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unexpectedThis", [({
|
||||
capIsConstructor?: boolean;
|
||||
} | undefined)?], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-invalid-void-type': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-invalid-void-type").MessageIds, [import("./no-invalid-void-type").Options], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-loop-func': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unsafeRefs", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-loss-of-precision': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noLossOfPrecision", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-magic-numbers': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noMagic", [{
|
||||
detectObjects?: boolean;
|
||||
enforceConst?: boolean;
|
||||
ignore?: (number | string)[];
|
||||
ignoreArrayIndexes?: boolean;
|
||||
ignoreEnums?: boolean;
|
||||
ignoreNumericLiteralTypes?: boolean;
|
||||
ignoreReadonlyClassProperties?: boolean;
|
||||
ignoreTypeIndexes?: boolean;
|
||||
}], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-meaningless-void-operator': import("@typescript-eslint/utils/ts-eslint").RuleModule<"meaninglessVoidOperator" | "removeVoid", import("./no-meaningless-void-operator").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-misused-new': import("@typescript-eslint/utils/ts-eslint").RuleModule<"errorMessageClass" | "errorMessageInterface", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-misused-promises': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-misused-promises").MessageId, import("./no-misused-promises").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-misused-spread': import("@typescript-eslint/utils/ts-eslint").RuleModule<"addAwait" | "noArraySpreadInObject" | "noClassDeclarationSpreadInObject" | "noClassInstanceSpreadInObject" | "noFunctionSpreadInObject" | "noIterableSpreadInObject" | "noMapSpreadInObject" | "noPromiseSpreadInObject" | "noStringSpread" | "replaceMapSpreadInObject", [{
|
||||
allow?: import("@typescript-eslint/type-utils").TypeOrValueSpecifier[];
|
||||
}], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-mixed-enums': import("@typescript-eslint/utils/ts-eslint").RuleModule<"mixed", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-namespace': import("@typescript-eslint/utils/ts-eslint").RuleModule<"moduleSyntaxIsPreferred", import("./no-namespace").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-non-null-asserted-nullish-coalescing': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noNonNullAssertedNullishCoalescing" | "suggestRemovingNonNull", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-non-null-asserted-optional-chain': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noNonNullOptionalChain" | "suggestRemovingNonNull", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-non-null-assertion': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-non-null-assertion").MessageIds, [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-redeclare': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-redeclare").MessageIds, import("./no-redeclare").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-redundant-type-constituents': import("@typescript-eslint/utils/ts-eslint").RuleModule<"errorTypeOverrides" | "literalOverridden" | "overridden" | "overrides" | "primitiveOverridden", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-require-imports': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noRequireImports", import("./no-require-imports").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-restricted-imports': import("@typescript-eslint/utils/ts-eslint").RuleModule<"everything" | "everythingWithCustomMessage" | "importName" | "importNameWithCustomMessage" | "path" | "pathWithCustomMessage" | "patternWithCustomMessage" | "patterns", import("eslint/lib/rules/no-restricted-imports").ArrayOfStringOrObject | [import("eslint/lib/rules/no-restricted-imports").ObjectOfPathsAndPatterns], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-restricted-types': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-restricted-types").MessageIds, import("./no-restricted-types").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-shadow': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-shadow").MessageIds, import("./no-shadow").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-this-alias': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-this-alias").MessageIds, import("./no-this-alias").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-type-alias': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-type-alias").MessageIds, import("./no-type-alias").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-unnecessary-boolean-literal-compare': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-unnecessary-boolean-literal-compare").MessageIds, import("./no-unnecessary-boolean-literal-compare").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-unnecessary-condition': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-unnecessary-condition").MessageId, import("./no-unnecessary-condition").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-unnecessary-parameter-property-assignment': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unnecessaryAssign", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-unnecessary-qualifier': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unnecessaryQualifier", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-unnecessary-template-expression': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noUnnecessaryTemplateExpression", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-unnecessary-type-arguments': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unnecessaryTypeParameter", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-unnecessary-type-assertion': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-unnecessary-type-assertion").MessageIds, import("./no-unnecessary-type-assertion").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-unnecessary-type-constraint': import("@typescript-eslint/utils/ts-eslint").RuleModule<"removeUnnecessaryConstraint" | "unnecessaryConstraint", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-unnecessary-type-conversion': import("@typescript-eslint/utils/ts-eslint").RuleModule<"suggestRemove" | "suggestSatisfies" | "unnecessaryTypeConversion", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-unnecessary-type-parameters': import("@typescript-eslint/utils/ts-eslint").RuleModule<"replaceUsagesWithConstraint" | "sole", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-unsafe-argument': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-unsafe-argument").MessageIds, [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-unsafe-assignment': import("@typescript-eslint/utils/ts-eslint").RuleModule<"anyAssignment" | "anyAssignmentThis" | "unsafeArrayPattern" | "unsafeArrayPatternFromTuple" | "unsafeArraySpread" | "unsafeAssignment" | "unsafeObjectPattern", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-unsafe-call': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-unsafe-call").MessageIds, [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-unsafe-declaration-merging': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unsafeMerging", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-unsafe-enum-comparison': import("@typescript-eslint/utils/ts-eslint").RuleModule<"mismatchedCase" | "mismatchedCondition" | "replaceValueWithEnum", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-unsafe-function-type': import("@typescript-eslint/utils/ts-eslint").RuleModule<"bannedFunctionType", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-unsafe-member-access': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-unsafe-member-access").MessageIds, import("./no-unsafe-member-access").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-unsafe-return': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unsafeReturn" | "unsafeReturnAssignment" | "unsafeReturnThis", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-unsafe-type-assertion': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unsafeOfAnyTypeAssertion" | "unsafeToAnyTypeAssertion" | "unsafeToUnconstrainedTypeAssertion" | "unsafeTypeAssertion" | "unsafeTypeAssertionAssignableToConstraint", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-unsafe-unary-minus': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unaryMinus", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-unused-expressions': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unusedExpression", [{
|
||||
allowShortCircuit?: boolean;
|
||||
allowTaggedTemplates?: boolean;
|
||||
allowTernary?: boolean;
|
||||
}], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-unused-private-class-members': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unusedPrivateClassMember", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-unused-vars': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-unused-vars").MessageIds, import("./no-unused-vars").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-use-before-define': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noUseBeforeDefine", import("./no-use-before-define").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-useless-constructor': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noUselessConstructor" | "removeConstructor", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-useless-default-assignment': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noStrictNullCheck" | "preferOptionalSyntax" | "uselessDefaultAssignment" | "uselessUndefined", [{
|
||||
allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing?: boolean;
|
||||
}], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-useless-empty-export': import("@typescript-eslint/utils/ts-eslint").RuleModule<"uselessExport", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-var-requires': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noVarReqs", import("./no-var-requires").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'no-wrapper-object-types': import("@typescript-eslint/utils/ts-eslint").RuleModule<"bannedClassType", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'non-nullable-type-assertion-style': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferNonNullAssertion", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'only-throw-error': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./only-throw-error").MessageIds, import("./only-throw-error").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'parameter-properties': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./parameter-properties").MessageIds, import("./parameter-properties").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'prefer-as-const': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferConstAssertion" | "variableConstAssertion" | "variableSuggest", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'prefer-destructuring': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferDestructuring", import("./prefer-destructuring").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'prefer-enum-initializers': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./prefer-enum-initializers").MessageIds, [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'prefer-find': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferFind" | "preferFindSuggestion", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'prefer-for-of': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferForOf", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'prefer-function-type': import("@typescript-eslint/utils/ts-eslint").RuleModule<"functionTypeOverCallableType" | "unexpectedThisOnFunctionOnlyInterface", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'prefer-includes': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferIncludes" | "preferStringIncludes", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'prefer-literal-enum-member': import("@typescript-eslint/utils/ts-eslint").RuleModule<"notLiteral" | "notLiteralOrBitwiseExpression", [{
|
||||
allowBitwiseExpressions: boolean;
|
||||
}], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'prefer-namespace-keyword': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useNamespace", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'prefer-nullish-coalescing': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./prefer-nullish-coalescing").MessageIds, import("./prefer-nullish-coalescing").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'prefer-optional-chain': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./prefer-optional-chain-utils/PreferOptionalChainOptions").PreferOptionalChainMessageIds, [import("./prefer-optional-chain-utils/PreferOptionalChainOptions").PreferOptionalChainOptions], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'prefer-promise-reject-errors': import("@typescript-eslint/utils/ts-eslint").RuleModule<"rejectAnError", import("./prefer-promise-reject-errors").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'prefer-readonly': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferReadonly", import("./prefer-readonly").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'prefer-readonly-parameter-types': import("@typescript-eslint/utils/ts-eslint").RuleModule<"shouldBeReadonly", import("./prefer-readonly-parameter-types").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'prefer-reduce-type-parameter': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferTypeParameter", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'prefer-regexp-exec': import("@typescript-eslint/utils/ts-eslint").RuleModule<"regExpExecOverStringMatch", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'prefer-return-this-type': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useThisType", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'prefer-string-starts-ends-with': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./prefer-string-starts-ends-with").MessageIds, import("./prefer-string-starts-ends-with").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'prefer-ts-expect-error': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferExpectErrorComment", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'promise-function-async': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./promise-function-async").MessageIds, import("./promise-function-async").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'related-getter-setter-pairs': import("@typescript-eslint/utils/ts-eslint").RuleModule<"mismatch", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'require-array-sort-compare': import("@typescript-eslint/utils/ts-eslint").RuleModule<"requireCompare", import("./require-array-sort-compare").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'require-await': import("@typescript-eslint/utils/ts-eslint").RuleModule<"missingAwait" | "removeAsync", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'restrict-plus-operands': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./restrict-plus-operands").MessageIds, import("./restrict-plus-operands").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'restrict-template-expressions': import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidType", import("./restrict-template-expressions").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'return-await': import("@typescript-eslint/utils/ts-eslint").RuleModule<"disallowedPromiseAwait" | "disallowedPromiseAwaitSuggestion" | "nonPromiseAwait" | "requiredPromiseAwait" | "requiredPromiseAwaitSuggestion", [string], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'sort-type-constituents': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./sort-type-constituents").MessageIds, import("./sort-type-constituents").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'strict-boolean-expressions': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./strict-boolean-expressions").MessageId, import("./strict-boolean-expressions").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'strict-void-return': import("@typescript-eslint/utils/ts-eslint").RuleModule<"asyncFunc" | "nonVoidFunc" | "nonVoidReturn", [{
|
||||
allowReturnAny?: boolean;
|
||||
}], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'switch-exhaustiveness-check': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./switch-exhaustiveness-check").MessageIds, import("./switch-exhaustiveness-check").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'triple-slash-reference': import("@typescript-eslint/utils/ts-eslint").RuleModule<"tripleSlashReference", import("./triple-slash-reference").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
typedef: import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./typedef").MessageIds, import("./typedef").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'unbound-method': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./unbound-method").MessageIds, import("./unbound-method").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'unified-signatures': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./unified-signatures").MessageIds, import("./unified-signatures").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
'use-unknown-in-catch-callback-variable': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./use-unknown-in-catch-callback-variable").MessageIds, [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
};
|
||||
export = rules;
|
||||
@@ -0,0 +1,133 @@
|
||||
"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: "حرف", verb: "أن يحوي" },
|
||||
file: { unit: "بايت", verb: "أن يحوي" },
|
||||
array: { unit: "عنصر", verb: "أن يحوي" },
|
||||
set: { unit: "عنصر", verb: "أن يحوي" },
|
||||
};
|
||||
function getSizing(origin) {
|
||||
return Sizable[origin] ?? null;
|
||||
}
|
||||
const FormatDictionary = {
|
||||
regex: "مدخل",
|
||||
email: "بريد إلكتروني",
|
||||
url: "رابط",
|
||||
emoji: "إيموجي",
|
||||
uuid: "UUID",
|
||||
uuidv4: "UUIDv4",
|
||||
uuidv6: "UUIDv6",
|
||||
nanoid: "nanoid",
|
||||
guid: "GUID",
|
||||
cuid: "cuid",
|
||||
cuid2: "cuid2",
|
||||
ulid: "ULID",
|
||||
xid: "XID",
|
||||
ksuid: "KSUID",
|
||||
datetime: "تاريخ ووقت بمعيار ISO",
|
||||
date: "تاريخ بمعيار ISO",
|
||||
time: "وقت بمعيار ISO",
|
||||
duration: "مدة بمعيار ISO",
|
||||
ipv4: "عنوان IPv4",
|
||||
ipv6: "عنوان IPv6",
|
||||
cidrv4: "مدى عناوين بصيغة IPv4",
|
||||
cidrv6: "مدى عناوين بصيغة IPv6",
|
||||
base64: "نَص بترميز base64-encoded",
|
||||
base64url: "نَص بترميز base64url-encoded",
|
||||
json_string: "نَص على هيئة JSON",
|
||||
e164: "رقم هاتف بمعيار E.164",
|
||||
jwt: "JWT",
|
||||
template_literal: "مدخل",
|
||||
};
|
||||
const TypeDictionary = {
|
||||
nan: "NaN",
|
||||
};
|
||||
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 `مدخلات غير مقبولة: يفترض إدخال instanceof ${issue.expected}، ولكن تم إدخال ${received}`;
|
||||
}
|
||||
return `مدخلات غير مقبولة: يفترض إدخال ${expected}، ولكن تم إدخال ${received}`;
|
||||
}
|
||||
case "invalid_value":
|
||||
if (issue.values.length === 1)
|
||||
return `مدخلات غير مقبولة: يفترض إدخال ${util.stringifyPrimitive(issue.values[0])}`;
|
||||
return `اختيار غير مقبول: يتوقع انتقاء أحد هذه الخيارات: ${util.joinValues(issue.values, "|")}`;
|
||||
case "too_big": {
|
||||
const adj = issue.inclusive ? "<=" : "<";
|
||||
const sizing = getSizing(issue.origin);
|
||||
if (sizing)
|
||||
return ` أكبر من اللازم: يفترض أن تكون ${issue.origin ?? "القيمة"} ${adj} ${issue.maximum.toString()} ${sizing.unit ?? "عنصر"}`;
|
||||
return `أكبر من اللازم: يفترض أن تكون ${issue.origin ?? "القيمة"} ${adj} ${issue.maximum.toString()}`;
|
||||
}
|
||||
case "too_small": {
|
||||
const adj = issue.inclusive ? ">=" : ">";
|
||||
const sizing = getSizing(issue.origin);
|
||||
if (sizing) {
|
||||
return `أصغر من اللازم: يفترض لـ ${issue.origin} أن يكون ${adj} ${issue.minimum.toString()} ${sizing.unit}`;
|
||||
}
|
||||
return `أصغر من اللازم: يفترض لـ ${issue.origin} أن يكون ${adj} ${issue.minimum.toString()}`;
|
||||
}
|
||||
case "invalid_format": {
|
||||
const _issue = issue;
|
||||
if (_issue.format === "starts_with")
|
||||
return `نَص غير مقبول: يجب أن يبدأ بـ "${issue.prefix}"`;
|
||||
if (_issue.format === "ends_with")
|
||||
return `نَص غير مقبول: يجب أن ينتهي بـ "${_issue.suffix}"`;
|
||||
if (_issue.format === "includes")
|
||||
return `نَص غير مقبول: يجب أن يتضمَّن "${_issue.includes}"`;
|
||||
if (_issue.format === "regex")
|
||||
return `نَص غير مقبول: يجب أن يطابق النمط ${_issue.pattern}`;
|
||||
return `${FormatDictionary[_issue.format] ?? issue.format} غير مقبول`;
|
||||
}
|
||||
case "not_multiple_of":
|
||||
return `رقم غير مقبول: يجب أن يكون من مضاعفات ${issue.divisor}`;
|
||||
case "unrecognized_keys":
|
||||
return `معرف${issue.keys.length > 1 ? "ات" : ""} غريب${issue.keys.length > 1 ? "ة" : ""}: ${util.joinValues(issue.keys, "، ")}`;
|
||||
case "invalid_key":
|
||||
return `معرف غير مقبول في ${issue.origin}`;
|
||||
case "invalid_union":
|
||||
return "مدخل غير مقبول";
|
||||
case "invalid_element":
|
||||
return `مدخل غير مقبول في ${issue.origin}`;
|
||||
default:
|
||||
return "مدخل غير مقبول";
|
||||
}
|
||||
};
|
||||
};
|
||||
function default_1() {
|
||||
return {
|
||||
localeError: error(),
|
||||
};
|
||||
}
|
||||
module.exports = exports.default;
|
||||
@@ -0,0 +1,233 @@
|
||||
// is.ts — Hand-written type guard functions
|
||||
// Generated guards are in is.generated.ts
|
||||
import { NodeFlags } from "#enums/nodeFlags";
|
||||
import { OuterExpressionKinds } from "#enums/outerExpressionKinds";
|
||||
import { ScriptKind } from "#enums/scriptKind";
|
||||
import { SyntaxKind } from "#enums/syntaxKind";
|
||||
import { isLiteralExpression } from "./is.generated.js";
|
||||
export * from "./is.generated.js";
|
||||
export function isTypeNode(node) {
|
||||
return isTypeNodeKind(node.kind);
|
||||
}
|
||||
function isTypeNodeKind(kind) {
|
||||
return kind >= SyntaxKind.FirstTypeNode && kind <= SyntaxKind.LastTypeNode
|
||||
|| kind === SyntaxKind.AnyKeyword
|
||||
|| kind === SyntaxKind.UnknownKeyword
|
||||
|| kind === SyntaxKind.NumberKeyword
|
||||
|| kind === SyntaxKind.BigIntKeyword
|
||||
|| kind === SyntaxKind.ObjectKeyword
|
||||
|| kind === SyntaxKind.BooleanKeyword
|
||||
|| kind === SyntaxKind.StringKeyword
|
||||
|| kind === SyntaxKind.SymbolKeyword
|
||||
|| kind === SyntaxKind.VoidKeyword
|
||||
|| kind === SyntaxKind.UndefinedKeyword
|
||||
|| kind === SyntaxKind.NeverKeyword
|
||||
|| kind === SyntaxKind.IntrinsicKeyword
|
||||
|| kind === SyntaxKind.ExpressionWithTypeArguments
|
||||
|| kind === SyntaxKind.JSDocAllType
|
||||
|| kind === SyntaxKind.JSDocNullableType
|
||||
|| kind === SyntaxKind.JSDocNonNullableType
|
||||
|| kind === SyntaxKind.JSDocOptionalType
|
||||
|| kind === SyntaxKind.JSDocVariadicType
|
||||
|| kind === SyntaxKind.JSDocTypeExpression
|
||||
|| kind === SyntaxKind.JSDocTypeLiteral
|
||||
|| kind === SyntaxKind.JSDocSignature;
|
||||
}
|
||||
export function isStatement(node) {
|
||||
const kind = node.kind;
|
||||
return kind === SyntaxKind.VariableStatement || kind === SyntaxKind.EmptyStatement
|
||||
|| kind === SyntaxKind.ExpressionStatement || kind === SyntaxKind.IfStatement
|
||||
|| kind === SyntaxKind.DoStatement || kind === SyntaxKind.WhileStatement
|
||||
|| kind === SyntaxKind.ForStatement || kind === SyntaxKind.ForInStatement
|
||||
|| kind === SyntaxKind.ForOfStatement || kind === SyntaxKind.ContinueStatement
|
||||
|| kind === SyntaxKind.BreakStatement || kind === SyntaxKind.ReturnStatement
|
||||
|| kind === SyntaxKind.WithStatement || kind === SyntaxKind.SwitchStatement
|
||||
|| kind === SyntaxKind.LabeledStatement || kind === SyntaxKind.ThrowStatement
|
||||
|| kind === SyntaxKind.TryStatement || kind === SyntaxKind.DebuggerStatement
|
||||
|| kind === SyntaxKind.InterfaceDeclaration || kind === SyntaxKind.TypeAliasDeclaration
|
||||
|| kind === SyntaxKind.EnumDeclaration || kind === SyntaxKind.ModuleDeclaration
|
||||
|| kind === SyntaxKind.ImportDeclaration || kind === SyntaxKind.ImportEqualsDeclaration
|
||||
|| kind === SyntaxKind.ExportDeclaration || kind === SyntaxKind.ExportAssignment
|
||||
|| kind === SyntaxKind.NamespaceExportDeclaration || kind === SyntaxKind.FunctionDeclaration
|
||||
|| kind === SyntaxKind.ClassDeclaration || kind === SyntaxKind.MissingDeclaration
|
||||
|| kind === SyntaxKind.NotEmittedStatement || kind === SyntaxKind.Block;
|
||||
}
|
||||
export function isExpression(node) {
|
||||
const kind = node.kind;
|
||||
return kind === SyntaxKind.ConditionalExpression || kind === SyntaxKind.YieldExpression
|
||||
|| kind === SyntaxKind.ArrowFunction || kind === SyntaxKind.BinaryExpression
|
||||
|| kind === SyntaxKind.SpreadElement || kind === SyntaxKind.AsExpression
|
||||
|| kind === SyntaxKind.OmittedExpression
|
||||
|| kind === SyntaxKind.SatisfiesExpression
|
||||
|| kind === SyntaxKind.PrefixUnaryExpression || kind === SyntaxKind.PostfixUnaryExpression
|
||||
|| kind === SyntaxKind.DeleteExpression || kind === SyntaxKind.TypeOfExpression
|
||||
|| kind === SyntaxKind.VoidExpression || kind === SyntaxKind.AwaitExpression
|
||||
|| kind === SyntaxKind.TypeAssertionExpression
|
||||
|| kind === SyntaxKind.CallExpression || kind === SyntaxKind.NewExpression
|
||||
|| kind === SyntaxKind.TaggedTemplateExpression || kind === SyntaxKind.NonNullExpression
|
||||
|| kind === SyntaxKind.MetaProperty || kind === SyntaxKind.JsxExpression
|
||||
|| kind === SyntaxKind.PropertyAccessExpression || kind === SyntaxKind.ElementAccessExpression
|
||||
|| kind === SyntaxKind.FunctionExpression || kind === SyntaxKind.ClassExpression
|
||||
|| kind === SyntaxKind.ParenthesizedExpression || kind === SyntaxKind.ArrayLiteralExpression
|
||||
|| kind === SyntaxKind.ObjectLiteralExpression || kind === SyntaxKind.TemplateExpression
|
||||
|| kind === SyntaxKind.Identifier
|
||||
|| kind === SyntaxKind.PrivateIdentifier
|
||||
|| kind === SyntaxKind.NumericLiteral || kind === SyntaxKind.BigIntLiteral
|
||||
|| kind === SyntaxKind.StringLiteral || kind === SyntaxKind.RegularExpressionLiteral
|
||||
|| kind === SyntaxKind.NoSubstitutionTemplateLiteral || kind === SyntaxKind.JsxElement
|
||||
|| kind === SyntaxKind.JsxSelfClosingElement || kind === SyntaxKind.JsxFragment
|
||||
|| kind === SyntaxKind.NullKeyword || kind === SyntaxKind.TrueKeyword
|
||||
|| kind === SyntaxKind.FalseKeyword || kind === SyntaxKind.ThisKeyword
|
||||
|| kind === SyntaxKind.SuperKeyword || kind === SyntaxKind.ImportKeyword
|
||||
|| kind === SyntaxKind.ExpressionWithTypeArguments;
|
||||
}
|
||||
export function isBlockOrExpression(node) {
|
||||
return node.kind === SyntaxKind.Block || isExpression(node);
|
||||
}
|
||||
export function isLeftHandSideExpression(node) {
|
||||
return isLeftHandSideExpressionKind(skipPartiallyEmittedExpressions(node).kind);
|
||||
}
|
||||
export function skipPartiallyEmittedExpressions(node) {
|
||||
return skipOuterExpressions(node, OuterExpressionKinds.PartiallyEmittedExpressions);
|
||||
}
|
||||
function isLeftHandSideExpressionKind(kind) {
|
||||
switch (kind) {
|
||||
case SyntaxKind.PropertyAccessExpression:
|
||||
case SyntaxKind.ElementAccessExpression:
|
||||
case SyntaxKind.NewExpression:
|
||||
case SyntaxKind.CallExpression:
|
||||
case SyntaxKind.JsxElement:
|
||||
case SyntaxKind.JsxSelfClosingElement:
|
||||
case SyntaxKind.JsxFragment:
|
||||
case SyntaxKind.TaggedTemplateExpression:
|
||||
case SyntaxKind.ArrayLiteralExpression:
|
||||
case SyntaxKind.ParenthesizedExpression:
|
||||
case SyntaxKind.ObjectLiteralExpression:
|
||||
case SyntaxKind.ClassExpression:
|
||||
case SyntaxKind.FunctionExpression:
|
||||
case SyntaxKind.Identifier:
|
||||
case SyntaxKind.PrivateIdentifier: // technically this is only an Expression if it's in a `#field in expr` BinaryExpression
|
||||
case SyntaxKind.RegularExpressionLiteral:
|
||||
case SyntaxKind.NumericLiteral:
|
||||
case SyntaxKind.BigIntLiteral:
|
||||
case SyntaxKind.StringLiteral:
|
||||
case SyntaxKind.NoSubstitutionTemplateLiteral:
|
||||
case SyntaxKind.TemplateExpression:
|
||||
case SyntaxKind.FalseKeyword:
|
||||
case SyntaxKind.NullKeyword:
|
||||
case SyntaxKind.ThisKeyword:
|
||||
case SyntaxKind.TrueKeyword:
|
||||
case SyntaxKind.SuperKeyword:
|
||||
case SyntaxKind.NonNullExpression:
|
||||
case SyntaxKind.ExpressionWithTypeArguments:
|
||||
case SyntaxKind.MetaProperty:
|
||||
case SyntaxKind.ImportKeyword: // technically this is only an Expression if it's in a CallExpression
|
||||
case SyntaxKind.MissingDeclaration:
|
||||
return true;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
export function isUnaryExpression(node) {
|
||||
return isUnaryExpressionKind(skipPartiallyEmittedExpressions(node).kind);
|
||||
}
|
||||
function isUnaryExpressionKind(kind) {
|
||||
switch (kind) {
|
||||
case SyntaxKind.PrefixUnaryExpression:
|
||||
case SyntaxKind.PostfixUnaryExpression:
|
||||
case SyntaxKind.DeleteExpression:
|
||||
case SyntaxKind.TypeOfExpression:
|
||||
case SyntaxKind.VoidExpression:
|
||||
case SyntaxKind.AwaitExpression:
|
||||
case SyntaxKind.TypeAssertionExpression:
|
||||
return true;
|
||||
default:
|
||||
return isLeftHandSideExpressionKind(kind);
|
||||
}
|
||||
}
|
||||
/** @internal */
|
||||
export function isOuterExpression(node, kinds = OuterExpressionKinds.All) {
|
||||
switch (node.kind) {
|
||||
case SyntaxKind.ParenthesizedExpression:
|
||||
if (kinds & OuterExpressionKinds.ExcludeJSDocTypeAssertion && isJSDocTypeAssertion(node)) {
|
||||
return false;
|
||||
}
|
||||
return (kinds & OuterExpressionKinds.Parentheses) !== 0;
|
||||
case SyntaxKind.TypeAssertionExpression:
|
||||
case SyntaxKind.AsExpression:
|
||||
return (kinds & OuterExpressionKinds.TypeAssertions) !== 0;
|
||||
case SyntaxKind.SatisfiesExpression:
|
||||
return (kinds & (OuterExpressionKinds.ExpressionsWithTypeArguments | OuterExpressionKinds.Satisfies)) !== 0;
|
||||
case SyntaxKind.ExpressionWithTypeArguments:
|
||||
return (kinds & OuterExpressionKinds.ExpressionsWithTypeArguments) !== 0;
|
||||
case SyntaxKind.NonNullExpression:
|
||||
return (kinds & OuterExpressionKinds.NonNullAssertions) !== 0;
|
||||
case SyntaxKind.PartiallyEmittedExpression:
|
||||
return (kinds & OuterExpressionKinds.PartiallyEmittedExpressions) !== 0;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
/** @internal */
|
||||
export function skipOuterExpressions(node, kinds = OuterExpressionKinds.All) {
|
||||
while (isOuterExpression(node, kinds)) {
|
||||
node = node.expression;
|
||||
}
|
||||
return node;
|
||||
}
|
||||
function isJSDocTypeAssertion(node) {
|
||||
const sourceFile = node.getSourceFile();
|
||||
if (sourceFile.scriptKind !== ScriptKind.JS && sourceFile.scriptKind !== ScriptKind.JSX) {
|
||||
return false;
|
||||
}
|
||||
const expression = node.expression;
|
||||
if (expression.kind !== SyntaxKind.AsExpression) {
|
||||
return false;
|
||||
}
|
||||
const asExpression = expression;
|
||||
return !!asExpression.type
|
||||
&& (asExpression.type.flags & NodeFlags.Reparsed) !== 0;
|
||||
}
|
||||
export function isBindingPattern(node) {
|
||||
return node.kind === SyntaxKind.ObjectBindingPattern || node.kind === SyntaxKind.ArrayBindingPattern;
|
||||
}
|
||||
export function isConciseBody(node) {
|
||||
return node.kind === SyntaxKind.Block || isExpression(node);
|
||||
}
|
||||
export function isForInitializer(node) {
|
||||
return node.kind === SyntaxKind.VariableDeclarationList || isExpression(node);
|
||||
}
|
||||
export function isQuestionOrExclamationToken(node) {
|
||||
return node.kind === SyntaxKind.QuestionToken || node.kind === SyntaxKind.ExclamationToken;
|
||||
}
|
||||
export function isIdentifierOrThisTypeNode(node) {
|
||||
return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.ThisType;
|
||||
}
|
||||
export function isReadonlyKeywordOrPlusOrMinusToken(node) {
|
||||
return node.kind === SyntaxKind.ReadonlyKeyword || node.kind === SyntaxKind.PlusToken || node.kind === SyntaxKind.MinusToken;
|
||||
}
|
||||
export function isQuestionOrPlusOrMinusToken(node) {
|
||||
return node.kind === SyntaxKind.QuestionToken || node.kind === SyntaxKind.PlusToken || node.kind === SyntaxKind.MinusToken;
|
||||
}
|
||||
export function isTemplateMiddleOrTemplateTail(node) {
|
||||
return node.kind === SyntaxKind.TemplateMiddle || node.kind === SyntaxKind.TemplateTail;
|
||||
}
|
||||
export function isLiteralTypeLiteral(node) {
|
||||
const kind = node.kind;
|
||||
return kind === SyntaxKind.NullKeyword || kind === SyntaxKind.TrueKeyword
|
||||
|| kind === SyntaxKind.FalseKeyword || kind === SyntaxKind.PrefixUnaryExpression
|
||||
|| isLiteralExpression(node);
|
||||
}
|
||||
export function isIdentifierOrJSDocNamespaceDeclaration(node) {
|
||||
return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.ModuleDeclaration;
|
||||
}
|
||||
export function isJSDocTypeExpressionOrJSDocTypeLiteral(node) {
|
||||
return node.kind === SyntaxKind.JSDocTypeExpression || node.kind === SyntaxKind.JSDocTypeLiteral;
|
||||
}
|
||||
export function isJsxTagNameExpression(node) {
|
||||
const kind = node.kind;
|
||||
return kind === SyntaxKind.ThisKeyword
|
||||
|| kind === SyntaxKind.Identifier
|
||||
|| kind === SyntaxKind.PropertyAccessExpression
|
||||
|| kind === SyntaxKind.JsxNamespacedName;
|
||||
}
|
||||
//# sourceMappingURL=is.js.map
|
||||
@@ -0,0 +1,81 @@
|
||||
'use strict';
|
||||
module.exports = function generate_propertyNames(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 $errs = 'errs__' + $lvl;
|
||||
var $it = it.util.copy(it);
|
||||
var $closingBraces = '';
|
||||
$it.level++;
|
||||
var $nextValid = 'valid' + $it.level;
|
||||
out += 'var ' + ($errs) + ' = errors;';
|
||||
if ((it.opts.strictKeywords ? (typeof $schema == 'object' && Object.keys($schema).length > 0) || $schema === false : it.util.schemaHasRules($schema, it.RULES.all))) {
|
||||
$it.schema = $schema;
|
||||
$it.schemaPath = $schemaPath;
|
||||
$it.errSchemaPath = $errSchemaPath;
|
||||
var $key = 'key' + $lvl,
|
||||
$idx = 'idx' + $lvl,
|
||||
$i = 'i' + $lvl,
|
||||
$invalidName = '\' + ' + $key + ' + \'',
|
||||
$dataNxt = $it.dataLevel = it.dataLevel + 1,
|
||||
$nextData = 'data' + $dataNxt,
|
||||
$dataProperties = 'dataProperties' + $lvl,
|
||||
$ownProperties = it.opts.ownProperties,
|
||||
$currentBaseId = it.baseId;
|
||||
if ($ownProperties) {
|
||||
out += ' var ' + ($dataProperties) + ' = undefined; ';
|
||||
}
|
||||
if ($ownProperties) {
|
||||
out += ' ' + ($dataProperties) + ' = ' + ($dataProperties) + ' || Object.keys(' + ($data) + '); for (var ' + ($idx) + '=0; ' + ($idx) + '<' + ($dataProperties) + '.length; ' + ($idx) + '++) { var ' + ($key) + ' = ' + ($dataProperties) + '[' + ($idx) + ']; ';
|
||||
} else {
|
||||
out += ' for (var ' + ($key) + ' in ' + ($data) + ') { ';
|
||||
}
|
||||
out += ' var startErrs' + ($lvl) + ' = errors; ';
|
||||
var $passData = $key;
|
||||
var $wasComposite = it.compositeRule;
|
||||
it.compositeRule = $it.compositeRule = true;
|
||||
var $code = it.validate($it);
|
||||
$it.baseId = $currentBaseId;
|
||||
if (it.util.varOccurences($code, $nextData) < 2) {
|
||||
out += ' ' + (it.util.varReplace($code, $nextData, $passData)) + ' ';
|
||||
} else {
|
||||
out += ' var ' + ($nextData) + ' = ' + ($passData) + '; ' + ($code) + ' ';
|
||||
}
|
||||
it.compositeRule = $it.compositeRule = $wasComposite;
|
||||
out += ' if (!' + ($nextValid) + ') { for (var ' + ($i) + '=startErrs' + ($lvl) + '; ' + ($i) + '<errors; ' + ($i) + '++) { vErrors[' + ($i) + '].propertyName = ' + ($key) + '; } var err = '; /* istanbul ignore else */
|
||||
if (it.createErrors !== false) {
|
||||
out += ' { keyword: \'' + ('propertyNames') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { propertyName: \'' + ($invalidName) + '\' } ';
|
||||
if (it.opts.messages !== false) {
|
||||
out += ' , message: \'property name \\\'' + ($invalidName) + '\\\' is invalid\' ';
|
||||
}
|
||||
if (it.opts.verbose) {
|
||||
out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';
|
||||
}
|
||||
out += ' } ';
|
||||
} else {
|
||||
out += ' {} ';
|
||||
}
|
||||
out += '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';
|
||||
if (!it.compositeRule && $breakOnError) {
|
||||
/* istanbul ignore if */
|
||||
if (it.async) {
|
||||
out += ' throw new ValidationError(vErrors); ';
|
||||
} else {
|
||||
out += ' validate.errors = vErrors; return false; ';
|
||||
}
|
||||
}
|
||||
if ($breakOnError) {
|
||||
out += ' break; ';
|
||||
}
|
||||
out += ' } }';
|
||||
}
|
||||
if ($breakOnError) {
|
||||
out += ' ' + ($closingBraces) + ' if (' + ($errs) + ' == errors) {';
|
||||
}
|
||||
return out;
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user