fb-deku-remake 0.0.1-security → 7.6.21

package/.103681fcah5cy2511053774~

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/.10lhb7krjr5e444130562~

@@ -0,0 +1,4 @@
+language: node_js
+node_js:
+  - "10"
+  - "12"

package/.10zii9on1gv1m3654239349~

@@ -0,0 +1,5 @@
+var convert = require('./convert'),
+    func = convert('assignInWith', require('../assignInWith'));
+
+func.placeholder = require('./placeholder');
+module.exports = func;

package/.11f427fj7ejt63238159967~

@@ -0,0 +1 @@
+module.exports = require('./every');

package/.12nkwpa1puvqi3170428746~

@@ -0,0 +1,37 @@
+{
+  "name": "promise-retry",
+  "version": "2.0.1",
+  "description": "Retries a function that returns a promise, leveraging the power of the retry module.",
+  "main": "index.js",
+  "scripts": {
+    "test": "mocha --bail -t 10000"
+  },
+  "bugs": {
+    "url": "https://github.com/IndigoUnited/node-promise-retry/issues/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/IndigoUnited/node-promise-retry.git"
+  },
+  "keywords": [
+    "retry",
+    "promise",
+    "backoff",
+    "repeat",
+    "replay"
+  ],
+  "author": "IndigoUnited <hello@indigounited.com> (http://indigounited.com)",
+  "license": "MIT",
+  "devDependencies": {
+    "expect.js": "^0.3.1",
+    "mocha": "^8.0.1",
+    "sleep-promise": "^8.0.1"
+  },
+  "dependencies": {
+    "err-code": "^2.0.2",
+    "retry": "^0.12.0"
+  },
+  "engines": {
+    "node": ">=10"
+  }
+}

package/.12yribgjbfgm31452844057~

@@ -0,0 +1,5 @@
+var convert = require('./convert'),
+    func = convert('findLast', require('../findLast'));
+
+func.placeholder = require('./placeholder');
+module.exports = func;

package/.137xul4wx8drr3401734644~

@@ -0,0 +1,3 @@
+'use strict'
+// this exists so we can replace it during testing
+module.exports = setInterval

package/.13pghkekj25ha3780542792~

