new license file version [CI SKIP]
This commit is contained in:
@@ -0,0 +1,60 @@
|
||||
import type {DelimiterCase} from './delimiter-case';
|
||||
|
||||
/**
|
||||
Convert object properties to delimiter case recursively.
|
||||
|
||||
This can be useful when, for example, converting some API types from a different style.
|
||||
|
||||
@see DelimiterCase
|
||||
@see DelimiterCasedProperties
|
||||
|
||||
@example
|
||||
```
|
||||
import type {DelimiterCasedPropertiesDeep} from 'type-fest';
|
||||
|
||||
interface User {
|
||||
userId: number;
|
||||
userName: string;
|
||||
}
|
||||
|
||||
interface UserWithFriends {
|
||||
userInfo: User;
|
||||
userFriends: User[];
|
||||
}
|
||||
|
||||
const result: DelimiterCasedPropertiesDeep<UserWithFriends, '-'> = {
|
||||
'user-info': {
|
||||
'user-id': 1,
|
||||
'user-name': 'Tom',
|
||||
},
|
||||
'user-friends': [
|
||||
{
|
||||
'user-id': 2,
|
||||
'user-name': 'Jerry',
|
||||
},
|
||||
{
|
||||
'user-id': 3,
|
||||
'user-name': 'Spike',
|
||||
},
|
||||
],
|
||||
};
|
||||
```
|
||||
|
||||
@category Change case
|
||||
@category Template literal
|
||||
@category Object
|
||||
*/
|
||||
export type DelimiterCasedPropertiesDeep<
|
||||
Value,
|
||||
Delimiter extends string,
|
||||
> = Value extends Function | Date | RegExp
|
||||
? Value
|
||||
: Value extends Array<infer U>
|
||||
? Array<DelimiterCasedPropertiesDeep<U, Delimiter>>
|
||||
: Value extends Set<infer U>
|
||||
? Set<DelimiterCasedPropertiesDeep<U, Delimiter>> : {
|
||||
[K in keyof Value as DelimiterCase<
|
||||
K,
|
||||
Delimiter
|
||||
>]: DelimiterCasedPropertiesDeep<Value[K], Delimiter>;
|
||||
};
|
||||
@@ -0,0 +1,30 @@
|
||||
'use strict';
|
||||
|
||||
var GetIntrinsic = require('get-intrinsic');
|
||||
var callBound = require('call-bind/callBound');
|
||||
|
||||
var $TypeError = GetIntrinsic('%TypeError%');
|
||||
|
||||
var IsIntegralNumber = require('./IsIntegralNumber');
|
||||
var StringToCodePoints = require('./StringToCodePoints');
|
||||
var Type = require('./Type');
|
||||
|
||||
var $indexOf = callBound('String.prototype.indexOf');
|
||||
|
||||
// https://262.ecma-international.org/13.0/#sec-getstringindex
|
||||
|
||||
module.exports = function GetStringIndex(S, e) {
|
||||
if (Type(S) !== 'String') {
|
||||
throw new $TypeError('Assertion failed: `S` must be a String');
|
||||
}
|
||||
if (!IsIntegralNumber(e) || e < 0) {
|
||||
throw new $TypeError('Assertion failed: `e` must be a non-negative integer');
|
||||
}
|
||||
|
||||
if (S === '') {
|
||||
return 0;
|
||||
}
|
||||
var codepoints = StringToCodePoints(S);
|
||||
var eUTF = e >= codepoints.length ? S.length : $indexOf(S, codepoints[e]);
|
||||
return eUTF;
|
||||
};
|
||||
@@ -0,0 +1,377 @@
|
||||
import assert from './_assert.js';
|
||||
import { Input, toBytes, u8, u32 } from './utils.js';
|
||||
import { blake2b } from './blake2b.js';
|
||||
import u64 from './_u64.js';
|
||||
|
||||
// Experimental implementation of argon2.
|
||||
// Could be broken & slow. May be removed at a later time.
|
||||
// RFC 9106
|
||||
|
||||
enum Types {
|
||||
Argond2d = 0,
|
||||
Argon2i = 1,
|
||||
Argon2id = 2,
|
||||
}
|
||||
|
||||
const ARGON2_SYNC_POINTS = 4;
|
||||
|
||||
const toBytesOptional = (buf?: Input) => (buf !== undefined ? toBytes(buf) : new Uint8Array([]));
|
||||
|
||||
function mul(a: number, b: number) {
|
||||
const aL = a & 0xffff;
|
||||
const aH = a >>> 16;
|
||||
const bL = b & 0xffff;
|
||||
const bH = b >>> 16;
|
||||
const ll = Math.imul(aL, bL);
|
||||
const hl = Math.imul(aH, bL);
|
||||
const lh = Math.imul(aL, bH);
|
||||
const hh = Math.imul(aH, bH);
|
||||
const BUF = ((ll >>> 16) + (hl & 0xffff) + lh) | 0;
|
||||
const h = ((hl >>> 16) + (BUF >>> 16) + hh) | 0;
|
||||
return { h, l: (BUF << 16) | (ll & 0xffff) };
|
||||
}
|
||||
|
||||
function relPos(areaSize: number, relativePos: number) {
|
||||
// areaSize - 1 - ((areaSize * ((relativePos ** 2) >>> 32)) >>> 32)
|
||||
return areaSize - 1 - mul(areaSize, mul(relativePos, relativePos).h).h;
|
||||
}
|
||||
|
||||
function mul2(a: number, b: number) {
|
||||
// 2 * a * b (via shifts)
|
||||
const { h, l } = mul(a, b);
|
||||
return { h: ((h << 1) | (l >>> 31)) & 0xffff_ffff, l: (l << 1) & 0xffff_ffff };
|
||||
}
|
||||
|
||||
function blamka(Ah: number, Al: number, Bh: number, Bl: number) {
|
||||
const { h: Ch, l: Cl } = mul2(Al, Bl);
|
||||
// A + B + (2 * A * B)
|
||||
const Rll = u64.add3L(Al, Bl, Cl);
|
||||
return { h: u64.add3H(Rll, Ah, Bh, Ch), l: Rll | 0 };
|
||||
}
|
||||
|
||||
// Temporary block buffer
|
||||
const BUF = new Uint32Array(256);
|
||||
|
||||
function G(a: number, b: number, c: number, d: number) {
|
||||
let Al = BUF[2*a], Ah = BUF[2*a + 1]; // prettier-ignore
|
||||
let Bl = BUF[2*b], Bh = BUF[2*b + 1]; // prettier-ignore
|
||||
let Cl = BUF[2*c], Ch = BUF[2*c + 1]; // prettier-ignore
|
||||
let Dl = BUF[2*d], Dh = BUF[2*d + 1]; // prettier-ignore
|
||||
|
||||
({ h: Ah, l: Al } = blamka(Ah, Al, Bh, Bl));
|
||||
({ Dh, Dl } = { Dh: Dh ^ Ah, Dl: Dl ^ Al });
|
||||
({ Dh, Dl } = { Dh: u64.rotr32H(Dh, Dl), Dl: u64.rotr32L(Dh, Dl) });
|
||||
|
||||
({ h: Ch, l: Cl } = blamka(Ch, Cl, Dh, Dl));
|
||||
({ Bh, Bl } = { Bh: Bh ^ Ch, Bl: Bl ^ Cl });
|
||||
({ Bh, Bl } = { Bh: u64.rotrSH(Bh, Bl, 24), Bl: u64.rotrSL(Bh, Bl, 24) });
|
||||
|
||||
({ h: Ah, l: Al } = blamka(Ah, Al, Bh, Bl));
|
||||
({ Dh, Dl } = { Dh: Dh ^ Ah, Dl: Dl ^ Al });
|
||||
({ Dh, Dl } = { Dh: u64.rotrSH(Dh, Dl, 16), Dl: u64.rotrSL(Dh, Dl, 16) });
|
||||
|
||||
({ h: Ch, l: Cl } = blamka(Ch, Cl, Dh, Dl));
|
||||
({ Bh, Bl } = { Bh: Bh ^ Ch, Bl: Bl ^ Cl });
|
||||
({ Bh, Bl } = { Bh: u64.rotrBH(Bh, Bl, 63), Bl: u64.rotrBL(Bh, Bl, 63) });
|
||||
|
||||
(BUF[2 * a] = Al), (BUF[2 * a + 1] = Ah);
|
||||
(BUF[2 * b] = Bl), (BUF[2 * b + 1] = Bh);
|
||||
(BUF[2 * c] = Cl), (BUF[2 * c + 1] = Ch);
|
||||
(BUF[2 * d] = Dl), (BUF[2 * d + 1] = Dh);
|
||||
}
|
||||
|
||||
// prettier-ignore
|
||||
function P(
|
||||
v00: number, v01: number, v02: number, v03: number, v04: number, v05: number, v06: number, v07: number,
|
||||
v08: number, v09: number, v10: number, v11: number, v12: number, v13: number, v14: number, v15: number,
|
||||
) {
|
||||
G(v00, v04, v08, v12);
|
||||
G(v01, v05, v09, v13);
|
||||
G(v02, v06, v10, v14);
|
||||
G(v03, v07, v11, v15);
|
||||
G(v00, v05, v10, v15);
|
||||
G(v01, v06, v11, v12);
|
||||
G(v02, v07, v08, v13);
|
||||
G(v03, v04, v09, v14);
|
||||
}
|
||||
|
||||
function block(x: Uint32Array, xPos: number, yPos: number, outPos: number, needXor: boolean) {
|
||||
for (let i = 0; i < 256; i++) BUF[i] = x[xPos + i] ^ x[yPos + i];
|
||||
|
||||
// columns
|
||||
for (let i = 0; i < 128; i += 16) {
|
||||
// prettier-ignore
|
||||
P(
|
||||
i, i + 1, i + 2, i + 3, i + 4, i + 5, i + 6, i + 7,
|
||||
i + 8, i + 9, i + 10, i + 11, i + 12, i + 13, i + 14, i + 15
|
||||
);
|
||||
}
|
||||
// rows
|
||||
for (let i = 0; i < 16; i += 2) {
|
||||
// prettier-ignore
|
||||
P(
|
||||
i, i + 1, i + 16, i + 17, i + 32, i + 33, i + 48, i + 49,
|
||||
i + 64, i + 65, i + 80, i + 81, i + 96, i + 97, i + 112, i + 113
|
||||
);
|
||||
}
|
||||
|
||||
if (needXor) for (let i = 0; i < 256; i++) x[outPos + i] ^= BUF[i] ^ x[xPos + i] ^ x[yPos + i];
|
||||
else for (let i = 0; i < 256; i++) x[outPos + i] = BUF[i] ^ x[xPos + i] ^ x[yPos + i];
|
||||
}
|
||||
|
||||
// Variable-Length Hash Function H'
|
||||
function Hp(A: Uint32Array, dkLen: number) {
|
||||
const A8 = u8(A);
|
||||
const T = new Uint32Array(1);
|
||||
const T8 = u8(T);
|
||||
T[0] = dkLen;
|
||||
// Fast path
|
||||
if (dkLen <= 64) return blake2b.create({ dkLen }).update(T8).update(A8).digest();
|
||||
const out = new Uint8Array(dkLen);
|
||||
let V = blake2b.create({}).update(T8).update(A8).digest();
|
||||
let pos = 0;
|
||||
// First block
|
||||
out.set(V.subarray(0, 32));
|
||||
pos += 32;
|
||||
// Rest blocks
|
||||
for (; dkLen - pos > 64; pos += 32) out.set((V = blake2b(V)).subarray(0, 32), pos);
|
||||
// Last block
|
||||
out.set(blake2b(V, { dkLen: dkLen - pos }), pos);
|
||||
return u32(out);
|
||||
}
|
||||
|
||||
function indexAlpha(
|
||||
r: number,
|
||||
s: number,
|
||||
laneLen: number,
|
||||
segmentLen: number,
|
||||
index: number,
|
||||
randL: number,
|
||||
sameLane: boolean = false
|
||||
) {
|
||||
let area;
|
||||
if (0 == r) {
|
||||
if (0 == s) area = index - 1;
|
||||
else if (sameLane) area = s * segmentLen + index - 1;
|
||||
else area = s * segmentLen + (index == 0 ? -1 : 0);
|
||||
} else if (sameLane) area = laneLen - segmentLen + index - 1;
|
||||
else area = laneLen - segmentLen + (index == 0 ? -1 : 0);
|
||||
const startPos = r !== 0 && s !== ARGON2_SYNC_POINTS - 1 ? (s + 1) * segmentLen : 0;
|
||||
const rel = relPos(area, randL);
|
||||
// NOTE: check about overflows here
|
||||
// absPos = (startPos + relPos) % laneLength;
|
||||
return (startPos + rel) % laneLen;
|
||||
}
|
||||
|
||||
// RFC 9106
|
||||
export type ArgonOpts = {
|
||||
t: number; // Time cost, iterations count
|
||||
m: number; // Memory cost (in KB)
|
||||
p: number; // Parallelization parameter
|
||||
version?: number; // Default: 0x13 (19)
|
||||
key?: Input; // Optional key
|
||||
personalization?: Input; // Optional arbitrary extra data
|
||||
dkLen?: number; // Desired number of returned bytes
|
||||
asyncTick?: number; // Maximum time in ms for which async function can block execution
|
||||
maxmem?: number;
|
||||
onProgress?: (progress: number) => void;
|
||||
};
|
||||
|
||||
function argon2Init(type: Types, password: Input, salt: Input, opts: ArgonOpts) {
|
||||
password = toBytes(password);
|
||||
salt = toBytes(salt);
|
||||
let { p, dkLen, m, t, version, key, personalization, maxmem, onProgress } = {
|
||||
...opts,
|
||||
version: opts.version || 0x13,
|
||||
dkLen: opts.dkLen || 32,
|
||||
maxmem: 2 ** 32,
|
||||
};
|
||||
// Validation
|
||||
assert.number(p);
|
||||
assert.number(dkLen);
|
||||
assert.number(m);
|
||||
assert.number(t);
|
||||
assert.number(version);
|
||||
if (dkLen < 4 || dkLen >= 2 ** 32) throw new Error('Argon2: dkLen should be at least 4 bytes');
|
||||
if (dkLen < 1 || p >= 2 ** 32) throw new Error('Argon2: p (paralllelism) should be at least 1');
|
||||
if (dkLen < 1 || p >= 2 ** 32) throw new Error('Argon2: t (iterations) should be at least 1');
|
||||
if (m < 8 * p) throw new Error(`Argon2: memory should be at least 8*p bytes`);
|
||||
if (version !== 16 && version !== 19) throw new Error(`Argon2: unknown version=${version}`);
|
||||
password = toBytes(password);
|
||||
if (password.length < 0 || password.length >= 2 ** 32)
|
||||
throw new Error('Argon2: password should be less than 4 GB');
|
||||
salt = toBytes(salt);
|
||||
if (salt.length < 8) throw new Error('Argon2: salt should be at least 8 bytes');
|
||||
key = toBytesOptional(key);
|
||||
personalization = toBytesOptional(personalization);
|
||||
if (onProgress !== undefined && typeof onProgress !== 'function')
|
||||
throw new Error('progressCb should be function');
|
||||
// Params
|
||||
const lanes = p;
|
||||
// m' = 4 * p * floor (m / 4p)
|
||||
const mP = 4 * p * Math.floor(m / (ARGON2_SYNC_POINTS * p));
|
||||
//q = m' / p columns
|
||||
const laneLen = Math.floor(mP / p);
|
||||
const segmentLen = Math.floor(laneLen / ARGON2_SYNC_POINTS);
|
||||
// H0
|
||||
const h = blake2b.create({});
|
||||
const BUF = new Uint32Array(1);
|
||||
const BUF8 = u8(BUF);
|
||||
for (const i of [p, dkLen, m, t, version, type]) {
|
||||
if (i < 0 || i >= 2 ** 32) throw new Error(`Argon2: wrong parameter=${i}, expected uint32`);
|
||||
BUF[0] = i;
|
||||
h.update(BUF8);
|
||||
}
|
||||
for (let i of [password, salt, key, personalization]) {
|
||||
BUF[0] = i.length;
|
||||
h.update(BUF8).update(i);
|
||||
}
|
||||
const H0 = new Uint32Array(18);
|
||||
const H0_8 = u8(H0);
|
||||
h.digestInto(H0_8);
|
||||
|
||||
// 256 u32 = 1024 (BLOCK_SIZE)
|
||||
const memUsed = mP * 256;
|
||||
if (memUsed < 0 || memUsed >= 2 ** 32 || memUsed > maxmem) {
|
||||
throw new Error(
|
||||
`Argon2: wrong params (memUsed=${memUsed} maxmem=${maxmem}), should be less than 2**32`
|
||||
);
|
||||
}
|
||||
const B = new Uint32Array(memUsed);
|
||||
// Fill first blocks
|
||||
for (let l = 0; l < p; l++) {
|
||||
const i = 256 * laneLen * l;
|
||||
// B[i][0] = H'^(1024)(H_0 || LE32(0) || LE32(i))
|
||||
H0[17] = l;
|
||||
H0[16] = 0;
|
||||
B.set(Hp(H0, 1024), i);
|
||||
// B[i][1] = H'^(1024)(H_0 || LE32(1) || LE32(i))
|
||||
H0[16] = 1;
|
||||
B.set(Hp(H0, 1024), i + 256);
|
||||
}
|
||||
let perBlock = () => {};
|
||||
if (onProgress) {
|
||||
const totalBlock = t * ARGON2_SYNC_POINTS * p * segmentLen;
|
||||
// Invoke callback if progress changes from 10.01 to 10.02
|
||||
// Allows to draw smooth progress bar on up to 8K screen
|
||||
const callbackPer = Math.max(Math.floor(totalBlock / 10000), 1);
|
||||
let blockCnt = 0;
|
||||
perBlock = () => {
|
||||
blockCnt++;
|
||||
if (onProgress && (!(blockCnt % callbackPer) || blockCnt === totalBlock))
|
||||
onProgress(blockCnt / totalBlock);
|
||||
};
|
||||
}
|
||||
return { type, mP, p, t, version, B, laneLen, lanes, segmentLen, dkLen, perBlock };
|
||||
}
|
||||
|
||||
function argon2Output(B: Uint32Array, p: number, laneLen: number, dkLen: number) {
|
||||
const B_final = new Uint32Array(256);
|
||||
for (let l = 0; l < p; l++)
|
||||
for (let j = 0; j < 256; j++) B_final[j] ^= B[256 * (laneLen * l + laneLen - 1) + j];
|
||||
return u8(Hp(B_final, dkLen));
|
||||
}
|
||||
|
||||
function processBlock(
|
||||
B: Uint32Array,
|
||||
address: Uint32Array,
|
||||
l: number,
|
||||
r: number,
|
||||
s: number,
|
||||
index: number,
|
||||
laneLen: number,
|
||||
segmentLen: number,
|
||||
lanes: number,
|
||||
offset: number,
|
||||
prev: number,
|
||||
dataIndependent: boolean,
|
||||
needXor: boolean
|
||||
) {
|
||||
if (offset % laneLen) prev = offset - 1;
|
||||
let randL, randH;
|
||||
if (dataIndependent) {
|
||||
if (index % 128 === 0) {
|
||||
address[256 + 12]++;
|
||||
block(address, 256, 2 * 256, 0, false);
|
||||
block(address, 0, 2 * 256, 0, false);
|
||||
}
|
||||
randL = address[2 * (index % 128)];
|
||||
randH = address[2 * (index % 128) + 1];
|
||||
} else {
|
||||
const T = 256 * prev;
|
||||
randL = B[T];
|
||||
randH = B[T + 1];
|
||||
}
|
||||
// address block
|
||||
const refLane = r === 0 && s === 0 ? l : randH % lanes;
|
||||
const refPos = indexAlpha(r, s, laneLen, segmentLen, index, randL, refLane == l);
|
||||
const refBlock = laneLen * refLane + refPos;
|
||||
// B[i][j] = G(B[i][j-1], B[l][z])
|
||||
block(B, 256 * prev, 256 * refBlock, offset * 256, needXor);
|
||||
}
|
||||
|
||||
function argon2(type: Types, password: Input, salt: Input, opts: ArgonOpts) {
|
||||
const { mP, p, t, version, B, laneLen, lanes, segmentLen, dkLen, perBlock } = argon2Init(
|
||||
type,
|
||||
password,
|
||||
salt,
|
||||
opts
|
||||
);
|
||||
// Pre-loop setup
|
||||
// [address, input, zero_block] format so we can pass single U32 to block function
|
||||
const address = new Uint32Array(3 * 256);
|
||||
address[256 + 6] = mP;
|
||||
address[256 + 8] = t;
|
||||
address[256 + 10] = type;
|
||||
for (let r = 0; r < t; r++) {
|
||||
const needXor = r !== 0 && version === 0x13;
|
||||
address[256 + 0] = r;
|
||||
for (let s = 0; s < ARGON2_SYNC_POINTS; s++) {
|
||||
address[256 + 4] = s;
|
||||
const dataIndependent = type == Types.Argon2i || (type == Types.Argon2id && r === 0 && s < 2);
|
||||
for (let l = 0; l < p; l++) {
|
||||
address[256 + 2] = l;
|
||||
address[256 + 12] = 0;
|
||||
let startPos = 0;
|
||||
if (r === 0 && s === 0) {
|
||||
startPos = 2;
|
||||
if (dataIndependent) {
|
||||
address[256 + 12]++;
|
||||
block(address, 256, 2 * 256, 0, false);
|
||||
block(address, 0, 2 * 256, 0, false);
|
||||
}
|
||||
}
|
||||
// current block postion
|
||||
let offset = l * laneLen + s * segmentLen + startPos;
|
||||
// previous block position
|
||||
let prev = offset % laneLen ? offset - 1 : offset + laneLen - 1;
|
||||
for (let index = startPos; index < segmentLen; index++, offset++, prev++) {
|
||||
perBlock();
|
||||
processBlock(
|
||||
B,
|
||||
address,
|
||||
l,
|
||||
r,
|
||||
s,
|
||||
index,
|
||||
laneLen,
|
||||
segmentLen,
|
||||
lanes,
|
||||
offset,
|
||||
prev,
|
||||
dataIndependent,
|
||||
needXor
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return argon2Output(B, p, laneLen, dkLen);
|
||||
}
|
||||
|
||||
export const argon2d = (password: Input, salt: Input, opts: ArgonOpts) =>
|
||||
argon2(Types.Argond2d, password, salt, opts);
|
||||
export const argon2i = (password: Input, salt: Input, opts: ArgonOpts) =>
|
||||
argon2(Types.Argon2i, password, salt, opts);
|
||||
export const argon2id = (password: Input, salt: Input, opts: ArgonOpts) =>
|
||||
argon2(Types.Argon2id, password, salt, opts);
|
||||
@@ -0,0 +1,65 @@
|
||||
{
|
||||
"name": "which-boxed-primitive",
|
||||
"version": "1.0.2",
|
||||
"description": "Which kind of boxed JS primitive is this?",
|
||||
"main": "index.js",
|
||||
"scripts": {
|
||||
"preversion": "auto-changelog",
|
||||
"prepublish": "not-in-publish || safe-publish-latest",
|
||||
"lint": "eslint --ext=js,mjs .",
|
||||
"pretest": "npm run lint",
|
||||
"tests-only": "nyc tape 'test/**/*.js'",
|
||||
"test": "npm run tests-only",
|
||||
"posttest": "aud --production",
|
||||
"version": "auto-changelog && git add CHANGELOG.md",
|
||||
"postversion": "auto-changelog && git add CHANGELOG.md && git commit --no-edit --amend && git tag -f \"v$(node -e \"console.log(require('./package.json').version)\")\""
|
||||
},
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "git+https://github.com/inspect-js/which-boxed-primitive.git"
|
||||
},
|
||||
"keywords": [
|
||||
"boxed",
|
||||
"primitive",
|
||||
"object",
|
||||
"ecmascript",
|
||||
"javascript",
|
||||
"which"
|
||||
],
|
||||
"author": "Jordan Harband <ljharb@gmail.com>",
|
||||
"funding": {
|
||||
"url": "https://github.com/sponsors/ljharb"
|
||||
},
|
||||
"license": "MIT",
|
||||
"bugs": {
|
||||
"url": "https://github.com/inspect-js/which-boxed-primitive/issues"
|
||||
},
|
||||
"homepage": "https://github.com/inspect-js/which-boxed-primitive#readme",
|
||||
"dependencies": {
|
||||
"is-bigint": "^1.0.1",
|
||||
"is-boolean-object": "^1.1.0",
|
||||
"is-number-object": "^1.0.4",
|
||||
"is-string": "^1.0.5",
|
||||
"is-symbol": "^1.0.3"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@ljharb/eslint-config": "^17.3.0",
|
||||
"aud": "^1.1.3",
|
||||
"auto-changelog": "^2.2.1",
|
||||
"eslint": "^7.15.0",
|
||||
"has-symbols": "^1.0.1",
|
||||
"in-publish": "^2.0.1",
|
||||
"nyc": "^10.3.2",
|
||||
"object-inspect": "^1.9.0",
|
||||
"safe-publish-latest": "^1.1.4",
|
||||
"tape": "^5.0.1"
|
||||
},
|
||||
"auto-changelog": {
|
||||
"output": "CHANGELOG.md",
|
||||
"template": "keepachangelog",
|
||||
"unreleased": false,
|
||||
"commitLimit": false,
|
||||
"backfillLimit": false,
|
||||
"hideCredit": true
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,5 @@
|
||||
var convert = require('./convert'),
|
||||
func = convert('pick', require('../pick'));
|
||||
|
||||
func.placeholder = require('./placeholder');
|
||||
module.exports = func;
|
||||
@@ -0,0 +1,32 @@
|
||||
var baseNth = require('./_baseNth'),
|
||||
baseRest = require('./_baseRest'),
|
||||
toInteger = require('./toInteger');
|
||||
|
||||
/**
|
||||
* Creates a function that gets the argument at index `n`. If `n` is negative,
|
||||
* the nth argument from the end is returned.
|
||||
*
|
||||
* @static
|
||||
* @memberOf _
|
||||
* @since 4.0.0
|
||||
* @category Util
|
||||
* @param {number} [n=0] The index of the argument to return.
|
||||
* @returns {Function} Returns the new pass-thru function.
|
||||
* @example
|
||||
*
|
||||
* var func = _.nthArg(1);
|
||||
* func('a', 'b', 'c', 'd');
|
||||
* // => 'b'
|
||||
*
|
||||
* var func = _.nthArg(-2);
|
||||
* func('a', 'b', 'c', 'd');
|
||||
* // => 'c'
|
||||
*/
|
||||
function nthArg(n) {
|
||||
n = toInteger(n);
|
||||
return baseRest(function(args) {
|
||||
return baseNth(args, n);
|
||||
});
|
||||
}
|
||||
|
||||
module.exports = nthArg;
|
||||
@@ -0,0 +1,60 @@
|
||||
{
|
||||
"name": "nanoid",
|
||||
"version": "3.3.4",
|
||||
"description": "A tiny (116 bytes), secure URL-friendly unique string ID generator",
|
||||
"keywords": [
|
||||
"uuid",
|
||||
"random",
|
||||
"id",
|
||||
"url"
|
||||
],
|
||||
"engines": {
|
||||
"node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
|
||||
},
|
||||
"author": "Andrey Sitnik <andrey@sitnik.ru>",
|
||||
"license": "MIT",
|
||||
"repository": "ai/nanoid",
|
||||
"browser": {
|
||||
"./index.js": "./index.browser.js",
|
||||
"./async/index.js": "./async/index.browser.js",
|
||||
"./async/index.cjs": "./async/index.browser.cjs",
|
||||
"./index.cjs": "./index.browser.cjs"
|
||||
},
|
||||
"react-native": "index.js",
|
||||
"bin": "./bin/nanoid.cjs",
|
||||
"sideEffects": false,
|
||||
"types": "./index.d.ts",
|
||||
"type": "module",
|
||||
"main": "index.cjs",
|
||||
"module": "index.js",
|
||||
"exports": {
|
||||
".": {
|
||||
"types": "./index.d.ts",
|
||||
"browser": "./index.browser.js",
|
||||
"require": "./index.cjs",
|
||||
"import": "./index.js",
|
||||
"default": "./index.js"
|
||||
},
|
||||
"./index.d.ts": "./index.d.ts",
|
||||
"./package.json": "./package.json",
|
||||
"./async/package.json": "./async/package.json",
|
||||
"./async": {
|
||||
"browser": "./async/index.browser.js",
|
||||
"require": "./async/index.cjs",
|
||||
"import": "./async/index.js",
|
||||
"default": "./async/index.js"
|
||||
},
|
||||
"./non-secure/package.json": "./non-secure/package.json",
|
||||
"./non-secure": {
|
||||
"require": "./non-secure/index.cjs",
|
||||
"import": "./non-secure/index.js",
|
||||
"default": "./non-secure/index.js"
|
||||
},
|
||||
"./url-alphabet/package.json": "./url-alphabet/package.json",
|
||||
"./url-alphabet": {
|
||||
"require": "./url-alphabet/index.cjs",
|
||||
"import": "./url-alphabet/index.js",
|
||||
"default": "./url-alphabet/index.js"
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,11 @@
|
||||
const redirectStatus = new Set([301, 302, 303, 307, 308]);
|
||||
|
||||
/**
|
||||
* Redirect code matching
|
||||
*
|
||||
* @param {number} code - Status code
|
||||
* @return {boolean}
|
||||
*/
|
||||
export const isRedirect = code => {
|
||||
return redirectStatus.has(code);
|
||||
};
|
||||
@@ -0,0 +1,341 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
function _export(target, all) {
|
||||
for(var name in all)Object.defineProperty(target, name, {
|
||||
enumerable: true,
|
||||
get: all[name]
|
||||
});
|
||||
}
|
||||
_export(exports, {
|
||||
formatVariantSelector: ()=>formatVariantSelector,
|
||||
eliminateIrrelevantSelectors: ()=>eliminateIrrelevantSelectors,
|
||||
finalizeSelector: ()=>finalizeSelector,
|
||||
handleMergePseudo: ()=>handleMergePseudo
|
||||
});
|
||||
const _postcssSelectorParser = /*#__PURE__*/ _interopRequireDefault(require("postcss-selector-parser"));
|
||||
const _unesc = /*#__PURE__*/ _interopRequireDefault(require("postcss-selector-parser/dist/util/unesc"));
|
||||
const _escapeClassName = /*#__PURE__*/ _interopRequireDefault(require("../util/escapeClassName"));
|
||||
const _prefixSelector = /*#__PURE__*/ _interopRequireDefault(require("../util/prefixSelector"));
|
||||
function _interopRequireDefault(obj) {
|
||||
return obj && obj.__esModule ? obj : {
|
||||
default: obj
|
||||
};
|
||||
}
|
||||
/** @typedef {import('postcss-selector-parser').Root} Root */ /** @typedef {import('postcss-selector-parser').Selector} Selector */ /** @typedef {import('postcss-selector-parser').Pseudo} Pseudo */ /** @typedef {import('postcss-selector-parser').Node} Node */ /** @typedef {{format: string, isArbitraryVariant: boolean}[]} RawFormats */ /** @typedef {import('postcss-selector-parser').Root} ParsedFormats */ /** @typedef {RawFormats | ParsedFormats} AcceptedFormats */ let MERGE = ":merge";
|
||||
function formatVariantSelector(formats, { context , candidate }) {
|
||||
var _context_tailwindConfig_prefix;
|
||||
let prefix = (_context_tailwindConfig_prefix = context === null || context === void 0 ? void 0 : context.tailwindConfig.prefix) !== null && _context_tailwindConfig_prefix !== void 0 ? _context_tailwindConfig_prefix : "";
|
||||
// Parse the format selector into an AST
|
||||
let parsedFormats = formats.map((format)=>{
|
||||
let ast = (0, _postcssSelectorParser.default)().astSync(format.format);
|
||||
return {
|
||||
...format,
|
||||
ast: format.isArbitraryVariant ? ast : (0, _prefixSelector.default)(prefix, ast)
|
||||
};
|
||||
});
|
||||
// We start with the candidate selector
|
||||
let formatAst = _postcssSelectorParser.default.root({
|
||||
nodes: [
|
||||
_postcssSelectorParser.default.selector({
|
||||
nodes: [
|
||||
_postcssSelectorParser.default.className({
|
||||
value: (0, _escapeClassName.default)(candidate)
|
||||
})
|
||||
]
|
||||
})
|
||||
]
|
||||
});
|
||||
// And iteratively merge each format selector into the candidate selector
|
||||
for (let { ast } of parsedFormats){
|
||||
[formatAst, ast] = handleMergePseudo(formatAst, ast);
|
||||
// 2. Merge the format selector into the current selector AST
|
||||
ast.walkNesting((nesting)=>nesting.replaceWith(...formatAst.nodes[0].nodes));
|
||||
// 3. Keep going!
|
||||
formatAst = ast;
|
||||
}
|
||||
return formatAst;
|
||||
}
|
||||
/**
|
||||
* Given any node in a selector this gets the "simple" selector it's a part of
|
||||
* A simple selector is just a list of nodes without any combinators
|
||||
* Technically :is(), :not(), :has(), etc… can have combinators but those are nested
|
||||
* inside the relevant node and won't be picked up so they're fine to ignore
|
||||
*
|
||||
* @param {Node} node
|
||||
* @returns {Node[]}
|
||||
**/ function simpleSelectorForNode(node) {
|
||||
/** @type {Node[]} */ let nodes = [];
|
||||
// Walk backwards until we hit a combinator node (or the start)
|
||||
while(node.prev() && node.prev().type !== "combinator"){
|
||||
node = node.prev();
|
||||
}
|
||||
// Now record all non-combinator nodes until we hit one (or the end)
|
||||
while(node && node.type !== "combinator"){
|
||||
nodes.push(node);
|
||||
node = node.next();
|
||||
}
|
||||
return nodes;
|
||||
}
|
||||
/**
|
||||
* Resorts the nodes in a selector to ensure they're in the correct order
|
||||
* Tags go before classes, and pseudo classes go after classes
|
||||
*
|
||||
* @param {Selector} sel
|
||||
* @returns {Selector}
|
||||
**/ function resortSelector(sel) {
|
||||
sel.sort((a, b)=>{
|
||||
if (a.type === "tag" && b.type === "class") {
|
||||
return -1;
|
||||
} else if (a.type === "class" && b.type === "tag") {
|
||||
return 1;
|
||||
} else if (a.type === "class" && b.type === "pseudo" && b.value.startsWith("::")) {
|
||||
return -1;
|
||||
} else if (a.type === "pseudo" && a.value.startsWith("::") && b.type === "class") {
|
||||
return 1;
|
||||
}
|
||||
return sel.index(a) - sel.index(b);
|
||||
});
|
||||
return sel;
|
||||
}
|
||||
function eliminateIrrelevantSelectors(sel, base) {
|
||||
let hasClassesMatchingCandidate = false;
|
||||
sel.walk((child)=>{
|
||||
if (child.type === "class" && child.value === base) {
|
||||
hasClassesMatchingCandidate = true;
|
||||
return false // Stop walking
|
||||
;
|
||||
}
|
||||
});
|
||||
if (!hasClassesMatchingCandidate) {
|
||||
sel.remove();
|
||||
}
|
||||
// We do NOT recursively eliminate sub selectors that don't have the base class
|
||||
// as this is NOT a safe operation. For example, if we have:
|
||||
// `.space-x-2 > :not([hidden]) ~ :not([hidden])`
|
||||
// We cannot remove the [hidden] from the :not() because it would change the
|
||||
// meaning of the selector.
|
||||
// TODO: Can we do this for :matches, :is, and :where?
|
||||
}
|
||||
function finalizeSelector(current, formats, { context , candidate , base }) {
|
||||
var _context_tailwindConfig;
|
||||
var _context_tailwindConfig_separator;
|
||||
let separator = (_context_tailwindConfig_separator = context === null || context === void 0 ? void 0 : (_context_tailwindConfig = context.tailwindConfig) === null || _context_tailwindConfig === void 0 ? void 0 : _context_tailwindConfig.separator) !== null && _context_tailwindConfig_separator !== void 0 ? _context_tailwindConfig_separator : ":";
|
||||
// Split by the separator, but ignore the separator inside square brackets:
|
||||
//
|
||||
// E.g.: dark:lg:hover:[paint-order:markers]
|
||||
// ┬ ┬ ┬ ┬
|
||||
// │ │ │ ╰── We will not split here
|
||||
// ╰──┴─────┴─────────────── We will split here
|
||||
//
|
||||
base = base !== null && base !== void 0 ? base : candidate.split(new RegExp(`\\${separator}(?![^[]*\\])`)).pop();
|
||||
// Parse the selector into an AST
|
||||
let selector = (0, _postcssSelectorParser.default)().astSync(current);
|
||||
// Normalize escaped classes, e.g.:
|
||||
//
|
||||
// The idea would be to replace the escaped `base` in the selector with the
|
||||
// `format`. However, in css you can escape the same selector in a few
|
||||
// different ways. This would result in different strings and therefore we
|
||||
// can't replace it properly.
|
||||
//
|
||||
// base: bg-[rgb(255,0,0)]
|
||||
// base in selector: bg-\\[rgb\\(255\\,0\\,0\\)\\]
|
||||
// escaped base: bg-\\[rgb\\(255\\2c 0\\2c 0\\)\\]
|
||||
//
|
||||
selector.walkClasses((node)=>{
|
||||
if (node.raws && node.value.includes(base)) {
|
||||
node.raws.value = (0, _escapeClassName.default)((0, _unesc.default)(node.raws.value));
|
||||
}
|
||||
});
|
||||
// Remove extraneous selectors that do not include the base candidate
|
||||
selector.each((sel)=>eliminateIrrelevantSelectors(sel, base));
|
||||
// If there are no formats that means there were no variants added to the candidate
|
||||
// so we can just return the selector as-is
|
||||
let formatAst = Array.isArray(formats) ? formatVariantSelector(formats, {
|
||||
context,
|
||||
candidate
|
||||
}) : formats;
|
||||
if (formatAst === null) {
|
||||
return selector.toString();
|
||||
}
|
||||
let simpleStart = _postcssSelectorParser.default.comment({
|
||||
value: "/*__simple__*/"
|
||||
});
|
||||
let simpleEnd = _postcssSelectorParser.default.comment({
|
||||
value: "/*__simple__*/"
|
||||
});
|
||||
// We can safely replace the escaped base now, since the `base` section is
|
||||
// now in a normalized escaped value.
|
||||
selector.walkClasses((node)=>{
|
||||
if (node.value !== base) {
|
||||
return;
|
||||
}
|
||||
let parent = node.parent;
|
||||
let formatNodes = formatAst.nodes[0].nodes;
|
||||
// Perf optimization: if the parent is a single class we can just replace it and be done
|
||||
if (parent.nodes.length === 1) {
|
||||
node.replaceWith(...formatNodes);
|
||||
return;
|
||||
}
|
||||
let simpleSelector = simpleSelectorForNode(node);
|
||||
parent.insertBefore(simpleSelector[0], simpleStart);
|
||||
parent.insertAfter(simpleSelector[simpleSelector.length - 1], simpleEnd);
|
||||
for (let child of formatNodes){
|
||||
parent.insertBefore(simpleSelector[0], child.clone());
|
||||
}
|
||||
node.remove();
|
||||
// Re-sort the simple selector to ensure it's in the correct order
|
||||
simpleSelector = simpleSelectorForNode(simpleStart);
|
||||
let firstNode = parent.index(simpleStart);
|
||||
parent.nodes.splice(firstNode, simpleSelector.length, ...resortSelector(_postcssSelectorParser.default.selector({
|
||||
nodes: simpleSelector
|
||||
})).nodes);
|
||||
simpleStart.remove();
|
||||
simpleEnd.remove();
|
||||
});
|
||||
// Remove unnecessary pseudo selectors that we used as placeholders
|
||||
selector.walkPseudos((p)=>{
|
||||
if (p.value === MERGE) {
|
||||
p.replaceWith(p.nodes);
|
||||
}
|
||||
});
|
||||
// Move pseudo elements to the end of the selector (if necessary)
|
||||
selector.each((sel)=>{
|
||||
let pseudoElements = collectPseudoElements(sel);
|
||||
if (pseudoElements.length > 0) {
|
||||
sel.nodes.push(pseudoElements.sort(sortSelector));
|
||||
}
|
||||
});
|
||||
return selector.toString();
|
||||
}
|
||||
function handleMergePseudo(selector, format) {
|
||||
/** @type {{pseudo: Pseudo, value: string}[]} */ let merges = [];
|
||||
// Find all :merge() pseudo-classes in `selector`
|
||||
selector.walkPseudos((pseudo)=>{
|
||||
if (pseudo.value === MERGE) {
|
||||
merges.push({
|
||||
pseudo,
|
||||
value: pseudo.nodes[0].toString()
|
||||
});
|
||||
}
|
||||
});
|
||||
// Find all :merge() "attachments" in `format` and attach them to the matching selector in `selector`
|
||||
format.walkPseudos((pseudo)=>{
|
||||
if (pseudo.value !== MERGE) {
|
||||
return;
|
||||
}
|
||||
let value = pseudo.nodes[0].toString();
|
||||
// Does `selector` contain a :merge() pseudo-class with the same value?
|
||||
let existing = merges.find((merge)=>merge.value === value);
|
||||
// Nope so there's nothing to do
|
||||
if (!existing) {
|
||||
return;
|
||||
}
|
||||
// Everything after `:merge()` up to the next combinator is what is attached to the merged selector
|
||||
let attachments = [];
|
||||
let next = pseudo.next();
|
||||
while(next && next.type !== "combinator"){
|
||||
attachments.push(next);
|
||||
next = next.next();
|
||||
}
|
||||
let combinator = next;
|
||||
existing.pseudo.parent.insertAfter(existing.pseudo, _postcssSelectorParser.default.selector({
|
||||
nodes: attachments.map((node)=>node.clone())
|
||||
}));
|
||||
pseudo.remove();
|
||||
attachments.forEach((node)=>node.remove());
|
||||
// What about this case:
|
||||
// :merge(.group):focus > &
|
||||
// :merge(.group):hover &
|
||||
if (combinator && combinator.type === "combinator") {
|
||||
combinator.remove();
|
||||
}
|
||||
});
|
||||
return [
|
||||
selector,
|
||||
format
|
||||
];
|
||||
}
|
||||
// Note: As a rule, double colons (::) should be used instead of a single colon
|
||||
// (:). This distinguishes pseudo-classes from pseudo-elements. However, since
|
||||
// this distinction was not present in older versions of the W3C spec, most
|
||||
// browsers support both syntaxes for the original pseudo-elements.
|
||||
let pseudoElementsBC = [
|
||||
":before",
|
||||
":after",
|
||||
":first-line",
|
||||
":first-letter"
|
||||
];
|
||||
// These pseudo-elements _can_ be combined with other pseudo selectors AND the order does matter.
|
||||
let pseudoElementExceptions = [
|
||||
"::file-selector-button",
|
||||
// Webkit scroll bar pseudo elements can be combined with user-action pseudo classes
|
||||
"::-webkit-scrollbar",
|
||||
"::-webkit-scrollbar-button",
|
||||
"::-webkit-scrollbar-thumb",
|
||||
"::-webkit-scrollbar-track",
|
||||
"::-webkit-scrollbar-track-piece",
|
||||
"::-webkit-scrollbar-corner",
|
||||
"::-webkit-resizer"
|
||||
];
|
||||
/**
|
||||
* This will make sure to move pseudo's to the correct spot (the end for
|
||||
* pseudo elements) because otherwise the selector will never work
|
||||
* anyway.
|
||||
*
|
||||
* E.g.:
|
||||
* - `before:hover:text-center` would result in `.before\:hover\:text-center:hover::before`
|
||||
* - `hover:before:text-center` would result in `.hover\:before\:text-center:hover::before`
|
||||
*
|
||||
* `::before:hover` doesn't work, which means that we can make it work for you by flipping the order.
|
||||
*
|
||||
* @param {Selector} selector
|
||||
**/ function collectPseudoElements(selector) {
|
||||
/** @type {Node[]} */ let nodes = [];
|
||||
for (let node of selector.nodes){
|
||||
if (isPseudoElement(node)) {
|
||||
nodes.push(node);
|
||||
selector.removeChild(node);
|
||||
}
|
||||
if (node === null || node === void 0 ? void 0 : node.nodes) {
|
||||
nodes.push(...collectPseudoElements(node));
|
||||
}
|
||||
}
|
||||
return nodes;
|
||||
}
|
||||
// This will make sure to move pseudo's to the correct spot (the end for
|
||||
// pseudo elements) because otherwise the selector will never work
|
||||
// anyway.
|
||||
//
|
||||
// E.g.:
|
||||
// - `before:hover:text-center` would result in `.before\:hover\:text-center:hover::before`
|
||||
// - `hover:before:text-center` would result in `.hover\:before\:text-center:hover::before`
|
||||
//
|
||||
// `::before:hover` doesn't work, which means that we can make it work
|
||||
// for you by flipping the order.
|
||||
function sortSelector(a, z) {
|
||||
// Both nodes are non-pseudo's so we can safely ignore them and keep
|
||||
// them in the same order.
|
||||
if (a.type !== "pseudo" && z.type !== "pseudo") {
|
||||
return 0;
|
||||
}
|
||||
// If one of them is a combinator, we need to keep it in the same order
|
||||
// because that means it will start a new "section" in the selector.
|
||||
if (a.type === "combinator" ^ z.type === "combinator") {
|
||||
return 0;
|
||||
}
|
||||
// One of the items is a pseudo and the other one isn't. Let's move
|
||||
// the pseudo to the right.
|
||||
if (a.type === "pseudo" ^ z.type === "pseudo") {
|
||||
return (a.type === "pseudo") - (z.type === "pseudo");
|
||||
}
|
||||
// Both are pseudo's, move the pseudo elements (except for
|
||||
// ::file-selector-button) to the right.
|
||||
return isPseudoElement(a) - isPseudoElement(z);
|
||||
}
|
||||
function isPseudoElement(node) {
|
||||
if (node.type !== "pseudo") return false;
|
||||
if (pseudoElementExceptions.includes(node.value)) return false;
|
||||
return node.value.startsWith("::") || pseudoElementsBC.includes(node.value);
|
||||
}
|
||||
@@ -0,0 +1 @@
|
||||
module.exports={A:{A:{"2":"J D E CC","8":"F A B"},B:{"1":"N O P Q R S T U V W X Y Z a b c d e i j k l m n o p q r s t u f H","8":"C K L G M"},C:{"1":"0 1 2 3 4 5 6 7 8 9 I v J D E F A B C K L G M N O w g x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB TB UB VB WB XB YB uB ZB vB aB bB cB dB eB fB gB hB iB jB kB h lB mB nB oB pB P Q R wB S T U V W X Y Z a b c d e i j k l m n o p q r s t u f H xB yB EC FC","2":"DC tB"},D:{"1":"0 1 2 3 4 5 6 7 8 9 I v J D E F A B C K L G M N O w g x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB TB UB VB WB XB YB uB ZB vB aB bB cB dB eB fB gB hB iB jB kB h lB mB nB oB pB P Q R S T U V W X Y Z a b c d e i j k l m n o p q r s t u f H xB yB GC"},E:{"2":"I v J D E F A B C K L G HC zB IC JC KC LC 0B qB rB 1B MC NC 2B 3B 4B 5B sB 6B 7B 8B 9B OC"},F:{"1":"0 1 2 3 4 5 6 7 8 9 B C G M N O w g x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB TB UB VB WB XB YB ZB aB bB cB dB eB fB gB hB iB jB kB h lB mB nB oB pB P Q R wB S T U V W X Y Z a b c d e RC SC qB AC TC rB","2":"F PC QC"},G:{"2":"E zB UC BC VC WC XC YC ZC aC bC cC dC eC fC gC hC iC jC kC lC mC nC 2B 3B 4B 5B sB 6B 7B 8B 9B"},H:{"2":"oC"},I:{"2":"tB I f pC qC rC sC BC tC uC"},J:{"2":"D A"},K:{"2":"A B C h qB AC rB"},L:{"2":"H"},M:{"1":"H"},N:{"8":"A B"},O:{"1":"vC"},P:{"2":"I g wC xC yC zC 0C 0B 1C 2C 3C 4C 5C sB 6C 7C 8C"},Q:{"1":"1B"},R:{"2":"9C"},S:{"1":"AD BD"}},B:6,C:"Ogg/Theora video format"};
|
||||
@@ -0,0 +1,70 @@
|
||||
# xdg-basedir
|
||||
|
||||
> Get [XDG Base Directory](https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html) paths
|
||||
|
||||
This package is meant for Linux. You should not use XDG on macOS or Windows. Instead, you should follow their platform conventions. You can use [`env-paths`](https://github.com/sindresorhus/env-paths) for that.
|
||||
|
||||
## Install
|
||||
|
||||
```
|
||||
$ npm install xdg-basedir
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
||||
```js
|
||||
import {xdgData, xdgConfig, xdgDataDirectories} from 'xdg-basedir';
|
||||
|
||||
console.log(xdgData);
|
||||
//=> '/home/sindresorhus/.local/share'
|
||||
|
||||
console.log(xdgConfig);
|
||||
//=> '/home/sindresorhus/.config'
|
||||
|
||||
console.log(xdgDataDirectories);
|
||||
//=> ['/home/sindresorhus/.local/share', '/usr/local/share/', '/usr/share/']
|
||||
```
|
||||
|
||||
## API
|
||||
|
||||
The exports `xdgData`, `xdgConfig`, `xdgCache`, `xdgRuntime` will return `undefined` in the uncommon case that both the XDG environment variable is not set and the users home directory can't be found. You need to handle this case. A common solution is to [fall back to a temporary directory](https://github.com/yeoman/configstore/blob/b82690fc401318ad18dcd7d151a0003a4898a314/index.js#L15).
|
||||
|
||||
### xdgData
|
||||
|
||||
Directory for user-specific data files.
|
||||
|
||||
### xdgConfig
|
||||
|
||||
Directory for user-specific configuration files.
|
||||
|
||||
### xdgState
|
||||
|
||||
Directory for user-specific state files.
|
||||
|
||||
### xdgCache
|
||||
|
||||
Directory for user-specific non-essential data files.
|
||||
|
||||
### xdgRuntime
|
||||
|
||||
Directory for user-specific non-essential runtime files and other file objects (such as sockets, named pipes, etc).
|
||||
|
||||
### xdgDataDirectories
|
||||
|
||||
Preference-ordered array of base directories to search for data files in addition to `xdgData`.
|
||||
|
||||
### xdgConfigDirectories
|
||||
|
||||
Preference-ordered array of base directories to search for configuration files in addition to `xdgConfig`.
|
||||
|
||||
---
|
||||
|
||||
<div align="center">
|
||||
<b>
|
||||
<a href="https://tidelift.com/subscription/pkg/npm-xdg-basedir?utm_source=npm-xdg-basedir&utm_medium=referral&utm_campaign=readme">Get professional support for this package with a Tidelift subscription</a>
|
||||
</b>
|
||||
<br>
|
||||
<sub>
|
||||
Tidelift helps make open source sustainable for maintainers while giving companies<br>assurances about security, maintenance, and licensing for their dependencies.
|
||||
</sub>
|
||||
</div>
|
||||
@@ -0,0 +1,4 @@
|
||||
import { MappedCode } from '../utils/mapped_code';
|
||||
import { Source } from './types';
|
||||
export declare function slice_source(code_slice: string, offset: number, { file_basename, filename, get_location }: Source): Source;
|
||||
export declare function replace_in_code(regex: RegExp, get_replacement: (...match: any[]) => Promise<MappedCode>, location: Source): Promise<MappedCode>;
|
||||
@@ -0,0 +1,61 @@
|
||||
let matchingBrackets = new Map([
|
||||
['{', '}'],
|
||||
['[', ']'],
|
||||
['(', ')'],
|
||||
])
|
||||
let inverseMatchingBrackets = new Map(
|
||||
Array.from(matchingBrackets.entries()).map(([k, v]) => [v, k])
|
||||
)
|
||||
|
||||
let quotes = new Set(['"', "'", '`'])
|
||||
|
||||
// Arbitrary values must contain balanced brackets (), [] and {}. Escaped
|
||||
// values don't count, and brackets inside quotes also don't count.
|
||||
//
|
||||
// E.g.: w-[this-is]w-[weird-and-invalid]
|
||||
// E.g.: w-[this-is\\]w-\\[weird-but-valid]
|
||||
// E.g.: content-['this-is-also-valid]-weirdly-enough']
|
||||
export default function isSyntacticallyValidPropertyValue(value) {
|
||||
let stack = []
|
||||
let inQuotes = false
|
||||
|
||||
for (let i = 0; i < value.length; i++) {
|
||||
let char = value[i]
|
||||
|
||||
if (char === ':' && !inQuotes && stack.length === 0) {
|
||||
return false
|
||||
}
|
||||
|
||||
// Non-escaped quotes allow us to "allow" anything in between
|
||||
if (quotes.has(char) && value[i - 1] !== '\\') {
|
||||
inQuotes = !inQuotes
|
||||
}
|
||||
|
||||
if (inQuotes) continue
|
||||
if (value[i - 1] === '\\') continue // Escaped
|
||||
|
||||
if (matchingBrackets.has(char)) {
|
||||
stack.push(char)
|
||||
} else if (inverseMatchingBrackets.has(char)) {
|
||||
let inverse = inverseMatchingBrackets.get(char)
|
||||
|
||||
// Nothing to pop from, therefore it is unbalanced
|
||||
if (stack.length <= 0) {
|
||||
return false
|
||||
}
|
||||
|
||||
// Popped value must match the inverse value, otherwise it is unbalanced
|
||||
if (stack.pop() !== inverse) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// If there is still something on the stack, it is also unbalanced
|
||||
if (stack.length > 0) {
|
||||
return false
|
||||
}
|
||||
|
||||
// All good, totally balanced!
|
||||
return true
|
||||
}
|
||||
@@ -0,0 +1,15 @@
|
||||
"use strict";
|
||||
|
||||
var toPosInt = require("../../number/to-pos-integer")
|
||||
, value = require("../../object/valid-value")
|
||||
, objHasOwnProperty = Object.prototype.hasOwnProperty;
|
||||
|
||||
module.exports = function () {
|
||||
var i, length;
|
||||
if (!(length = toPosInt(value(this).length))) return null;
|
||||
i = 0;
|
||||
while (!objHasOwnProperty.call(this, i)) {
|
||||
if (++i === length) return null;
|
||||
}
|
||||
return i;
|
||||
};
|
||||
@@ -0,0 +1,22 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.distinct = void 0;
|
||||
var lift_1 = require("../util/lift");
|
||||
var OperatorSubscriber_1 = require("./OperatorSubscriber");
|
||||
var noop_1 = require("../util/noop");
|
||||
var innerFrom_1 = require("../observable/innerFrom");
|
||||
function distinct(keySelector, flushes) {
|
||||
return lift_1.operate(function (source, subscriber) {
|
||||
var distinctKeys = new Set();
|
||||
source.subscribe(OperatorSubscriber_1.createOperatorSubscriber(subscriber, function (value) {
|
||||
var key = keySelector ? keySelector(value) : value;
|
||||
if (!distinctKeys.has(key)) {
|
||||
distinctKeys.add(key);
|
||||
subscriber.next(value);
|
||||
}
|
||||
}));
|
||||
flushes && innerFrom_1.innerFrom(flushes).subscribe(OperatorSubscriber_1.createOperatorSubscriber(subscriber, function () { return distinctKeys.clear(); }, noop_1.noop));
|
||||
});
|
||||
}
|
||||
exports.distinct = distinct;
|
||||
//# sourceMappingURL=distinct.js.map
|
||||
@@ -0,0 +1,11 @@
|
||||
const path = require('path');
|
||||
|
||||
const EXTRE = /^[.]?[^.]+([.].*)$/;
|
||||
|
||||
module.exports = function (input) {
|
||||
var extension = EXTRE.exec(path.basename(input));
|
||||
if (!extension) {
|
||||
return;
|
||||
}
|
||||
return extension[1];
|
||||
};
|
||||
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"CSVError.js","sourceRoot":"","sources":["../src/CSVError.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA;IAAsC,4BAAK;IAUzC,kBACS,GAAW,EACX,IAAY,EACZ,KAAc;QAHvB,YAKE,kBAAM,SAAS,GAAG,GAAG,GAAG,sBAAsB,GAAG,IAAI,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,GAAG,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,SAE1F;QANQ,SAAG,GAAH,GAAG,CAAQ;QACX,UAAI,GAAJ,IAAI,CAAQ;QACZ,WAAK,GAAL,KAAK,CAAS;QAGrB,KAAI,CAAC,IAAI,GAAG,iBAAiB,CAAC;;IAChC,CAAC;IAhBM,0BAAiB,GAAxB,UAAyB,KAAa,EAAE,KAAc;QACpD,OAAO,IAAI,QAAQ,CAAC,mBAAmB,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;IACzD,CAAC;IACM,uBAAc,GAArB,UAAsB,KAAa,EAAE,KAAc;QACjD,OAAO,IAAI,QAAQ,CAAC,gBAAgB,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;IACtD,CAAC;IACM,iBAAQ,GAAf,UAAgB,GAAG;QACjB,OAAO,IAAI,QAAQ,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC;IACpD,CAAC;IASD,yBAAM,GAAN;QACE,OAAO;YACL,GAAG,EAAE,IAAI,CAAC,GAAG;YACb,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,KAAK,EAAE,IAAI,CAAC,KAAK;SAClB,CAAA;IACH,CAAC;IAEH,eAAC;AAAD,CAAC,AA1BD,CAAsC,KAAK,GA0B1C"}
|
||||
@@ -0,0 +1,37 @@
|
||||
var baseRepeat = require('./_baseRepeat'),
|
||||
isIterateeCall = require('./_isIterateeCall'),
|
||||
toInteger = require('./toInteger'),
|
||||
toString = require('./toString');
|
||||
|
||||
/**
|
||||
* Repeats the given string `n` times.
|
||||
*
|
||||
* @static
|
||||
* @memberOf _
|
||||
* @since 3.0.0
|
||||
* @category String
|
||||
* @param {string} [string=''] The string to repeat.
|
||||
* @param {number} [n=1] The number of times to repeat the string.
|
||||
* @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
|
||||
* @returns {string} Returns the repeated string.
|
||||
* @example
|
||||
*
|
||||
* _.repeat('*', 3);
|
||||
* // => '***'
|
||||
*
|
||||
* _.repeat('abc', 2);
|
||||
* // => 'abcabc'
|
||||
*
|
||||
* _.repeat('abc', 0);
|
||||
* // => ''
|
||||
*/
|
||||
function repeat(string, n, guard) {
|
||||
if ((guard ? isIterateeCall(string, n, guard) : n === undefined)) {
|
||||
n = 1;
|
||||
} else {
|
||||
n = toInteger(n);
|
||||
}
|
||||
return baseRepeat(toString(string), n);
|
||||
}
|
||||
|
||||
module.exports = repeat;
|
||||
@@ -0,0 +1,32 @@
|
||||
import { Observable } from '../Observable';
|
||||
import { Subscriber } from '../Subscriber';
|
||||
import { OperatorFunction } from '../types';
|
||||
import { isFunction } from './isFunction';
|
||||
|
||||
/**
|
||||
* Used to determine if an object is an Observable with a lift function.
|
||||
*/
|
||||
export function hasLift(source: any): source is { lift: InstanceType<typeof Observable>['lift'] } {
|
||||
return isFunction(source?.lift);
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates an `OperatorFunction`. Used to define operators throughout the library in a concise way.
|
||||
* @param init The logic to connect the liftedSource to the subscriber at the moment of subscription.
|
||||
*/
|
||||
export function operate<T, R>(
|
||||
init: (liftedSource: Observable<T>, subscriber: Subscriber<R>) => (() => void) | void
|
||||
): OperatorFunction<T, R> {
|
||||
return (source: Observable<T>) => {
|
||||
if (hasLift(source)) {
|
||||
return source.lift(function (this: Subscriber<R>, liftedSource: Observable<T>) {
|
||||
try {
|
||||
return init(liftedSource, this);
|
||||
} catch (err) {
|
||||
this.error(err);
|
||||
}
|
||||
});
|
||||
}
|
||||
throw new TypeError('Unable to lift unknown Observable type');
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,58 @@
|
||||
# Changelog
|
||||
|
||||
All notable changes to this project will be documented in this file.
|
||||
|
||||
The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
|
||||
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
|
||||
|
||||
## [v2.0.2](https://github.com/inspect-js/is-set/compare/v2.0.1...v2.0.2) - 2020-12-13
|
||||
|
||||
### Commits
|
||||
|
||||
- [Tests] migrate tests to Github Actions [`10a1a86`](https://github.com/inspect-js/is-set/commit/10a1a869d5f76921eed5bb7f1503be6f03eea8a2)
|
||||
- [meta] do not publish github action workflow files [`9611423`](https://github.com/inspect-js/is-set/commit/9611423c4a6baa08a38f46ddafcca3ed4ea0ad97)
|
||||
- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `aud`, `auto-changelog`, `es6-shim`, `object-inspect`, `tape` [`7d4d9b3`](https://github.com/inspect-js/is-set/commit/7d4d9b3ce8434a96c238cef62a7ce9ce79bd6079)
|
||||
- [Tests] run `nyc` on all tests [`dff5fb6`](https://github.com/inspect-js/is-set/commit/dff5fb6cec206e51c6a7311fdb866bb0a0783b1a)
|
||||
- [actions] add "Allow Edits" workflow [`6bed76a`](https://github.com/inspect-js/is-set/commit/6bed76af3119e489e622b3ea30807484dbb7fca9)
|
||||
- [readme] remove travis badge [`ee9e740`](https://github.com/inspect-js/is-set/commit/ee9e74012ba35e86a4e92d7165548341d4323755)
|
||||
- [Tests] add `core-js` tests [`9ef1b4e`](https://github.com/inspect-js/is-set/commit/9ef1b4ed0e55cec4154189247b6d7f6ad570e2f1)
|
||||
- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `tape` [`5661354`](https://github.com/inspect-js/is-set/commit/5661354f7a9861998257fdacfa9975feae9415b8)
|
||||
- [actions] switch Automatic Rebase workflow to `pull_request_target` event [`2cea69e`](https://github.com/inspect-js/is-set/commit/2cea69e16f64d7e706945010e03401a0a66507a3)
|
||||
- [Dev Deps] update `es5-shim`, `tape` [`9e24b51`](https://github.com/inspect-js/is-set/commit/9e24b5158a0490c6b94deb31e76b06337eaafce6)
|
||||
- [Dev Deps] update `auto-changelog`; add `aud` [`69ae556`](https://github.com/inspect-js/is-set/commit/69ae5561fe2408f301479dfa65dac0255e16952e)
|
||||
- Fix typo in README.md, Map -> Set [`5fe826a`](https://github.com/inspect-js/is-set/commit/5fe826a1e11bf810b7174e2dfaf893a5682511d4)
|
||||
- [Tests] only audit prod deps [`c7c67f6`](https://github.com/inspect-js/is-set/commit/c7c67f6b1a32b2b24709d733a6681cbe1ec67640)
|
||||
- [meta] normalize line endings [`6ef4ebd`](https://github.com/inspect-js/is-set/commit/6ef4ebdf090bdf1f42eb912b6af2cf31df4abaef)
|
||||
|
||||
## [v2.0.1](https://github.com/inspect-js/is-set/compare/v2.0.0...v2.0.1) - 2019-12-17
|
||||
|
||||
### Fixed
|
||||
|
||||
- [Refactor] avoid top-level return, because babel and webpack are broken [`#5`](https://github.com/inspect-js/is-set/issues/5) [`#4`](https://github.com/inspect-js/is-set/issues/4) [`#3`](https://github.com/inspect-js/is-set/issues/3) [`#78`](https://github.com/inspect-js/node-deep-equal/issues/78) [`#7`](https://github.com/es-shims/Promise.allSettled/issues/7) [`#12`](https://github.com/airbnb/js-shims/issues/12)
|
||||
|
||||
### Commits
|
||||
|
||||
- [actions] add automatic rebasing / merge commit blocking [`db358ba`](https://github.com/inspect-js/is-set/commit/db358ba503aa86fe2d375e188dcdfa7174a070c8)
|
||||
- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `tape` [`13e5083`](https://github.com/inspect-js/is-set/commit/13e50834eacb1c1830feb598da70ca6d0c53d2f7)
|
||||
|
||||
## [v2.0.0](https://github.com/inspect-js/is-set/compare/v1.0.0...v2.0.0) - 2019-11-12
|
||||
|
||||
### Commits
|
||||
|
||||
- Initial commit [`0299bc8`](https://github.com/inspect-js/is-set/commit/0299bc8fce41dce4586ac2f79c73802ad6a72c3d)
|
||||
- Tests [`dec24eb`](https://github.com/inspect-js/is-set/commit/dec24eb0b9f57f14be8eedd0e572f94f81572e82)
|
||||
- readme [`9b16e7f`](https://github.com/inspect-js/is-set/commit/9b16e7ff417b5c7be9829f22e32249d737bb8f6e)
|
||||
- implementation [`3da6156`](https://github.com/inspect-js/is-set/commit/3da6156dae02e71d541bc8a0d3b751734b98e06d)
|
||||
- npm init [`89fdc8b`](https://github.com/inspect-js/is-set/commit/89fdc8b3d980f6ca414f71dff2af38ed102321a1)
|
||||
- [meta] add `funding` field; create `FUNDING.yml` [`77f2be9`](https://github.com/inspect-js/is-set/commit/77f2be9f281439472f81a0378632bc5eeb25a79b)
|
||||
- [meta] add `safe-publish-latest`, `auto-changelog` [`cef1b4c`](https://github.com/inspect-js/is-set/commit/cef1b4cef15c565e76e3d46e66087821c4c437ae)
|
||||
- [Tests] add `npm run lint` [`2a8284c`](https://github.com/inspect-js/is-set/commit/2a8284c6d2265ecd5c98bd4a008a82f0b519cd0a)
|
||||
- [Tests] use shared travis-ci configs [`d2e342f`](https://github.com/inspect-js/is-set/commit/d2e342f3b8477cc74bcab44297d20d10fcf3718b)
|
||||
- Only apps should have lockfiles [`624072b`](https://github.com/inspect-js/is-set/commit/624072b92774aaa6d851837c882181995d88ece8)
|
||||
- [Tests] add `npx aud` in `posttest` [`214247c`](https://github.com/inspect-js/is-set/commit/214247c3fcd61b164c18b56524cdc183fc485450)
|
||||
|
||||
## v1.0.0 - 2015-02-18
|
||||
|
||||
### Commits
|
||||
|
||||
- init [`2f11646`](https://github.com/inspect-js/is-set/commit/2f1164617bee9c05c0f7ffae8fca2feed13bade7)
|
||||
@@ -0,0 +1,23 @@
|
||||
(The MIT License)
|
||||
|
||||
Copyright (c) 2014 Jonathan Ong <me@jongleberry.com>
|
||||
Copyright (c) 2015 Douglas Christopher Wilson <doug@somethingdoug.com>
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining
|
||||
a copy of this software and associated documentation files (the
|
||||
'Software'), to deal in the Software without restriction, including
|
||||
without limitation the rights to use, copy, modify, merge, publish,
|
||||
distribute, sublicense, and/or sell copies of the Software, and to
|
||||
permit persons to whom the Software is furnished to do so, subject to
|
||||
the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be
|
||||
included in all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
|
||||
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
||||
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
||||
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
||||
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
@@ -0,0 +1,5 @@
|
||||
var convert = require('./convert'),
|
||||
func = convert('take', require('../take'));
|
||||
|
||||
func.placeholder = require('./placeholder');
|
||||
module.exports = func;
|
||||
@@ -0,0 +1 @@
|
||||
module.exports={A:{A:{"2":"J D E F A B CC"},B:{"1":"L G M N O P Q R S T U V W X Y Z a b c d e i j k l m n o p q r s t u f H","2":"C K"},C:{"1":"5 6 7 8 9 AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB TB UB VB WB XB YB uB ZB vB aB bB cB dB eB fB gB hB iB jB kB h lB mB nB oB pB P Q R wB S T U V W X Y Z a b c d e i j k l m n o p q r s t u f H xB yB","2":"0 1 2 3 4 DC tB I v J D E F A B C K L G M N O w g x y z EC FC"},D:{"1":"0 1 2 3 4 5 6 7 8 9 g x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB TB UB VB WB XB YB uB ZB vB aB bB cB dB eB fB gB hB iB jB kB h lB mB nB oB pB P Q R S T U V W X Y Z a b c d e i j k l m n o p q r s t u f H xB yB GC","2":"I v J D E F A B C K L G M N O w"},E:{"1":"K L G rB 1B MC NC 2B 3B 4B 5B sB 6B 7B 8B 9B OC","2":"I v J D E F A B C HC zB IC JC KC LC 0B qB"},F:{"1":"0 1 2 3 4 5 6 7 8 9 B C N O w g x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB TB UB VB WB XB YB ZB aB bB cB dB eB fB gB hB iB jB kB h lB mB nB oB pB P Q R wB S T U V W X Y Z a b c d e qB AC TC rB","2":"F G M PC QC RC SC"},G:{"2":"E zB UC BC VC WC XC YC ZC aC bC cC dC eC fC","129":"gC hC iC jC kC lC mC nC 2B 3B 4B 5B sB 6B 7B 8B 9B"},H:{"2":"oC"},I:{"1":"f tC uC","2":"tB I pC qC rC sC BC"},J:{"1":"D A"},K:{"1":"A B C h qB AC rB"},L:{"1":"H"},M:{"1":"H"},N:{"2":"A B"},O:{"1":"vC"},P:{"1":"I g wC xC yC zC 0C 0B 1C 2C 3C 4C 5C sB 6C 7C 8C"},Q:{"1":"1B"},R:{"1":"9C"},S:{"1":"BD","2":"AD"}},B:1,C:"Color input type"};
|
||||
@@ -0,0 +1,10 @@
|
||||
"use strict";
|
||||
|
||||
var resolveException = require("../lib/resolve-exception")
|
||||
, coerce = require("./coerce");
|
||||
|
||||
module.exports = function (value/*, options*/) {
|
||||
var coerced = coerce(value);
|
||||
if (coerced !== null) return coerced;
|
||||
return resolveException(value, "%v is not a string", arguments[1]);
|
||||
};
|
||||
@@ -0,0 +1,9 @@
|
||||
{
|
||||
"extends": "./tsconfig.base.json",
|
||||
"compilerOptions": {
|
||||
"module": "esnext",
|
||||
"importHelpers": true,
|
||||
"target": "es2015",
|
||||
"outDir": "../dist/esm"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,154 @@
|
||||
"use strict";;
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
var tslib_1 = require("tslib");
|
||||
var types_1 = tslib_1.__importDefault(require("./types"));
|
||||
function default_1(fork) {
|
||||
var types = fork.use(types_1.default);
|
||||
var getFieldNames = types.getFieldNames;
|
||||
var getFieldValue = types.getFieldValue;
|
||||
var isArray = types.builtInTypes.array;
|
||||
var isObject = types.builtInTypes.object;
|
||||
var isDate = types.builtInTypes.Date;
|
||||
var isRegExp = types.builtInTypes.RegExp;
|
||||
var hasOwn = Object.prototype.hasOwnProperty;
|
||||
function astNodesAreEquivalent(a, b, problemPath) {
|
||||
if (isArray.check(problemPath)) {
|
||||
problemPath.length = 0;
|
||||
}
|
||||
else {
|
||||
problemPath = null;
|
||||
}
|
||||
return areEquivalent(a, b, problemPath);
|
||||
}
|
||||
astNodesAreEquivalent.assert = function (a, b) {
|
||||
var problemPath = [];
|
||||
if (!astNodesAreEquivalent(a, b, problemPath)) {
|
||||
if (problemPath.length === 0) {
|
||||
if (a !== b) {
|
||||
throw new Error("Nodes must be equal");
|
||||
}
|
||||
}
|
||||
else {
|
||||
throw new Error("Nodes differ in the following path: " +
|
||||
problemPath.map(subscriptForProperty).join(""));
|
||||
}
|
||||
}
|
||||
};
|
||||
function subscriptForProperty(property) {
|
||||
if (/[_$a-z][_$a-z0-9]*/i.test(property)) {
|
||||
return "." + property;
|
||||
}
|
||||
return "[" + JSON.stringify(property) + "]";
|
||||
}
|
||||
function areEquivalent(a, b, problemPath) {
|
||||
if (a === b) {
|
||||
return true;
|
||||
}
|
||||
if (isArray.check(a)) {
|
||||
return arraysAreEquivalent(a, b, problemPath);
|
||||
}
|
||||
if (isObject.check(a)) {
|
||||
return objectsAreEquivalent(a, b, problemPath);
|
||||
}
|
||||
if (isDate.check(a)) {
|
||||
return isDate.check(b) && (+a === +b);
|
||||
}
|
||||
if (isRegExp.check(a)) {
|
||||
return isRegExp.check(b) && (a.source === b.source &&
|
||||
a.global === b.global &&
|
||||
a.multiline === b.multiline &&
|
||||
a.ignoreCase === b.ignoreCase);
|
||||
}
|
||||
return a == b;
|
||||
}
|
||||
function arraysAreEquivalent(a, b, problemPath) {
|
||||
isArray.assert(a);
|
||||
var aLength = a.length;
|
||||
if (!isArray.check(b) || b.length !== aLength) {
|
||||
if (problemPath) {
|
||||
problemPath.push("length");
|
||||
}
|
||||
return false;
|
||||
}
|
||||
for (var i = 0; i < aLength; ++i) {
|
||||
if (problemPath) {
|
||||
problemPath.push(i);
|
||||
}
|
||||
if (i in a !== i in b) {
|
||||
return false;
|
||||
}
|
||||
if (!areEquivalent(a[i], b[i], problemPath)) {
|
||||
return false;
|
||||
}
|
||||
if (problemPath) {
|
||||
var problemPathTail = problemPath.pop();
|
||||
if (problemPathTail !== i) {
|
||||
throw new Error("" + problemPathTail);
|
||||
}
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
function objectsAreEquivalent(a, b, problemPath) {
|
||||
isObject.assert(a);
|
||||
if (!isObject.check(b)) {
|
||||
return false;
|
||||
}
|
||||
// Fast path for a common property of AST nodes.
|
||||
if (a.type !== b.type) {
|
||||
if (problemPath) {
|
||||
problemPath.push("type");
|
||||
}
|
||||
return false;
|
||||
}
|
||||
var aNames = getFieldNames(a);
|
||||
var aNameCount = aNames.length;
|
||||
var bNames = getFieldNames(b);
|
||||
var bNameCount = bNames.length;
|
||||
if (aNameCount === bNameCount) {
|
||||
for (var i = 0; i < aNameCount; ++i) {
|
||||
var name = aNames[i];
|
||||
var aChild = getFieldValue(a, name);
|
||||
var bChild = getFieldValue(b, name);
|
||||
if (problemPath) {
|
||||
problemPath.push(name);
|
||||
}
|
||||
if (!areEquivalent(aChild, bChild, problemPath)) {
|
||||
return false;
|
||||
}
|
||||
if (problemPath) {
|
||||
var problemPathTail = problemPath.pop();
|
||||
if (problemPathTail !== name) {
|
||||
throw new Error("" + problemPathTail);
|
||||
}
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
if (!problemPath) {
|
||||
return false;
|
||||
}
|
||||
// Since aNameCount !== bNameCount, we need to find some name that's
|
||||
// missing in aNames but present in bNames, or vice-versa.
|
||||
var seenNames = Object.create(null);
|
||||
for (i = 0; i < aNameCount; ++i) {
|
||||
seenNames[aNames[i]] = true;
|
||||
}
|
||||
for (i = 0; i < bNameCount; ++i) {
|
||||
name = bNames[i];
|
||||
if (!hasOwn.call(seenNames, name)) {
|
||||
problemPath.push(name);
|
||||
return false;
|
||||
}
|
||||
delete seenNames[name];
|
||||
}
|
||||
for (name in seenNames) {
|
||||
problemPath.push(name);
|
||||
break;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
return astNodesAreEquivalent;
|
||||
}
|
||||
exports.default = default_1;
|
||||
module.exports = exports["default"];
|
||||
@@ -0,0 +1,7 @@
|
||||
import UpdateNotifier from './update-notifier.js';
|
||||
|
||||
export default function updateNotifier(options) {
|
||||
const updateNotifier = new UpdateNotifier(options);
|
||||
updateNotifier.check();
|
||||
return updateNotifier;
|
||||
}
|
||||
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"createObject.d.ts","sourceRoot":"","sources":["../../../../src/internal/util/createObject.ts"],"names":[],"mappings":"AAAA,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,OAEzD"}
|
||||
@@ -0,0 +1,23 @@
|
||||
'use strict';
|
||||
|
||||
var GetIntrinsic = require('get-intrinsic');
|
||||
|
||||
var $BigInt = GetIntrinsic('%BigInt%', true);
|
||||
var $TypeError = GetIntrinsic('%TypeError%');
|
||||
var $SyntaxError = GetIntrinsic('%SyntaxError%');
|
||||
|
||||
// https://262.ecma-international.org/14.0/#sec-stringtobigint
|
||||
|
||||
module.exports = function StringToBigInt(argument) {
|
||||
if (typeof argument !== 'string') {
|
||||
throw new $TypeError('`argument` must be a string');
|
||||
}
|
||||
if (!$BigInt) {
|
||||
throw new $SyntaxError('BigInts are not supported in this environment');
|
||||
}
|
||||
try {
|
||||
return $BigInt(argument);
|
||||
} catch (e) {
|
||||
return void undefined;
|
||||
}
|
||||
};
|
||||
@@ -0,0 +1,40 @@
|
||||
# functions-have-names <sup>[![Version Badge][npm-version-svg]][package-url]</sup>
|
||||
|
||||
[![github actions][actions-image]][actions-url]
|
||||
[![coverage][codecov-image]][codecov-url]
|
||||
[![dependency status][deps-svg]][deps-url]
|
||||
[![dev dependency status][dev-deps-svg]][dev-deps-url]
|
||||
[![License][license-image]][license-url]
|
||||
[![Downloads][downloads-image]][downloads-url]
|
||||
|
||||
[![npm badge][npm-badge-png]][package-url]
|
||||
|
||||
Does this JS environment support the `name` property on functions?
|
||||
|
||||
## Example
|
||||
|
||||
```js
|
||||
var functionsHaveNames = require('functions-have-names');
|
||||
var assert = require('assert');
|
||||
|
||||
assert.equal(functionsHaveNames(), true); // will be `false` in IE 6-8
|
||||
```
|
||||
|
||||
## Tests
|
||||
Simply clone the repo, `npm install`, and run `npm test`
|
||||
|
||||
[package-url]: https://npmjs.org/package/functions-have-names
|
||||
[npm-version-svg]: https://versionbadg.es/inspect-js/functions-have-names.svg
|
||||
[deps-svg]: https://david-dm.org/inspect-js/functions-have-names.svg
|
||||
[deps-url]: https://david-dm.org/inspect-js/functions-have-names
|
||||
[dev-deps-svg]: https://david-dm.org/inspect-js/functions-have-names/dev-status.svg
|
||||
[dev-deps-url]: https://david-dm.org/inspect-js/functions-have-names#info=devDependencies
|
||||
[npm-badge-png]: https://nodei.co/npm/functions-have-names.png?downloads=true&stars=true
|
||||
[license-image]: https://img.shields.io/npm/l/functions-have-names.svg
|
||||
[license-url]: LICENSE
|
||||
[downloads-image]: https://img.shields.io/npm/dm/functions-have-names.svg
|
||||
[downloads-url]: https://npm-stat.com/charts.html?package=functions-have-names
|
||||
[codecov-image]: https://codecov.io/gh/inspect-js/functions-have-names/branch/main/graphs/badge.svg
|
||||
[codecov-url]: https://app.codecov.io/gh/inspect-js/functions-have-names/
|
||||
[actions-image]: https://img.shields.io/endpoint?url=https://github-actions-badge-u3jn4tfpocch.runkit.sh/inspect-js/functions-have-names
|
||||
[actions-url]: https://github.com/inspect-js/functions-have-names/actions
|
||||
@@ -0,0 +1,7 @@
|
||||
export var UNICODE_EXTENSION_SEQUENCE_REGEX = /-u(?:-[0-9a-z]{2,8})+/gi;
|
||||
export function invariant(condition, message, Err) {
|
||||
if (Err === void 0) { Err = Error; }
|
||||
if (!condition) {
|
||||
throw new Err(message);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,16 @@
|
||||
'use strict';
|
||||
|
||||
var IsUnclampedIntegerElementType = require('./IsUnclampedIntegerElementType');
|
||||
var IsBigIntElementType = require('./IsBigIntElementType');
|
||||
|
||||
// https://262.ecma-international.org/11.0/#sec-isnotearconfiguration
|
||||
|
||||
module.exports = function IsNoTearConfiguration(type, order) {
|
||||
if (IsUnclampedIntegerElementType(type)) {
|
||||
return true;
|
||||
}
|
||||
if (IsBigIntElementType(type) && order !== 'Init' && order !== 'Unordered') {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
};
|
||||
@@ -0,0 +1,21 @@
|
||||
Copyright (C) 2012 Yusuke Suzuki (twitter: @Constellation) and other contributors.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
* Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
* Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in the
|
||||
documentation and/or other materials provided with the distribution.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||||
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
@@ -0,0 +1,10 @@
|
||||
import { operate } from '../util/lift';
|
||||
import { createOperatorSubscriber } from './OperatorSubscriber';
|
||||
export function skipWhile(predicate) {
|
||||
return operate((source, subscriber) => {
|
||||
let taking = false;
|
||||
let index = 0;
|
||||
source.subscribe(createOperatorSubscriber(subscriber, (value) => (taking || (taking = !predicate(value, index++))) && subscriber.next(value)));
|
||||
});
|
||||
}
|
||||
//# sourceMappingURL=skipWhile.js.map
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,187 @@
|
||||
<p align="center">
|
||||
<a href="http://gulpjs.com">
|
||||
<img height="257" width="114" src="https://raw.githubusercontent.com/gulpjs/artwork/master/gulp-2x.png">
|
||||
</a>
|
||||
</p>
|
||||
|
||||
# interpret
|
||||
|
||||
[![NPM version][npm-image]][npm-url] [![Downloads][downloads-image]][npm-url] [![Travis Build Status][travis-image]][travis-url] [![AppVeyor Build Status][appveyor-image]][appveyor-url] [![Coveralls Status][coveralls-image]][coveralls-url] [![Gitter chat][gitter-image]][gitter-url]
|
||||
|
||||
A dictionary of file extensions and associated module loaders.
|
||||
|
||||
## What is it
|
||||
This is used by [Liftoff](http://github.com/tkellen/node-liftoff) to automatically require dependencies for configuration files, and by [rechoir](http://github.com/tkellen/node-rechoir) for registering module loaders.
|
||||
|
||||
## API
|
||||
|
||||
### extensions
|
||||
Map file types to modules which provide a [require.extensions] loader.
|
||||
|
||||
```js
|
||||
{
|
||||
'.babel.js': [
|
||||
{
|
||||
module: '@babel/register',
|
||||
register: function(hook) {
|
||||
// register on .js extension due to https://github.com/joyent/node/blob/v0.12.0/lib/module.js#L353
|
||||
// which only captures the final extension (.babel.js -> .js)
|
||||
hook({ extensions: '.js' });
|
||||
},
|
||||
},
|
||||
{
|
||||
module: 'babel-register',
|
||||
register: function(hook) {
|
||||
hook({ extensions: '.js' });
|
||||
},
|
||||
},
|
||||
{
|
||||
module: 'babel-core/register',
|
||||
register: function(hook) {
|
||||
hook({ extensions: '.js' });
|
||||
},
|
||||
},
|
||||
{
|
||||
module: 'babel/register',
|
||||
register: function(hook) {
|
||||
hook({ extensions: '.js' });
|
||||
},
|
||||
},
|
||||
],
|
||||
'.babel.ts': [
|
||||
{
|
||||
module: '@babel/register',
|
||||
register: function(hook) {
|
||||
hook({ extensions: '.ts' });
|
||||
},
|
||||
},
|
||||
],
|
||||
'.buble.js': 'buble/register',
|
||||
'.cirru': 'cirru-script/lib/register',
|
||||
'.cjsx': 'node-cjsx/register',
|
||||
'.co': 'coco',
|
||||
'.coffee': ['coffeescript/register', 'coffee-script/register', 'coffeescript', 'coffee-script'],
|
||||
'.coffee.md': ['coffeescript/register', 'coffee-script/register', 'coffeescript', 'coffee-script'],
|
||||
'.csv': 'require-csv',
|
||||
'.eg': 'earlgrey/register',
|
||||
'.esm.js': {
|
||||
module: 'esm',
|
||||
register: function(hook) {
|
||||
// register on .js extension due to https://github.com/joyent/node/blob/v0.12.0/lib/module.js#L353
|
||||
// which only captures the final extension (.babel.js -> .js)
|
||||
var esmLoader = hook(module);
|
||||
require.extensions['.js'] = esmLoader('module')._extensions['.js'];
|
||||
},
|
||||
},
|
||||
'.iced': ['iced-coffee-script/register', 'iced-coffee-script'],
|
||||
'.iced.md': 'iced-coffee-script/register',
|
||||
'.ini': 'require-ini',
|
||||
'.js': null,
|
||||
'.json': null,
|
||||
'.json5': 'json5/lib/require',
|
||||
'.jsx': [
|
||||
{
|
||||
module: '@babel/register',
|
||||
register: function(hook) {
|
||||
hook({ extensions: '.jsx' });
|
||||
},
|
||||
},
|
||||
{
|
||||
module: 'babel-register',
|
||||
register: function(hook) {
|
||||
hook({ extensions: '.jsx' });
|
||||
},
|
||||
},
|
||||
{
|
||||
module: 'babel-core/register',
|
||||
register: function(hook) {
|
||||
hook({ extensions: '.jsx' });
|
||||
},
|
||||
},
|
||||
{
|
||||
module: 'babel/register',
|
||||
register: function(hook) {
|
||||
hook({ extensions: '.jsx' });
|
||||
},
|
||||
},
|
||||
{
|
||||
module: 'node-jsx',
|
||||
register: function(hook) {
|
||||
hook.install({ extension: '.jsx', harmony: true });
|
||||
},
|
||||
},
|
||||
],
|
||||
'.litcoffee': ['coffeescript/register', 'coffee-script/register', 'coffeescript', 'coffee-script'],
|
||||
'.liticed': 'iced-coffee-script/register',
|
||||
'.ls': ['livescript', 'LiveScript'],
|
||||
'.mjs': '/absolute/path/to/interpret/mjs-stub.js',
|
||||
'.node': null,
|
||||
'.toml': {
|
||||
module: 'toml-require',
|
||||
register: function(hook) {
|
||||
hook.install();
|
||||
},
|
||||
},
|
||||
'.ts': [
|
||||
'ts-node/register',
|
||||
'typescript-node/register',
|
||||
'typescript-register',
|
||||
'typescript-require',
|
||||
'sucrase/register/ts',
|
||||
{
|
||||
module: '@babel/register',
|
||||
register: function(hook) {
|
||||
hook({ extensions: '.ts' });
|
||||
},
|
||||
},
|
||||
],
|
||||
'.tsx': [
|
||||
'ts-node/register',
|
||||
'typescript-node/register',
|
||||
'sucrase/register',
|
||||
{
|
||||
module: '@babel/register',
|
||||
register: function(hook) {
|
||||
hook({ extensions: '.tsx' });
|
||||
},
|
||||
},
|
||||
],
|
||||
'.wisp': 'wisp/engine/node',
|
||||
'.xml': 'require-xml',
|
||||
'.yaml': 'require-yaml',
|
||||
'.yml': 'require-yaml',
|
||||
}
|
||||
```
|
||||
|
||||
### jsVariants
|
||||
Same as above, but only include the extensions which are javascript variants.
|
||||
|
||||
## How to use it
|
||||
|
||||
Consumers should use the exported `extensions` or `jsVariants` object to determine which module should be loaded for a given extension. If a matching extension is found, consumers should do the following:
|
||||
|
||||
1. If the value is null, do nothing.
|
||||
|
||||
2. If the value is a string, try to require it.
|
||||
|
||||
3. If the value is an object, try to require the `module` property. If successful, the `register` property (a function) should be called with the module passed as the first argument.
|
||||
|
||||
4. If the value is an array, iterate over it, attempting step #2 or #3 until one of the attempts does not throw.
|
||||
|
||||
[require.extensions]: http://nodejs.org/api/globals.html#globals_require_extensions
|
||||
|
||||
[downloads-image]: http://img.shields.io/npm/dm/interpret.svg
|
||||
[npm-url]: https://www.npmjs.com/package/interpret
|
||||
[npm-image]: http://img.shields.io/npm/v/interpret.svg
|
||||
|
||||
[travis-url]: https://travis-ci.org/gulpjs/interpret
|
||||
[travis-image]: http://img.shields.io/travis/gulpjs/interpret.svg?label=travis-ci
|
||||
|
||||
[appveyor-url]: https://ci.appveyor.com/project/gulpjs/interpret
|
||||
[appveyor-image]: https://img.shields.io/appveyor/ci/gulpjs/interpret.svg?label=appveyor
|
||||
|
||||
[coveralls-url]: https://coveralls.io/r/gulpjs/interpret
|
||||
[coveralls-image]: http://img.shields.io/coveralls/gulpjs/interpret/master.svg
|
||||
|
||||
[gitter-url]: https://gitter.im/gulpjs/gulp
|
||||
[gitter-image]: https://badges.gitter.im/gulpjs/gulp.svg
|
||||
Reference in New Issue
Block a user