StenoType
Collection
Collection of models and datasets for TypeScript-related projects from Ming-Ho Yee's dissertation (https://doi.org/10.17760/D20653005).
•
9 items
•
Updated
name
stringlengths 2
31
| dataset
stringclasses 4
values | size
int64 1.66k
14.8k
| content
stringlengths 1.66k
14.8k
| content_without_annotations
stringlengths 1.66k
14.8k
| loc
int64 51
494
| functions
int64 3
40
| function_signatures
int64 0
0
| function_parameters
int64 4
64
| variable_declarations
int64 5
54
| property_declarations
int64 0
0
| function_usages
int64 1
21
| trivial_types
int64 0
0
| predefined_types
int64 0
0
| type_definitions
int64 0
1
| dynamism_heuristic
int64 0
34
| loc_per_function
float64 5.38
57.8
| estimated_tokens
int64 494
3.9k
| typechecks
bool 2
classes |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
ansi-colors | top1k-typed-nodeps | 8,320 | function getDefaultExportFromCjs (x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
}
var ansiColors = {exports: {}};
var symbols = {exports: {}};
// FILE: symbols.js
var hasRequiredSymbols;
function requireSymbols () {
if (hasRequiredSymbols) return symbols.exports;
hasRequiredSymbols = 1;
(function (module) {
const isHyper = typeof process !== 'undefined' && process.env.TERM_PROGRAM === 'Hyper';
const isWindows = typeof process !== 'undefined' && process.platform === 'win32';
const isLinux = typeof process !== 'undefined' && process.platform === 'linux';
const common = {
ballotDisabled: '☒',
ballotOff: '☐',
ballotOn: '☑',
bullet: '•',
bulletWhite: '◦',
fullBlock: '█',
heart: '❤',
identicalTo: '≡',
line: '─',
mark: '※',
middot: '·',
minus: '－',
multiplication: '×',
obelus: '÷',
pencilDownRight: '✎',
pencilRight: '✏',
pencilUpRight: '✐',
percent: '%',
pilcrow2: '❡',
pilcrow: '¶',
plusMinus: '±',
question: '?',
section: '§',
starsOff: '☆',
starsOn: '★',
upDownArrow: '↕'
};
const windows = Object.assign({}, common, {
check: '√',
cross: '×',
ellipsisLarge: '...',
ellipsis: '...',
info: 'i',
questionSmall: '?',
pointer: '>',
pointerSmall: '»',
radioOff: '( )',
radioOn: '(*)',
warning: '‼'
});
const other = Object.assign({}, common, {
ballotCross: '✘',
check: '✔',
cross: '✖',
ellipsisLarge: '⋯',
ellipsis: '…',
info: 'ℹ',
questionFull: '？',
questionSmall: '﹖',
pointer: isLinux ? '▸' : '❯',
pointerSmall: isLinux ? '‣' : '›',
radioOff: '◯',
radioOn: '◉',
warning: '⚠'
});
module.exports = (isWindows && !isHyper) ? windows : other;
Reflect.defineProperty(module.exports, 'common', { enumerable: false, value: common });
Reflect.defineProperty(module.exports, 'windows', { enumerable: false, value: windows });
Reflect.defineProperty(module.exports, 'other', { enumerable: false, value: other });
} (symbols));
return symbols.exports;
}
// FILE: index.js
const isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val);
/* eslint-disable no-control-regex */
// this is a modified version of https://github.com/chalk/ansi-regex (MIT License)
const ANSI_REGEX = /[\u001b\u009b][[\]#;?()]*(?:(?:(?:[^\W_]*;?[^\W_]*)\u0007)|(?:(?:[0-9]{1,4}(;[0-9]{0,4})*)?[~0-9=<>cf-nqrtyA-PRZ]))/g;
const hasColor = () => {
if (typeof process !== 'undefined') {
return process.env.FORCE_COLOR !== '0';
}
return false;
};
const create = () => {
const colors = {
enabled: hasColor(),
visible: true,
styles: {},
keys: {}
};
const ansi = style => {
let open = style.open = `\u001b[${style.codes[0]}m`;
let close = style.close = `\u001b[${style.codes[1]}m`;
let regex = style.regex = new RegExp(`\\u001b\\[${style.codes[1]}m`, 'g');
style.wrap = (input, newline) => {
if (input.includes(close)) input = input.replace(regex, close + open);
let output = open + input + close;
// see https://github.com/chalk/chalk/pull/92, thanks to the
// chalk contributors for this fix. However, we've confirmed that
// this issue is also present in Windows terminals
return newline ? output.replace(/\r*\n/g, `${close}$&${open}`) : output;
};
return style;
};
const wrap = (style, input, newline) => {
return typeof style === 'function' ? style(input) : style.wrap(input, newline);
};
const style = (input, stack) => {
if (input === '' || input == null) return '';
if (colors.enabled === false) return input;
if (colors.visible === false) return '';
let str = '' + input;
let nl = str.includes('\n');
let n = stack.length;
if (n > 0 && stack.includes('unstyle')) {
stack = [...new Set(['unstyle', ...stack])].reverse();
}
while (n-- > 0) str = wrap(colors.styles[stack[n]], str, nl);
return str;
};
const define = (name, codes, type) => {
colors.styles[name] = ansi({ name, codes });
let keys = colors.keys[type] || (colors.keys[type] = []);
keys.push(name);
Reflect.defineProperty(colors, name, {
configurable: true,
enumerable: true,
set(value) {
colors.alias(name, value);
},
get() {
let color = input => style(input, color.stack);
Reflect.setPrototypeOf(color, colors);
color.stack = this.stack ? this.stack.concat(name) : [name];
return color;
}
});
};
define('reset', [0, 0], 'modifier');
define('bold', [1, 22], 'modifier');
define('dim', [2, 22], 'modifier');
define('italic', [3, 23], 'modifier');
define('underline', [4, 24], 'modifier');
define('inverse', [7, 27], 'modifier');
define('hidden', [8, 28], 'modifier');
define('strikethrough', [9, 29], 'modifier');
define('black', [30, 39], 'color');
define('red', [31, 39], 'color');
define('green', [32, 39], 'color');
define('yellow', [33, 39], 'color');
define('blue', [34, 39], 'color');
define('magenta', [35, 39], 'color');
define('cyan', [36, 39], 'color');
define('white', [37, 39], 'color');
define('gray', [90, 39], 'color');
define('grey', [90, 39], 'color');
define('bgBlack', [40, 49], 'bg');
define('bgRed', [41, 49], 'bg');
define('bgGreen', [42, 49], 'bg');
define('bgYellow', [43, 49], 'bg');
define('bgBlue', [44, 49], 'bg');
define('bgMagenta', [45, 49], 'bg');
define('bgCyan', [46, 49], 'bg');
define('bgWhite', [47, 49], 'bg');
define('blackBright', [90, 39], 'bright');
define('redBright', [91, 39], 'bright');
define('greenBright', [92, 39], 'bright');
define('yellowBright', [93, 39], 'bright');
define('blueBright', [94, 39], 'bright');
define('magentaBright', [95, 39], 'bright');
define('cyanBright', [96, 39], 'bright');
define('whiteBright', [97, 39], 'bright');
define('bgBlackBright', [100, 49], 'bgBright');
define('bgRedBright', [101, 49], 'bgBright');
define('bgGreenBright', [102, 49], 'bgBright');
define('bgYellowBright', [103, 49], 'bgBright');
define('bgBlueBright', [104, 49], 'bgBright');
define('bgMagentaBright', [105, 49], 'bgBright');
define('bgCyanBright', [106, 49], 'bgBright');
define('bgWhiteBright', [107, 49], 'bgBright');
colors.ansiRegex = ANSI_REGEX;
colors.hasColor = colors.hasAnsi = str => {
colors.ansiRegex.lastIndex = 0;
return typeof str === 'string' && str !== '' && colors.ansiRegex.test(str);
};
colors.alias = (name, color) => {
let fn = typeof color === 'string' ? colors[color] : color;
if (typeof fn !== 'function') {
throw new TypeError('Expected alias to be the name of an existing color (string) or a function');
}
if (!fn.stack) {
Reflect.defineProperty(fn, 'name', { value: name });
colors.styles[name] = fn;
fn.stack = [name];
}
Reflect.defineProperty(colors, name, {
configurable: true,
enumerable: true,
set(value) {
colors.alias(name, value);
},
get() {
let color = input => style(input, color.stack);
Reflect.setPrototypeOf(color, colors);
color.stack = this.stack ? this.stack.concat(fn.stack) : fn.stack;
return color;
}
});
};
colors.theme = custom => {
if (!isObject(custom)) throw new TypeError('Expected theme to be an object');
for (let name of Object.keys(custom)) {
colors.alias(name, custom[name]);
}
return colors;
};
colors.alias('unstyle', str => {
if (typeof str === 'string' && str !== '') {
colors.ansiRegex.lastIndex = 0;
return str.replace(colors.ansiRegex, '');
}
return '';
});
colors.alias('noop', str => str);
colors.none = colors.clear = colors.noop;
colors.stripColor = colors.unstyle;
colors.symbols = requireSymbols();
colors.define = define;
return colors;
};
ansiColors.exports = create();
var create_1 = ansiColors.exports.create = create;
var ansiColorsExports = ansiColors.exports;
var index = /*@__PURE__*/getDefaultExportFromCjs(ansiColorsExports);
export { create_1 as create, index as default };
| function getDefaultExportFromCjs (x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
}
var ansiColors = {exports: {}};
var symbols = {exports: {}};
// FILE: symbols.js
var hasRequiredSymbols;
function requireSymbols () {
if (hasRequiredSymbols) return symbols.exports;
hasRequiredSymbols = 1;
(function (module) {
const isHyper = typeof process !== 'undefined' && process.env.TERM_PROGRAM === 'Hyper';
const isWindows = typeof process !== 'undefined' && process.platform === 'win32';
const isLinux = typeof process !== 'undefined' && process.platform === 'linux';
const common = {
ballotDisabled: '☒',
ballotOff: '☐',
ballotOn: '☑',
bullet: '•',
bulletWhite: '◦',
fullBlock: '█',
heart: '❤',
identicalTo: '≡',
line: '─',
mark: '※',
middot: '·',
minus: '－',
multiplication: '×',
obelus: '÷',
pencilDownRight: '✎',
pencilRight: '✏',
pencilUpRight: '✐',
percent: '%',
pilcrow2: '❡',
pilcrow: '¶',
plusMinus: '±',
question: '?',
section: '§',
starsOff: '☆',
starsOn: '★',
upDownArrow: '↕'
};
const windows = Object.assign({}, common, {
check: '√',
cross: '×',
ellipsisLarge: '...',
ellipsis: '...',
info: 'i',
questionSmall: '?',
pointer: '>',
pointerSmall: '»',
radioOff: '( )',
radioOn: '(*)',
warning: '‼'
});
const other = Object.assign({}, common, {
ballotCross: '✘',
check: '✔',
cross: '✖',
ellipsisLarge: '⋯',
ellipsis: '…',
info: 'ℹ',
questionFull: '？',
questionSmall: '﹖',
pointer: isLinux ? '▸' : '❯',
pointerSmall: isLinux ? '‣' : '›',
radioOff: '◯',
radioOn: '◉',
warning: '⚠'
});
module.exports = (isWindows && !isHyper) ? windows : other;
Reflect.defineProperty(module.exports, 'common', { enumerable: false, value: common });
Reflect.defineProperty(module.exports, 'windows', { enumerable: false, value: windows });
Reflect.defineProperty(module.exports, 'other', { enumerable: false, value: other });
} (symbols));
return symbols.exports;
}
// FILE: index.js
const isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val);
/* eslint-disable no-control-regex */
// this is a modified version of https://github.com/chalk/ansi-regex (MIT License)
const ANSI_REGEX = /[\u001b\u009b][[\]#;?()]*(?:(?:(?:[^\W_]*;?[^\W_]*)\u0007)|(?:(?:[0-9]{1,4}(;[0-9]{0,4})*)?[~0-9=<>cf-nqrtyA-PRZ]))/g;
const hasColor = () => {
if (typeof process !== 'undefined') {
return process.env.FORCE_COLOR !== '0';
}
return false;
};
const create = () => {
const colors = {
enabled: hasColor(),
visible: true,
styles: {},
keys: {}
};
const ansi = style => {
let open = style.open = `\u001b[${style.codes[0]}m`;
let close = style.close = `\u001b[${style.codes[1]}m`;
let regex = style.regex = new RegExp(`\\u001b\\[${style.codes[1]}m`, 'g');
style.wrap = (input, newline) => {
if (input.includes(close)) input = input.replace(regex, close + open);
let output = open + input + close;
// see https://github.com/chalk/chalk/pull/92, thanks to the
// chalk contributors for this fix. However, we've confirmed that
// this issue is also present in Windows terminals
return newline ? output.replace(/\r*\n/g, `${close}$&${open}`) : output;
};
return style;
};
const wrap = (style, input, newline) => {
return typeof style === 'function' ? style(input) : style.wrap(input, newline);
};
const style = (input, stack) => {
if (input === '' || input == null) return '';
if (colors.enabled === false) return input;
if (colors.visible === false) return '';
let str = '' + input;
let nl = str.includes('\n');
let n = stack.length;
if (n > 0 && stack.includes('unstyle')) {
stack = [...new Set(['unstyle', ...stack])].reverse();
}
while (n-- > 0) str = wrap(colors.styles[stack[n]], str, nl);
return str;
};
const define = (name, codes, type) => {
colors.styles[name] = ansi({ name, codes });
let keys = colors.keys[type] || (colors.keys[type] = []);
keys.push(name);
Reflect.defineProperty(colors, name, {
configurable: true,
enumerable: true,
set(value) {
colors.alias(name, value);
},
get() {
let color = input => style(input, color.stack);
Reflect.setPrototypeOf(color, colors);
color.stack = this.stack ? this.stack.concat(name) : [name];
return color;
}
});
};
define('reset', [0, 0], 'modifier');
define('bold', [1, 22], 'modifier');
define('dim', [2, 22], 'modifier');
define('italic', [3, 23], 'modifier');
define('underline', [4, 24], 'modifier');
define('inverse', [7, 27], 'modifier');
define('hidden', [8, 28], 'modifier');
define('strikethrough', [9, 29], 'modifier');
define('black', [30, 39], 'color');
define('red', [31, 39], 'color');
define('green', [32, 39], 'color');
define('yellow', [33, 39], 'color');
define('blue', [34, 39], 'color');
define('magenta', [35, 39], 'color');
define('cyan', [36, 39], 'color');
define('white', [37, 39], 'color');
define('gray', [90, 39], 'color');
define('grey', [90, 39], 'color');
define('bgBlack', [40, 49], 'bg');
define('bgRed', [41, 49], 'bg');
define('bgGreen', [42, 49], 'bg');
define('bgYellow', [43, 49], 'bg');
define('bgBlue', [44, 49], 'bg');
define('bgMagenta', [45, 49], 'bg');
define('bgCyan', [46, 49], 'bg');
define('bgWhite', [47, 49], 'bg');
define('blackBright', [90, 39], 'bright');
define('redBright', [91, 39], 'bright');
define('greenBright', [92, 39], 'bright');
define('yellowBright', [93, 39], 'bright');
define('blueBright', [94, 39], 'bright');
define('magentaBright', [95, 39], 'bright');
define('cyanBright', [96, 39], 'bright');
define('whiteBright', [97, 39], 'bright');
define('bgBlackBright', [100, 49], 'bgBright');
define('bgRedBright', [101, 49], 'bgBright');
define('bgGreenBright', [102, 49], 'bgBright');
define('bgYellowBright', [103, 49], 'bgBright');
define('bgBlueBright', [104, 49], 'bgBright');
define('bgMagentaBright', [105, 49], 'bgBright');
define('bgCyanBright', [106, 49], 'bgBright');
define('bgWhiteBright', [107, 49], 'bgBright');
colors.ansiRegex = ANSI_REGEX;
colors.hasColor = colors.hasAnsi = str => {
colors.ansiRegex.lastIndex = 0;
return typeof str === 'string' && str !== '' && colors.ansiRegex.test(str);
};
colors.alias = (name, color) => {
let fn = typeof color === 'string' ? colors[color] : color;
if (typeof fn !== 'function') {
throw new TypeError('Expected alias to be the name of an existing color (string) or a function');
}
if (!fn.stack) {
Reflect.defineProperty(fn, 'name', { value: name });
colors.styles[name] = fn;
fn.stack = [name];
}
Reflect.defineProperty(colors, name, {
configurable: true,
enumerable: true,
set(value) {
colors.alias(name, value);
},
get() {
let color = input => style(input, color.stack);
Reflect.setPrototypeOf(color, colors);
color.stack = this.stack ? this.stack.concat(fn.stack) : fn.stack;
return color;
}
});
};
colors.theme = custom => {
if (!isObject(custom)) throw new TypeError('Expected theme to be an object');
for (let name of Object.keys(custom)) {
colors.alias(name, custom[name]);
}
return colors;
};
colors.alias('unstyle', str => {
if (typeof str === 'string' && str !== '') {
colors.ansiRegex.lastIndex = 0;
return str.replace(colors.ansiRegex, '');
}
return '';
});
colors.alias('noop', str => str);
colors.none = colors.clear = colors.noop;
colors.stripColor = colors.unstyle;
colors.symbols = requireSymbols();
colors.define = define;
return colors;
};
ansiColors.exports = create();
var create_1 = ansiColors.exports.create = create;
var ansiColorsExports = ansiColors.exports;
var index = /*@__PURE__*/getDefaultExportFromCjs(ansiColorsExports);
export { create_1 as create, index as default };
| 233 | 22 | 0 | 24 | 32 | 0 | 10 | 0 | 0 | 0 | 10 | 16.636364 | 2,698 | false |
setimmediate | top1k-typed-nodeps | 6,768 | var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
var setImmediate = {};
// FILE: setImmediate.js
(function (global, undefined$1) {
if (global.setImmediate) {
return;
}
var nextHandle = 1; // Spec says greater than zero
var tasksByHandle = {};
var currentlyRunningATask = false;
var doc = global.document;
var registerImmediate;
function setImmediate(callback) {
// Callback can either be a function or a string
if (typeof callback !== "function") {
callback = new Function("" + callback);
}
// Copy function arguments
var args = new Array(arguments.length - 1);
for (var i = 0; i < args.length; i++) {
args[i] = arguments[i + 1];
}
// Store and register the task
var task = { callback: callback, args: args };
tasksByHandle[nextHandle] = task;
registerImmediate(nextHandle);
return nextHandle++;
}
function clearImmediate(handle) {
delete tasksByHandle[handle];
}
function run(task) {
var callback = task.callback;
var args = task.args;
switch (args.length) {
case 0:
callback();
break;
case 1:
callback(args[0]);
break;
case 2:
callback(args[0], args[1]);
break;
case 3:
callback(args[0], args[1], args[2]);
break;
default:
callback.apply(undefined$1, args);
break;
}
}
function runIfPresent(handle) {
// From the spec: "Wait until any invocations of this algorithm started before this one have completed."
// So if we're currently running a task, we'll need to delay this invocation.
if (currentlyRunningATask) {
// Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a
// "too much recursion" error.
setTimeout(runIfPresent, 0, handle);
} else {
var task = tasksByHandle[handle];
if (task) {
currentlyRunningATask = true;
try {
run(task);
} finally {
clearImmediate(handle);
currentlyRunningATask = false;
}
}
}
}
function installNextTickImplementation() {
registerImmediate = function(handle) {
process.nextTick(function () { runIfPresent(handle); });
};
}
function canUsePostMessage() {
// The test against `importScripts` prevents this implementation from being installed inside a web worker,
// where `global.postMessage` means something completely different and can't be used for this purpose.
if (global.postMessage && !global.importScripts) {
var postMessageIsAsynchronous = true;
var oldOnMessage = global.onmessage;
global.onmessage = function() {
postMessageIsAsynchronous = false;
};
global.postMessage("", "*");
global.onmessage = oldOnMessage;
return postMessageIsAsynchronous;
}
}
function installPostMessageImplementation() {
// Installs an event handler on `global` for the `message` event: see
// * https://developer.mozilla.org/en/DOM/window.postMessage
// * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages
var messagePrefix = "setImmediate$" + Math.random() + "$";
var onGlobalMessage = function(event) {
if (event.source === global &&
typeof event.data === "string" &&
event.data.indexOf(messagePrefix) === 0) {
runIfPresent(+event.data.slice(messagePrefix.length));
}
};
if (global.addEventListener) {
global.addEventListener("message", onGlobalMessage, false);
} else {
global.attachEvent("onmessage", onGlobalMessage);
}
registerImmediate = function(handle) {
global.postMessage(messagePrefix + handle, "*");
};
}
function installMessageChannelImplementation() {
var channel = new MessageChannel();
channel.port1.onmessage = function(event) {
var handle = event.data;
runIfPresent(handle);
};
registerImmediate = function(handle) {
channel.port2.postMessage(handle);
};
}
function installReadyStateChangeImplementation() {
var html = doc.documentElement;
registerImmediate = function(handle) {
// Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted
// into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.
var script = doc.createElement("script");
script.onreadystatechange = function () {
runIfPresent(handle);
script.onreadystatechange = null;
html.removeChild(script);
script = null;
};
html.appendChild(script);
};
}
function installSetTimeoutImplementation() {
registerImmediate = function(handle) {
setTimeout(runIfPresent, 0, handle);
};
}
// If supported, we should attach to the prototype of global, since that is where setTimeout et al. live.
var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global);
attachTo = attachTo && attachTo.setTimeout ? attachTo : global;
// Don't get fooled by e.g. browserify environments.
if ({}.toString.call(global.process) === "[object process]") {
// For Node.js before 0.9
installNextTickImplementation();
} else if (canUsePostMessage()) {
// For non-IE10 modern browsers
installPostMessageImplementation();
} else if (global.MessageChannel) {
// For web workers, where supported
installMessageChannelImplementation();
} else if (doc && "onreadystatechange" in doc.createElement("script")) {
// For IE 6–8
installReadyStateChangeImplementation();
} else {
// For older browsers
installSetTimeoutImplementation();
}
attachTo.setImmediate = setImmediate;
attachTo.clearImmediate = clearImmediate;
}(typeof self === "undefined" ? typeof commonjsGlobal === "undefined" ? commonjsGlobal : commonjsGlobal : self));
export { setImmediate as default };
| var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
var setImmediate = {};
// FILE: setImmediate.js
(function (global, undefined$1) {
if (global.setImmediate) {
return;
}
var nextHandle = 1; // Spec says greater than zero
var tasksByHandle = {};
var currentlyRunningATask = false;
var doc = global.document;
var registerImmediate;
function setImmediate(callback) {
// Callback can either be a function or a string
if (typeof callback !== "function") {
callback = new Function("" + callback);
}
// Copy function arguments
var args = new Array(arguments.length - 1);
for (var i = 0; i < args.length; i++) {
args[i] = arguments[i + 1];
}
// Store and register the task
var task = { callback: callback, args: args };
tasksByHandle[nextHandle] = task;
registerImmediate(nextHandle);
return nextHandle++;
}
function clearImmediate(handle) {
delete tasksByHandle[handle];
}
function run(task) {
var callback = task.callback;
var args = task.args;
switch (args.length) {
case 0:
callback();
break;
case 1:
callback(args[0]);
break;
case 2:
callback(args[0], args[1]);
break;
case 3:
callback(args[0], args[1], args[2]);
break;
default:
callback.apply(undefined$1, args);
break;
}
}
function runIfPresent(handle) {
// From the spec: "Wait until any invocations of this algorithm started before this one have completed."
// So if we're currently running a task, we'll need to delay this invocation.
if (currentlyRunningATask) {
// Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a
// "too much recursion" error.
setTimeout(runIfPresent, 0, handle);
} else {
var task = tasksByHandle[handle];
if (task) {
currentlyRunningATask = true;
try {
run(task);
} finally {
clearImmediate(handle);
currentlyRunningATask = false;
}
}
}
}
function installNextTickImplementation() {
registerImmediate = function(handle) {
process.nextTick(function () { runIfPresent(handle); });
};
}
function canUsePostMessage() {
// The test against `importScripts` prevents this implementation from being installed inside a web worker,
// where `global.postMessage` means something completely different and can't be used for this purpose.
if (global.postMessage && !global.importScripts) {
var postMessageIsAsynchronous = true;
var oldOnMessage = global.onmessage;
global.onmessage = function() {
postMessageIsAsynchronous = false;
};
global.postMessage("", "*");
global.onmessage = oldOnMessage;
return postMessageIsAsynchronous;
}
}
function installPostMessageImplementation() {
// Installs an event handler on `global` for the `message` event: see
// * https://developer.mozilla.org/en/DOM/window.postMessage
// * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages
var messagePrefix = "setImmediate$" + Math.random() + "$";
var onGlobalMessage = function(event) {
if (event.source === global &&
typeof event.data === "string" &&
event.data.indexOf(messagePrefix) === 0) {
runIfPresent(+event.data.slice(messagePrefix.length));
}
};
if (global.addEventListener) {
global.addEventListener("message", onGlobalMessage, false);
} else {
global.attachEvent("onmessage", onGlobalMessage);
}
registerImmediate = function(handle) {
global.postMessage(messagePrefix + handle, "*");
};
}
function installMessageChannelImplementation() {
var channel = new MessageChannel();
channel.port1.onmessage = function(event) {
var handle = event.data;
runIfPresent(handle);
};
registerImmediate = function(handle) {
channel.port2.postMessage(handle);
};
}
function installReadyStateChangeImplementation() {
var html = doc.documentElement;
registerImmediate = function(handle) {
// Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted
// into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.
var script = doc.createElement("script");
script.onreadystatechange = function () {
runIfPresent(handle);
script.onreadystatechange = null;
html.removeChild(script);
script = null;
};
html.appendChild(script);
};
}
function installSetTimeoutImplementation() {
registerImmediate = function(handle) {
setTimeout(runIfPresent, 0, handle);
};
}
// If supported, we should attach to the prototype of global, since that is where setTimeout et al. live.
var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global);
attachTo = attachTo && attachTo.setTimeout ? attachTo : global;
// Don't get fooled by e.g. browserify environments.
if ({}.toString.call(global.process) === "[object process]") {
// For Node.js before 0.9
installNextTickImplementation();
} else if (canUsePostMessage()) {
// For non-IE10 modern browsers
installPostMessageImplementation();
} else if (global.MessageChannel) {
// For web workers, where supported
installMessageChannelImplementation();
} else if (doc && "onreadystatechange" in doc.createElement("script")) {
// For IE 6–8
installReadyStateChangeImplementation();
} else {
// For older browsers
installSetTimeoutImplementation();
}
attachTo.setImmediate = setImmediate;
attachTo.clearImmediate = clearImmediate;
}(typeof self === "undefined" ? typeof commonjsGlobal === "undefined" ? commonjsGlobal : commonjsGlobal : self));
export { setImmediate as default };
| 144 | 21 | 0 | 13 | 22 | 0 | 10 | 0 | 0 | 0 | 8 | 12.380952 | 1,446 | false |
source-map-url | top1k-untyped-nodeps | 1,713 | var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
function getDefaultExportFromCjs (x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
}
var sourceMapUrl$1 = {exports: {}};
// FILE: source-map-url.js
(function (module, exports) {
// Copyright 2014 Simon Lydell
// X11 (“MIT”) Licensed. (See LICENSE.)
void (function(root, factory) {
{
module.exports = factory();
}
}(commonjsGlobal, function() {
var innerRegex = /[#@] sourceMappingURL=([^\s'"]*)/;
var regex = RegExp(
"(?:" +
"/\\*" +
"(?:\\s*\r?\n(?://)?)?" +
"(?:" + innerRegex.source + ")" +
"\\s*" +
"\\*/" +
"|" +
"//(?:" + innerRegex.source + ")" +
")" +
"\\s*"
);
return {
regex: regex,
_innerRegex: innerRegex,
getFrom: function(code) {
var match = code.match(regex);
return (match ? match[1] || match[2] || "" : null)
},
existsIn: function(code) {
return regex.test(code)
},
removeFrom: function(code) {
return code.replace(regex, "")
},
insertBefore: function(code, string) {
var match = code.match(regex);
if (match) {
return code.slice(0, match.index) + string + code.slice(match.index)
} else {
return code + string
}
}
}
}));
} (sourceMapUrl$1));
var sourceMapUrlExports = sourceMapUrl$1.exports;
var sourceMapUrl = /*@__PURE__*/getDefaultExportFromCjs(sourceMapUrlExports);
export { sourceMapUrl as default };
| var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
function getDefaultExportFromCjs (x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
}
var sourceMapUrl$1 = {exports: {}};
// FILE: source-map-url.js
(function (module, exports) {
// Copyright 2014 Simon Lydell
// X11 (“MIT”) Licensed. (See LICENSE.)
void (function(root, factory) {
{
module.exports = factory();
}
}(commonjsGlobal, function() {
var innerRegex = /[#@] sourceMappingURL=([^\s'"]*)/;
var regex = RegExp(
"(?:" +
"/\\*" +
"(?:\\s*\r?\n(?://)?)?" +
"(?:" + innerRegex.source + ")" +
"\\s*" +
"\\*/" +
"|" +
"//(?:" + innerRegex.source + ")" +
")" +
"\\s*"
);
return {
regex: regex,
_innerRegex: innerRegex,
getFrom: function(code) {
var match = code.match(regex);
return (match ? match[1] || match[2] || "" : null)
},
existsIn: function(code) {
return regex.test(code)
},
removeFrom: function(code) {
return code.replace(regex, "")
},
insertBefore: function(code, string) {
var match = code.match(regex);
if (match) {
return code.slice(0, match.index) + string + code.slice(match.index)
} else {
return code + string
}
}
}
}));
} (sourceMapUrl$1));
var sourceMapUrlExports = sourceMapUrl$1.exports;
var sourceMapUrl = /*@__PURE__*/getDefaultExportFromCjs(sourceMapUrlExports);
export { sourceMapUrl as default };
| 51 | 8 | 0 | 10 | 8 | 0 | 1 | 0 | 0 | 0 | 4 | 11.25 | 494 | true |
which | top1k-typed-with-typed-deps | 3,508 | import require$$0 from 'path';
import require$$1 from 'isexe';
function getDefaultExportFromCjs (x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
}
// FILE: which.js
const isWindows = process.platform === 'win32' ||
process.env.OSTYPE === 'cygwin' ||
process.env.OSTYPE === 'msys';
const path = require$$0;
const COLON = isWindows ? ';' : ':';
const isexe = require$$1;
const getNotFoundError = (cmd) =>
Object.assign(new Error(`not found: ${cmd}`), { code: 'ENOENT' });
const getPathInfo = (cmd, opt) => {
const colon = opt.colon || COLON;
// If it has a slash, then we don't bother searching the pathenv.
// just check the file itself, and that's it.
const pathEnv = cmd.match(/\//) || isWindows && cmd.match(/\\/) ? ['']
: (
[
// windows always checks the cwd first
...(isWindows ? [process.cwd()] : []),
...(opt.path || process.env.PATH ||
/* istanbul ignore next: very unusual */ '').split(colon),
]
);
const pathExtExe = isWindows
? opt.pathExt || process.env.PATHEXT || '.EXE;.CMD;.BAT;.COM'
: '';
const pathExt = isWindows ? pathExtExe.split(colon) : [''];
if (isWindows) {
if (cmd.indexOf('.') !== -1 && pathExt[0] !== '')
pathExt.unshift('');
}
return {
pathEnv,
pathExt,
pathExtExe,
}
};
const which = (cmd, opt, cb) => {
if (typeof opt === 'function') {
cb = opt;
opt = {};
}
if (!opt)
opt = {};
const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
const found = [];
const step = i => new Promise((resolve, reject) => {
if (i === pathEnv.length)
return opt.all && found.length ? resolve(found)
: reject(getNotFoundError(cmd))
const ppRaw = pathEnv[i];
const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
const pCmd = path.join(pathPart, cmd);
const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd
: pCmd;
resolve(subStep(p, i, 0));
});
const subStep = (p, i, ii) => new Promise((resolve, reject) => {
if (ii === pathExt.length)
return resolve(step(i + 1))
const ext = pathExt[ii];
isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
if (!er && is) {
if (opt.all)
found.push(p + ext);
else
return resolve(p + ext)
}
return resolve(subStep(p, i, ii + 1))
});
});
return cb ? step(0).then(res => cb(null, res), cb) : step(0)
};
const whichSync = (cmd, opt) => {
opt = opt || {};
const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
const found = [];
for (let i = 0; i < pathEnv.length; i ++) {
const ppRaw = pathEnv[i];
const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
const pCmd = path.join(pathPart, cmd);
const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd
: pCmd;
for (let j = 0; j < pathExt.length; j ++) {
const cur = p + pathExt[j];
try {
const is = isexe.sync(cur, { pathExt: pathExtExe });
if (is) {
if (opt.all)
found.push(cur);
else
return cur
}
} catch (ex) {}
}
}
if (opt.all && found.length)
return found
if (opt.nothrow)
return null
throw getNotFoundError(cmd)
};
var which_1 = which;
which.sync = whichSync;
var which$1 = /*@__PURE__*/getDefaultExportFromCjs(which_1);
export { which$1 as default };
| import require$$0 from 'path';
import require$$1 from 'isexe';
function getDefaultExportFromCjs (x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
}
// FILE: which.js
const isWindows = process.platform === 'win32' ||
process.env.OSTYPE === 'cygwin' ||
process.env.OSTYPE === 'msys';
const path = require$$0;
const COLON = isWindows ? ';' : ':';
const isexe = require$$1;
const getNotFoundError = (cmd) =>
Object.assign(new Error(`not found: ${cmd}`), { code: 'ENOENT' });
const getPathInfo = (cmd, opt) => {
const colon = opt.colon || COLON;
// If it has a slash, then we don't bother searching the pathenv.
// just check the file itself, and that's it.
const pathEnv = cmd.match(/\//) || isWindows && cmd.match(/\\/) ? ['']
: (
[
// windows always checks the cwd first
...(isWindows ? [process.cwd()] : []),
...(opt.path || process.env.PATH ||
/* istanbul ignore next: very unusual */ '').split(colon),
]
);
const pathExtExe = isWindows
? opt.pathExt || process.env.PATHEXT || '.EXE;.CMD;.BAT;.COM'
: '';
const pathExt = isWindows ? pathExtExe.split(colon) : [''];
if (isWindows) {
if (cmd.indexOf('.') !== -1 && pathExt[0] !== '')
pathExt.unshift('');
}
return {
pathEnv,
pathExt,
pathExtExe,
}
};
const which = (cmd, opt, cb) => {
if (typeof opt === 'function') {
cb = opt;
opt = {};
}
if (!opt)
opt = {};
const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
const found = [];
const step = i => new Promise((resolve, reject) => {
if (i === pathEnv.length)
return opt.all && found.length ? resolve(found)
: reject(getNotFoundError(cmd))
const ppRaw = pathEnv[i];
const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
const pCmd = path.join(pathPart, cmd);
const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd
: pCmd;
resolve(subStep(p, i, 0));
});
const subStep = (p, i, ii) => new Promise((resolve, reject) => {
if (ii === pathExt.length)
return resolve(step(i + 1))
const ext = pathExt[ii];
isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
if (!er && is) {
if (opt.all)
found.push(p + ext);
else
return resolve(p + ext)
}
return resolve(subStep(p, i, ii + 1))
});
});
return cb ? step(0).then(res => cb(null, res), cb) : step(0)
};
const whichSync = (cmd, opt) => {
opt = opt || {};
const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
const found = [];
for (let i = 0; i < pathEnv.length; i ++) {
const ppRaw = pathEnv[i];
const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
const pCmd = path.join(pathPart, cmd);
const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd
: pCmd;
for (let j = 0; j < pathExt.length; j ++) {
const cur = p + pathExt[j];
try {
const is = isexe.sync(cur, { pathExt: pathExtExe });
if (is) {
if (opt.all)
found.push(cur);
else
return cur
}
} catch (ex) {}
}
}
if (opt.all && found.length)
return found
if (opt.nothrow)
return null
throw getNotFoundError(cmd)
};
var which_1 = which;
which.sync = whichSync;
var which$1 = /*@__PURE__*/getDefaultExportFromCjs(which_1);
export { which$1 as default };
| 106 | 11 | 0 | 20 | 33 | 0 | 5 | 0 | 0 | 0 | 1 | 12.636364 | 1,135 | true |
acorn-import-assertions | top1k-untyped-nodeps | 7,561 | import * as _acorn from 'acorn';
// FILE: src/index.js
const leftCurlyBrace = "{".charCodeAt(0);
const space = " ".charCodeAt(0);
const keyword = "assert";
const FUNC_STATEMENT = 1, FUNC_NULLABLE_ID = 4;
function importAssertions(Parser) {
// Use supplied version acorn version if present, to avoid
// reference mismatches due to different acorn versions. This
// allows this plugin to be used with Rollup which supplies
// its own internal version of acorn and thereby sidesteps
// the package manager.
const acorn = Parser.acorn || _acorn;
const { tokTypes: tt, TokenType } = acorn;
return class extends Parser {
constructor(...args) {
super(...args);
this.assertToken = new TokenType(keyword);
}
_codeAt(i) {
return this.input.charCodeAt(i);
}
_eat(t) {
if (this.type !== t) {
this.unexpected();
}
this.next();
}
readToken(code) {
let i = 0;
for (; i < keyword.length; i++) {
if (this._codeAt(this.pos + i) !== keyword.charCodeAt(i)) {
return super.readToken(code);
}
}
// ensure that the keyword is at the correct location
// ie `assert{...` or `assert {...`
for (;; i++) {
if (this._codeAt(this.pos + i) === leftCurlyBrace) {
// Found '{'
break;
} else if (this._codeAt(this.pos + i) === space) {
// white space is allowed between `assert` and `{`, so continue.
continue;
} else {
return super.readToken(code);
}
}
// If we're inside a dynamic import expression we'll parse
// the `assert` keyword as a standard object property name
// ie `import(""./foo.json", { assert: { type: "json" } })`
if (this.type.label === "{") {
return super.readToken(code);
}
this.pos += keyword.length;
return this.finishToken(this.assertToken);
}
parseDynamicImport(node) {
this.next(); // skip `(`
// Parse node.source.
node.source = this.parseMaybeAssign();
if (this.eat(tt.comma)) {
const obj = this.parseObj(false);
node.arguments = [obj];
}
this._eat(tt.parenR);
return this.finishNode(node, "ImportExpression");
}
// ported from acorn/src/statement.js pp.parseExport
parseExport(node, exports) {
this.next();
// export * from '...'
if (this.eat(tt.star)) {
if (this.options.ecmaVersion >= 11) {
if (this.eatContextual("as")) {
node.exported = this.parseIdent(true);
this.checkExport(exports, node.exported.name, this.lastTokStart);
} else {
node.exported = null;
}
}
this.expectContextual("from");
if (this.type !== tt.string) { this.unexpected(); }
node.source = this.parseExprAtom();
if (this.type === this.assertToken) {
this.next();
const assertions = this.parseImportAssertions();
if (assertions) {
node.assertions = assertions;
}
}
this.semicolon();
return this.finishNode(node, "ExportAllDeclaration")
}
if (this.eat(tt._default)) { // export default ...
this.checkExport(exports, "default", this.lastTokStart);
var isAsync;
if (this.type === tt._function || (isAsync = this.isAsyncFunction())) {
var fNode = this.startNode();
this.next();
if (isAsync) { this.next(); }
node.declaration = this.parseFunction(fNode, FUNC_STATEMENT | FUNC_NULLABLE_ID, false, isAsync);
} else if (this.type === tt._class) {
var cNode = this.startNode();
node.declaration = this.parseClass(cNode, "nullableID");
} else {
node.declaration = this.parseMaybeAssign();
this.semicolon();
}
return this.finishNode(node, "ExportDefaultDeclaration")
}
// export var|const|let|function|class ...
if (this.shouldParseExportStatement()) {
node.declaration = this.parseStatement(null);
if (node.declaration.type === "VariableDeclaration")
{ this.checkVariableExport(exports, node.declaration.declarations); }
else
{ this.checkExport(exports, node.declaration.id.name, node.declaration.id.start); }
node.specifiers = [];
node.source = null;
} else { // export { x, y as z } [from '...']
node.declaration = null;
node.specifiers = this.parseExportSpecifiers(exports);
if (this.eatContextual("from")) {
if (this.type !== tt.string) { this.unexpected(); }
node.source = this.parseExprAtom();
if (this.type === this.assertToken) {
this.next();
const assertions = this.parseImportAssertions();
if (assertions) {
node.assertions = assertions;
}
}
} else {
for (var i = 0, list = node.specifiers; i < list.length; i += 1) {
// check for keywords used as local names
var spec = list[i];
this.checkUnreserved(spec.local);
// check if export is defined
this.checkLocalExport(spec.local);
}
node.source = null;
}
this.semicolon();
}
return this.finishNode(node, "ExportNamedDeclaration")
}
parseImport(node) {
this.next();
// import '...'
if (this.type === tt.string) {
node.specifiers = [];
node.source = this.parseExprAtom();
} else {
node.specifiers = this.parseImportSpecifiers();
this.expectContextual("from");
node.source =
this.type === tt.string ? this.parseExprAtom() : this.unexpected();
}
if (this.type === this.assertToken) {
this.next();
const assertions = this.parseImportAssertions();
if (assertions) {
node.assertions = assertions;
}
}
this.semicolon();
return this.finishNode(node, "ImportDeclaration");
}
parseImportAssertions() {
this._eat(tt.braceL);
const attrs = this.parseAssertEntries();
this._eat(tt.braceR);
return attrs;
}
parseAssertEntries() {
const attrs = [];
const attrNames = new Set();
do {
if (this.type === tt.braceR) {
break;
}
const node = this.startNode();
// parse AssertionKey : IdentifierName, StringLiteral
let assertionKeyNode;
if (this.type === tt.string) {
assertionKeyNode = this.parseLiteral(this.value);
} else {
assertionKeyNode = this.parseIdent(true);
}
this.next();
node.key = assertionKeyNode;
// check if we already have an entry for an attribute
// if a duplicate entry is found, throw an error
// for now this logic will come into play only when someone declares `type` twice
if (attrNames.has(node.key.name)) {
this.raise(this.pos, "Duplicated key in assertions");
}
attrNames.add(node.key.name);
if (this.type !== tt.string) {
this.raise(
this.pos,
"Only string is supported as an assertion value"
);
}
node.value = this.parseLiteral(this.value);
attrs.push(this.finishNode(node, "ImportAttribute"));
} while (this.eat(tt.comma));
return attrs;
}
};
}
export { importAssertions };
| import * as _acorn from 'acorn';
// FILE: src/index.js
const leftCurlyBrace = "{".charCodeAt(0);
const space = " ".charCodeAt(0);
const keyword = "assert";
const FUNC_STATEMENT = 1, FUNC_NULLABLE_ID = 4;
function importAssertions(Parser) {
// Use supplied version acorn version if present, to avoid
// reference mismatches due to different acorn versions. This
// allows this plugin to be used with Rollup which supplies
// its own internal version of acorn and thereby sidesteps
// the package manager.
const acorn = Parser.acorn || _acorn;
const { tokTypes: tt, TokenType } = acorn;
return class extends Parser {
constructor(...args) {
super(...args);
this.assertToken = new TokenType(keyword);
}
_codeAt(i) {
return this.input.charCodeAt(i);
}
_eat(t) {
if (this.type !== t) {
this.unexpected();
}
this.next();
}
readToken(code) {
let i = 0;
for (; i < keyword.length; i++) {
if (this._codeAt(this.pos + i) !== keyword.charCodeAt(i)) {
return super.readToken(code);
}
}
// ensure that the keyword is at the correct location
// ie `assert{...` or `assert {...`
for (;; i++) {
if (this._codeAt(this.pos + i) === leftCurlyBrace) {
// Found '{'
break;
} else if (this._codeAt(this.pos + i) === space) {
// white space is allowed between `assert` and `{`, so continue.
continue;
} else {
return super.readToken(code);
}
}
// If we're inside a dynamic import expression we'll parse
// the `assert` keyword as a standard object property name
// ie `import(""./foo.json", { assert: { type: "json" } })`
if (this.type.label === "{") {
return super.readToken(code);
}
this.pos += keyword.length;
return this.finishToken(this.assertToken);
}
parseDynamicImport(node) {
this.next(); // skip `(`
// Parse node.source.
node.source = this.parseMaybeAssign();
if (this.eat(tt.comma)) {
const obj = this.parseObj(false);
node.arguments = [obj];
}
this._eat(tt.parenR);
return this.finishNode(node, "ImportExpression");
}
// ported from acorn/src/statement.js pp.parseExport
parseExport(node, exports) {
this.next();
// export * from '...'
if (this.eat(tt.star)) {
if (this.options.ecmaVersion >= 11) {
if (this.eatContextual("as")) {
node.exported = this.parseIdent(true);
this.checkExport(exports, node.exported.name, this.lastTokStart);
} else {
node.exported = null;
}
}
this.expectContextual("from");
if (this.type !== tt.string) { this.unexpected(); }
node.source = this.parseExprAtom();
if (this.type === this.assertToken) {
this.next();
const assertions = this.parseImportAssertions();
if (assertions) {
node.assertions = assertions;
}
}
this.semicolon();
return this.finishNode(node, "ExportAllDeclaration")
}
if (this.eat(tt._default)) { // export default ...
this.checkExport(exports, "default", this.lastTokStart);
var isAsync;
if (this.type === tt._function || (isAsync = this.isAsyncFunction())) {
var fNode = this.startNode();
this.next();
if (isAsync) { this.next(); }
node.declaration = this.parseFunction(fNode, FUNC_STATEMENT | FUNC_NULLABLE_ID, false, isAsync);
} else if (this.type === tt._class) {
var cNode = this.startNode();
node.declaration = this.parseClass(cNode, "nullableID");
} else {
node.declaration = this.parseMaybeAssign();
this.semicolon();
}
return this.finishNode(node, "ExportDefaultDeclaration")
}
// export var|const|let|function|class ...
if (this.shouldParseExportStatement()) {
node.declaration = this.parseStatement(null);
if (node.declaration.type === "VariableDeclaration")
{ this.checkVariableExport(exports, node.declaration.declarations); }
else
{ this.checkExport(exports, node.declaration.id.name, node.declaration.id.start); }
node.specifiers = [];
node.source = null;
} else { // export { x, y as z } [from '...']
node.declaration = null;
node.specifiers = this.parseExportSpecifiers(exports);
if (this.eatContextual("from")) {
if (this.type !== tt.string) { this.unexpected(); }
node.source = this.parseExprAtom();
if (this.type === this.assertToken) {
this.next();
const assertions = this.parseImportAssertions();
if (assertions) {
node.assertions = assertions;
}
}
} else {
for (var i = 0, list = node.specifiers; i < list.length; i += 1) {
// check for keywords used as local names
var spec = list[i];
this.checkUnreserved(spec.local);
// check if export is defined
this.checkLocalExport(spec.local);
}
node.source = null;
}
this.semicolon();
}
return this.finishNode(node, "ExportNamedDeclaration")
}
parseImport(node) {
this.next();
// import '...'
if (this.type === tt.string) {
node.specifiers = [];
node.source = this.parseExprAtom();
} else {
node.specifiers = this.parseImportSpecifiers();
this.expectContextual("from");
node.source =
this.type === tt.string ? this.parseExprAtom() : this.unexpected();
}
if (this.type === this.assertToken) {
this.next();
const assertions = this.parseImportAssertions();
if (assertions) {
node.assertions = assertions;
}
}
this.semicolon();
return this.finishNode(node, "ImportDeclaration");
}
parseImportAssertions() {
this._eat(tt.braceL);
const attrs = this.parseAssertEntries();
this._eat(tt.braceR);
return attrs;
}
parseAssertEntries() {
const attrs = [];
const attrNames = new Set();
do {
if (this.type === tt.braceR) {
break;
}
const node = this.startNode();
// parse AssertionKey : IdentifierName, StringLiteral
let assertionKeyNode;
if (this.type === tt.string) {
assertionKeyNode = this.parseLiteral(this.value);
} else {
assertionKeyNode = this.parseIdent(true);
}
this.next();
node.key = assertionKeyNode;
// check if we already have an entry for an attribute
// if a duplicate entry is found, throw an error
// for now this logic will come into play only when someone declares `type` twice
if (attrNames.has(node.key.name)) {
this.raise(this.pos, "Duplicated key in assertions");
}
attrNames.add(node.key.name);
if (this.type !== tt.string) {
this.raise(
this.pos,
"Only string is supported as an assertion value"
);
}
node.value = this.parseLiteral(this.value);
attrs.push(this.finishNode(node, "ImportAttribute"));
} while (this.eat(tt.comma));
return attrs;
}
};
}
export { importAssertions };
| 189 | 10 | 0 | 9 | 23 | 0 | 5 | 0 | 0 | 0 | 0 | 34 | 1,898 | false |
through2 | top1k-typed-with-typed-deps | 2,318 | import require$$0 from 'readable-stream';
function getDefaultExportFromCjs (x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
}
var through2$2 = {exports: {}};
// FILE: through2.js
const { Transform } = require$$0;
function inherits (fn, sup) {
fn.super_ = sup;
fn.prototype = Object.create(sup.prototype, {
constructor: { value: fn, enumerable: false, writable: true, configurable: true }
});
}
// create a new export function, used by both the main export and
// the .ctor export, contains common logic for dealing with arguments
function through2 (construct) {
return (options, transform, flush) => {
if (typeof options === 'function') {
flush = transform;
transform = options;
options = {};
}
if (typeof transform !== 'function') {
// noop
transform = (chunk, enc, cb) => cb(null, chunk);
}
if (typeof flush !== 'function') {
flush = null;
}
return construct(options, transform, flush)
}
}
// main export, just make me a transform stream!
const make = through2((options, transform, flush) => {
const t2 = new Transform(options);
t2._transform = transform;
if (flush) {
t2._flush = flush;
}
return t2
});
// make me a reusable prototype that I can `new`, or implicitly `new`
// with a constructor call
const ctor = through2((options, transform, flush) => {
function Through2 (override) {
if (!(this instanceof Through2)) {
return new Through2(override)
}
this.options = Object.assign({}, options, override);
Transform.call(this, this.options);
this._transform = transform;
if (flush) {
this._flush = flush;
}
}
inherits(Through2, Transform);
return Through2
});
const obj = through2(function (options, transform, flush) {
const t2 = new Transform(Object.assign({ objectMode: true, highWaterMark: 16 }, options));
t2._transform = transform;
if (flush) {
t2._flush = flush;
}
return t2
});
through2$2.exports = make;
var ctor_1 = through2$2.exports.ctor = ctor;
var obj_1 = through2$2.exports.obj = obj;
var through2Exports = through2$2.exports;
var through2$1 = /*@__PURE__*/getDefaultExportFromCjs(through2Exports);
export { ctor_1 as ctor, through2$1 as default, obj_1 as obj };
| import require$$0 from 'readable-stream';
function getDefaultExportFromCjs (x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
}
var through2$2 = {exports: {}};
// FILE: through2.js
const { Transform } = require$$0;
function inherits (fn, sup) {
fn.super_ = sup;
fn.prototype = Object.create(sup.prototype, {
constructor: { value: fn, enumerable: false, writable: true, configurable: true }
});
}
// create a new export function, used by both the main export and
// the .ctor export, contains common logic for dealing with arguments
function through2 (construct) {
return (options, transform, flush) => {
if (typeof options === 'function') {
flush = transform;
transform = options;
options = {};
}
if (typeof transform !== 'function') {
// noop
transform = (chunk, enc, cb) => cb(null, chunk);
}
if (typeof flush !== 'function') {
flush = null;
}
return construct(options, transform, flush)
}
}
// main export, just make me a transform stream!
const make = through2((options, transform, flush) => {
const t2 = new Transform(options);
t2._transform = transform;
if (flush) {
t2._flush = flush;
}
return t2
});
// make me a reusable prototype that I can `new`, or implicitly `new`
// with a constructor call
const ctor = through2((options, transform, flush) => {
function Through2 (override) {
if (!(this instanceof Through2)) {
return new Through2(override)
}
this.options = Object.assign({}, options, override);
Transform.call(this, this.options);
this._transform = transform;
if (flush) {
this._flush = flush;
}
}
inherits(Through2, Transform);
return Through2
});
const obj = through2(function (options, transform, flush) {
const t2 = new Transform(Object.assign({ objectMode: true, highWaterMark: 16 }, options));
t2._transform = transform;
if (flush) {
t2._flush = flush;
}
return t2
});
through2$2.exports = make;
var ctor_1 = through2$2.exports.ctor = ctor;
var obj_1 = through2$2.exports.obj = obj;
var through2Exports = through2$2.exports;
var through2$1 = /*@__PURE__*/getDefaultExportFromCjs(through2Exports);
export { ctor_1 as ctor, through2$1 as default, obj_1 as obj };
| 65 | 9 | 0 | 20 | 11 | 0 | 3 | 0 | 0 | 0 | 4 | 7.333333 | 662 | false |
asynckit | top1k-untyped-nodeps | 8,630 | function getDefaultExportFromCjs (x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
}
// FILE: lib/defer.js
var defer_1 = defer$1;
/**
* Runs provided function on next iteration of the event loop
*
* @param {function} fn - function to run
*/
function defer$1(fn)
{
var nextTick = typeof setImmediate == 'function'
? setImmediate
: (
typeof process == 'object' && typeof process.nextTick == 'function'
? process.nextTick
: null
);
if (nextTick)
{
nextTick(fn);
}
else
{
setTimeout(fn, 0);
}
}
// FILE: lib/async.js
var defer = defer_1;
// API
var async_1 = async$2;
/**
* Runs provided callback asynchronously
* even if callback itself is not
*
* @param {function} callback - callback to invoke
* @returns {function} - augmented callback
*/
function async$2(callback)
{
var isAsync = false;
// check if async happened
defer(function() { isAsync = true; });
return function async_callback(err, result)
{
if (isAsync)
{
callback(err, result);
}
else
{
defer(function nextTick_callback()
{
callback(err, result);
});
}
};
}
// FILE: lib/abort.js
// API
var abort_1 = abort$2;
/**
* Aborts leftover active jobs
*
* @param {object} state - current state object
*/
function abort$2(state)
{
Object.keys(state.jobs).forEach(clean.bind(state));
// reset leftover jobs
state.jobs = {};
}
/**
* Cleans up leftover job by invoking abort function for the provided job id
*
* @this state
* @param {string|number} key - job id to abort
*/
function clean(key)
{
if (typeof this.jobs[key] == 'function')
{
this.jobs[key]();
}
}
// FILE: lib/iterate.js
var async$1 = async_1
, abort$1 = abort_1
;
// API
var iterate_1 = iterate$2;
/**
* Iterates over each job object
*
* @param {array|object} list - array or object (named list) to iterate over
* @param {function} iterator - iterator to run
* @param {object} state - current job status
* @param {function} callback - invoked when all elements processed
*/
function iterate$2(list, iterator, state, callback)
{
// store current index
var key = state['keyedList'] ? state['keyedList'][state.index] : state.index;
state.jobs[key] = runJob(iterator, key, list[key], function(error, output)
{
// don't repeat yourself
// skip secondary callbacks
if (!(key in state.jobs))
{
return;
}
// clean up jobs
delete state.jobs[key];
if (error)
{
// don't process rest of the results
// stop still active jobs
// and reset the list
abort$1(state);
}
else
{
state.results[key] = output;
}
// return salvaged results
callback(error, state.results);
});
}
/**
* Runs iterator over provided job element
*
* @param {function} iterator - iterator to invoke
* @param {string|number} key - key/index of the element in the list of jobs
* @param {mixed} item - job description
* @param {function} callback - invoked after iterator is done with the job
* @returns {function|mixed} - job abort function or something else
*/
function runJob(iterator, key, item, callback)
{
var aborter;
// allow shortcut if iterator expects only two arguments
if (iterator.length == 2)
{
aborter = iterator(item, async$1(callback));
}
// otherwise go with full three arguments
else
{
aborter = iterator(item, key, async$1(callback));
}
return aborter;
}
// FILE: lib/state.js
// API
var state_1 = state;
/**
* Creates initial state object
* for iteration over list
*
* @param {array|object} list - list to iterate over
* @param {function|null} sortMethod - function to use for keys sort,
* or `null` to keep them as is
* @returns {object} - initial state object
*/
function state(list, sortMethod)
{
var isNamedList = !Array.isArray(list)
, initState =
{
index : 0,
keyedList: isNamedList || sortMethod ? Object.keys(list) : null,
jobs : {},
results : isNamedList ? {} : [],
size : isNamedList ? Object.keys(list).length : list.length
}
;
if (sortMethod)
{
// sort array keys based on it's values
// sort object's keys just on own merit
initState.keyedList.sort(isNamedList ? sortMethod : function(a, b)
{
return sortMethod(list[a], list[b]);
});
}
return initState;
}
// FILE: lib/terminator.js
var abort = abort_1
, async = async_1
;
// API
var terminator_1 = terminator$2;
/**
* Terminates jobs in the attached state context
*
* @this AsyncKitState#
* @param {function} callback - final callback to invoke after termination
*/
function terminator$2(callback)
{
if (!Object.keys(this.jobs).length)
{
return;
}
// fast forward iteration index
this.index = this.size;
// abort jobs
abort(this);
// send back results we have so far
async(callback)(null, this.results);
}
// FILE: parallel.js
var iterate$1 = iterate_1
, initState$1 = state_1
, terminator$1 = terminator_1
;
// Public API
var parallel_1 = parallel;
/**
* Runs iterator over provided array elements in parallel
*
* @param {array|object} list - array or object (named list) to iterate over
* @param {function} iterator - iterator to run
* @param {function} callback - invoked when all elements processed
* @returns {function} - jobs terminator
*/
function parallel(list, iterator, callback)
{
var state = initState$1(list);
while (state.index < (state['keyedList'] || list).length)
{
iterate$1(list, iterator, state, function(error, result)
{
if (error)
{
callback(error, result);
return;
}
// looks like it's the last one
if (Object.keys(state.jobs).length === 0)
{
callback(null, state.results);
return;
}
});
state.index++;
}
return terminator$1.bind(state, callback);
}
var serialOrdered$2 = {exports: {}};
// FILE: serialOrdered.js
var iterate = iterate_1
, initState = state_1
, terminator = terminator_1
;
// Public API
serialOrdered$2.exports = serialOrdered$1;
// sorting helpers
serialOrdered$2.exports.ascending = ascending;
serialOrdered$2.exports.descending = descending;
/**
* Runs iterator over provided sorted array elements in series
*
* @param {array|object} list - array or object (named list) to iterate over
* @param {function} iterator - iterator to run
* @param {function} sortMethod - custom sort function
* @param {function} callback - invoked when all elements processed
* @returns {function} - jobs terminator
*/
function serialOrdered$1(list, iterator, sortMethod, callback)
{
var state = initState(list, sortMethod);
iterate(list, iterator, state, function iteratorHandler(error, result)
{
if (error)
{
callback(error, result);
return;
}
state.index++;
// are we there yet?
if (state.index < (state['keyedList'] || list).length)
{
iterate(list, iterator, state, iteratorHandler);
return;
}
// done here
callback(null, state.results);
});
return terminator.bind(state, callback);
}
/*
* -- Sort methods
*/
/**
* sort helper to sort array elements in ascending order
*
* @param {mixed} a - an item to compare
* @param {mixed} b - an item to compare
* @returns {number} - comparison result
*/
function ascending(a, b)
{
return a < b ? -1 : a > b ? 1 : 0;
}
/**
* sort helper to sort array elements in descending order
*
* @param {mixed} a - an item to compare
* @param {mixed} b - an item to compare
* @returns {number} - comparison result
*/
function descending(a, b)
{
return -1 * ascending(a, b);
}
var serialOrderedExports = serialOrdered$2.exports;
// FILE: serial.js
var serialOrdered = serialOrderedExports;
// Public API
var serial_1 = serial;
/**
* Runs iterator over provided array elements in series
*
* @param {array|object} list - array or object (named list) to iterate over
* @param {function} iterator - iterator to run
* @param {function} callback - invoked when all elements processed
* @returns {function} - jobs terminator
*/
function serial(list, iterator, callback)
{
return serialOrdered(list, iterator, null, callback);
}
// FILE: index.js
var asynckit =
{
parallel : parallel_1,
serial : serial_1,
serialOrdered : serialOrderedExports
};
var index = /*@__PURE__*/getDefaultExportFromCjs(asynckit);
export { index as default };
| function getDefaultExportFromCjs (x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
}
// FILE: lib/defer.js
var defer_1 = defer$1;
/**
* Runs provided function on next iteration of the event loop
*
* @param {function} fn - function to run
*/
function defer$1(fn)
{
var nextTick = typeof setImmediate == 'function'
? setImmediate
: (
typeof process == 'object' && typeof process.nextTick == 'function'
? process.nextTick
: null
);
if (nextTick)
{
nextTick(fn);
}
else
{
setTimeout(fn, 0);
}
}
// FILE: lib/async.js
var defer = defer_1;
// API
var async_1 = async$2;
/**
* Runs provided callback asynchronously
* even if callback itself is not
*
* @param {function} callback - callback to invoke
* @returns {function} - augmented callback
*/
function async$2(callback)
{
var isAsync = false;
// check if async happened
defer(function() { isAsync = true; });
return function async_callback(err, result)
{
if (isAsync)
{
callback(err, result);
}
else
{
defer(function nextTick_callback()
{
callback(err, result);
});
}
};
}
// FILE: lib/abort.js
// API
var abort_1 = abort$2;
/**
* Aborts leftover active jobs
*
* @param {object} state - current state object
*/
function abort$2(state)
{
Object.keys(state.jobs).forEach(clean.bind(state));
// reset leftover jobs
state.jobs = {};
}
/**
* Cleans up leftover job by invoking abort function for the provided job id
*
* @this state
* @param {string|number} key - job id to abort
*/
function clean(key)
{
if (typeof this.jobs[key] == 'function')
{
this.jobs[key]();
}
}
// FILE: lib/iterate.js
var async$1 = async_1
, abort$1 = abort_1
;
// API
var iterate_1 = iterate$2;
/**
* Iterates over each job object
*
* @param {array|object} list - array or object (named list) to iterate over
* @param {function} iterator - iterator to run
* @param {object} state - current job status
* @param {function} callback - invoked when all elements processed
*/
function iterate$2(list, iterator, state, callback)
{
// store current index
var key = state['keyedList'] ? state['keyedList'][state.index] : state.index;
state.jobs[key] = runJob(iterator, key, list[key], function(error, output)
{
// don't repeat yourself
// skip secondary callbacks
if (!(key in state.jobs))
{
return;
}
// clean up jobs
delete state.jobs[key];
if (error)
{
// don't process rest of the results
// stop still active jobs
// and reset the list
abort$1(state);
}
else
{
state.results[key] = output;
}
// return salvaged results
callback(error, state.results);
});
}
/**
* Runs iterator over provided job element
*
* @param {function} iterator - iterator to invoke
* @param {string|number} key - key/index of the element in the list of jobs
* @param {mixed} item - job description
* @param {function} callback - invoked after iterator is done with the job
* @returns {function|mixed} - job abort function or something else
*/
function runJob(iterator, key, item, callback)
{
var aborter;
// allow shortcut if iterator expects only two arguments
if (iterator.length == 2)
{
aborter = iterator(item, async$1(callback));
}
// otherwise go with full three arguments
else
{
aborter = iterator(item, key, async$1(callback));
}
return aborter;
}
// FILE: lib/state.js
// API
var state_1 = state;
/**
* Creates initial state object
* for iteration over list
*
* @param {array|object} list - list to iterate over
* @param {function|null} sortMethod - function to use for keys sort,
* or `null` to keep them as is
* @returns {object} - initial state object
*/
function state(list, sortMethod)
{
var isNamedList = !Array.isArray(list)
, initState =
{
index : 0,
keyedList: isNamedList || sortMethod ? Object.keys(list) : null,
jobs : {},
results : isNamedList ? {} : [],
size : isNamedList ? Object.keys(list).length : list.length
}
;
if (sortMethod)
{
// sort array keys based on it's values
// sort object's keys just on own merit
initState.keyedList.sort(isNamedList ? sortMethod : function(a, b)
{
return sortMethod(list[a], list[b]);
});
}
return initState;
}
// FILE: lib/terminator.js
var abort = abort_1
, async = async_1
;
// API
var terminator_1 = terminator$2;
/**
* Terminates jobs in the attached state context
*
* @this AsyncKitState#
* @param {function} callback - final callback to invoke after termination
*/
function terminator$2(callback)
{
if (!Object.keys(this.jobs).length)
{
return;
}
// fast forward iteration index
this.index = this.size;
// abort jobs
abort(this);
// send back results we have so far
async(callback)(null, this.results);
}
// FILE: parallel.js
var iterate$1 = iterate_1
, initState$1 = state_1
, terminator$1 = terminator_1
;
// Public API
var parallel_1 = parallel;
/**
* Runs iterator over provided array elements in parallel
*
* @param {array|object} list - array or object (named list) to iterate over
* @param {function} iterator - iterator to run
* @param {function} callback - invoked when all elements processed
* @returns {function} - jobs terminator
*/
function parallel(list, iterator, callback)
{
var state = initState$1(list);
while (state.index < (state['keyedList'] || list).length)
{
iterate$1(list, iterator, state, function(error, result)
{
if (error)
{
callback(error, result);
return;
}
// looks like it's the last one
if (Object.keys(state.jobs).length === 0)
{
callback(null, state.results);
return;
}
});
state.index++;
}
return terminator$1.bind(state, callback);
}
var serialOrdered$2 = {exports: {}};
// FILE: serialOrdered.js
var iterate = iterate_1
, initState = state_1
, terminator = terminator_1
;
// Public API
serialOrdered$2.exports = serialOrdered$1;
// sorting helpers
serialOrdered$2.exports.ascending = ascending;
serialOrdered$2.exports.descending = descending;
/**
* Runs iterator over provided sorted array elements in series
*
* @param {array|object} list - array or object (named list) to iterate over
* @param {function} iterator - iterator to run
* @param {function} sortMethod - custom sort function
* @param {function} callback - invoked when all elements processed
* @returns {function} - jobs terminator
*/
function serialOrdered$1(list, iterator, sortMethod, callback)
{
var state = initState(list, sortMethod);
iterate(list, iterator, state, function iteratorHandler(error, result)
{
if (error)
{
callback(error, result);
return;
}
state.index++;
// are we there yet?
if (state.index < (state['keyedList'] || list).length)
{
iterate(list, iterator, state, iteratorHandler);
return;
}
// done here
callback(null, state.results);
});
return terminator.bind(state, callback);
}
/*
* -- Sort methods
*/
/**
* sort helper to sort array elements in ascending order
*
* @param {mixed} a - an item to compare
* @param {mixed} b - an item to compare
* @returns {number} - comparison result
*/
function ascending(a, b)
{
return a < b ? -1 : a > b ? 1 : 0;
}
/**
* sort helper to sort array elements in descending order
*
* @param {mixed} a - an item to compare
* @param {mixed} b - an item to compare
* @returns {number} - comparison result
*/
function descending(a, b)
{
return -1 * ascending(a, b);
}
var serialOrderedExports = serialOrdered$2.exports;
// FILE: serial.js
var serialOrdered = serialOrderedExports;
// Public API
var serial_1 = serial;
/**
* Runs iterator over provided array elements in series
*
* @param {array|object} list - array or object (named list) to iterate over
* @param {function} iterator - iterator to run
* @param {function} callback - invoked when all elements processed
* @returns {function} - jobs terminator
*/
function serial(list, iterator, callback)
{
return serialOrdered(list, iterator, null, callback);
}
// FILE: index.js
var asynckit =
{
parallel : parallel_1,
serial : serial_1,
serialOrdered : serialOrderedExports
};
var index = /*@__PURE__*/getDefaultExportFromCjs(asynckit);
export { index as default };
| 208 | 21 | 0 | 40 | 32 | 0 | 3 | 0 | 0 | 0 | 4 | 8.571429 | 2,474 | false |
glob-parent | top1k-typed-with-typed-deps | 1,932 | import require$$0 from 'is-glob';
import require$$1 from 'path';
import require$$2 from 'os';
function getDefaultExportFromCjs (x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
}
// FILE: index.js
var isGlob = require$$0;
var pathPosixDirname = require$$1.posix.dirname;
var isWin32 = require$$2.platform() === 'win32';
var slash = '/';
var backslash = /\\/g;
var escaped = /\\([!*?|[\](){}])/g;
/**
* @param {string} str
* @param {Object} opts
* @param {boolean} [opts.flipBackslashes=true]
*/
var globParent = function globParent(str, opts) {
var options = Object.assign({ flipBackslashes: true }, opts);
// flip windows path separators
if (options.flipBackslashes && isWin32 && str.indexOf(slash) < 0) {
str = str.replace(backslash, slash);
}
// special case for strings ending in enclosure containing path separator
if (isEnclosure(str)) {
str += slash;
}
// preserves full path in case of trailing path separator
str += 'a';
// remove path parts that are globby
do {
str = pathPosixDirname(str);
} while (isGlobby(str));
// remove escape chars and return result
return str.replace(escaped, '$1');
};
function isEnclosure(str) {
var lastChar = str.slice(-1);
var enclosureStart;
switch (lastChar) {
case '}':
enclosureStart = '{';
break;
case ']':
enclosureStart = '[';
break;
default:
return false;
}
var foundIndex = str.indexOf(enclosureStart);
if (foundIndex < 0) {
return false;
}
return str.slice(foundIndex + 1, -1).includes(slash);
}
function isGlobby(str) {
if (/\([^()]+$/.test(str)) {
return true;
}
if (str[0] === '{' || str[0] === '[') {
return true;
}
if (/[^\\][{[]/.test(str)) {
return true;
}
return isGlob(str);
}
var index = /*@__PURE__*/getDefaultExportFromCjs(globParent);
export { index as default };
| import require$$0 from 'is-glob';
import require$$1 from 'path';
import require$$2 from 'os';
function getDefaultExportFromCjs (x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
}
// FILE: index.js
var isGlob = require$$0;
var pathPosixDirname = require$$1.posix.dirname;
var isWin32 = require$$2.platform() === 'win32';
var slash = '/';
var backslash = /\\/g;
var escaped = /\\([!*?|[\](){}])/g;
/**
* @param {string} str
* @param {Object} opts
* @param {boolean} [opts.flipBackslashes=true]
*/
var globParent = function globParent(str, opts) {
var options = Object.assign({ flipBackslashes: true }, opts);
// flip windows path separators
if (options.flipBackslashes && isWin32 && str.indexOf(slash) < 0) {
str = str.replace(backslash, slash);
}
// special case for strings ending in enclosure containing path separator
if (isEnclosure(str)) {
str += slash;
}
// preserves full path in case of trailing path separator
str += 'a';
// remove path parts that are globby
do {
str = pathPosixDirname(str);
} while (isGlobby(str));
// remove escape chars and return result
return str.replace(escaped, '$1');
};
function isEnclosure(str) {
var lastChar = str.slice(-1);
var enclosureStart;
switch (lastChar) {
case '}':
enclosureStart = '{';
break;
case ']':
enclosureStart = '[';
break;
default:
return false;
}
var foundIndex = str.indexOf(enclosureStart);
if (foundIndex < 0) {
return false;
}
return str.slice(foundIndex + 1, -1).includes(slash);
}
function isGlobby(str) {
if (/\([^()]+$/.test(str)) {
return true;
}
if (str[0] === '{' || str[0] === '[') {
return true;
}
if (/[^\\][{[]/.test(str)) {
return true;
}
return isGlob(str);
}
var index = /*@__PURE__*/getDefaultExportFromCjs(globParent);
export { index as default };
| 59 | 4 | 0 | 5 | 12 | 0 | 3 | 0 | 0 | 0 | 0 | 10 | 604 | true |
figgy-pudding | top1k-untyped-nodeps | 4,970 | function getDefaultExportFromCjs (x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
}
// FILE: index.js
class FiggyPudding {
constructor (specs, opts, providers) {
this.__specs = specs || {};
Object.keys(this.__specs).forEach(alias => {
if (typeof this.__specs[alias] === 'string') {
const key = this.__specs[alias];
const realSpec = this.__specs[key];
if (realSpec) {
const aliasArr = realSpec.aliases || [];
aliasArr.push(alias, key);
realSpec.aliases = [...(new Set(aliasArr))];
this.__specs[alias] = realSpec;
} else {
throw new Error(`Alias refers to invalid key: ${key} -> ${alias}`)
}
}
});
this.__opts = opts || {};
this.__providers = reverse((providers).filter(
x => x != null && typeof x === 'object'
));
this.__isFiggyPudding = true;
}
get (key) {
return pudGet(this, key, true)
}
get [Symbol.toStringTag] () { return 'FiggyPudding' }
forEach (fn, thisArg = this) {
for (let [key, value] of this.entries()) {
fn.call(thisArg, value, key, this);
}
}
toJSON () {
const obj = {};
this.forEach((val, key) => {
obj[key] = val;
});
return obj
}
* entries (_matcher) {
for (let key of Object.keys(this.__specs)) {
yield [key, this.get(key)];
}
const matcher = _matcher || this.__opts.other;
if (matcher) {
const seen = new Set();
for (let p of this.__providers) {
const iter = p.entries ? p.entries(matcher) : entries(p);
for (let [key, val] of iter) {
if (matcher(key) && !seen.has(key)) {
seen.add(key);
yield [key, val];
}
}
}
}
}
* [Symbol.iterator] () {
for (let [key, value] of this.entries()) {
yield [key, value];
}
}
* keys () {
for (let [key] of this.entries()) {
yield key;
}
}
* values () {
for (let [, value] of this.entries()) {
yield value;
}
}
concat (...moreConfig) {
return new Proxy(new FiggyPudding(
this.__specs,
this.__opts,
reverse(this.__providers).concat(moreConfig)
), proxyHandler)
}
}
try {
const util = require('util');
FiggyPudding.prototype[util.inspect.custom] = function (depth, opts) {
return (
this[Symbol.toStringTag] + ' '
) + util.inspect(this.toJSON(), opts)
};
} catch (e) {}
function BadKeyError (key) {
throw Object.assign(new Error(
`invalid config key requested: ${key}`
), {code: 'EBADKEY'})
}
function pudGet (pud, key, validate) {
let spec = pud.__specs[key];
if (validate && !spec && (!pud.__opts.other || !pud.__opts.other(key))) {
BadKeyError(key);
} else {
if (!spec) { spec = {}; }
let ret;
for (let p of pud.__providers) {
ret = tryGet(key, p);
if (ret === undefined && spec.aliases && spec.aliases.length) {
for (let alias of spec.aliases) {
if (alias === key) { continue }
ret = tryGet(alias, p);
if (ret !== undefined) {
break
}
}
}
if (ret !== undefined) {
break
}
}
if (ret === undefined && spec.default !== undefined) {
if (typeof spec.default === 'function') {
return spec.default(pud)
} else {
return spec.default
}
} else {
return ret
}
}
}
function tryGet (key, p) {
let ret;
if (p.__isFiggyPudding) {
ret = pudGet(p, key, false);
} else if (typeof p.get === 'function') {
ret = p.get(key);
} else {
ret = p[key];
}
return ret
}
const proxyHandler = {
has (obj, prop) {
return prop in obj.__specs && pudGet(obj, prop, false) !== undefined
},
ownKeys (obj) {
return Object.keys(obj.__specs)
},
get (obj, prop) {
if (
typeof prop === 'symbol' ||
prop.slice(0, 2) === '__' ||
prop in FiggyPudding.prototype
) {
return obj[prop]
}
return obj.get(prop)
},
set (obj, prop, value) {
if (
typeof prop === 'symbol' ||
prop.slice(0, 2) === '__'
) {
obj[prop] = value;
return true
} else {
throw new Error('figgyPudding options cannot be modified. Use .concat() instead.')
}
},
deleteProperty () {
throw new Error('figgyPudding options cannot be deleted. Use .concat() and shadow them instead.')
}
};
var figgyPudding_1 = figgyPudding;
function figgyPudding (specs, opts) {
function factory (...providers) {
return new Proxy(new FiggyPudding(
specs,
opts,
providers
), proxyHandler)
}
return factory
}
function reverse (arr) {
const ret = [];
arr.forEach(x => ret.unshift(x));
return ret
}
function entries (obj) {
return Object.keys(obj).map(k => [k, obj[k]])
}
var index = /*@__PURE__*/getDefaultExportFromCjs(figgyPudding_1);
export { index as default };
| function getDefaultExportFromCjs (x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
}
// FILE: index.js
class FiggyPudding {
constructor (specs, opts, providers) {
this.__specs = specs || {};
Object.keys(this.__specs).forEach(alias => {
if (typeof this.__specs[alias] === 'string') {
const key = this.__specs[alias];
const realSpec = this.__specs[key];
if (realSpec) {
const aliasArr = realSpec.aliases || [];
aliasArr.push(alias, key);
realSpec.aliases = [...(new Set(aliasArr))];
this.__specs[alias] = realSpec;
} else {
throw new Error(`Alias refers to invalid key: ${key} -> ${alias}`)
}
}
});
this.__opts = opts || {};
this.__providers = reverse((providers).filter(
x => x != null && typeof x === 'object'
));
this.__isFiggyPudding = true;
}
get (key) {
return pudGet(this, key, true)
}
get [Symbol.toStringTag] () { return 'FiggyPudding' }
forEach (fn, thisArg = this) {
for (let [key, value] of this.entries()) {
fn.call(thisArg, value, key, this);
}
}
toJSON () {
const obj = {};
this.forEach((val, key) => {
obj[key] = val;
});
return obj
}
* entries (_matcher) {
for (let key of Object.keys(this.__specs)) {
yield [key, this.get(key)];
}
const matcher = _matcher || this.__opts.other;
if (matcher) {
const seen = new Set();
for (let p of this.__providers) {
const iter = p.entries ? p.entries(matcher) : entries(p);
for (let [key, val] of iter) {
if (matcher(key) && !seen.has(key)) {
seen.add(key);
yield [key, val];
}
}
}
}
}
* [Symbol.iterator] () {
for (let [key, value] of this.entries()) {
yield [key, value];
}
}
* keys () {
for (let [key] of this.entries()) {
yield key;
}
}
* values () {
for (let [, value] of this.entries()) {
yield value;
}
}
concat (...moreConfig) {
return new Proxy(new FiggyPudding(
this.__specs,
this.__opts,
reverse(this.__providers).concat(moreConfig)
), proxyHandler)
}
}
try {
const util = require('util');
FiggyPudding.prototype[util.inspect.custom] = function (depth, opts) {
return (
this[Symbol.toStringTag] + ' '
) + util.inspect(this.toJSON(), opts)
};
} catch (e) {}
function BadKeyError (key) {
throw Object.assign(new Error(
`invalid config key requested: ${key}`
), {code: 'EBADKEY'})
}
function pudGet (pud, key, validate) {
let spec = pud.__specs[key];
if (validate && !spec && (!pud.__opts.other || !pud.__opts.other(key))) {
BadKeyError(key);
} else {
if (!spec) { spec = {}; }
let ret;
for (let p of pud.__providers) {
ret = tryGet(key, p);
if (ret === undefined && spec.aliases && spec.aliases.length) {
for (let alias of spec.aliases) {
if (alias === key) { continue }
ret = tryGet(alias, p);
if (ret !== undefined) {
break
}
}
}
if (ret !== undefined) {
break
}
}
if (ret === undefined && spec.default !== undefined) {
if (typeof spec.default === 'function') {
return spec.default(pud)
} else {
return spec.default
}
} else {
return ret
}
}
}
function tryGet (key, p) {
let ret;
if (p.__isFiggyPudding) {
ret = pudGet(p, key, false);
} else if (typeof p.get === 'function') {
ret = p.get(key);
} else {
ret = p[key];
}
return ret
}
const proxyHandler = {
has (obj, prop) {
return prop in obj.__specs && pudGet(obj, prop, false) !== undefined
},
ownKeys (obj) {
return Object.keys(obj.__specs)
},
get (obj, prop) {
if (
typeof prop === 'symbol' ||
prop.slice(0, 2) === '__' ||
prop in FiggyPudding.prototype
) {
return obj[prop]
}
return obj.get(prop)
},
set (obj, prop, value) {
if (
typeof prop === 'symbol' ||
prop.slice(0, 2) === '__'
) {
obj[prop] = value;
return true
} else {
throw new Error('figgyPudding options cannot be modified. Use .concat() instead.')
}
},
deleteProperty () {
throw new Error('figgyPudding options cannot be deleted. Use .concat() and shadow them instead.')
}
};
var figgyPudding_1 = figgyPudding;
function figgyPudding (specs, opts) {
function factory (...providers) {
return new Proxy(new FiggyPudding(
specs,
opts,
providers
), proxyHandler)
}
return factory
}
function reverse (arr) {
const ret = [];
arr.forEach(x => ret.unshift(x));
return ret
}
function entries (obj) {
return Object.keys(obj).map(k => [k, obj[k]])
}
var index = /*@__PURE__*/getDefaultExportFromCjs(figgyPudding_1);
export { index as default };
| 193 | 29 | 0 | 36 | 15 | 0 | 12 | 0 | 0 | 1 | 6 | 5.517241 | 1,477 | false |
pumpify | top1k-typed-with-typed-deps | 2,231 | import require$$0 from 'pump';
import require$$1 from 'inherits';
import require$$2 from 'duplexify';
function getDefaultExportFromCjs (x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
}
var pumpify = {exports: {}};
// FILE: index.js
var pump = require$$0;
var inherits = require$$1;
var Duplexify = require$$2;
var toArray = function(args) {
if (!args.length) return []
return Array.isArray(args[0]) ? args[0] : Array.prototype.slice.call(args)
};
var define = function(opts) {
var Pumpify = function() {
var streams = toArray(arguments);
if (!(this instanceof Pumpify)) return new Pumpify(streams)
Duplexify.call(this, null, null, opts);
if (streams.length) this.setPipeline(streams);
};
inherits(Pumpify, Duplexify);
Pumpify.prototype.setPipeline = function() {
var streams = toArray(arguments);
var self = this;
var ended = false;
var w = streams[0];
var r = streams[streams.length-1];
r = r.readable ? r : null;
w = w.writable ? w : null;
var onclose = function() {
streams[0].emit('error', new Error('stream was destroyed'));
};
this.on('close', onclose);
this.on('prefinish', function() {
if (!ended) self.cork();
});
pump(streams, function(err) {
self.removeListener('close', onclose);
if (err) return self.destroy(err.message === 'premature close' ? null : err)
ended = true;
// pump ends after the last stream is not writable *but*
// pumpify still forwards the readable part so we need to catch errors
// still, so reenable autoDestroy in this case
if (self._autoDestroy === false) self._autoDestroy = true;
self.uncork();
});
if (this.destroyed) return onclose()
this.setWritable(w);
this.setReadable(r);
};
return Pumpify
};
pumpify.exports = define({autoDestroy:false, destroy:false});
var obj = pumpify.exports.obj = define({autoDestroy: false, destroy:false, objectMode:true, highWaterMark:16});
var ctor = pumpify.exports.ctor = define;
var pumpifyExports = pumpify.exports;
var index = /*@__PURE__*/getDefaultExportFromCjs(pumpifyExports);
export { ctor, index as default, obj };
| import require$$0 from 'pump';
import require$$1 from 'inherits';
import require$$2 from 'duplexify';
function getDefaultExportFromCjs (x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
}
var pumpify = {exports: {}};
// FILE: index.js
var pump = require$$0;
var inherits = require$$1;
var Duplexify = require$$2;
var toArray = function(args) {
if (!args.length) return []
return Array.isArray(args[0]) ? args[0] : Array.prototype.slice.call(args)
};
var define = function(opts) {
var Pumpify = function() {
var streams = toArray(arguments);
if (!(this instanceof Pumpify)) return new Pumpify(streams)
Duplexify.call(this, null, null, opts);
if (streams.length) this.setPipeline(streams);
};
inherits(Pumpify, Duplexify);
Pumpify.prototype.setPipeline = function() {
var streams = toArray(arguments);
var self = this;
var ended = false;
var w = streams[0];
var r = streams[streams.length-1];
r = r.readable ? r : null;
w = w.writable ? w : null;
var onclose = function() {
streams[0].emit('error', new Error('stream was destroyed'));
};
this.on('close', onclose);
this.on('prefinish', function() {
if (!ended) self.cork();
});
pump(streams, function(err) {
self.removeListener('close', onclose);
if (err) return self.destroy(err.message === 'premature close' ? null : err)
ended = true;
// pump ends after the last stream is not writable *but*
// pumpify still forwards the readable part so we need to catch errors
// still, so reenable autoDestroy in this case
if (self._autoDestroy === false) self._autoDestroy = true;
self.uncork();
});
if (this.destroyed) return onclose()
this.setWritable(w);
this.setReadable(r);
};
return Pumpify
};
pumpify.exports = define({autoDestroy:false, destroy:false});
var obj = pumpify.exports.obj = define({autoDestroy: false, destroy:false, objectMode:true, highWaterMark:16});
var ctor = pumpify.exports.ctor = define;
var pumpifyExports = pumpify.exports;
var index = /*@__PURE__*/getDefaultExportFromCjs(pumpifyExports);
export { ctor, index as default, obj };
| 56 | 8 | 0 | 4 | 18 | 0 | 5 | 0 | 0 | 0 | 1 | 9 | 645 | false |
pop-iterate | top1k-untyped-nodeps | 2,479 | function getDefaultExportFromCjs (x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
}
// FILE: iteration.js
var iteration = Iteration$2;
function Iteration$2(value, done, index) {
this.value = value;
this.done = done;
this.index = index;
}
Iteration$2.prototype.equals = function (other) {
return (
typeof other == 'object' &&
other.value === this.value &&
other.done === this.done &&
other.index === this.index
);
};
// FILE: array-iterator.js
var Iteration$1 = iteration;
var arrayIterator = ArrayIterator$2;
function ArrayIterator$2(iterable, start, stop, step) {
this.array = iterable;
this.start = start || 0;
this.stop = stop || Infinity;
this.step = step || 1;
}
ArrayIterator$2.prototype.next = function () {
var iteration;
if (this.start < Math.min(this.array.length, this.stop)) {
iteration = new Iteration$1(this.array[this.start], false, this.start);
this.start += this.step;
} else {
iteration = new Iteration$1(undefined, true);
}
return iteration;
};
// FILE: object-iterator.js
var Iteration = iteration;
var ArrayIterator$1 = arrayIterator;
var objectIterator = ObjectIterator$1;
function ObjectIterator$1(iterable, start, stop, step) {
this.object = iterable;
this.keysIterator = new ArrayIterator$1(Object.keys(iterable), start, stop, step);
}
ObjectIterator$1.prototype.next = function () {
var iteration = this.keysIterator.next();
if (iteration.done) {
return iteration;
}
var key = iteration.value;
return new Iteration(this.object[key], false, key);
};
// FILE: pop-iterate.js
var ArrayIterator = arrayIterator;
var ObjectIterator = objectIterator;
var popIterate = iterate;
function iterate(iterable, start, stop, step) {
if (!iterable) {
return empty;
} else if (Array.isArray(iterable)) {
return new ArrayIterator(iterable, start, stop, step);
} else if (typeof iterable.next === "function") {
return iterable;
} else if (typeof iterable.iterate === "function") {
return iterable.iterate(start, stop, step);
} else if (typeof iterable === "object") {
return new ObjectIterator(iterable);
} else {
throw new TypeError("Can't iterate " + iterable);
}
}
var popIterate$1 = /*@__PURE__*/getDefaultExportFromCjs(popIterate);
export { popIterate$1 as default };
| function getDefaultExportFromCjs (x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
}
// FILE: iteration.js
var iteration = Iteration$2;
function Iteration$2(value, done, index) {
this.value = value;
this.done = done;
this.index = index;
}
Iteration$2.prototype.equals = function (other) {
return (
typeof other == 'object' &&
other.value === this.value &&
other.done === this.done &&
other.index === this.index
);
};
// FILE: array-iterator.js
var Iteration$1 = iteration;
var arrayIterator = ArrayIterator$2;
function ArrayIterator$2(iterable, start, stop, step) {
this.array = iterable;
this.start = start || 0;
this.stop = stop || Infinity;
this.step = step || 1;
}
ArrayIterator$2.prototype.next = function () {
var iteration;
if (this.start < Math.min(this.array.length, this.stop)) {
iteration = new Iteration$1(this.array[this.start], false, this.start);
this.start += this.step;
} else {
iteration = new Iteration$1(undefined, true);
}
return iteration;
};
// FILE: object-iterator.js
var Iteration = iteration;
var ArrayIterator$1 = arrayIterator;
var objectIterator = ObjectIterator$1;
function ObjectIterator$1(iterable, start, stop, step) {
this.object = iterable;
this.keysIterator = new ArrayIterator$1(Object.keys(iterable), start, stop, step);
}
ObjectIterator$1.prototype.next = function () {
var iteration = this.keysIterator.next();
if (iteration.done) {
return iteration;
}
var key = iteration.value;
return new Iteration(this.object[key], false, key);
};
// FILE: pop-iterate.js
var ArrayIterator = arrayIterator;
var ObjectIterator = objectIterator;
var popIterate = iterate;
function iterate(iterable, start, stop, step) {
if (!iterable) {
return empty;
} else if (Array.isArray(iterable)) {
return new ArrayIterator(iterable, start, stop, step);
} else if (typeof iterable.next === "function") {
return iterable;
} else if (typeof iterable.iterate === "function") {
return iterable.iterate(start, stop, step);
} else if (typeof iterable === "object") {
return new ObjectIterator(iterable);
} else {
throw new TypeError("Can't iterate " + iterable);
}
}
var popIterate$1 = /*@__PURE__*/getDefaultExportFromCjs(popIterate);
export { popIterate$1 as default };
| 70 | 8 | 0 | 17 | 13 | 0 | 3 | 0 | 0 | 0 | 4 | 5.375 | 684 | false |
miller-rabin | top1k-untyped-with-typed-deps | 2,780 | import require$$0 from 'bn.js';
import require$$1 from 'brorand';
function getDefaultExportFromCjs (x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
}
// FILE: lib/mr.js
var bn = require$$0;
var brorand = require$$1;
function MillerRabin(rand) {
this.rand = rand || new brorand.Rand();
}
var mr = MillerRabin;
MillerRabin.create = function create(rand) {
return new MillerRabin(rand);
};
MillerRabin.prototype._randbelow = function _randbelow(n) {
var len = n.bitLength();
var min_bytes = Math.ceil(len / 8);
// Generage random bytes until a number less than n is found.
// This ensures that 0..n-1 have an equal probability of being selected.
do
var a = new bn(this.rand.generate(min_bytes));
while (a.cmp(n) >= 0);
return a;
};
MillerRabin.prototype._randrange = function _randrange(start, stop) {
// Generate a random number greater than or equal to start and less than stop.
var size = stop.sub(start);
return start.add(this._randbelow(size));
};
MillerRabin.prototype.test = function test(n, k, cb) {
var len = n.bitLength();
var red = bn.mont(n);
var rone = new bn(1).toRed(red);
if (!k)
k = Math.max(1, (len / 48) | 0);
// Find d and s, (n - 1) = (2 ^ s) * d;
var n1 = n.subn(1);
for (var s = 0; !n1.testn(s); s++) {}
var d = n.shrn(s);
var rn1 = n1.toRed(red);
var prime = true;
for (; k > 0; k--) {
var a = this._randrange(new bn(2), n1);
if (cb)
cb(a);
var x = a.toRed(red).redPow(d);
if (x.cmp(rone) === 0 || x.cmp(rn1) === 0)
continue;
for (var i = 1; i < s; i++) {
x = x.redSqr();
if (x.cmp(rone) === 0)
return false;
if (x.cmp(rn1) === 0)
break;
}
if (i === s)
return false;
}
return prime;
};
MillerRabin.prototype.getDivisor = function getDivisor(n, k) {
var len = n.bitLength();
var red = bn.mont(n);
var rone = new bn(1).toRed(red);
if (!k)
k = Math.max(1, (len / 48) | 0);
// Find d and s, (n - 1) = (2 ^ s) * d;
var n1 = n.subn(1);
for (var s = 0; !n1.testn(s); s++) {}
var d = n.shrn(s);
var rn1 = n1.toRed(red);
for (; k > 0; k--) {
var a = this._randrange(new bn(2), n1);
var g = n.gcd(a);
if (g.cmpn(1) !== 0)
return g;
var x = a.toRed(red).redPow(d);
if (x.cmp(rone) === 0 || x.cmp(rn1) === 0)
continue;
for (var i = 1; i < s; i++) {
x = x.redSqr();
if (x.cmp(rone) === 0)
return x.fromRed().subn(1).gcd(n);
if (x.cmp(rn1) === 0)
break;
}
if (i === s) {
x = x.redSqr();
return x.fromRed().subn(1).gcd(n);
}
}
return false;
};
var mr$1 = /*@__PURE__*/getDefaultExportFromCjs(mr);
export { mr$1 as default };
| import require$$0 from 'bn.js';
import require$$1 from 'brorand';
function getDefaultExportFromCjs (x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
}
// FILE: lib/mr.js
var bn = require$$0;
var brorand = require$$1;
function MillerRabin(rand) {
this.rand = rand || new brorand.Rand();
}
var mr = MillerRabin;
MillerRabin.create = function create(rand) {
return new MillerRabin(rand);
};
MillerRabin.prototype._randbelow = function _randbelow(n) {
var len = n.bitLength();
var min_bytes = Math.ceil(len / 8);
// Generage random bytes until a number less than n is found.
// This ensures that 0..n-1 have an equal probability of being selected.
do
var a = new bn(this.rand.generate(min_bytes));
while (a.cmp(n) >= 0);
return a;
};
MillerRabin.prototype._randrange = function _randrange(start, stop) {
// Generate a random number greater than or equal to start and less than stop.
var size = stop.sub(start);
return start.add(this._randbelow(size));
};
MillerRabin.prototype.test = function test(n, k, cb) {
var len = n.bitLength();
var red = bn.mont(n);
var rone = new bn(1).toRed(red);
if (!k)
k = Math.max(1, (len / 48) | 0);
// Find d and s, (n - 1) = (2 ^ s) * d;
var n1 = n.subn(1);
for (var s = 0; !n1.testn(s); s++) {}
var d = n.shrn(s);
var rn1 = n1.toRed(red);
var prime = true;
for (; k > 0; k--) {
var a = this._randrange(new bn(2), n1);
if (cb)
cb(a);
var x = a.toRed(red).redPow(d);
if (x.cmp(rone) === 0 || x.cmp(rn1) === 0)
continue;
for (var i = 1; i < s; i++) {
x = x.redSqr();
if (x.cmp(rone) === 0)
return false;
if (x.cmp(rn1) === 0)
break;
}
if (i === s)
return false;
}
return prime;
};
MillerRabin.prototype.getDivisor = function getDivisor(n, k) {
var len = n.bitLength();
var red = bn.mont(n);
var rone = new bn(1).toRed(red);
if (!k)
k = Math.max(1, (len / 48) | 0);
// Find d and s, (n - 1) = (2 ^ s) * d;
var n1 = n.subn(1);
for (var s = 0; !n1.testn(s); s++) {}
var d = n.shrn(s);
var rn1 = n1.toRed(red);
for (; k > 0; k--) {
var a = this._randrange(new bn(2), n1);
var g = n.gcd(a);
if (g.cmpn(1) !== 0)
return g;
var x = a.toRed(red).redPow(d);
if (x.cmp(rone) === 0 || x.cmp(rn1) === 0)
continue;
for (var i = 1; i < s; i++) {
x = x.redSqr();
if (x.cmp(rone) === 0)
return x.fromRed().subn(1).gcd(n);
if (x.cmp(rn1) === 0)
break;
}
if (i === s) {
x = x.redSqr();
return x.fromRed().subn(1).gcd(n);
}
}
return false;
};
var mr$1 = /*@__PURE__*/getDefaultExportFromCjs(mr);
export { mr$1 as default };
| 90 | 7 | 0 | 11 | 30 | 0 | 3 | 0 | 0 | 0 | 0 | 9.857143 | 1,078 | false |
@sinonjs_commons | top1k-typed-with-typed-deps | 9,663 | import require$$0 from 'type-detect';
var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
function getDefaultExportFromCjs (x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
}
// FILE: lib/global.js
/**
* A reference to the global object
*
* @type {object} globalObject
*/
var globalObject;
/* istanbul ignore else */
if (typeof commonjsGlobal !== "undefined") {
// Node
globalObject = commonjsGlobal;
} else if (typeof window !== "undefined") {
// Browser
globalObject = window;
} else {
// WebWorker
globalObject = self;
}
var global$1 = globalObject;
// FILE: lib/prototypes/copy-prototype.js
var call = Function.call;
var copyPrototype$6 = function copyPrototypeMethods(prototype) {
// eslint-disable-next-line @sinonjs/no-prototype-methods/no-prototype-methods
return Object.getOwnPropertyNames(prototype).reduce(function(result, name) {
// ignore size because it throws from Map
if (
name !== "size" &&
name !== "caller" &&
name !== "callee" &&
name !== "arguments" &&
typeof prototype[name] === "function"
) {
result[name] = call.bind(prototype[name]);
}
return result;
}, Object.create(null));
};
// FILE: lib/prototypes/array.js
var copyPrototype$5 = copyPrototype$6;
var array = copyPrototype$5(Array.prototype);
// FILE: lib/called-in-order.js
var every$1 = array.every;
/**
* @private
*/
function hasCallsLeft(callMap, spy) {
if (callMap[spy.id] === undefined) {
callMap[spy.id] = 0;
}
return callMap[spy.id] < spy.callCount;
}
/**
* @private
*/
function checkAdjacentCalls(callMap, spy, index, spies) {
var calledBeforeNext = true;
if (index !== spies.length - 1) {
calledBeforeNext = spy.calledBefore(spies[index + 1]);
}
if (hasCallsLeft(callMap, spy) && calledBeforeNext) {
callMap[spy.id] += 1;
return true;
}
return false;
}
/**
* A Sinon proxy object (fake, spy, stub)
*
* @typedef {object} SinonProxy
* @property {Function} calledBefore - A method that determines if this proxy was called before another one
* @property {string} id - Some id
* @property {number} callCount - Number of times this proxy has been called
*/
/**
* Returns true when the spies have been called in the order they were supplied in
*
* @param {SinonProxy[] | SinonProxy} spies An array of proxies, or several proxies as arguments
* @returns {boolean} true when spies are called in order, false otherwise
*/
function calledInOrder(spies) {
var callMap = {};
// eslint-disable-next-line no-underscore-dangle
var _spies = arguments.length > 1 ? arguments : spies;
return every$1(_spies, checkAdjacentCalls.bind(null, callMap));
}
var calledInOrder_1 = calledInOrder;
// FILE: lib/function-name.js
/**
* Returns a display name for a function
*
* @param {Function} func
* @returns {string}
*/
var functionName$1 = function functionName(func) {
if (!func) {
return "";
}
try {
return (
func.displayName ||
func.name ||
// Use function decomposition as a last resort to get function
// name. Does not rely on function decomposition to work - if it
// doesn't debugging will be slightly less informative
// (i.e. toString will say 'spy' rather than 'myFunc').
(String(func).match(/function ([^\s(]+)/) || [])[1]
);
} catch (e) {
// Stringify may fail and we might get an exception, as a last-last
// resort fall back to empty string.
return "";
}
};
// FILE: lib/class-name.js
var functionName = functionName$1;
/**
* Returns a display name for a value from a constructor
*
* @param {object} value A value to examine
* @returns {(string|null)} A string or null
*/
function className(value) {
return (
(value.constructor && value.constructor.name) ||
// The next branch is for IE11 support only:
// Because the name property is not set on the prototype
// of the Function object, we finally try to grab the
// name from its definition. This will never be reached
// in node, so we are not able to test this properly.
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name
(typeof value.constructor === "function" &&
/* istanbul ignore next */
functionName(value.constructor)) ||
null
);
}
var className_1 = className;
var deprecated = {};
// FILE: lib/deprecated.js
/* eslint-disable no-console */
(function (exports) {
/**
* Returns a function that will invoke the supplied function and print a
* deprecation warning to the console each time it is called.
*
* @param {Function} func
* @param {string} msg
* @returns {Function}
*/
exports.wrap = function(func, msg) {
var wrapped = function() {
exports.printWarning(msg);
return func.apply(this, arguments);
};
if (func.prototype) {
wrapped.prototype = func.prototype;
}
return wrapped;
};
/**
* Returns a string which can be supplied to `wrap()` to notify the user that a
* particular part of the sinon API has been deprecated.
*
* @param {string} packageName
* @param {string} funcName
* @returns {string}
*/
exports.defaultMsg = function(packageName, funcName) {
return (
packageName +
"." +
funcName +
" is deprecated and will be removed from the public API in a future version of " +
packageName +
"."
);
};
/**
* Prints a warning on the console, when it exists
*
* @param {string} msg
* @returns {undefined}
*/
exports.printWarning = function(msg) {
/* istanbul ignore next */
if (typeof process === "object" && process.emitWarning) {
// Emit Warnings in Node
process.emitWarning(msg);
} else if (console.info) {
console.info(msg);
} else {
console.log(msg);
}
};
} (deprecated));
// FILE: lib/every.js
/**
* Returns true when fn returns true for all members of obj.
* This is an every implementation that works for all iterables
*
* @param {object} obj
* @param {Function} fn
* @returns {boolean}
*/
var every = function every(obj, fn) {
var pass = true;
try {
// eslint-disable-next-line @sinonjs/no-prototype-methods/no-prototype-methods
obj.forEach(function() {
if (!fn.apply(this, arguments)) {
// Throwing an error is the only way to break `forEach`
throw new Error();
}
});
} catch (e) {
pass = false;
}
return pass;
};
// FILE: lib/order-by-first-call.js
var sort = array.sort;
var slice = array.slice;
/**
* @private
*/
function comparator(a, b) {
// uuid, won't ever be equal
var aCall = a.getCall(0);
var bCall = b.getCall(0);
var aId = (aCall && aCall.callId) || -1;
var bId = (bCall && bCall.callId) || -1;
return aId < bId ? -1 : 1;
}
/**
* A Sinon proxy object (fake, spy, stub)
*
* @typedef {object} SinonProxy
* @property {Function} getCall - A method that can return the first call
*/
/**
* Sorts an array of SinonProxy instances (fake, spy, stub) by their first call
*
* @param {SinonProxy[] | SinonProxy} spies
* @returns {SinonProxy[]}
*/
function orderByFirstCall(spies) {
return sort(slice(spies), comparator);
}
var orderByFirstCall_1 = orderByFirstCall;
// FILE: lib/prototypes/function.js
var copyPrototype$4 = copyPrototype$6;
var _function = copyPrototype$4(Function.prototype);
// FILE: lib/prototypes/map.js
var copyPrototype$3 = copyPrototype$6;
var map = copyPrototype$3(Map.prototype);
// FILE: lib/prototypes/object.js
var copyPrototype$2 = copyPrototype$6;
var object = copyPrototype$2(Object.prototype);
// FILE: lib/prototypes/set.js
var copyPrototype$1 = copyPrototype$6;
var set = copyPrototype$1(Set.prototype);
// FILE: lib/prototypes/string.js
var copyPrototype = copyPrototype$6;
var string = copyPrototype(String.prototype);
// FILE: lib/prototypes/index.js
var prototypes = {
array: array,
function: _function,
map: map,
object: object,
set: set,
string: string
};
// FILE: lib/type-of.js
var type = require$$0;
/**
* Returns the lower-case result of running type from type-detect on the value
*
* @param {*} value
* @returns {string}
*/
var typeOf = function typeOf(value) {
return type(value).toLowerCase();
};
// FILE: lib/value-to-string.js
/**
* Returns a string representation of the value
*
* @param {*} value
* @returns {string}
*/
function valueToString(value) {
if (value && value.toString) {
// eslint-disable-next-line @sinonjs/no-prototype-methods/no-prototype-methods
return value.toString();
}
return String(value);
}
var valueToString_1 = valueToString;
// FILE: lib/index.js
var lib = {
global: global$1,
calledInOrder: calledInOrder_1,
className: className_1,
deprecated: deprecated,
every: every,
functionName: functionName$1,
orderByFirstCall: orderByFirstCall_1,
prototypes: prototypes,
typeOf: typeOf,
valueToString: valueToString_1
};
var index = /*@__PURE__*/getDefaultExportFromCjs(lib);
export { index as default };
| import require$$0 from 'type-detect';
var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
function getDefaultExportFromCjs (x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
}
// FILE: lib/global.js
/**
* A reference to the global object
*
* @type {object} globalObject
*/
var globalObject;
/* istanbul ignore else */
if (typeof commonjsGlobal !== "undefined") {
// Node
globalObject = commonjsGlobal;
} else if (typeof window !== "undefined") {
// Browser
globalObject = window;
} else {
// WebWorker
globalObject = self;
}
var global$1 = globalObject;
// FILE: lib/prototypes/copy-prototype.js
var call = Function.call;
var copyPrototype$6 = function copyPrototypeMethods(prototype) {
// eslint-disable-next-line @sinonjs/no-prototype-methods/no-prototype-methods
return Object.getOwnPropertyNames(prototype).reduce(function(result, name) {
// ignore size because it throws from Map
if (
name !== "size" &&
name !== "caller" &&
name !== "callee" &&
name !== "arguments" &&
typeof prototype[name] === "function"
) {
result[name] = call.bind(prototype[name]);
}
return result;
}, Object.create(null));
};
// FILE: lib/prototypes/array.js
var copyPrototype$5 = copyPrototype$6;
var array = copyPrototype$5(Array.prototype);
// FILE: lib/called-in-order.js
var every$1 = array.every;
/**
* @private
*/
function hasCallsLeft(callMap, spy) {
if (callMap[spy.id] === undefined) {
callMap[spy.id] = 0;
}
return callMap[spy.id] < spy.callCount;
}
/**
* @private
*/
function checkAdjacentCalls(callMap, spy, index, spies) {
var calledBeforeNext = true;
if (index !== spies.length - 1) {
calledBeforeNext = spy.calledBefore(spies[index + 1]);
}
if (hasCallsLeft(callMap, spy) && calledBeforeNext) {
callMap[spy.id] += 1;
return true;
}
return false;
}
/**
* A Sinon proxy object (fake, spy, stub)
*
* @typedef {object} SinonProxy
* @property {Function} calledBefore - A method that determines if this proxy was called before another one
* @property {string} id - Some id
* @property {number} callCount - Number of times this proxy has been called
*/
/**
* Returns true when the spies have been called in the order they were supplied in
*
* @param {SinonProxy[] | SinonProxy} spies An array of proxies, or several proxies as arguments
* @returns {boolean} true when spies are called in order, false otherwise
*/
function calledInOrder(spies) {
var callMap = {};
// eslint-disable-next-line no-underscore-dangle
var _spies = arguments.length > 1 ? arguments : spies;
return every$1(_spies, checkAdjacentCalls.bind(null, callMap));
}
var calledInOrder_1 = calledInOrder;
// FILE: lib/function-name.js
/**
* Returns a display name for a function
*
* @param {Function} func
* @returns {string}
*/
var functionName$1 = function functionName(func) {
if (!func) {
return "";
}
try {
return (
func.displayName ||
func.name ||
// Use function decomposition as a last resort to get function
// name. Does not rely on function decomposition to work - if it
// doesn't debugging will be slightly less informative
// (i.e. toString will say 'spy' rather than 'myFunc').
(String(func).match(/function ([^\s(]+)/) || [])[1]
);
} catch (e) {
// Stringify may fail and we might get an exception, as a last-last
// resort fall back to empty string.
return "";
}
};
// FILE: lib/class-name.js
var functionName = functionName$1;
/**
* Returns a display name for a value from a constructor
*
* @param {object} value A value to examine
* @returns {(string|null)} A string or null
*/
function className(value) {
return (
(value.constructor && value.constructor.name) ||
// The next branch is for IE11 support only:
// Because the name property is not set on the prototype
// of the Function object, we finally try to grab the
// name from its definition. This will never be reached
// in node, so we are not able to test this properly.
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name
(typeof value.constructor === "function" &&
/* istanbul ignore next */
functionName(value.constructor)) ||
null
);
}
var className_1 = className;
var deprecated = {};
// FILE: lib/deprecated.js
/* eslint-disable no-console */
(function (exports) {
/**
* Returns a function that will invoke the supplied function and print a
* deprecation warning to the console each time it is called.
*
* @param {Function} func
* @param {string} msg
* @returns {Function}
*/
exports.wrap = function(func, msg) {
var wrapped = function() {
exports.printWarning(msg);
return func.apply(this, arguments);
};
if (func.prototype) {
wrapped.prototype = func.prototype;
}
return wrapped;
};
/**
* Returns a string which can be supplied to `wrap()` to notify the user that a
* particular part of the sinon API has been deprecated.
*
* @param {string} packageName
* @param {string} funcName
* @returns {string}
*/
exports.defaultMsg = function(packageName, funcName) {
return (
packageName +
"." +
funcName +
" is deprecated and will be removed from the public API in a future version of " +
packageName +
"."
);
};
/**
* Prints a warning on the console, when it exists
*
* @param {string} msg
* @returns {undefined}
*/
exports.printWarning = function(msg) {
/* istanbul ignore next */
if (typeof process === "object" && process.emitWarning) {
// Emit Warnings in Node
process.emitWarning(msg);
} else if (console.info) {
console.info(msg);
} else {
console.log(msg);
}
};
} (deprecated));
// FILE: lib/every.js
/**
* Returns true when fn returns true for all members of obj.
* This is an every implementation that works for all iterables
*
* @param {object} obj
* @param {Function} fn
* @returns {boolean}
*/
var every = function every(obj, fn) {
var pass = true;
try {
// eslint-disable-next-line @sinonjs/no-prototype-methods/no-prototype-methods
obj.forEach(function() {
if (!fn.apply(this, arguments)) {
// Throwing an error is the only way to break `forEach`
throw new Error();
}
});
} catch (e) {
pass = false;
}
return pass;
};
// FILE: lib/order-by-first-call.js
var sort = array.sort;
var slice = array.slice;
/**
* @private
*/
function comparator(a, b) {
// uuid, won't ever be equal
var aCall = a.getCall(0);
var bCall = b.getCall(0);
var aId = (aCall && aCall.callId) || -1;
var bId = (bCall && bCall.callId) || -1;
return aId < bId ? -1 : 1;
}
/**
* A Sinon proxy object (fake, spy, stub)
*
* @typedef {object} SinonProxy
* @property {Function} getCall - A method that can return the first call
*/
/**
* Sorts an array of SinonProxy instances (fake, spy, stub) by their first call
*
* @param {SinonProxy[] | SinonProxy} spies
* @returns {SinonProxy[]}
*/
function orderByFirstCall(spies) {
return sort(slice(spies), comparator);
}
var orderByFirstCall_1 = orderByFirstCall;
// FILE: lib/prototypes/function.js
var copyPrototype$4 = copyPrototype$6;
var _function = copyPrototype$4(Function.prototype);
// FILE: lib/prototypes/map.js
var copyPrototype$3 = copyPrototype$6;
var map = copyPrototype$3(Map.prototype);
// FILE: lib/prototypes/object.js
var copyPrototype$2 = copyPrototype$6;
var object = copyPrototype$2(Object.prototype);
// FILE: lib/prototypes/set.js
var copyPrototype$1 = copyPrototype$6;
var set = copyPrototype$1(Set.prototype);
// FILE: lib/prototypes/string.js
var copyPrototype = copyPrototype$6;
var string = copyPrototype(String.prototype);
// FILE: lib/prototypes/index.js
var prototypes = {
array: array,
function: _function,
map: map,
object: object,
set: set,
string: string
};
// FILE: lib/type-of.js
var type = require$$0;
/**
* Returns the lower-case result of running type from type-detect on the value
*
* @param {*} value
* @returns {string}
*/
var typeOf = function typeOf(value) {
return type(value).toLowerCase();
};
// FILE: lib/value-to-string.js
/**
* Returns a string representation of the value
*
* @param {*} value
* @returns {string}
*/
function valueToString(value) {
if (value && value.toString) {
// eslint-disable-next-line @sinonjs/no-prototype-methods/no-prototype-methods
return value.toString();
}
return String(value);
}
var valueToString_1 = valueToString;
// FILE: lib/index.js
var lib = {
global: global$1,
calledInOrder: calledInOrder_1,
className: className_1,
deprecated: deprecated,
every: every,
functionName: functionName$1,
orderByFirstCall: orderByFirstCall_1,
prototypes: prototypes,
typeOf: typeOf,
valueToString: valueToString_1
};
var index = /*@__PURE__*/getDefaultExportFromCjs(lib);
export { index as default };
| 180 | 19 | 0 | 26 | 42 | 0 | 4 | 0 | 0 | 0 | 9 | 7.157895 | 2,685 | false |
etag | top1k-typed-nodeps | 2,774 | import require$$0 from 'crypto';
import require$$1 from 'fs';
function getDefaultExportFromCjs (x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
}
// FILE: index.js
/*!
* etag
* Copyright(c) 2014-2016 Douglas Christopher Wilson
* MIT Licensed
*/
/**
* Module exports.
* @public
*/
var etag_1 = etag;
/**
* Module dependencies.
* @private
*/
var crypto = require$$0;
var Stats = require$$1.Stats;
/**
* Module variables.
* @private
*/
var toString = Object.prototype.toString;
/**
* Generate an entity tag.
*
* @param {Buffer|string} entity
* @return {string}
* @private
*/
function entitytag (entity) {
if (entity.length === 0) {
// fast-path empty
return '"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk"'
}
// compute hash of entity
var hash = crypto
.createHash('sha1')
.update(entity, 'utf8')
.digest('base64')
.substring(0, 27);
// compute length of entity
var len = typeof entity === 'string'
? Buffer.byteLength(entity, 'utf8')
: entity.length;
return '"' + len.toString(16) + '-' + hash + '"'
}
/**
* Create a simple ETag.
*
* @param {string|Buffer|Stats} entity
* @param {object} [options]
* @param {boolean} [options.weak]
* @return {String}
* @public
*/
function etag (entity, options) {
if (entity == null) {
throw new TypeError('argument entity is required')
}
// support fs.Stats object
var isStats = isstats(entity);
var weak = options && typeof options.weak === 'boolean'
? options.weak
: isStats;
// validate argument
if (!isStats && typeof entity !== 'string' && !Buffer.isBuffer(entity)) {
throw new TypeError('argument entity must be string, Buffer, or fs.Stats')
}
// generate entity tag
var tag = isStats
? stattag(entity)
: entitytag(entity);
return weak
? 'W/' + tag
: tag
}
/**
* Determine if object is a Stats object.
*
* @param {object} obj
* @return {boolean}
* @api private
*/
function isstats (obj) {
// genuine fs.Stats
if (typeof Stats === 'function' && obj instanceof Stats) {
return true
}
// quack quack
return obj && typeof obj === 'object' &&
'ctime' in obj && toString.call(obj.ctime) === '[object Date]' &&
'mtime' in obj && toString.call(obj.mtime) === '[object Date]' &&
'ino' in obj && typeof obj.ino === 'number' &&
'size' in obj && typeof obj.size === 'number'
}
/**
* Generate a tag for a stat.
*
* @param {object} stat
* @return {string}
* @private
*/
function stattag (stat) {
var mtime = stat.mtime.getTime().toString(16);
var size = stat.size.toString(16);
return '"' + size + '-' + mtime + '"'
}
var index = /*@__PURE__*/getDefaultExportFromCjs(etag_1);
export { index as default };
| import require$$0 from 'crypto';
import require$$1 from 'fs';
function getDefaultExportFromCjs (x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
}
// FILE: index.js
/*!
* etag
* Copyright(c) 2014-2016 Douglas Christopher Wilson
* MIT Licensed
*/
/**
* Module exports.
* @public
*/
var etag_1 = etag;
/**
* Module dependencies.
* @private
*/
var crypto = require$$0;
var Stats = require$$1.Stats;
/**
* Module variables.
* @private
*/
var toString = Object.prototype.toString;
/**
* Generate an entity tag.
*
* @param {Buffer|string} entity
* @return {string}
* @private
*/
function entitytag (entity) {
if (entity.length === 0) {
// fast-path empty
return '"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk"'
}
// compute hash of entity
var hash = crypto
.createHash('sha1')
.update(entity, 'utf8')
.digest('base64')
.substring(0, 27);
// compute length of entity
var len = typeof entity === 'string'
? Buffer.byteLength(entity, 'utf8')
: entity.length;
return '"' + len.toString(16) + '-' + hash + '"'
}
/**
* Create a simple ETag.
*
* @param {string|Buffer|Stats} entity
* @param {object} [options]
* @param {boolean} [options.weak]
* @return {String}
* @public
*/
function etag (entity, options) {
if (entity == null) {
throw new TypeError('argument entity is required')
}
// support fs.Stats object
var isStats = isstats(entity);
var weak = options && typeof options.weak === 'boolean'
? options.weak
: isStats;
// validate argument
if (!isStats && typeof entity !== 'string' && !Buffer.isBuffer(entity)) {
throw new TypeError('argument entity must be string, Buffer, or fs.Stats')
}
// generate entity tag
var tag = isStats
? stattag(entity)
: entitytag(entity);
return weak
? 'W/' + tag
: tag
}
/**
* Determine if object is a Stats object.
*
* @param {object} obj
* @return {boolean}
* @api private
*/
function isstats (obj) {
// genuine fs.Stats
if (typeof Stats === 'function' && obj instanceof Stats) {
return true
}
// quack quack
return obj && typeof obj === 'object' &&
'ctime' in obj && toString.call(obj.ctime) === '[object Date]' &&
'mtime' in obj && toString.call(obj.mtime) === '[object Date]' &&
'ino' in obj && typeof obj.ino === 'number' &&
'size' in obj && typeof obj.size === 'number'
}
/**
* Generate a tag for a stat.
*
* @param {object} stat
* @return {string}
* @private
*/
function stattag (stat) {
var mtime = stat.mtime.getTime().toString(16);
var size = stat.size.toString(16);
return '"' + size + '-' + mtime + '"'
}
var index = /*@__PURE__*/getDefaultExportFromCjs(etag_1);
export { index as default };
| 58 | 5 | 0 | 6 | 12 | 0 | 4 | 0 | 0 | 0 | 8 | 8 | 871 | true |
quick-lru | top1k-typed-nodeps | 5,901 | // FILE: index.js
class QuickLRU extends Map {
constructor(options = {}) {
super();
if (!(options.maxSize && options.maxSize > 0)) {
throw new TypeError('`maxSize` must be a number greater than 0');
}
if (typeof options.maxAge === 'number' && options.maxAge === 0) {
throw new TypeError('`maxAge` must be a number greater than 0');
}
// TODO: Use private class fields when ESLint supports them.
this.maxSize = options.maxSize;
this.maxAge = options.maxAge || Number.POSITIVE_INFINITY;
this.onEviction = options.onEviction;
this.cache = new Map();
this.oldCache = new Map();
this._size = 0;
}
// TODO: Use private class methods when targeting Node.js 16.
_emitEvictions(cache) {
if (typeof this.onEviction !== 'function') {
return;
}
for (const [key, item] of cache) {
this.onEviction(key, item.value);
}
}
_deleteIfExpired(key, item) {
if (typeof item.expiry === 'number' && item.expiry <= Date.now()) {
if (typeof this.onEviction === 'function') {
this.onEviction(key, item.value);
}
return this.delete(key);
}
return false;
}
_getOrDeleteIfExpired(key, item) {
const deleted = this._deleteIfExpired(key, item);
if (deleted === false) {
return item.value;
}
}
_getItemValue(key, item) {
return item.expiry ? this._getOrDeleteIfExpired(key, item) : item.value;
}
_peek(key, cache) {
const item = cache.get(key);
return this._getItemValue(key, item);
}
_set(key, value) {
this.cache.set(key, value);
this._size++;
if (this._size >= this.maxSize) {
this._size = 0;
this._emitEvictions(this.oldCache);
this.oldCache = this.cache;
this.cache = new Map();
}
}
_moveToRecent(key, item) {
this.oldCache.delete(key);
this._set(key, item);
}
* _entriesAscending() {
for (const item of this.oldCache) {
const [key, value] = item;
if (!this.cache.has(key)) {
const deleted = this._deleteIfExpired(key, value);
if (deleted === false) {
yield item;
}
}
}
for (const item of this.cache) {
const [key, value] = item;
const deleted = this._deleteIfExpired(key, value);
if (deleted === false) {
yield item;
}
}
}
get(key) {
if (this.cache.has(key)) {
const item = this.cache.get(key);
return this._getItemValue(key, item);
}
if (this.oldCache.has(key)) {
const item = this.oldCache.get(key);
if (this._deleteIfExpired(key, item) === false) {
this._moveToRecent(key, item);
return item.value;
}
}
}
set(key, value, {maxAge = this.maxAge} = {}) {
const expiry =
typeof maxAge === 'number' && maxAge !== Number.POSITIVE_INFINITY ?
Date.now() + maxAge :
undefined;
if (this.cache.has(key)) {
this.cache.set(key, {
value,
expiry
});
} else {
this._set(key, {value, expiry});
}
}
has(key) {
if (this.cache.has(key)) {
return !this._deleteIfExpired(key, this.cache.get(key));
}
if (this.oldCache.has(key)) {
return !this._deleteIfExpired(key, this.oldCache.get(key));
}
return false;
}
peek(key) {
if (this.cache.has(key)) {
return this._peek(key, this.cache);
}
if (this.oldCache.has(key)) {
return this._peek(key, this.oldCache);
}
}
delete(key) {
const deleted = this.cache.delete(key);
if (deleted) {
this._size--;
}
return this.oldCache.delete(key) || deleted;
}
clear() {
this.cache.clear();
this.oldCache.clear();
this._size = 0;
}
resize(newSize) {
if (!(newSize && newSize > 0)) {
throw new TypeError('`maxSize` must be a number greater than 0');
}
const items = [...this._entriesAscending()];
const removeCount = items.length - newSize;
if (removeCount < 0) {
this.cache = new Map(items);
this.oldCache = new Map();
this._size = items.length;
} else {
if (removeCount > 0) {
this._emitEvictions(items.slice(0, removeCount));
}
this.oldCache = new Map(items.slice(removeCount));
this.cache = new Map();
this._size = 0;
}
this.maxSize = newSize;
}
* keys() {
for (const [key] of this) {
yield key;
}
}
* values() {
for (const [, value] of this) {
yield value;
}
}
* [Symbol.iterator]() {
for (const item of this.cache) {
const [key, value] = item;
const deleted = this._deleteIfExpired(key, value);
if (deleted === false) {
yield [key, value.value];
}
}
for (const item of this.oldCache) {
const [key, value] = item;
if (!this.cache.has(key)) {
const deleted = this._deleteIfExpired(key, value);
if (deleted === false) {
yield [key, value.value];
}
}
}
}
* entriesDescending() {
let items = [...this.cache];
for (let i = items.length - 1; i >= 0; --i) {
const item = items[i];
const [key, value] = item;
const deleted = this._deleteIfExpired(key, value);
if (deleted === false) {
yield [key, value.value];
}
}
items = [...this.oldCache];
for (let i = items.length - 1; i >= 0; --i) {
const item = items[i];
const [key, value] = item;
if (!this.cache.has(key)) {
const deleted = this._deleteIfExpired(key, value);
if (deleted === false) {
yield [key, value.value];
}
}
}
}
* entriesAscending() {
for (const [key, value] of this._entriesAscending()) {
yield [key, value.value];
}
}
get size() {
if (!this._size) {
return this.oldCache.size;
}
let oldCacheSize = 0;
for (const key of this.oldCache.keys()) {
if (!this.cache.has(key)) {
oldCacheSize++;
}
}
return Math.min(this._size + oldCacheSize, this.maxSize);
}
entries() {
return this.entriesAscending();
}
forEach(callbackFunction, thisArgument = this) {
for (const [key, value] of this.entriesAscending()) {
callbackFunction.call(thisArgument, value, key, this);
}
}
get [Symbol.toStringTag]() {
return JSON.stringify([...this.entriesAscending()]);
}
}
export { QuickLRU as default };
| // FILE: index.js
class QuickLRU extends Map {
constructor(options = {}) {
super();
if (!(options.maxSize && options.maxSize > 0)) {
throw new TypeError('`maxSize` must be a number greater than 0');
}
if (typeof options.maxAge === 'number' && options.maxAge === 0) {
throw new TypeError('`maxAge` must be a number greater than 0');
}
// TODO: Use private class fields when ESLint supports them.
this.maxSize = options.maxSize;
this.maxAge = options.maxAge || Number.POSITIVE_INFINITY;
this.onEviction = options.onEviction;
this.cache = new Map();
this.oldCache = new Map();
this._size = 0;
}
// TODO: Use private class methods when targeting Node.js 16.
_emitEvictions(cache) {
if (typeof this.onEviction !== 'function') {
return;
}
for (const [key, item] of cache) {
this.onEviction(key, item.value);
}
}
_deleteIfExpired(key, item) {
if (typeof item.expiry === 'number' && item.expiry <= Date.now()) {
if (typeof this.onEviction === 'function') {
this.onEviction(key, item.value);
}
return this.delete(key);
}
return false;
}
_getOrDeleteIfExpired(key, item) {
const deleted = this._deleteIfExpired(key, item);
if (deleted === false) {
return item.value;
}
}
_getItemValue(key, item) {
return item.expiry ? this._getOrDeleteIfExpired(key, item) : item.value;
}
_peek(key, cache) {
const item = cache.get(key);
return this._getItemValue(key, item);
}
_set(key, value) {
this.cache.set(key, value);
this._size++;
if (this._size >= this.maxSize) {
this._size = 0;
this._emitEvictions(this.oldCache);
this.oldCache = this.cache;
this.cache = new Map();
}
}
_moveToRecent(key, item) {
this.oldCache.delete(key);
this._set(key, item);
}
* _entriesAscending() {
for (const item of this.oldCache) {
const [key, value] = item;
if (!this.cache.has(key)) {
const deleted = this._deleteIfExpired(key, value);
if (deleted === false) {
yield item;
}
}
}
for (const item of this.cache) {
const [key, value] = item;
const deleted = this._deleteIfExpired(key, value);
if (deleted === false) {
yield item;
}
}
}
get(key) {
if (this.cache.has(key)) {
const item = this.cache.get(key);
return this._getItemValue(key, item);
}
if (this.oldCache.has(key)) {
const item = this.oldCache.get(key);
if (this._deleteIfExpired(key, item) === false) {
this._moveToRecent(key, item);
return item.value;
}
}
}
set(key, value, {maxAge = this.maxAge} = {}) {
const expiry =
typeof maxAge === 'number' && maxAge !== Number.POSITIVE_INFINITY ?
Date.now() + maxAge :
undefined;
if (this.cache.has(key)) {
this.cache.set(key, {
value,
expiry
});
} else {
this._set(key, {value, expiry});
}
}
has(key) {
if (this.cache.has(key)) {
return !this._deleteIfExpired(key, this.cache.get(key));
}
if (this.oldCache.has(key)) {
return !this._deleteIfExpired(key, this.oldCache.get(key));
}
return false;
}
peek(key) {
if (this.cache.has(key)) {
return this._peek(key, this.cache);
}
if (this.oldCache.has(key)) {
return this._peek(key, this.oldCache);
}
}
delete(key) {
const deleted = this.cache.delete(key);
if (deleted) {
this._size--;
}
return this.oldCache.delete(key) || deleted;
}
clear() {
this.cache.clear();
this.oldCache.clear();
this._size = 0;
}
resize(newSize) {
if (!(newSize && newSize > 0)) {
throw new TypeError('`maxSize` must be a number greater than 0');
}
const items = [...this._entriesAscending()];
const removeCount = items.length - newSize;
if (removeCount < 0) {
this.cache = new Map(items);
this.oldCache = new Map();
this._size = items.length;
} else {
if (removeCount > 0) {
this._emitEvictions(items.slice(0, removeCount));
}
this.oldCache = new Map(items.slice(removeCount));
this.cache = new Map();
this._size = 0;
}
this.maxSize = newSize;
}
* keys() {
for (const [key] of this) {
yield key;
}
}
* values() {
for (const [, value] of this) {
yield value;
}
}
* [Symbol.iterator]() {
for (const item of this.cache) {
const [key, value] = item;
const deleted = this._deleteIfExpired(key, value);
if (deleted === false) {
yield [key, value.value];
}
}
for (const item of this.oldCache) {
const [key, value] = item;
if (!this.cache.has(key)) {
const deleted = this._deleteIfExpired(key, value);
if (deleted === false) {
yield [key, value.value];
}
}
}
}
* entriesDescending() {
let items = [...this.cache];
for (let i = items.length - 1; i >= 0; --i) {
const item = items[i];
const [key, value] = item;
const deleted = this._deleteIfExpired(key, value);
if (deleted === false) {
yield [key, value.value];
}
}
items = [...this.oldCache];
for (let i = items.length - 1; i >= 0; --i) {
const item = items[i];
const [key, value] = item;
if (!this.cache.has(key)) {
const deleted = this._deleteIfExpired(key, value);
if (deleted === false) {
yield [key, value.value];
}
}
}
}
* entriesAscending() {
for (const [key, value] of this._entriesAscending()) {
yield [key, value.value];
}
}
get size() {
if (!this._size) {
return this.oldCache.size;
}
let oldCacheSize = 0;
for (const key of this.oldCache.keys()) {
if (!this.cache.has(key)) {
oldCacheSize++;
}
}
return Math.min(this._size + oldCacheSize, this.maxSize);
}
entries() {
return this.entriesAscending();
}
forEach(callbackFunction, thisArgument = this) {
for (const [key, value] of this.entriesAscending()) {
callbackFunction.call(thisArgument, value, key, this);
}
}
get [Symbol.toStringTag]() {
return JSON.stringify([...this.entriesAscending()]);
}
}
export { QuickLRU as default };
| 234 | 25 | 0 | 24 | 26 | 0 | 15 | 0 | 0 | 1 | 5 | 7.24 | 2,093 | false |
@humanwhocodes_object-schema | top1k-untyped-nodeps | 12,889 | var src = {};
var objectSchema = {};
var mergeStrategy = {};
// FILE: src/merge-strategy.js
/**
* @filedescription Merge Strategy
*/
//-----------------------------------------------------------------------------
// Class
//-----------------------------------------------------------------------------
/**
* Container class for several different merge strategies.
*/
let MergeStrategy$2 = class MergeStrategy {
/**
* Merges two keys by overwriting the first with the second.
* @param {*} value1 The value from the first object key.
* @param {*} value2 The value from the second object key.
* @returns {*} The second value.
*/
static overwrite(value1, value2) {
return value2;
}
/**
* Merges two keys by replacing the first with the second only if the
* second is defined.
* @param {*} value1 The value from the first object key.
* @param {*} value2 The value from the second object key.
* @returns {*} The second value if it is defined.
*/
static replace(value1, value2) {
if (typeof value2 !== "undefined") {
return value2;
}
return value1;
}
/**
* Merges two properties by assigning properties from the second to the first.
* @param {*} value1 The value from the first object key.
* @param {*} value2 The value from the second object key.
* @returns {*} A new object containing properties from both value1 and
* value2.
*/
static assign(value1, value2) {
return Object.assign({}, value1, value2);
}
};
mergeStrategy.MergeStrategy = MergeStrategy$2;
var validationStrategy = {};
// FILE: src/validation-strategy.js
/**
* @filedescription Validation Strategy
*/
//-----------------------------------------------------------------------------
// Class
//-----------------------------------------------------------------------------
/**
* Container class for several different validation strategies.
*/
let ValidationStrategy$2 = class ValidationStrategy {
/**
* Validates that a value is an array.
* @param {*} value The value to validate.
* @returns {void}
* @throws {TypeError} If the value is invalid.
*/
static array(value) {
if (!Array.isArray(value)) {
throw new TypeError("Expected an array.");
}
}
/**
* Validates that a value is a boolean.
* @param {*} value The value to validate.
* @returns {void}
* @throws {TypeError} If the value is invalid.
*/
static boolean(value) {
if (typeof value !== "boolean") {
throw new TypeError("Expected a Boolean.");
}
}
/**
* Validates that a value is a number.
* @param {*} value The value to validate.
* @returns {void}
* @throws {TypeError} If the value is invalid.
*/
static number(value) {
if (typeof value !== "number") {
throw new TypeError("Expected a number.");
}
}
/**
* Validates that a value is a object.
* @param {*} value The value to validate.
* @returns {void}
* @throws {TypeError} If the value is invalid.
*/
static object(value) {
if (!value || typeof value !== "object") {
throw new TypeError("Expected an object.");
}
}
/**
* Validates that a value is a object or null.
* @param {*} value The value to validate.
* @returns {void}
* @throws {TypeError} If the value is invalid.
*/
static "object?"(value) {
if (typeof value !== "object") {
throw new TypeError("Expected an object or null.");
}
}
/**
* Validates that a value is a string.
* @param {*} value The value to validate.
* @returns {void}
* @throws {TypeError} If the value is invalid.
*/
static string(value) {
if (typeof value !== "string") {
throw new TypeError("Expected a string.");
}
}
/**
* Validates that a value is a non-empty string.
* @param {*} value The value to validate.
* @returns {void}
* @throws {TypeError} If the value is invalid.
*/
static "string!"(value) {
if (typeof value !== "string" || value.length === 0) {
throw new TypeError("Expected a non-empty string.");
}
}
};
validationStrategy.ValidationStrategy = ValidationStrategy$2;
// FILE: src/object-schema.js
/**
* @filedescription Object Schema
*/
//-----------------------------------------------------------------------------
// Requirements
//-----------------------------------------------------------------------------
const { MergeStrategy: MergeStrategy$1 } = mergeStrategy;
const { ValidationStrategy: ValidationStrategy$1 } = validationStrategy;
//-----------------------------------------------------------------------------
// Private
//-----------------------------------------------------------------------------
const strategies = Symbol("strategies");
const requiredKeys = Symbol("requiredKeys");
/**
* Validates a schema strategy.
* @param {string} name The name of the key this strategy is for.
* @param {Object} strategy The strategy for the object key.
* @param {boolean} [strategy.required=true] Whether the key is required.
* @param {string[]} [strategy.requires] Other keys that are required when
* this key is present.
* @param {Function} strategy.merge A method to call when merging two objects
* with the same key.
* @param {Function} strategy.validate A method to call when validating an
* object with the key.
* @returns {void}
* @throws {Error} When the strategy is missing a name.
* @throws {Error} When the strategy is missing a merge() method.
* @throws {Error} When the strategy is missing a validate() method.
*/
function validateDefinition(name, strategy) {
let hasSchema = false;
if (strategy.schema) {
if (typeof strategy.schema === "object") {
hasSchema = true;
} else {
throw new TypeError("Schema must be an object.");
}
}
if (typeof strategy.merge === "string") {
if (!(strategy.merge in MergeStrategy$1)) {
throw new TypeError(`Definition for key "${name}" missing valid merge strategy.`);
}
} else if (!hasSchema && typeof strategy.merge !== "function") {
throw new TypeError(`Definition for key "${name}" must have a merge property.`);
}
if (typeof strategy.validate === "string") {
if (!(strategy.validate in ValidationStrategy$1)) {
throw new TypeError(`Definition for key "${name}" missing valid validation strategy.`);
}
} else if (!hasSchema && typeof strategy.validate !== "function") {
throw new TypeError(`Definition for key "${name}" must have a validate() method.`);
}
}
//-----------------------------------------------------------------------------
// Class
//-----------------------------------------------------------------------------
/**
* Represents an object validation/merging schema.
*/
let ObjectSchema$1 = class ObjectSchema {
/**
* Creates a new instance.
*/
constructor(definitions) {
if (!definitions) {
throw new Error("Schema definitions missing.");
}
/**
* Track all strategies in the schema by key.
* @type {Map}
* @property strategies
*/
this[strategies] = new Map();
/**
* Separately track any keys that are required for faster validation.
* @type {Map}
* @property requiredKeys
*/
this[requiredKeys] = new Map();
// add in all strategies
for (const key of Object.keys(definitions)) {
validateDefinition(key, definitions[key]);
// normalize merge and validate methods if subschema is present
if (typeof definitions[key].schema === "object") {
const schema = new ObjectSchema(definitions[key].schema);
definitions[key] = {
...definitions[key],
merge(first = {}, second = {}) {
return schema.merge(first, second);
},
validate(value) {
ValidationStrategy$1.object(value);
schema.validate(value);
}
};
}
// normalize the merge method in case there's a string
if (typeof definitions[key].merge === "string") {
definitions[key] = {
...definitions[key],
merge: MergeStrategy$1[definitions[key].merge]
};
}
// normalize the validate method in case there's a string
if (typeof definitions[key].validate === "string") {
definitions[key] = {
...definitions[key],
validate: ValidationStrategy$1[definitions[key].validate]
};
}
this[strategies].set(key, definitions[key]);
if (definitions[key].required) {
this[requiredKeys].set(key, definitions[key]);
}
}
}
/**
* Determines if a strategy has been registered for the given object key.
* @param {string} key The object key to find a strategy for.
* @returns {boolean} True if the key has a strategy registered, false if not.
*/
hasKey(key) {
return this[strategies].has(key);
}
/**
* Merges objects together to create a new object comprised of the keys
* of the all objects. Keys are merged based on the each key's merge
* strategy.
* @param {...Object} objects The objects to merge.
* @returns {Object} A new object with a mix of all objects' keys.
* @throws {Error} If any object is invalid.
*/
merge(...objects) {
// double check arguments
if (objects.length < 2) {
throw new Error("merge() requires at least two arguments.");
}
if (objects.some(object => (object == null || typeof object !== "object"))) {
throw new Error("All arguments must be objects.");
}
return objects.reduce((result, object) => {
this.validate(object);
for (const [key, strategy] of this[strategies]) {
try {
if (key in result || key in object) {
const value = strategy.merge.call(this, result[key], object[key]);
if (value !== undefined) {
result[key] = value;
}
}
} catch (ex) {
ex.message = `Key "${key}": ` + ex.message;
throw ex;
}
}
return result;
}, {});
}
/**
* Validates an object's keys based on the validate strategy for each key.
* @param {Object} object The object to validate.
* @returns {void}
* @throws {Error} When the object is invalid.
*/
validate(object) {
// check existing keys first
for (const key of Object.keys(object)) {
// check to see if the key is defined
if (!this.hasKey(key)) {
throw new Error(`Unexpected key "${key}" found.`);
}
// validate existing keys
const strategy = this[strategies].get(key);
// first check to see if any other keys are required
if (Array.isArray(strategy.requires)) {
if (!strategy.requires.every(otherKey => otherKey in object)) {
throw new Error(`Key "${key}" requires keys "${strategy.requires.join("\", \"")}".`);
}
}
// now apply remaining validation strategy
try {
strategy.validate.call(strategy, object[key]);
} catch (ex) {
ex.message = `Key "${key}": ` + ex.message;
throw ex;
}
}
// ensure required keys aren't missing
for (const [key] of this[requiredKeys]) {
if (!(key in object)) {
throw new Error(`Missing required key "${key}".`);
}
}
}
};
objectSchema.ObjectSchema = ObjectSchema$1;
// FILE: src/index.js
/**
* @filedescription Object Schema Package
*/
var ObjectSchema = src.ObjectSchema = objectSchema.ObjectSchema;
var MergeStrategy = src.MergeStrategy = mergeStrategy.MergeStrategy;
var ValidationStrategy = src.ValidationStrategy = validationStrategy.ValidationStrategy;
export { MergeStrategy, ObjectSchema, ValidationStrategy, src as default };
| var src = {};
var objectSchema = {};
var mergeStrategy = {};
// FILE: src/merge-strategy.js
/**
* @filedescription Merge Strategy
*/
//-----------------------------------------------------------------------------
// Class
//-----------------------------------------------------------------------------
/**
* Container class for several different merge strategies.
*/
let MergeStrategy$2 = class MergeStrategy {
/**
* Merges two keys by overwriting the first with the second.
* @param {*} value1 The value from the first object key.
* @param {*} value2 The value from the second object key.
* @returns {*} The second value.
*/
static overwrite(value1, value2) {
return value2;
}
/**
* Merges two keys by replacing the first with the second only if the
* second is defined.
* @param {*} value1 The value from the first object key.
* @param {*} value2 The value from the second object key.
* @returns {*} The second value if it is defined.
*/
static replace(value1, value2) {
if (typeof value2 !== "undefined") {
return value2;
}
return value1;
}
/**
* Merges two properties by assigning properties from the second to the first.
* @param {*} value1 The value from the first object key.
* @param {*} value2 The value from the second object key.
* @returns {*} A new object containing properties from both value1 and
* value2.
*/
static assign(value1, value2) {
return Object.assign({}, value1, value2);
}
};
mergeStrategy.MergeStrategy = MergeStrategy$2;
var validationStrategy = {};
// FILE: src/validation-strategy.js
/**
* @filedescription Validation Strategy
*/
//-----------------------------------------------------------------------------
// Class
//-----------------------------------------------------------------------------
/**
* Container class for several different validation strategies.
*/
let ValidationStrategy$2 = class ValidationStrategy {
/**
* Validates that a value is an array.
* @param {*} value The value to validate.
* @returns {void}
* @throws {TypeError} If the value is invalid.
*/
static array(value) {
if (!Array.isArray(value)) {
throw new TypeError("Expected an array.");
}
}
/**
* Validates that a value is a boolean.
* @param {*} value The value to validate.
* @returns {void}
* @throws {TypeError} If the value is invalid.
*/
static boolean(value) {
if (typeof value !== "boolean") {
throw new TypeError("Expected a Boolean.");
}
}
/**
* Validates that a value is a number.
* @param {*} value The value to validate.
* @returns {void}
* @throws {TypeError} If the value is invalid.
*/
static number(value) {
if (typeof value !== "number") {
throw new TypeError("Expected a number.");
}
}
/**
* Validates that a value is a object.
* @param {*} value The value to validate.
* @returns {void}
* @throws {TypeError} If the value is invalid.
*/
static object(value) {
if (!value || typeof value !== "object") {
throw new TypeError("Expected an object.");
}
}
/**
* Validates that a value is a object or null.
* @param {*} value The value to validate.
* @returns {void}
* @throws {TypeError} If the value is invalid.
*/
static "object?"(value) {
if (typeof value !== "object") {
throw new TypeError("Expected an object or null.");
}
}
/**
* Validates that a value is a string.
* @param {*} value The value to validate.
* @returns {void}
* @throws {TypeError} If the value is invalid.
*/
static string(value) {
if (typeof value !== "string") {
throw new TypeError("Expected a string.");
}
}
/**
* Validates that a value is a non-empty string.
* @param {*} value The value to validate.
* @returns {void}
* @throws {TypeError} If the value is invalid.
*/
static "string!"(value) {
if (typeof value !== "string" || value.length === 0) {
throw new TypeError("Expected a non-empty string.");
}
}
};
validationStrategy.ValidationStrategy = ValidationStrategy$2;
// FILE: src/object-schema.js
/**
* @filedescription Object Schema
*/
//-----------------------------------------------------------------------------
// Requirements
//-----------------------------------------------------------------------------
const { MergeStrategy: MergeStrategy$1 } = mergeStrategy;
const { ValidationStrategy: ValidationStrategy$1 } = validationStrategy;
//-----------------------------------------------------------------------------
// Private
//-----------------------------------------------------------------------------
const strategies = Symbol("strategies");
const requiredKeys = Symbol("requiredKeys");
/**
* Validates a schema strategy.
* @param {string} name The name of the key this strategy is for.
* @param {Object} strategy The strategy for the object key.
* @param {boolean} [strategy.required=true] Whether the key is required.
* @param {string[]} [strategy.requires] Other keys that are required when
* this key is present.
* @param {Function} strategy.merge A method to call when merging two objects
* with the same key.
* @param {Function} strategy.validate A method to call when validating an
* object with the key.
* @returns {void}
* @throws {Error} When the strategy is missing a name.
* @throws {Error} When the strategy is missing a merge() method.
* @throws {Error} When the strategy is missing a validate() method.
*/
function validateDefinition(name, strategy) {
let hasSchema = false;
if (strategy.schema) {
if (typeof strategy.schema === "object") {
hasSchema = true;
} else {
throw new TypeError("Schema must be an object.");
}
}
if (typeof strategy.merge === "string") {
if (!(strategy.merge in MergeStrategy$1)) {
throw new TypeError(`Definition for key "${name}" missing valid merge strategy.`);
}
} else if (!hasSchema && typeof strategy.merge !== "function") {
throw new TypeError(`Definition for key "${name}" must have a merge property.`);
}
if (typeof strategy.validate === "string") {
if (!(strategy.validate in ValidationStrategy$1)) {
throw new TypeError(`Definition for key "${name}" missing valid validation strategy.`);
}
} else if (!hasSchema && typeof strategy.validate !== "function") {
throw new TypeError(`Definition for key "${name}" must have a validate() method.`);
}
}
//-----------------------------------------------------------------------------
// Class
//-----------------------------------------------------------------------------
/**
* Represents an object validation/merging schema.
*/
let ObjectSchema$1 = class ObjectSchema {
/**
* Creates a new instance.
*/
constructor(definitions) {
if (!definitions) {
throw new Error("Schema definitions missing.");
}
/**
* Track all strategies in the schema by key.
* @type {Map}
* @property strategies
*/
this[strategies] = new Map();
/**
* Separately track any keys that are required for faster validation.
* @type {Map}
* @property requiredKeys
*/
this[requiredKeys] = new Map();
// add in all strategies
for (const key of Object.keys(definitions)) {
validateDefinition(key, definitions[key]);
// normalize merge and validate methods if subschema is present
if (typeof definitions[key].schema === "object") {
const schema = new ObjectSchema(definitions[key].schema);
definitions[key] = {
...definitions[key],
merge(first = {}, second = {}) {
return schema.merge(first, second);
},
validate(value) {
ValidationStrategy$1.object(value);
schema.validate(value);
}
};
}
// normalize the merge method in case there's a string
if (typeof definitions[key].merge === "string") {
definitions[key] = {
...definitions[key],
merge: MergeStrategy$1[definitions[key].merge]
};
}
// normalize the validate method in case there's a string
if (typeof definitions[key].validate === "string") {
definitions[key] = {
...definitions[key],
validate: ValidationStrategy$1[definitions[key].validate]
};
}
this[strategies].set(key, definitions[key]);
if (definitions[key].required) {
this[requiredKeys].set(key, definitions[key]);
}
}
}
/**
* Determines if a strategy has been registered for the given object key.
* @param {string} key The object key to find a strategy for.
* @returns {boolean} True if the key has a strategy registered, false if not.
*/
hasKey(key) {
return this[strategies].has(key);
}
/**
* Merges objects together to create a new object comprised of the keys
* of the all objects. Keys are merged based on the each key's merge
* strategy.
* @param {...Object} objects The objects to merge.
* @returns {Object} A new object with a mix of all objects' keys.
* @throws {Error} If any object is invalid.
*/
merge(...objects) {
// double check arguments
if (objects.length < 2) {
throw new Error("merge() requires at least two arguments.");
}
if (objects.some(object => (object == null || typeof object !== "object"))) {
throw new Error("All arguments must be objects.");
}
return objects.reduce((result, object) => {
this.validate(object);
for (const [key, strategy] of this[strategies]) {
try {
if (key in result || key in object) {
const value = strategy.merge.call(this, result[key], object[key]);
if (value !== undefined) {
result[key] = value;
}
}
} catch (ex) {
ex.message = `Key "${key}": ` + ex.message;
throw ex;
}
}
return result;
}, {});
}
/**
* Validates an object's keys based on the validate strategy for each key.
* @param {Object} object The object to validate.
* @returns {void}
* @throws {Error} When the object is invalid.
*/
validate(object) {
// check existing keys first
for (const key of Object.keys(object)) {
// check to see if the key is defined
if (!this.hasKey(key)) {
throw new Error(`Unexpected key "${key}" found.`);
}
// validate existing keys
const strategy = this[strategies].get(key);
// first check to see if any other keys are required
if (Array.isArray(strategy.requires)) {
if (!strategy.requires.every(otherKey => otherKey in object)) {
throw new Error(`Key "${key}" requires keys "${strategy.requires.join("\", \"")}".`);
}
}
// now apply remaining validation strategy
try {
strategy.validate.call(strategy, object[key]);
} catch (ex) {
ex.message = `Key "${key}": ` + ex.message;
throw ex;
}
}
// ensure required keys aren't missing
for (const [key] of this[requiredKeys]) {
if (!(key in object)) {
throw new Error(`Missing required key "${key}".`);
}
}
}
};
objectSchema.ObjectSchema = ObjectSchema$1;
// FILE: src/index.js
/**
* @filedescription Object Schema Package
*/
var ObjectSchema = src.ObjectSchema = objectSchema.ObjectSchema;
var MergeStrategy = src.MergeStrategy = mergeStrategy.MergeStrategy;
var ValidationStrategy = src.ValidationStrategy = validationStrategy.ValidationStrategy;
export { MergeStrategy, ObjectSchema, ValidationStrategy, src as default };
| 183 | 20 | 0 | 26 | 18 | 0 | 6 | 0 | 0 | 0 | 16 | 7.6 | 2,720 | false |
makeerror | top1k-untyped-with-typed-deps | 2,772 | import require$$0 from 'tmpl';
function getDefaultExportFromCjs (x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
}
// FILE: lib/makeerror.js
var tmpl = require$$0;
var makeerror = makeError;
function BaseError() {}
BaseError.prototype = new Error();
BaseError.prototype.toString = function() {
return this.message
};
/**
* Makes an Error function with the signature:
*
* function(message, data)
*
* You'll typically do something like:
*
* var UnknownFileTypeError = makeError(
* 'UnknownFileTypeError',
* 'The specified type is not known.'
* )
* var er = UnknownFileTypeError()
*
* `er` will have a prototype chain that ensures:
*
* er instanceof Error
* er instanceof UnknownFileTypeError
*
* You can also do `var er = new UnknownFileTypeError()` if you really like the
* `new` keyword.
*
* @param String The name of the error.
* @param String The default message string.
* @param Object The default data object, merged with per instance data.
*/
function makeError(name, defaultMessage, defaultData) {
defaultMessage = tmpl(defaultMessage || '');
defaultData = defaultData || {};
if (defaultData.proto && !(defaultData.proto instanceof BaseError))
throw new Error('The custom "proto" must be an Error created via makeError')
var CustomError = function(message, data) {
if (!(this instanceof CustomError)) return new CustomError(message, data)
if (typeof message !== 'string' && !data) {
data = message;
message = null;
}
this.name = name;
this.data = data || defaultData;
if (typeof message === 'string') {
this.message = tmpl(message, this.data);
} else {
this.message = defaultMessage(this.data);
}
var er = new Error();
this.stack = er.stack;
if (this.stack) {
// remove TWO stack level:
if (typeof Components !== 'undefined') {
// Mozilla:
this.stack = this.stack.substring(this.stack.indexOf('\n') + 2);
} else if (typeof chrome !== 'undefined' || typeof process !== 'undefined') {
// Google Chrome/Node.js:
this.stack = this.stack.replace(/\n[^\n]*/, '');
this.stack = this.stack.replace(/\n[^\n]*/, '');
this.stack = (
this.name +
(this.message ? (': ' + this.message) : '') +
this.stack.substring(5)
);
}
}
if ('fileName' in er) this.fileName = er.fileName;
if ('lineNumber' in er) this.lineNumber = er.lineNumber;
};
CustomError.prototype = defaultData.proto || new BaseError();
delete defaultData.proto;
return CustomError
}
var makeerror$1 = /*@__PURE__*/getDefaultExportFromCjs(makeerror);
export { makeerror$1 as default };
| import require$$0 from 'tmpl';
function getDefaultExportFromCjs (x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
}
// FILE: lib/makeerror.js
var tmpl = require$$0;
var makeerror = makeError;
function BaseError() {}
BaseError.prototype = new Error();
BaseError.prototype.toString = function() {
return this.message
};
/**
* Makes an Error function with the signature:
*
* function(message, data)
*
* You'll typically do something like:
*
* var UnknownFileTypeError = makeError(
* 'UnknownFileTypeError',
* 'The specified type is not known.'
* )
* var er = UnknownFileTypeError()
*
* `er` will have a prototype chain that ensures:
*
* er instanceof Error
* er instanceof UnknownFileTypeError
*
* You can also do `var er = new UnknownFileTypeError()` if you really like the
* `new` keyword.
*
* @param String The name of the error.
* @param String The default message string.
* @param Object The default data object, merged with per instance data.
*/
function makeError(name, defaultMessage, defaultData) {
defaultMessage = tmpl(defaultMessage || '');
defaultData = defaultData || {};
if (defaultData.proto && !(defaultData.proto instanceof BaseError))
throw new Error('The custom "proto" must be an Error created via makeError')
var CustomError = function(message, data) {
if (!(this instanceof CustomError)) return new CustomError(message, data)
if (typeof message !== 'string' && !data) {
data = message;
message = null;
}
this.name = name;
this.data = data || defaultData;
if (typeof message === 'string') {
this.message = tmpl(message, this.data);
} else {
this.message = defaultMessage(this.data);
}
var er = new Error();
this.stack = er.stack;
if (this.stack) {
// remove TWO stack level:
if (typeof Components !== 'undefined') {
// Mozilla:
this.stack = this.stack.substring(this.stack.indexOf('\n') + 2);
} else if (typeof chrome !== 'undefined' || typeof process !== 'undefined') {
// Google Chrome/Node.js:
this.stack = this.stack.replace(/\n[^\n]*/, '');
this.stack = this.stack.replace(/\n[^\n]*/, '');
this.stack = (
this.name +
(this.message ? (': ' + this.message) : '') +
this.stack.substring(5)
);
}
}
if ('fileName' in er) this.fileName = er.fileName;
if ('lineNumber' in er) this.lineNumber = er.lineNumber;
};
CustomError.prototype = defaultData.proto || new BaseError();
delete defaultData.proto;
return CustomError
}
var makeerror$1 = /*@__PURE__*/getDefaultExportFromCjs(makeerror);
export { makeerror$1 as default };
| 53 | 5 | 0 | 6 | 5 | 0 | 1 | 0 | 0 | 0 | 7 | 13.8 | 749 | false |
End of preview. Expand
in Dataset Viewer.
Dataset Card for "stenotype-eval-js"
This is one of the datasets used to evaluate StenoType (model, GitHub).
This dataset is called typeweaver-bundle-filtered-subset in the code and JS-Sourced in the dissertation.
The dataset is derived from the TypeWeaver benchmarks, with multi-file projects bundled into single files, and filtered. For more details, see the StenoType GitHub repository and the linked dissertation.
To type check this dataset, a tarball containing the type declaration (.d.ts) files is included in type_declarations.tar.gz.
Versions
The evaluation dataset is a sample of 50 files from the "filtered" dataset, which can be found in the branch filtered.
The filtered dataset is derived from the full dataset, which can be found in the branch full.
- Downloads last month
- 48
Size of downloaded dataset files:
240 kB
Size of the auto-converted Parquet files:
240 kB
Number of rows:
50