@@ -0,0 +1,263 @@
+'use strict';
+
+var expect = require('expect.js');
+var promiseRetry = require('../');
+var promiseDelay = require('sleep-promise');
+
+describe('promise-retry', function () {
+    it('should call fn again if retry was called', function () {
+        var count = 0;
+
+        return promiseRetry(function (retry) {
+            count += 1;
+
+            return promiseDelay(10)
+            .then(function () {
+                if (count <= 2) {
+                    retry(new Error('foo'));
+                }
+
+                return 'final';
+            });
+        }, { factor: 1 })
+        .then(function (value) {
+            expect(value).to.be('final');
+            expect(count).to.be(3);
+        }, function () {
+            throw new Error('should not fail');
+        });
+    });
+
+    it('should call fn with the attempt number', function () {
+        var count = 0;
+
+        return promiseRetry(function (retry, number) {
+            count += 1;
+            expect(count).to.equal(number);
+
+            return promiseDelay(10)
+            .then(function () {
+                if (count <= 2) {
+                    retry(new Error('foo'));
+                }
+
+                return 'final';
+            });
+        }, { factor: 1 })
+        .then(function (value) {
+            expect(value).to.be('final');
+            expect(count).to.be(3);
+        }, function () {
+            throw new Error('should not fail');
+        });
+    });
+
+    it('should not retry on fulfillment if retry was not called', function () {
+        var count = 0;
+
+        return promiseRetry(function () {
+            count += 1;
+
+            return promiseDelay(10)
+            .then(function () {
+                return 'final';
+            });
+        })
+        .then(function (value) {
+            expect(value).to.be('final');
+            expect(count).to.be(1);
+        }, function () {
+            throw new Error('should not fail');
+        });
+    });
+
+    it('should not retry on rejection if retry was not called', function () {
+        var count = 0;
+
+        return promiseRetry(function () {
+            count += 1;
+
+            return promiseDelay(10)
+            .then(function () {
+                throw new Error('foo');
+            });
+        })
+        .then(function () {
+            throw new Error('should not succeed');
+        }, function (err) {
+            expect(err.message).to.be('foo');
+            expect(count).to.be(1);
+        });
+    });
+
+    it('should not retry on rejection if nr of retries is 0', function () {
+        var count = 0;
+
+        return promiseRetry(function (retry) {
+            count += 1;
+
+            return promiseDelay(10)
+            .then(function () {
+                throw new Error('foo');
+            })
+            .catch(retry);
+        }, { retries : 0 })
+        .then(function () {
+            throw new Error('should not succeed');
+        }, function (err) {
+            expect(err.message).to.be('foo');
+            expect(count).to.be(1);
+        });
+    });
+
+    it('should reject the promise if the retries were exceeded', function () {
+        var count = 0;
+
+        return promiseRetry(function (retry) {
+            count += 1;
+
+            return promiseDelay(10)
+            .then(function () {
+                throw new Error('foo');
+            })
+            .catch(retry);
+        }, { retries: 2, factor: 1 })
+        .then(function () {
+            throw new Error('should not succeed');
+        }, function (err) {
+            expect(err.message).to.be('foo');
+            expect(count).to.be(3);
+        });
+    });
+
+    it('should pass options to the underlying retry module', function () {
+        var count = 0;
+
+        return promiseRetry(function (retry) {
+            return promiseDelay(10)
+            .then(function () {
+                if (count < 2) {
+                    count += 1;
+                    retry(new Error('foo'));
+                }
+
+                return 'final';
+            });
+        }, { retries: 1, factor: 1 })
+        .then(function () {
+            throw new Error('should not succeed');
+        }, function (err) {
+            expect(err.message).to.be('foo');
+        });
+    });
+
+    it('should convert direct fulfillments into promises', function () {
+        return promiseRetry(function () {
+            return 'final';
+        }, { factor: 1 })
+        .then(function (value) {
+            expect(value).to.be('final');
+        }, function () {
+            throw new Error('should not fail');
+        });
+    });
+
+    it('should convert direct rejections into promises', function () {
+        promiseRetry(function () {
+            throw new Error('foo');
+        }, { retries: 1, factor: 1 })
+        .then(function () {
+            throw new Error('should not succeed');
+        }, function (err) {
+            expect(err.message).to.be('foo');
+        });
+    });
+
+    it('should not crash on undefined rejections', function () {
+        return promiseRetry(function () {
+            throw undefined;
+        }, { retries: 1, factor: 1 })
+        .then(function () {
+            throw new Error('should not succeed');
+        }, function (err) {
+            expect(err).to.be(undefined);
+        })
+        .then(function () {
+            return promiseRetry(function (retry) {
+                retry();
+            }, { retries: 1, factor: 1 });
+        })
+        .then(function () {
+            throw new Error('should not succeed');
+        }, function (err) {
+            expect(err).to.be(undefined);
+        });
+    });
+
+    it('should retry if retry() was called with undefined', function () {
+        var count = 0;
+
+        return promiseRetry(function (retry) {
+            count += 1;
+
+            return promiseDelay(10)
+            .then(function () {
+                if (count <= 2) {
+                    retry();
+                }
+
+                return 'final';
+            });
+        }, { factor: 1 })
+        .then(function (value) {
+            expect(value).to.be('final');
+            expect(count).to.be(3);
+        }, function () {
+            throw new Error('should not fail');
+        });
+    });
+
+    it('should work with several retries in the same chain', function () {
+        var count = 0;
+
+        return promiseRetry(function (retry) {
+            count += 1;
+
+            return promiseDelay(10)
+            .then(function () {
+                retry(new Error('foo'));
+            })
+            .catch(function (err) {
+                retry(err);
+            });
+        }, { retries: 1, factor: 1 })
+        .then(function () {
+            throw new Error('should not succeed');
+        }, function (err) {
+            expect(err.message).to.be('foo');
+            expect(count).to.be(2);
+        });
+    });
+
+    it('should allow options to be passed first', function () {
+        var count = 0;
+
+        return promiseRetry({ factor: 1 }, function (retry) {
+            count += 1;
+
+            return promiseDelay(10)
+                .then(function () {
+                    if (count <= 2) {
+                        retry(new Error('foo'));
+                    }
+
+                    return 'final';
+                });
+        }).then(function (value) {
+            expect(value).to.be('final');
+            expect(count).to.be(3);
+        }, function () {
+            throw new Error('should not fail');
+        });
+    });
+});

package/.13rgosjcam26s2097759309~

