update
This commit is contained in:
@@ -0,0 +1,11 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.default = _writeOnlyError;
|
||||
function _writeOnlyError(name) {
|
||||
throw new TypeError('"' + name + '" is write-only');
|
||||
}
|
||||
|
||||
//# sourceMappingURL=writeOnlyError.js.map
|
||||
@@ -0,0 +1,26 @@
|
||||
module.exports = function (opts) {
|
||||
var sep = opts ? opts.sep : '{}'
|
||||
var len = sep.length
|
||||
|
||||
var whitespace = '\\s*'
|
||||
var left = escape(sep.substring(0, len / 2)) + whitespace
|
||||
var right = whitespace + escape(sep.substring(len / 2, len))
|
||||
|
||||
return function (template, values) {
|
||||
Object.keys(values).forEach(function (key) {
|
||||
var value = String(values[key]).replace(/\$/g, '$$$$')
|
||||
template = template.replace(regExp(key), value)
|
||||
})
|
||||
return template
|
||||
}
|
||||
|
||||
function escape (s) {
|
||||
return [].map.call(s, function (char) {
|
||||
return '\\' + char
|
||||
}).join('')
|
||||
}
|
||||
|
||||
function regExp (key) {
|
||||
return new RegExp(left + key + right, 'g')
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,45 @@
|
||||
import crypto from 'crypto'
|
||||
import { urlAlphabet } from './url-alphabet/index.js'
|
||||
const POOL_SIZE_MULTIPLIER = 128
|
||||
let pool, poolOffset
|
||||
let fillPool = bytes => {
|
||||
if (!pool || pool.length < bytes) {
|
||||
pool = Buffer.allocUnsafe(bytes * POOL_SIZE_MULTIPLIER)
|
||||
crypto.randomFillSync(pool)
|
||||
poolOffset = 0
|
||||
} else if (poolOffset + bytes > pool.length) {
|
||||
crypto.randomFillSync(pool)
|
||||
poolOffset = 0
|
||||
}
|
||||
poolOffset += bytes
|
||||
}
|
||||
let random = bytes => {
|
||||
fillPool((bytes |= 0))
|
||||
return pool.subarray(poolOffset - bytes, poolOffset)
|
||||
}
|
||||
let customRandom = (alphabet, defaultSize, getRandom) => {
|
||||
let mask = (2 << (31 - Math.clz32((alphabet.length - 1) | 1))) - 1
|
||||
let step = Math.ceil((1.6 * mask * defaultSize) / alphabet.length)
|
||||
return (size = defaultSize) => {
|
||||
let id = ''
|
||||
while (true) {
|
||||
let bytes = getRandom(step)
|
||||
let i = step
|
||||
while (i--) {
|
||||
id += alphabet[bytes[i] & mask] || ''
|
||||
if (id.length === size) return id
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
let customAlphabet = (alphabet, size = 21) =>
|
||||
customRandom(alphabet, size, random)
|
||||
let nanoid = (size = 21) => {
|
||||
fillPool((size |= 0))
|
||||
let id = ''
|
||||
for (let i = poolOffset - size; i < poolOffset; i++) {
|
||||
id += urlAlphabet[pool[i] & 63]
|
||||
}
|
||||
return id
|
||||
}
|
||||
export { nanoid, customAlphabet, customRandom, urlAlphabet, random }
|
||||
@@ -0,0 +1,69 @@
|
||||
// Generated by LiveScript 1.6.0
|
||||
var apply, curry, flip, fix, over, memoize, toString$ = {}.toString;
|
||||
apply = curry$(function(f, list){
|
||||
return f.apply(null, list);
|
||||
});
|
||||
curry = function(f){
|
||||
return curry$(f);
|
||||
};
|
||||
flip = curry$(function(f, x, y){
|
||||
return f(y, x);
|
||||
});
|
||||
fix = function(f){
|
||||
return function(g){
|
||||
return function(){
|
||||
return f(g(g)).apply(null, arguments);
|
||||
};
|
||||
}(function(g){
|
||||
return function(){
|
||||
return f(g(g)).apply(null, arguments);
|
||||
};
|
||||
});
|
||||
};
|
||||
over = curry$(function(f, g, x, y){
|
||||
return f(g(x), g(y));
|
||||
});
|
||||
memoize = function(f){
|
||||
var memo;
|
||||
memo = {};
|
||||
return function(){
|
||||
var args, res$, i$, to$, key, arg;
|
||||
res$ = [];
|
||||
for (i$ = 0, to$ = arguments.length; i$ < to$; ++i$) {
|
||||
res$.push(arguments[i$]);
|
||||
}
|
||||
args = res$;
|
||||
key = (function(){
|
||||
var i$, ref$, len$, results$ = [];
|
||||
for (i$ = 0, len$ = (ref$ = args).length; i$ < len$; ++i$) {
|
||||
arg = ref$[i$];
|
||||
results$.push(arg + toString$.call(arg).slice(8, -1));
|
||||
}
|
||||
return results$;
|
||||
}()).join('');
|
||||
return memo[key] = key in memo
|
||||
? memo[key]
|
||||
: f.apply(null, args);
|
||||
};
|
||||
};
|
||||
module.exports = {
|
||||
curry: curry,
|
||||
flip: flip,
|
||||
fix: fix,
|
||||
apply: apply,
|
||||
over: over,
|
||||
memoize: memoize
|
||||
};
|
||||
function curry$(f, bound){
|
||||
var context,
|
||||
_curry = function(args) {
|
||||
return f.length > 1 ? function(){
|
||||
var params = args ? args.concat() : [];
|
||||
context = bound ? context || this : this;
|
||||
return params.push.apply(params, arguments) <
|
||||
f.length && arguments.length ?
|
||||
_curry.call(context, params) : f.apply(context, params);
|
||||
} : f;
|
||||
};
|
||||
return _curry();
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,47 @@
|
||||
// given a set of versions and a range, create a "simplified" range
|
||||
// that includes the same versions that the original range does
|
||||
// If the original range is shorter than the simplified one, return that.
|
||||
const satisfies = require('../functions/satisfies.js')
|
||||
const compare = require('../functions/compare.js')
|
||||
module.exports = (versions, range, options) => {
|
||||
const set = []
|
||||
let first = null
|
||||
let prev = null
|
||||
const v = versions.sort((a, b) => compare(a, b, options))
|
||||
for (const version of v) {
|
||||
const included = satisfies(version, range, options)
|
||||
if (included) {
|
||||
prev = version
|
||||
if (!first) {
|
||||
first = version
|
||||
}
|
||||
} else {
|
||||
if (prev) {
|
||||
set.push([first, prev])
|
||||
}
|
||||
prev = null
|
||||
first = null
|
||||
}
|
||||
}
|
||||
if (first) {
|
||||
set.push([first, null])
|
||||
}
|
||||
|
||||
const ranges = []
|
||||
for (const [min, max] of set) {
|
||||
if (min === max) {
|
||||
ranges.push(min)
|
||||
} else if (!max && min === v[0]) {
|
||||
ranges.push('*')
|
||||
} else if (!max) {
|
||||
ranges.push(`>=${min}`)
|
||||
} else if (min === v[0]) {
|
||||
ranges.push(`<=${max}`)
|
||||
} else {
|
||||
ranges.push(`${min} - ${max}`)
|
||||
}
|
||||
}
|
||||
const simplified = ranges.join(' || ')
|
||||
const original = typeof range.raw === 'string' ? range.raw : String(range)
|
||||
return simplified.length < original.length ? simplified : range
|
||||
}
|
||||
@@ -0,0 +1,133 @@
|
||||
/*
|
||||
MIT License http://www.opensource.org/licenses/mit-license.php
|
||||
Author Maël Nison @arcanis
|
||||
*/
|
||||
|
||||
"use strict";
|
||||
|
||||
/** @typedef {import("./Resolver")} Resolver */
|
||||
/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
|
||||
/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */
|
||||
/**
|
||||
* @typedef {Object} PnpApiImpl
|
||||
* @property {function(string, string, object): string | null} resolveToUnqualified
|
||||
*/
|
||||
|
||||
module.exports = class PnpPlugin {
|
||||
/**
|
||||
* @param {string | ResolveStepHook} source source
|
||||
* @param {PnpApiImpl} pnpApi pnpApi
|
||||
* @param {string | ResolveStepHook} target target
|
||||
* @param {string | ResolveStepHook} alternateTarget alternateTarget
|
||||
*/
|
||||
constructor(source, pnpApi, target, alternateTarget) {
|
||||
this.source = source;
|
||||
this.pnpApi = pnpApi;
|
||||
this.target = target;
|
||||
this.alternateTarget = alternateTarget;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {Resolver} resolver the resolver
|
||||
* @returns {void}
|
||||
*/
|
||||
apply(resolver) {
|
||||
/** @type {ResolveStepHook} */
|
||||
const target = resolver.ensureHook(this.target);
|
||||
const alternateTarget = resolver.ensureHook(this.alternateTarget);
|
||||
resolver
|
||||
.getHook(this.source)
|
||||
.tapAsync("PnpPlugin", (request, resolveContext, callback) => {
|
||||
const req = request.request;
|
||||
if (!req) return callback();
|
||||
|
||||
// The trailing slash indicates to PnP that this value is a folder rather than a file
|
||||
const issuer = `${request.path}/`;
|
||||
|
||||
const packageMatch = /^(@[^/]+\/)?[^/]+/.exec(req);
|
||||
if (!packageMatch) return callback();
|
||||
|
||||
const packageName = packageMatch[0];
|
||||
const innerRequest = `.${req.slice(packageName.length)}`;
|
||||
|
||||
/** @type {string|undefined|null} */
|
||||
let resolution;
|
||||
/** @type {string|undefined|null} */
|
||||
let apiResolution;
|
||||
try {
|
||||
resolution = this.pnpApi.resolveToUnqualified(packageName, issuer, {
|
||||
considerBuiltins: false
|
||||
});
|
||||
|
||||
if (resolution === null) {
|
||||
// This is either not a PnP managed issuer or it's a Node builtin
|
||||
// Try to continue resolving with our alternatives
|
||||
resolver.doResolve(
|
||||
alternateTarget,
|
||||
request,
|
||||
"issuer is not managed by a pnpapi",
|
||||
resolveContext,
|
||||
(err, result) => {
|
||||
if (err) return callback(err);
|
||||
if (result) return callback(null, result);
|
||||
// Skip alternatives
|
||||
return callback(null, null);
|
||||
}
|
||||
);
|
||||
return;
|
||||
}
|
||||
|
||||
if (resolveContext.fileDependencies) {
|
||||
apiResolution = this.pnpApi.resolveToUnqualified("pnpapi", issuer, {
|
||||
considerBuiltins: false
|
||||
});
|
||||
}
|
||||
} catch (/** @type {unknown} */ error) {
|
||||
if (
|
||||
/** @type {Error & { code: string }} */
|
||||
(error).code === "MODULE_NOT_FOUND" &&
|
||||
/** @type {Error & { pnpCode: string }} */
|
||||
(error).pnpCode === "UNDECLARED_DEPENDENCY"
|
||||
) {
|
||||
// This is not a PnP managed dependency.
|
||||
// Try to continue resolving with our alternatives
|
||||
if (resolveContext.log) {
|
||||
resolveContext.log(`request is not managed by the pnpapi`);
|
||||
for (const line of /** @type {Error} */ (error).message
|
||||
.split("\n")
|
||||
.filter(Boolean))
|
||||
resolveContext.log(` ${line}`);
|
||||
}
|
||||
return callback();
|
||||
}
|
||||
return callback(/** @type {Error} */ (error));
|
||||
}
|
||||
|
||||
if (resolution === packageName) return callback();
|
||||
|
||||
if (apiResolution && resolveContext.fileDependencies) {
|
||||
resolveContext.fileDependencies.add(apiResolution);
|
||||
}
|
||||
/** @type {ResolveRequest} */
|
||||
const obj = {
|
||||
...request,
|
||||
path: resolution,
|
||||
request: innerRequest,
|
||||
ignoreSymlinks: true,
|
||||
fullySpecified: request.fullySpecified && innerRequest !== "."
|
||||
};
|
||||
resolver.doResolve(
|
||||
target,
|
||||
obj,
|
||||
`resolved by pnp to ${resolution}`,
|
||||
resolveContext,
|
||||
(err, result) => {
|
||||
if (err) return callback(err);
|
||||
if (result) return callback(null, result);
|
||||
// Skip alternatives
|
||||
return callback(null, null);
|
||||
}
|
||||
);
|
||||
});
|
||||
}
|
||||
};
|
||||
@@ -0,0 +1,793 @@
|
||||
/*
|
||||
Copyright (C) 2015 Yusuke Suzuki <utatane.tea@gmail.com>
|
||||
|
||||
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.
|
||||
*/
|
||||
|
||||
import estraverse from "estraverse";
|
||||
|
||||
import Reference from "./reference.js";
|
||||
import Variable from "./variable.js";
|
||||
import { Definition } from "./definition.js";
|
||||
import { assert } from "./assert.js";
|
||||
|
||||
const { Syntax } = estraverse;
|
||||
|
||||
/**
|
||||
* Test if scope is struct
|
||||
* @param {Scope} scope scope
|
||||
* @param {Block} block block
|
||||
* @param {boolean} isMethodDefinition is method definition
|
||||
* @returns {boolean} is strict scope
|
||||
*/
|
||||
function isStrictScope(scope, block, isMethodDefinition) {
|
||||
let body;
|
||||
|
||||
// When upper scope is exists and strict, inner scope is also strict.
|
||||
if (scope.upper && scope.upper.isStrict) {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (isMethodDefinition) {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (scope.type === "class" || scope.type === "module") {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (scope.type === "block" || scope.type === "switch") {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (scope.type === "function") {
|
||||
if (block.type === Syntax.ArrowFunctionExpression && block.body.type !== Syntax.BlockStatement) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (block.type === Syntax.Program) {
|
||||
body = block;
|
||||
} else {
|
||||
body = block.body;
|
||||
}
|
||||
|
||||
if (!body) {
|
||||
return false;
|
||||
}
|
||||
} else if (scope.type === "global") {
|
||||
body = block;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Search for a 'use strict' directive.
|
||||
for (let i = 0, iz = body.body.length; i < iz; ++i) {
|
||||
const stmt = body.body[i];
|
||||
|
||||
/*
|
||||
* Check if the current statement is a directive.
|
||||
* If it isn't, then we're past the directive prologue
|
||||
* so stop the search because directives cannot
|
||||
* appear after this point.
|
||||
*
|
||||
* Some parsers set `directive:null` on non-directive
|
||||
* statements, so the `typeof` check is safer than
|
||||
* checking for property existence.
|
||||
*/
|
||||
if (typeof stmt.directive !== "string") {
|
||||
break;
|
||||
}
|
||||
|
||||
if (stmt.directive === "use strict") {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Register scope
|
||||
* @param {ScopeManager} scopeManager scope manager
|
||||
* @param {Scope} scope scope
|
||||
* @returns {void}
|
||||
*/
|
||||
function registerScope(scopeManager, scope) {
|
||||
scopeManager.scopes.push(scope);
|
||||
|
||||
const scopes = scopeManager.__nodeToScope.get(scope.block);
|
||||
|
||||
if (scopes) {
|
||||
scopes.push(scope);
|
||||
} else {
|
||||
scopeManager.__nodeToScope.set(scope.block, [scope]);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Should be statically
|
||||
* @param {Object} def def
|
||||
* @returns {boolean} should be statically
|
||||
*/
|
||||
function shouldBeStatically(def) {
|
||||
return (
|
||||
(def.type === Variable.ClassName) ||
|
||||
(def.type === Variable.Variable && def.parent.kind !== "var")
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* @constructor Scope
|
||||
*/
|
||||
class Scope {
|
||||
constructor(scopeManager, type, upperScope, block, isMethodDefinition) {
|
||||
|
||||
/**
|
||||
* One of "global", "module", "function", "function-expression-name", "block", "switch", "catch", "with", "for",
|
||||
* "class", "class-field-initializer", "class-static-block".
|
||||
* @member {string} Scope#type
|
||||
*/
|
||||
this.type = type;
|
||||
|
||||
/**
|
||||
* The scoped {@link Variable}s of this scope, as <code>{ Variable.name
|
||||
* : Variable }</code>.
|
||||
* @member {Map} Scope#set
|
||||
*/
|
||||
this.set = new Map();
|
||||
|
||||
/**
|
||||
* The tainted variables of this scope, as <code>{ Variable.name :
|
||||
* boolean }</code>.
|
||||
* @member {Map} Scope#taints
|
||||
*/
|
||||
this.taints = new Map();
|
||||
|
||||
/**
|
||||
* Generally, through the lexical scoping of JS you can always know
|
||||
* which variable an identifier in the source code refers to. There are
|
||||
* a few exceptions to this rule. With 'global' and 'with' scopes you
|
||||
* can only decide at runtime which variable a reference refers to.
|
||||
* Moreover, if 'eval()' is used in a scope, it might introduce new
|
||||
* bindings in this or its parent scopes.
|
||||
* All those scopes are considered 'dynamic'.
|
||||
* @member {boolean} Scope#dynamic
|
||||
*/
|
||||
this.dynamic = this.type === "global" || this.type === "with";
|
||||
|
||||
/**
|
||||
* A reference to the scope-defining syntax node.
|
||||
* @member {espree.Node} Scope#block
|
||||
*/
|
||||
this.block = block;
|
||||
|
||||
/**
|
||||
* The {@link Reference|references} that are not resolved with this scope.
|
||||
* @member {Reference[]} Scope#through
|
||||
*/
|
||||
this.through = [];
|
||||
|
||||
/**
|
||||
* The scoped {@link Variable}s of this scope. In the case of a
|
||||
* 'function' scope this includes the automatic argument <em>arguments</em> as
|
||||
* its first element, as well as all further formal arguments.
|
||||
* @member {Variable[]} Scope#variables
|
||||
*/
|
||||
this.variables = [];
|
||||
|
||||
/**
|
||||
* Any variable {@link Reference|reference} found in this scope. This
|
||||
* includes occurrences of local variables as well as variables from
|
||||
* parent scopes (including the global scope). For local variables
|
||||
* this also includes defining occurrences (like in a 'var' statement).
|
||||
* In a 'function' scope this does not include the occurrences of the
|
||||
* formal parameter in the parameter list.
|
||||
* @member {Reference[]} Scope#references
|
||||
*/
|
||||
this.references = [];
|
||||
|
||||
/**
|
||||
* For 'global' and 'function' scopes, this is a self-reference. For
|
||||
* other scope types this is the <em>variableScope</em> value of the
|
||||
* parent scope.
|
||||
* @member {Scope} Scope#variableScope
|
||||
*/
|
||||
this.variableScope =
|
||||
this.type === "global" ||
|
||||
this.type === "module" ||
|
||||
this.type === "function" ||
|
||||
this.type === "class-field-initializer" ||
|
||||
this.type === "class-static-block"
|
||||
? this
|
||||
: upperScope.variableScope;
|
||||
|
||||
/**
|
||||
* Whether this scope is created by a FunctionExpression.
|
||||
* @member {boolean} Scope#functionExpressionScope
|
||||
*/
|
||||
this.functionExpressionScope = false;
|
||||
|
||||
/**
|
||||
* Whether this is a scope that contains an 'eval()' invocation.
|
||||
* @member {boolean} Scope#directCallToEvalScope
|
||||
*/
|
||||
this.directCallToEvalScope = false;
|
||||
|
||||
/**
|
||||
* @member {boolean} Scope#thisFound
|
||||
*/
|
||||
this.thisFound = false;
|
||||
|
||||
this.__left = [];
|
||||
|
||||
/**
|
||||
* Reference to the parent {@link Scope|scope}.
|
||||
* @member {Scope} Scope#upper
|
||||
*/
|
||||
this.upper = upperScope;
|
||||
|
||||
/**
|
||||
* Whether 'use strict' is in effect in this scope.
|
||||
* @member {boolean} Scope#isStrict
|
||||
*/
|
||||
this.isStrict = scopeManager.isStrictModeSupported()
|
||||
? isStrictScope(this, block, isMethodDefinition)
|
||||
: false;
|
||||
|
||||
/**
|
||||
* List of nested {@link Scope}s.
|
||||
* @member {Scope[]} Scope#childScopes
|
||||
*/
|
||||
this.childScopes = [];
|
||||
if (this.upper) {
|
||||
this.upper.childScopes.push(this);
|
||||
}
|
||||
|
||||
this.__declaredVariables = scopeManager.__declaredVariables;
|
||||
|
||||
registerScope(scopeManager, this);
|
||||
}
|
||||
|
||||
__shouldStaticallyClose(scopeManager) {
|
||||
return (!this.dynamic || scopeManager.__isOptimistic());
|
||||
}
|
||||
|
||||
__shouldStaticallyCloseForGlobal(ref) {
|
||||
|
||||
// On global scope, let/const/class declarations should be resolved statically.
|
||||
const name = ref.identifier.name;
|
||||
|
||||
if (!this.set.has(name)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
const variable = this.set.get(name);
|
||||
const defs = variable.defs;
|
||||
|
||||
return defs.length > 0 && defs.every(shouldBeStatically);
|
||||
}
|
||||
|
||||
__staticCloseRef(ref) {
|
||||
if (!this.__resolve(ref)) {
|
||||
this.__delegateToUpperScope(ref);
|
||||
}
|
||||
}
|
||||
|
||||
__dynamicCloseRef(ref) {
|
||||
|
||||
// notify all names are through to global
|
||||
let current = this;
|
||||
|
||||
do {
|
||||
current.through.push(ref);
|
||||
current = current.upper;
|
||||
} while (current);
|
||||
}
|
||||
|
||||
__globalCloseRef(ref) {
|
||||
|
||||
// let/const/class declarations should be resolved statically.
|
||||
// others should be resolved dynamically.
|
||||
if (this.__shouldStaticallyCloseForGlobal(ref)) {
|
||||
this.__staticCloseRef(ref);
|
||||
} else {
|
||||
this.__dynamicCloseRef(ref);
|
||||
}
|
||||
}
|
||||
|
||||
__close(scopeManager) {
|
||||
let closeRef;
|
||||
|
||||
if (this.__shouldStaticallyClose(scopeManager)) {
|
||||
closeRef = this.__staticCloseRef;
|
||||
} else if (this.type !== "global") {
|
||||
closeRef = this.__dynamicCloseRef;
|
||||
} else {
|
||||
closeRef = this.__globalCloseRef;
|
||||
}
|
||||
|
||||
// Try Resolving all references in this scope.
|
||||
for (let i = 0, iz = this.__left.length; i < iz; ++i) {
|
||||
const ref = this.__left[i];
|
||||
|
||||
closeRef.call(this, ref);
|
||||
}
|
||||
this.__left = null;
|
||||
|
||||
return this.upper;
|
||||
}
|
||||
|
||||
// To override by function scopes.
|
||||
// References in default parameters isn't resolved to variables which are in their function body.
|
||||
__isValidResolution(ref, variable) { // eslint-disable-line class-methods-use-this, no-unused-vars -- Desired as instance method with signature
|
||||
return true;
|
||||
}
|
||||
|
||||
__resolve(ref) {
|
||||
const name = ref.identifier.name;
|
||||
|
||||
if (!this.set.has(name)) {
|
||||
return false;
|
||||
}
|
||||
const variable = this.set.get(name);
|
||||
|
||||
if (!this.__isValidResolution(ref, variable)) {
|
||||
return false;
|
||||
}
|
||||
variable.references.push(ref);
|
||||
variable.stack = variable.stack && ref.from.variableScope === this.variableScope;
|
||||
if (ref.tainted) {
|
||||
variable.tainted = true;
|
||||
this.taints.set(variable.name, true);
|
||||
}
|
||||
ref.resolved = variable;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
__delegateToUpperScope(ref) {
|
||||
if (this.upper) {
|
||||
this.upper.__left.push(ref);
|
||||
}
|
||||
this.through.push(ref);
|
||||
}
|
||||
|
||||
__addDeclaredVariablesOfNode(variable, node) {
|
||||
if (node === null || node === void 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
let variables = this.__declaredVariables.get(node);
|
||||
|
||||
if (variables === null || variables === void 0) {
|
||||
variables = [];
|
||||
this.__declaredVariables.set(node, variables);
|
||||
}
|
||||
if (!variables.includes(variable)) {
|
||||
variables.push(variable);
|
||||
}
|
||||
}
|
||||
|
||||
__defineGeneric(name, set, variables, node, def) {
|
||||
let variable;
|
||||
|
||||
variable = set.get(name);
|
||||
if (!variable) {
|
||||
variable = new Variable(name, this);
|
||||
set.set(name, variable);
|
||||
variables.push(variable);
|
||||
}
|
||||
|
||||
if (def) {
|
||||
variable.defs.push(def);
|
||||
this.__addDeclaredVariablesOfNode(variable, def.node);
|
||||
this.__addDeclaredVariablesOfNode(variable, def.parent);
|
||||
}
|
||||
if (node) {
|
||||
variable.identifiers.push(node);
|
||||
}
|
||||
}
|
||||
|
||||
__define(node, def) {
|
||||
if (node && node.type === Syntax.Identifier) {
|
||||
this.__defineGeneric(
|
||||
node.name,
|
||||
this.set,
|
||||
this.variables,
|
||||
node,
|
||||
def
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
__referencing(node, assign, writeExpr, maybeImplicitGlobal, partial, init) {
|
||||
|
||||
// because Array element may be null
|
||||
if (!node || (node.type !== Syntax.Identifier && node.type !== "JSXIdentifier")) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Specially handle like `this`.
|
||||
if (node.name === "super") {
|
||||
return;
|
||||
}
|
||||
|
||||
const ref = new Reference(node, this, assign || Reference.READ, writeExpr, maybeImplicitGlobal, !!partial, !!init);
|
||||
|
||||
this.references.push(ref);
|
||||
this.__left.push(ref);
|
||||
}
|
||||
|
||||
__detectEval() {
|
||||
let current = this;
|
||||
|
||||
this.directCallToEvalScope = true;
|
||||
do {
|
||||
current.dynamic = true;
|
||||
current = current.upper;
|
||||
} while (current);
|
||||
}
|
||||
|
||||
__detectThis() {
|
||||
this.thisFound = true;
|
||||
}
|
||||
|
||||
__isClosed() {
|
||||
return this.__left === null;
|
||||
}
|
||||
|
||||
/**
|
||||
* returns resolved {Reference}
|
||||
* @function Scope#resolve
|
||||
* @param {Espree.Identifier} ident identifier to be resolved.
|
||||
* @returns {Reference} reference
|
||||
*/
|
||||
resolve(ident) {
|
||||
let ref, i, iz;
|
||||
|
||||
assert(this.__isClosed(), "Scope should be closed.");
|
||||
assert(ident.type === Syntax.Identifier, "Target should be identifier.");
|
||||
for (i = 0, iz = this.references.length; i < iz; ++i) {
|
||||
ref = this.references[i];
|
||||
if (ref.identifier === ident) {
|
||||
return ref;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* returns this scope is static
|
||||
* @function Scope#isStatic
|
||||
* @returns {boolean} static
|
||||
*/
|
||||
isStatic() {
|
||||
return !this.dynamic;
|
||||
}
|
||||
|
||||
/**
|
||||
* returns this scope has materialized arguments
|
||||
* @function Scope#isArgumentsMaterialized
|
||||
* @returns {boolean} arguemnts materialized
|
||||
*/
|
||||
isArgumentsMaterialized() { // eslint-disable-line class-methods-use-this -- Desired as instance method
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* returns this scope has materialized `this` reference
|
||||
* @function Scope#isThisMaterialized
|
||||
* @returns {boolean} this materialized
|
||||
*/
|
||||
isThisMaterialized() { // eslint-disable-line class-methods-use-this -- Desired as instance method
|
||||
return true;
|
||||
}
|
||||
|
||||
isUsedName(name) {
|
||||
if (this.set.has(name)) {
|
||||
return true;
|
||||
}
|
||||
for (let i = 0, iz = this.through.length; i < iz; ++i) {
|
||||
if (this.through[i].identifier.name === name) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Global scope.
|
||||
*/
|
||||
class GlobalScope extends Scope {
|
||||
constructor(scopeManager, block) {
|
||||
super(scopeManager, "global", null, block, false);
|
||||
this.implicit = {
|
||||
set: new Map(),
|
||||
variables: [],
|
||||
|
||||
/**
|
||||
* List of {@link Reference}s that are left to be resolved (i.e. which
|
||||
* need to be linked to the variable they refer to).
|
||||
* @member {Reference[]} Scope#implicit#left
|
||||
*/
|
||||
left: []
|
||||
};
|
||||
}
|
||||
|
||||
__close(scopeManager) {
|
||||
const implicit = [];
|
||||
|
||||
for (let i = 0, iz = this.__left.length; i < iz; ++i) {
|
||||
const ref = this.__left[i];
|
||||
|
||||
if (ref.__maybeImplicitGlobal && !this.set.has(ref.identifier.name)) {
|
||||
implicit.push(ref.__maybeImplicitGlobal);
|
||||
}
|
||||
}
|
||||
|
||||
// create an implicit global variable from assignment expression
|
||||
for (let i = 0, iz = implicit.length; i < iz; ++i) {
|
||||
const info = implicit[i];
|
||||
|
||||
this.__defineImplicit(info.pattern,
|
||||
new Definition(
|
||||
Variable.ImplicitGlobalVariable,
|
||||
info.pattern,
|
||||
info.node,
|
||||
null,
|
||||
null,
|
||||
null
|
||||
));
|
||||
|
||||
}
|
||||
|
||||
this.implicit.left = this.__left;
|
||||
|
||||
return super.__close(scopeManager);
|
||||
}
|
||||
|
||||
__defineImplicit(node, def) {
|
||||
if (node && node.type === Syntax.Identifier) {
|
||||
this.__defineGeneric(
|
||||
node.name,
|
||||
this.implicit.set,
|
||||
this.implicit.variables,
|
||||
node,
|
||||
def
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Module scope.
|
||||
*/
|
||||
class ModuleScope extends Scope {
|
||||
constructor(scopeManager, upperScope, block) {
|
||||
super(scopeManager, "module", upperScope, block, false);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Function expression name scope.
|
||||
*/
|
||||
class FunctionExpressionNameScope extends Scope {
|
||||
constructor(scopeManager, upperScope, block) {
|
||||
super(scopeManager, "function-expression-name", upperScope, block, false);
|
||||
this.__define(block.id,
|
||||
new Definition(
|
||||
Variable.FunctionName,
|
||||
block.id,
|
||||
block,
|
||||
null,
|
||||
null,
|
||||
null
|
||||
));
|
||||
this.functionExpressionScope = true;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Catch scope.
|
||||
*/
|
||||
class CatchScope extends Scope {
|
||||
constructor(scopeManager, upperScope, block) {
|
||||
super(scopeManager, "catch", upperScope, block, false);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* With statement scope.
|
||||
*/
|
||||
class WithScope extends Scope {
|
||||
constructor(scopeManager, upperScope, block) {
|
||||
super(scopeManager, "with", upperScope, block, false);
|
||||
}
|
||||
|
||||
__close(scopeManager) {
|
||||
if (this.__shouldStaticallyClose(scopeManager)) {
|
||||
return super.__close(scopeManager);
|
||||
}
|
||||
|
||||
for (let i = 0, iz = this.__left.length; i < iz; ++i) {
|
||||
const ref = this.__left[i];
|
||||
|
||||
ref.tainted = true;
|
||||
this.__delegateToUpperScope(ref);
|
||||
}
|
||||
this.__left = null;
|
||||
|
||||
return this.upper;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Block scope.
|
||||
*/
|
||||
class BlockScope extends Scope {
|
||||
constructor(scopeManager, upperScope, block) {
|
||||
super(scopeManager, "block", upperScope, block, false);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Switch scope.
|
||||
*/
|
||||
class SwitchScope extends Scope {
|
||||
constructor(scopeManager, upperScope, block) {
|
||||
super(scopeManager, "switch", upperScope, block, false);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Function scope.
|
||||
*/
|
||||
class FunctionScope extends Scope {
|
||||
constructor(scopeManager, upperScope, block, isMethodDefinition) {
|
||||
super(scopeManager, "function", upperScope, block, isMethodDefinition);
|
||||
|
||||
// section 9.2.13, FunctionDeclarationInstantiation.
|
||||
// NOTE Arrow functions never have an arguments objects.
|
||||
if (this.block.type !== Syntax.ArrowFunctionExpression) {
|
||||
this.__defineArguments();
|
||||
}
|
||||
}
|
||||
|
||||
isArgumentsMaterialized() {
|
||||
|
||||
// TODO(Constellation)
|
||||
// We can more aggressive on this condition like this.
|
||||
//
|
||||
// function t() {
|
||||
// // arguments of t is always hidden.
|
||||
// function arguments() {
|
||||
// }
|
||||
// }
|
||||
if (this.block.type === Syntax.ArrowFunctionExpression) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!this.isStatic()) {
|
||||
return true;
|
||||
}
|
||||
|
||||
const variable = this.set.get("arguments");
|
||||
|
||||
assert(variable, "Always have arguments variable.");
|
||||
return variable.tainted || variable.references.length !== 0;
|
||||
}
|
||||
|
||||
isThisMaterialized() {
|
||||
if (!this.isStatic()) {
|
||||
return true;
|
||||
}
|
||||
return this.thisFound;
|
||||
}
|
||||
|
||||
__defineArguments() {
|
||||
this.__defineGeneric(
|
||||
"arguments",
|
||||
this.set,
|
||||
this.variables,
|
||||
null,
|
||||
null
|
||||
);
|
||||
this.taints.set("arguments", true);
|
||||
}
|
||||
|
||||
// References in default parameters isn't resolved to variables which are in their function body.
|
||||
// const x = 1
|
||||
// function f(a = x) { // This `x` is resolved to the `x` in the outer scope.
|
||||
// const x = 2
|
||||
// console.log(a)
|
||||
// }
|
||||
__isValidResolution(ref, variable) {
|
||||
|
||||
// If `options.nodejsScope` is true, `this.block` becomes a Program node.
|
||||
if (this.block.type === "Program") {
|
||||
return true;
|
||||
}
|
||||
|
||||
const bodyStart = this.block.body.range[0];
|
||||
|
||||
// It's invalid resolution in the following case:
|
||||
return !(
|
||||
variable.scope === this &&
|
||||
ref.identifier.range[0] < bodyStart && // the reference is in the parameter part.
|
||||
variable.defs.every(d => d.name.range[0] >= bodyStart) // the variable is in the body.
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Scope of for, for-in, and for-of statements.
|
||||
*/
|
||||
class ForScope extends Scope {
|
||||
constructor(scopeManager, upperScope, block) {
|
||||
super(scopeManager, "for", upperScope, block, false);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Class scope.
|
||||
*/
|
||||
class ClassScope extends Scope {
|
||||
constructor(scopeManager, upperScope, block) {
|
||||
super(scopeManager, "class", upperScope, block, false);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Class field initializer scope.
|
||||
*/
|
||||
class ClassFieldInitializerScope extends Scope {
|
||||
constructor(scopeManager, upperScope, block) {
|
||||
super(scopeManager, "class-field-initializer", upperScope, block, true);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Class static block scope.
|
||||
*/
|
||||
class ClassStaticBlockScope extends Scope {
|
||||
constructor(scopeManager, upperScope, block) {
|
||||
super(scopeManager, "class-static-block", upperScope, block, true);
|
||||
}
|
||||
}
|
||||
|
||||
export {
|
||||
Scope,
|
||||
GlobalScope,
|
||||
ModuleScope,
|
||||
FunctionExpressionNameScope,
|
||||
CatchScope,
|
||||
WithScope,
|
||||
BlockScope,
|
||||
SwitchScope,
|
||||
FunctionScope,
|
||||
ForScope,
|
||||
ClassScope,
|
||||
ClassFieldInitializerScope,
|
||||
ClassStaticBlockScope
|
||||
};
|
||||
|
||||
/* vim: set sw=4 ts=4 et tw=80 : */
|
||||
@@ -0,0 +1 @@
|
||||
module.exports={A:{A:{"2":"K D E F A B mC"},B:{"1":"OB I","2":"0 9 C L M G N O P Q H R S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB"},C:{"2":"0 1 2 3 4 5 6 7 8 9 nC LC J PB K D E F A B C L M G N O P QB RB SB TB UB VB WB XB YB ZB aB bB cB dB eB fB gB hB iB jB kB lB mB nB oB pB qB rB sB tB uB vB MC wB NC xB yB zB 0B 1B 2B 3B 4B 5B 6B 7B 8B 9B AC BC CC DC Q H R OC S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB I PC EC QC RC oC pC qC rC"},D:{"1":"OB I PC EC QC RC","2":"0 1 2 3 4 5 6 7 8 9 J PB K D E F A B C L M G N O P QB RB SB TB UB VB WB XB YB ZB aB bB cB dB eB fB gB hB iB jB kB lB mB nB oB pB qB rB sB tB uB vB MC wB NC xB yB zB 0B 1B 2B 3B 4B 5B 6B 7B 8B 9B AC BC CC DC Q H R S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB"},E:{"2":"J PB K D E F A B C L M G sC SC tC uC vC wC TC FC GC xC yC zC UC VC HC 0C IC WC XC YC ZC aC 1C JC bC cC dC eC fC 2C KC gC hC iC jC 3C"},F:{"2":"0 1 2 3 4 5 6 7 8 F B C G N O P QB RB SB TB UB VB WB XB YB ZB 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 0B 1B 2B 3B 4B 5B 6B 7B 8B 9B AC BC CC DC Q H R OC S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z 4C 5C 6C 7C FC kC 8C GC"},G:{"2":"E SC 9C lC AD BD CD DD ED FD GD HD ID JD KD LD MD ND OD PD QD RD SD UC VC HC TD IC WC XC YC ZC aC UD JC bC cC dC eC fC VD KC gC hC iC jC"},H:{"2":"WD"},I:{"1":"I","2":"LC J XD YD ZD aD lC bD cD"},J:{"2":"D A"},K:{"2":"A B C H FC kC GC"},L:{"1":"I"},M:{"2":"EC"},N:{"2":"A B"},O:{"2":"HC"},P:{"2":"1 2 3 4 5 6 7 8 J dD eD fD gD hD TC iD jD kD lD mD IC JC KC nD"},Q:{"2":"oD"},R:{"2":"pD"},S:{"2":"qD rD"}},B:7,C:"CSS3 attr() function for all properties",D:true};
|
||||
@@ -0,0 +1 @@
|
||||
{"version":3,"names":["addComments","node","type","comments","key","concat","push"],"sources":["../../src/comments/addComments.ts"],"sourcesContent":["import type * as t from \"../index.ts\";\n\n/**\n * Add comments of certain type to a node.\n */\nexport default function addComments<T extends t.Node>(\n node: T,\n type: t.CommentTypeShorthand,\n comments: Array<t.Comment>,\n): T {\n if (!comments || !node) return node;\n\n const key = `${type}Comments` as const;\n\n if (node[key]) {\n if (type === \"leading\") {\n node[key] = comments.concat(node[key]);\n } else {\n node[key].push(...comments);\n }\n } else {\n node[key] = comments;\n }\n\n return node;\n}\n"],"mappings":";;;;;;AAKe,SAASA,WAAWA,CACjCC,IAAO,EACPC,IAA4B,EAC5BC,QAA0B,EACvB;EACH,IAAI,CAACA,QAAQ,IAAI,CAACF,IAAI,EAAE,OAAOA,IAAI;EAEnC,MAAMG,GAAG,GAAG,GAAGF,IAAI,UAAmB;EAEtC,IAAID,IAAI,CAACG,GAAG,CAAC,EAAE;IACb,IAAIF,IAAI,KAAK,SAAS,EAAE;MACtBD,IAAI,CAACG,GAAG,CAAC,GAAGD,QAAQ,CAACE,MAAM,CAACJ,IAAI,CAACG,GAAG,CAAC,CAAC;IACxC,CAAC,MAAM;MACLH,IAAI,CAACG,GAAG,CAAC,CAACE,IAAI,CAAC,GAAGH,QAAQ,CAAC;IAC7B;EACF,CAAC,MAAM;IACLF,IAAI,CAACG,GAAG,CAAC,GAAGD,QAAQ;EACtB;EAEA,OAAOF,IAAI;AACb","ignoreList":[]}
|
||||
@@ -0,0 +1,40 @@
|
||||
{
|
||||
"name": "imurmurhash",
|
||||
"version": "0.1.4",
|
||||
"description": "An incremental implementation of MurmurHash3",
|
||||
"homepage": "https://github.com/jensyt/imurmurhash-js",
|
||||
"main": "imurmurhash.js",
|
||||
"files": [
|
||||
"imurmurhash.js",
|
||||
"imurmurhash.min.js",
|
||||
"package.json",
|
||||
"README.md"
|
||||
],
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "https://github.com/jensyt/imurmurhash-js"
|
||||
},
|
||||
"bugs": {
|
||||
"url": "https://github.com/jensyt/imurmurhash-js/issues"
|
||||
},
|
||||
"keywords": [
|
||||
"murmur",
|
||||
"murmurhash",
|
||||
"murmurhash3",
|
||||
"hash",
|
||||
"incremental"
|
||||
],
|
||||
"author": {
|
||||
"name": "Jens Taylor",
|
||||
"email": "jensyt@gmail.com",
|
||||
"url": "https://github.com/homebrewing"
|
||||
},
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
},
|
||||
"devDependencies": {
|
||||
},
|
||||
"engines": {
|
||||
"node": ">=0.8.19"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,37 @@
|
||||
/*
|
||||
MIT License http://www.opensource.org/licenses/mit-license.php
|
||||
Author Tobias Koppers @sokra
|
||||
*/
|
||||
"use strict";
|
||||
|
||||
const Hook = require("./Hook");
|
||||
const HookCodeFactory = require("./HookCodeFactory");
|
||||
|
||||
class AsyncParallelHookCodeFactory extends HookCodeFactory {
|
||||
content({ onError, onDone }) {
|
||||
return this.callTapsParallel({
|
||||
onError: (i, err, done, doneBreak) => onError(err) + doneBreak(true),
|
||||
onDone
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
const factory = new AsyncParallelHookCodeFactory();
|
||||
|
||||
const COMPILE = function(options) {
|
||||
factory.setup(this, options);
|
||||
return factory.create(options);
|
||||
};
|
||||
|
||||
function AsyncParallelHook(args = [], name = undefined) {
|
||||
const hook = new Hook(args, name);
|
||||
hook.constructor = AsyncParallelHook;
|
||||
hook.compile = COMPILE;
|
||||
hook._call = undefined;
|
||||
hook.call = undefined;
|
||||
return hook;
|
||||
}
|
||||
|
||||
AsyncParallelHook.prototype = null;
|
||||
|
||||
module.exports = AsyncParallelHook;
|
||||
@@ -0,0 +1,9 @@
|
||||
import { Parser } from './postcss.js'
|
||||
|
||||
interface Parse extends Parser {
|
||||
default: Parse
|
||||
}
|
||||
|
||||
declare const parse: Parse
|
||||
|
||||
export = parse
|
||||
@@ -0,0 +1,42 @@
|
||||
var test = require('tape');
|
||||
var stringify = require('../');
|
||||
|
||||
test('nested', function (t) {
|
||||
t.plan(1);
|
||||
var obj = { c: 8, b: [{z:6,y:5,x:4},7], a: 3 };
|
||||
t.equal(stringify(obj), '{"a":3,"b":[{"x":4,"y":5,"z":6},7],"c":8}');
|
||||
});
|
||||
|
||||
test('cyclic (default)', function (t) {
|
||||
t.plan(1);
|
||||
var one = { a: 1 };
|
||||
var two = { a: 2, one: one };
|
||||
one.two = two;
|
||||
try {
|
||||
stringify(one);
|
||||
} catch (ex) {
|
||||
t.equal(ex.toString(), 'TypeError: Converting circular structure to JSON');
|
||||
}
|
||||
});
|
||||
|
||||
test('cyclic (specifically allowed)', function (t) {
|
||||
t.plan(1);
|
||||
var one = { a: 1 };
|
||||
var two = { a: 2, one: one };
|
||||
one.two = two;
|
||||
t.equal(stringify(one, {cycles:true}), '{"a":1,"two":{"a":2,"one":"__cycle__"}}');
|
||||
});
|
||||
|
||||
test('repeated non-cyclic value', function(t) {
|
||||
t.plan(1);
|
||||
var one = { x: 1 };
|
||||
var two = { a: one, b: one };
|
||||
t.equal(stringify(two), '{"a":{"x":1},"b":{"x":1}}');
|
||||
});
|
||||
|
||||
test('acyclic but with reused obj-property pointers', function (t) {
|
||||
t.plan(1);
|
||||
var x = { a: 1 }
|
||||
var y = { b: x, c: x }
|
||||
t.equal(stringify(y), '{"b":{"a":1},"c":{"a":1}}');
|
||||
});
|
||||
@@ -0,0 +1,65 @@
|
||||
/** @implements {IPDFStream} */
|
||||
export class PDFFetchStream implements IPDFStream {
|
||||
constructor(source: any);
|
||||
source: any;
|
||||
isHttp: boolean;
|
||||
headers: Headers;
|
||||
_fullRequestReader: PDFFetchStreamReader | null;
|
||||
_rangeRequestReaders: any[];
|
||||
get _progressiveDataLength(): number;
|
||||
getFullReader(): PDFFetchStreamReader;
|
||||
getRangeReader(begin: any, end: any): PDFFetchStreamRangeReader | null;
|
||||
cancelAllRequests(reason: any): void;
|
||||
}
|
||||
/** @implements {IPDFStreamReader} */
|
||||
declare class PDFFetchStreamReader implements IPDFStreamReader {
|
||||
constructor(stream: any);
|
||||
_stream: any;
|
||||
_reader: ReadableStreamDefaultReader<Uint8Array> | null;
|
||||
_loaded: number;
|
||||
_filename: string | null;
|
||||
_withCredentials: any;
|
||||
_contentLength: any;
|
||||
_headersCapability: any;
|
||||
_disableRange: any;
|
||||
_rangeChunkSize: any;
|
||||
_abortController: AbortController;
|
||||
_isStreamingSupported: boolean;
|
||||
_isRangeSupported: boolean;
|
||||
onProgress: any;
|
||||
get headersReady(): any;
|
||||
get filename(): string | null;
|
||||
get contentLength(): any;
|
||||
get isRangeSupported(): boolean;
|
||||
get isStreamingSupported(): boolean;
|
||||
read(): Promise<{
|
||||
value: Uint8Array | undefined;
|
||||
done: true;
|
||||
} | {
|
||||
value: ArrayBufferLike;
|
||||
done: boolean;
|
||||
}>;
|
||||
cancel(reason: any): void;
|
||||
}
|
||||
/** @implements {IPDFStreamRangeReader} */
|
||||
declare class PDFFetchStreamRangeReader implements IPDFStreamRangeReader {
|
||||
constructor(stream: any, begin: any, end: any);
|
||||
_stream: any;
|
||||
_reader: ReadableStreamDefaultReader<Uint8Array> | null;
|
||||
_loaded: number;
|
||||
_withCredentials: any;
|
||||
_readCapability: any;
|
||||
_isStreamingSupported: boolean;
|
||||
_abortController: AbortController;
|
||||
onProgress: any;
|
||||
get isStreamingSupported(): boolean;
|
||||
read(): Promise<{
|
||||
value: Uint8Array | undefined;
|
||||
done: true;
|
||||
} | {
|
||||
value: ArrayBufferLike;
|
||||
done: boolean;
|
||||
}>;
|
||||
cancel(reason: any): void;
|
||||
}
|
||||
export {};
|
||||
@@ -0,0 +1,202 @@
|
||||
/**
|
||||
* @fileoverview Utility for caching lint results.
|
||||
* @author Kevin Partington
|
||||
*/
|
||||
"use strict";
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Requirements
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
const fs = require("node:fs");
|
||||
const fileEntryCache = require("file-entry-cache");
|
||||
const stringify = require("json-stable-stringify-without-jsonify");
|
||||
const pkg = require("../../package.json");
|
||||
const assert = require("../shared/assert");
|
||||
const hash = require("./hash");
|
||||
|
||||
const debug = require("debug")("eslint:lint-result-cache");
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Helpers
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
const configHashCache = new WeakMap();
|
||||
const nodeVersion = process && process.version;
|
||||
|
||||
const validCacheStrategies = ["metadata", "content"];
|
||||
const invalidCacheStrategyErrorMessage = `Cache strategy must be one of: ${validCacheStrategies
|
||||
.map(strategy => `"${strategy}"`)
|
||||
.join(", ")}`;
|
||||
|
||||
/**
|
||||
* Tests whether a provided cacheStrategy is valid
|
||||
* @param {string} cacheStrategy The cache strategy to use
|
||||
* @returns {boolean} true if `cacheStrategy` is one of `validCacheStrategies`; false otherwise
|
||||
*/
|
||||
function isValidCacheStrategy(cacheStrategy) {
|
||||
return validCacheStrategies.includes(cacheStrategy);
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculates the hash of the config
|
||||
* @param {ConfigArray} config The config.
|
||||
* @returns {string} The hash of the config
|
||||
*/
|
||||
function hashOfConfigFor(config) {
|
||||
if (!configHashCache.has(config)) {
|
||||
configHashCache.set(
|
||||
config,
|
||||
hash(`${pkg.version}_${nodeVersion}_${stringify(config)}`),
|
||||
);
|
||||
}
|
||||
|
||||
return configHashCache.get(config);
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Public Interface
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Lint result cache. This wraps around the file-entry-cache module,
|
||||
* transparently removing properties that are difficult or expensive to
|
||||
* serialize and adding them back in on retrieval.
|
||||
*/
|
||||
class LintResultCache {
|
||||
/**
|
||||
* Creates a new LintResultCache instance.
|
||||
* @param {string} cacheFileLocation The cache file location.
|
||||
* @param {"metadata" | "content"} cacheStrategy The cache strategy to use.
|
||||
*/
|
||||
constructor(cacheFileLocation, cacheStrategy) {
|
||||
assert(cacheFileLocation, "Cache file location is required");
|
||||
assert(cacheStrategy, "Cache strategy is required");
|
||||
assert(
|
||||
isValidCacheStrategy(cacheStrategy),
|
||||
invalidCacheStrategyErrorMessage,
|
||||
);
|
||||
|
||||
debug(`Caching results to ${cacheFileLocation}`);
|
||||
|
||||
const useChecksum = cacheStrategy === "content";
|
||||
|
||||
debug(`Using "${cacheStrategy}" strategy to detect changes`);
|
||||
|
||||
this.fileEntryCache = fileEntryCache.create(
|
||||
cacheFileLocation,
|
||||
void 0,
|
||||
useChecksum,
|
||||
);
|
||||
this.cacheFileLocation = cacheFileLocation;
|
||||
}
|
||||
|
||||
/**
|
||||
* Retrieve cached lint results for a given file path, if present in the
|
||||
* cache. If the file is present and has not been changed, rebuild any
|
||||
* missing result information.
|
||||
* @param {string} filePath The file for which to retrieve lint results.
|
||||
* @param {ConfigArray} config The config of the file.
|
||||
* @returns {Object|null} The rebuilt lint results, or null if the file is
|
||||
* changed or not in the filesystem.
|
||||
*/
|
||||
getCachedLintResults(filePath, config) {
|
||||
/*
|
||||
* Cached lint results are valid if and only if:
|
||||
* 1. The file is present in the filesystem
|
||||
* 2. The file has not changed since the time it was previously linted
|
||||
* 3. The ESLint configuration has not changed since the time the file
|
||||
* was previously linted
|
||||
* If any of these are not true, we will not reuse the lint results.
|
||||
*/
|
||||
const fileDescriptor = this.fileEntryCache.getFileDescriptor(filePath);
|
||||
const hashOfConfig = hashOfConfigFor(config);
|
||||
const changed =
|
||||
fileDescriptor.changed ||
|
||||
fileDescriptor.meta.hashOfConfig !== hashOfConfig;
|
||||
|
||||
if (fileDescriptor.notFound) {
|
||||
debug(`File not found on the file system: ${filePath}`);
|
||||
return null;
|
||||
}
|
||||
|
||||
if (changed) {
|
||||
debug(`Cache entry not found or no longer valid: ${filePath}`);
|
||||
return null;
|
||||
}
|
||||
|
||||
const cachedResults = fileDescriptor.meta.results;
|
||||
|
||||
// Just in case, not sure if this can ever happen.
|
||||
if (!cachedResults) {
|
||||
return cachedResults;
|
||||
}
|
||||
|
||||
/*
|
||||
* Shallow clone the object to ensure that any properties added or modified afterwards
|
||||
* will not be accidentally stored in the cache file when `reconcile()` is called.
|
||||
* https://github.com/eslint/eslint/issues/13507
|
||||
* All intentional changes to the cache file must be done through `setCachedLintResults()`.
|
||||
*/
|
||||
const results = { ...cachedResults };
|
||||
|
||||
// If source is present but null, need to reread the file from the filesystem.
|
||||
if (results.source === null) {
|
||||
debug(
|
||||
`Rereading cached result source from filesystem: ${filePath}`,
|
||||
);
|
||||
results.source = fs.readFileSync(filePath, "utf-8");
|
||||
}
|
||||
|
||||
return results;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the cached lint results for a given file path, after removing any
|
||||
* information that will be both unnecessary and difficult to serialize.
|
||||
* Avoids caching results with an "output" property (meaning fixes were
|
||||
* applied), to prevent potentially incorrect results if fixes are not
|
||||
* written to disk.
|
||||
* @param {string} filePath The file for which to set lint results.
|
||||
* @param {ConfigArray} config The config of the file.
|
||||
* @param {Object} result The lint result to be set for the file.
|
||||
* @returns {void}
|
||||
*/
|
||||
setCachedLintResults(filePath, config, result) {
|
||||
if (result && Object.hasOwn(result, "output")) {
|
||||
return;
|
||||
}
|
||||
|
||||
const fileDescriptor = this.fileEntryCache.getFileDescriptor(filePath);
|
||||
|
||||
if (fileDescriptor && !fileDescriptor.notFound) {
|
||||
debug(`Updating cached result: ${filePath}`);
|
||||
|
||||
// Serialize the result, except that we want to remove the file source if present.
|
||||
const resultToSerialize = Object.assign({}, result);
|
||||
|
||||
/*
|
||||
* Set result.source to null.
|
||||
* In `getCachedLintResults`, if source is explicitly null, we will
|
||||
* read the file from the filesystem to set the value again.
|
||||
*/
|
||||
if (Object.hasOwn(resultToSerialize, "source")) {
|
||||
resultToSerialize.source = null;
|
||||
}
|
||||
|
||||
fileDescriptor.meta.results = resultToSerialize;
|
||||
fileDescriptor.meta.hashOfConfig = hashOfConfigFor(config);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Persists the in-memory cache to disk.
|
||||
* @returns {void}
|
||||
*/
|
||||
reconcile() {
|
||||
debug(`Persisting cached results: ${this.cacheFileLocation}`);
|
||||
this.fileEntryCache.reconcile();
|
||||
}
|
||||
}
|
||||
|
||||
module.exports = LintResultCache;
|
||||
@@ -0,0 +1,67 @@
|
||||
/**
|
||||
* @fileoverview Disallow the use of process.exit()
|
||||
* @author Nicholas C. Zakas
|
||||
* @deprecated in ESLint v7.0.0
|
||||
*/
|
||||
"use strict";
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Rule Definition
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/** @type {import('../shared/types').Rule} */
|
||||
module.exports = {
|
||||
meta: {
|
||||
deprecated: {
|
||||
message: "Node.js rules were moved out of ESLint core.",
|
||||
url: "https://eslint.org/docs/latest/use/migrating-to-7.0.0#deprecate-node-rules",
|
||||
deprecatedSince: "7.0.0",
|
||||
availableUntil: null,
|
||||
replacedBy: [
|
||||
{
|
||||
message:
|
||||
"eslint-plugin-n now maintains deprecated Node.js-related rules.",
|
||||
plugin: {
|
||||
name: "eslint-plugin-n",
|
||||
url: "https://github.com/eslint-community/eslint-plugin-n",
|
||||
},
|
||||
rule: {
|
||||
name: "no-process-exit",
|
||||
url: "https://github.com/eslint-community/eslint-plugin-n/tree/master/docs/rules/no-process-exit.md",
|
||||
},
|
||||
},
|
||||
],
|
||||
},
|
||||
|
||||
type: "suggestion",
|
||||
|
||||
docs: {
|
||||
description: "Disallow the use of `process.exit()`",
|
||||
recommended: false,
|
||||
url: "https://eslint.org/docs/latest/rules/no-process-exit",
|
||||
},
|
||||
|
||||
schema: [],
|
||||
|
||||
messages: {
|
||||
noProcessExit: "Don't use process.exit(); throw an error instead.",
|
||||
},
|
||||
},
|
||||
|
||||
create(context) {
|
||||
//--------------------------------------------------------------------------
|
||||
// Public
|
||||
//--------------------------------------------------------------------------
|
||||
|
||||
return {
|
||||
"CallExpression > MemberExpression.callee[object.name = 'process'][property.name = 'exit']"(
|
||||
node,
|
||||
) {
|
||||
context.report({
|
||||
node: node.parent,
|
||||
messageId: "noProcessExit",
|
||||
});
|
||||
},
|
||||
};
|
||||
},
|
||||
};
|
||||
@@ -0,0 +1,43 @@
|
||||
import * as React from 'react'
|
||||
import { isNotFound } from '@tanstack/router-core'
|
||||
import { CatchBoundary } from './CatchBoundary'
|
||||
import { useRouterState } from './useRouterState'
|
||||
import type { ErrorInfo } from 'react'
|
||||
import type { NotFoundError } from '@tanstack/router-core'
|
||||
|
||||
export function CatchNotFound(props: {
|
||||
fallback?: (error: NotFoundError) => React.ReactElement
|
||||
onCatch?: (error: Error, errorInfo: ErrorInfo) => void
|
||||
children: React.ReactNode
|
||||
}) {
|
||||
// TODO: Some way for the user to programmatically reset the not-found boundary?
|
||||
const resetKey = useRouterState({
|
||||
select: (s) => `not-found-${s.location.pathname}-${s.status}`,
|
||||
})
|
||||
|
||||
return (
|
||||
<CatchBoundary
|
||||
getResetKey={() => resetKey}
|
||||
onCatch={(error, errorInfo) => {
|
||||
if (isNotFound(error)) {
|
||||
props.onCatch?.(error, errorInfo)
|
||||
} else {
|
||||
throw error
|
||||
}
|
||||
}}
|
||||
errorComponent={({ error }: { error: Error }) => {
|
||||
if (isNotFound(error)) {
|
||||
return props.fallback?.(error)
|
||||
} else {
|
||||
throw error
|
||||
}
|
||||
}}
|
||||
>
|
||||
{props.children}
|
||||
</CatchBoundary>
|
||||
)
|
||||
}
|
||||
|
||||
export function DefaultGlobalNotFound() {
|
||||
return <p>Not Found</p>
|
||||
}
|
||||
@@ -0,0 +1 @@
|
||||
{"version":3,"names":["_rewriteStackTrace","require","ConfigError","Error","constructor","message","filename","expectedError","injectVirtualStackFrame","exports","default"],"sources":["../../src/errors/config-error.ts"],"sourcesContent":["import {\n injectVirtualStackFrame,\n expectedError,\n} from \"./rewrite-stack-trace.ts\";\n\nexport default class ConfigError extends Error {\n constructor(message: string, filename?: string) {\n super(message);\n expectedError(this);\n if (filename) injectVirtualStackFrame(this, filename);\n }\n}\n"],"mappings":";;;;;;AAAA,IAAAA,kBAAA,GAAAC,OAAA;AAKe,MAAMC,WAAW,SAASC,KAAK,CAAC;EAC7CC,WAAWA,CAACC,OAAe,EAAEC,QAAiB,EAAE;IAC9C,KAAK,CAACD,OAAO,CAAC;IACd,IAAAE,gCAAa,EAAC,IAAI,CAAC;IACnB,IAAID,QAAQ,EAAE,IAAAE,0CAAuB,EAAC,IAAI,EAAEF,QAAQ,CAAC;EACvD;AACF;AAACG,OAAA,CAAAC,OAAA,GAAAR,WAAA;AAAA","ignoreList":[]}
|
||||
Reference in New Issue
Block a user