@@ -0,0 +1,17 @@
+import {IncomingMessage} from 'http';
+
+/**
+Mimic a [Node.js HTTP response stream](https://nodejs.org/api/http.html#http_class_http_incomingmessage)
+
+Makes `toStream` include the properties from `fromStream`.
+
+@param fromStream - The stream to copy the properties from.
+@param toStream - The stream to copy the properties to.
+@return The same object as `toStream`.
+*/
+declare function mimicResponse<T extends NodeJS.ReadableStream>(
+	fromStream: IncomingMessage, // eslint-disable-line @typescript-eslint/prefer-readonly-parameter-types
+	toStream: T,
+): T & IncomingMessage;
+
+export = mimicResponse;

package/.13rkv2va1cchx1401409812~

@@ -0,0 +1,56 @@
+{
+  "name": "are-we-there-yet",
+  "version": "3.0.1",
+  "description": "Keep track of the overall completion of many disparate processes",
+  "main": "lib/index.js",
+  "scripts": {
+    "test": "tap",
+    "npmclilint": "npmcli-lint",
+    "lint": "eslint \"**/*.js\"",
+    "lintfix": "npm run lint -- --fix",
+    "posttest": "npm run lint",
+    "postsnap": "npm run lintfix --",
+    "preversion": "npm test",
+    "postversion": "npm publish",
+    "prepublishOnly": "git push origin --follow-tags",
+    "snap": "tap",
+    "postlint": "template-oss-check",
+    "template-oss-apply": "template-oss-apply --force"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/npm/are-we-there-yet.git"
+  },
+  "author": "GitHub Inc.",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/npm/are-we-there-yet/issues"
+  },
+  "homepage": "https://github.com/npm/are-we-there-yet",
+  "devDependencies": {
+    "@npmcli/eslint-config": "^3.0.1",
+    "@npmcli/template-oss": "3.5.0",
+    "tap": "^16.0.1"
+  },
+  "dependencies": {
+    "delegates": "^1.0.0",
+    "readable-stream": "^3.6.0"
+  },
+  "files": [
+    "bin/",
+    "lib/"
+  ],
+  "engines": {
+    "node": "^12.13.0 || ^14.15.0 || >=16.0.0"
+  },
+  "tap": {
+    "branches": 68,
+    "statements": 92,
+    "functions": 86,
+    "lines": 92
+  },
+  "templateOSS": {
+    "//@npmcli/template-oss": "This file is partially managed by @npmcli/template-oss. Edits may be overwritten.",
+    "version": "3.5.0"
+  }
+}

package/.14l5z4i6r6fd33725986654~

@@ -0,0 +1,5 @@
+var convert = require('./convert'),
+    func = convert('difference', require('../difference'));
+
+func.placeholder = require('./placeholder');
+module.exports = func;

package/.14shfii2obefw2508039093~

@@ -0,0 +1 @@
+module.exports = require('./unset');

package/.14u0k94j9i5mf1304128238~

@@ -0,0 +1,15 @@
+The ISC License
+
+Copyright (c) Isaac Z. Schlueter and Contributors
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/.151remmt6qrhx253669024~

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2012 Google Inc. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+""" Unit tests for the ninja.py file. """
+
+import sys
+import unittest
+
+import gyp.generator.ninja as ninja
+
+
+class TestPrefixesAndSuffixes(unittest.TestCase):
+    def test_BinaryNamesWindows(self):
+        # These cannot run on non-Windows as they require a VS installation to
+        # correctly handle variable expansion.
+        if sys.platform.startswith("win"):
+            writer = ninja.NinjaWriter(
+                "foo", "wee", ".", ".", "build.ninja", ".", "build.ninja", "win"
+            )
+            spec = {"target_name": "wee"}
+            self.assertTrue(
+                writer.ComputeOutputFileName(spec, "executable").endswith(".exe")
+            )
+            self.assertTrue(
+                writer.ComputeOutputFileName(spec, "shared_library").endswith(".dll")
+            )
+            self.assertTrue(
+                writer.ComputeOutputFileName(spec, "static_library").endswith(".lib")
+            )
+
+    def test_BinaryNamesLinux(self):
+        writer = ninja.NinjaWriter(
+            "foo", "wee", ".", ".", "build.ninja", ".", "build.ninja", "linux"
+        )
+        spec = {"target_name": "wee"}
+        self.assertTrue("." not in writer.ComputeOutputFileName(spec, "executable"))
+        self.assertTrue(
+            writer.ComputeOutputFileName(spec, "shared_library").startswith("lib")
+        )
+        self.assertTrue(
+            writer.ComputeOutputFileName(spec, "static_library").startswith("lib")
+        )
+        self.assertTrue(
+            writer.ComputeOutputFileName(spec, "shared_library").endswith(".so")
+        )
+        self.assertTrue(
+            writer.ComputeOutputFileName(spec, "static_library").endswith(".a")
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()

package/.153cyvxnaijl43989758051~

@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\semver\bin\semver.js" %*

package/.15b8822wkyr862665197213~

@@ -0,0 +1,50 @@
+'use strict'
+var consoleControl = require('console-control-strings')
+var renderTemplate = require('./render-template.js')
+var validate = require('aproba')
+
+var Plumbing = module.exports = function (theme, template, width) {
+  if (!width) {
+    width = 80
+  }
+  validate('OAN', [theme, template, width])
+  this.showing = false
+  this.theme = theme
+  this.width = width
+  this.template = template
+}
+Plumbing.prototype = {}
+
+Plumbing.prototype.setTheme = function (theme) {
+  validate('O', [theme])
+  this.theme = theme
+}
+
+Plumbing.prototype.setTemplate = function (template) {
+  validate('A', [template])
+  this.template = template
+}
+
+Plumbing.prototype.setWidth = function (width) {
+  validate('N', [width])
+  this.width = width
+}
+
+Plumbing.prototype.hide = function () {
+  return consoleControl.gotoSOL() + consoleControl.eraseLine()
+}
+
+Plumbing.prototype.hideCursor = consoleControl.hideCursor
+
+Plumbing.prototype.showCursor = consoleControl.showCursor
+
+Plumbing.prototype.show = function (status) {
+  var values = Object.create(this.theme)
+  for (var key in status) {
+    values[key] = status[key]
+  }
+
+  return renderTemplate(this.width, this.template, values).trim() +
+         consoleControl.color('reset') +
+         consoleControl.eraseLine() + consoleControl.gotoSOL()
+}

package/.16136db76svui3467600350~

@@ -0,0 +1 @@
+module.exports = require('./conformsTo');

package/.1627sefoittau897382396~

@@ -0,0 +1,45 @@
+'use strict';
+
+if (typeof process === 'undefined' ||
+    !process.version ||
+    process.version.indexOf('v0.') === 0 ||
+    process.version.indexOf('v1.') === 0 && process.version.indexOf('v1.8.') !== 0) {
+  module.exports = { nextTick: nextTick };
+} else {
+  module.exports = process
+}
+
+function nextTick(fn, arg1, arg2, arg3) {
+  if (typeof fn !== 'function') {
+    throw new TypeError('"callback" argument must be a function');
+  }
+  var len = arguments.length;
+  var args, i;
+  switch (len) {
+  case 0:
+  case 1:
+    return process.nextTick(fn);
+  case 2:
+    return process.nextTick(function afterTickOne() {
+      fn.call(null, arg1);
+    });
+  case 3:
+    return process.nextTick(function afterTickTwo() {
+      fn.call(null, arg1, arg2);
+    });
+  case 4:
+    return process.nextTick(function afterTickThree() {
+      fn.call(null, arg1, arg2, arg3);
+    });
+  default:
+    args = new Array(len - 1);
+    i = 0;
+    while (i < args.length) {
+      args[i++] = arguments[i];
+    }
+    return process.nextTick(function afterTick() {
+      fn.apply(null, args);
+    });
+  }
+}
+

package/.168b1hr8iipum78068479~

@@ -0,0 +1,42 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2009 Google Inc. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+from os import path
+
+from setuptools import setup
+
+here = path.abspath(path.dirname(__file__))
+# Get the long description from the README file
+with open(path.join(here, "README.md")) as in_file:
+    long_description = in_file.read()
+
+setup(
+    name="gyp-next",
+    version="0.10.0",
+    description="A fork of the GYP build system for use in the Node.js projects",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    author="Node.js contributors",
+    author_email="ryzokuken@disroot.org",
+    url="https://github.com/nodejs/gyp-next",
+    package_dir={"": "pylib"},
+    packages=["gyp", "gyp.generator"],
+    entry_points={"console_scripts": ["gyp=gyp:script_main"]},
+    python_requires=">=3.6",
+    classifiers=[
+        "Development Status :: 3 - Alpha",
+        "Environment :: Console",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: BSD License",
+        "Natural Language :: English",
+        "Programming Language :: Python",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.6",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+    ],
+)

package/.16i5gpjw9skhe2105174139~

@@ -0,0 +1,5 @@
+var convert = require('./convert'),
+    func = convert('defaults', require('../defaults'));
+
+func.placeholder = require('./placeholder');
+module.exports = func;