@uides/stepwise 2.0.2 → 2.0.4-platform-162.23-01-26-13-03

package/src/generators/node_modules/@pkgjs/parseargs/internal/primordials.js

@@ -1,393 +0,0 @@
-/*
-This file is copied from https://github.com/nodejs/node/blob/v14.19.3/lib/internal/per_context/primordials.js
-under the following license:
-
-Copyright Node.js contributors. All rights reserved.
-
-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.
-*/
-
-'use strict';
-
-/* eslint-disable node-core/prefer-primordials */
-
-// This file subclasses and stores the JS builtins that come from the VM
-// so that Node.js's builtin modules do not need to later look these up from
-// the global proxy, which can be mutated by users.
-
-// Use of primordials have sometimes a dramatic impact on performance, please
-// benchmark all changes made in performance-sensitive areas of the codebase.
-// See: https://github.com/nodejs/node/pull/38248
-
-const primordials = {};
-
-const {
-  defineProperty: ReflectDefineProperty,
-  getOwnPropertyDescriptor: ReflectGetOwnPropertyDescriptor,
-  ownKeys: ReflectOwnKeys,
-} = Reflect;
-
-// `uncurryThis` is equivalent to `func => Function.prototype.call.bind(func)`.
-// It is using `bind.bind(call)` to avoid using `Function.prototype.bind`
-// and `Function.prototype.call` after it may have been mutated by users.
-const { apply, bind, call } = Function.prototype;
-const uncurryThis = bind.bind(call);
-primordials.uncurryThis = uncurryThis;
-
-// `applyBind` is equivalent to `func => Function.prototype.apply.bind(func)`.
-// It is using `bind.bind(apply)` to avoid using `Function.prototype.bind`
-// and `Function.prototype.apply` after it may have been mutated by users.
-const applyBind = bind.bind(apply);
-primordials.applyBind = applyBind;
-
-// Methods that accept a variable number of arguments, and thus it's useful to
-// also create `${prefix}${key}Apply`, which uses `Function.prototype.apply`,
-// instead of `Function.prototype.call`, and thus doesn't require iterator
-// destructuring.
-const varargsMethods = [
-  // 'ArrayPrototypeConcat' is omitted, because it performs the spread
-  // on its own for arrays and array-likes with a truthy
-  // @@isConcatSpreadable symbol property.
-  'ArrayOf',
-  'ArrayPrototypePush',
-  'ArrayPrototypeUnshift',
-  // 'FunctionPrototypeCall' is omitted, since there's 'ReflectApply'
-  // and 'FunctionPrototypeApply'.
-  'MathHypot',
-  'MathMax',
-  'MathMin',
-  'StringPrototypeConcat',
-  'TypedArrayOf',
-];
-
-function getNewKey(key) {
-  return typeof key === 'symbol' ?
-    `Symbol${key.description[7].toUpperCase()}${key.description.slice(8)}` :
-    `${key[0].toUpperCase()}${key.slice(1)}`;
-}
-
-function copyAccessor(dest, prefix, key, { enumerable, get, set }) {
-  ReflectDefineProperty(dest, `${prefix}Get${key}`, {
-    value: uncurryThis(get),
-    enumerable
-  });
-  if (set !== undefined) {
-    ReflectDefineProperty(dest, `${prefix}Set${key}`, {
-      value: uncurryThis(set),
-      enumerable
-    });
-  }
-}
-
-function copyPropsRenamed(src, dest, prefix) {
-  for (const key of ReflectOwnKeys(src)) {
-    const newKey = getNewKey(key);
-    const desc = ReflectGetOwnPropertyDescriptor(src, key);
-    if ('get' in desc) {
-      copyAccessor(dest, prefix, newKey, desc);
-    } else {
-      const name = `${prefix}${newKey}`;
-      ReflectDefineProperty(dest, name, desc);
-      if (varargsMethods.includes(name)) {
-        ReflectDefineProperty(dest, `${name}Apply`, {
-          // `src` is bound as the `this` so that the static `this` points
-          // to the object it was defined on,
-          // e.g.: `ArrayOfApply` gets a `this` of `Array`:
-          value: applyBind(desc.value, src),
-        });
-      }
-    }
-  }
-}
-
-function copyPropsRenamedBound(src, dest, prefix) {
-  for (const key of ReflectOwnKeys(src)) {
-    const newKey = getNewKey(key);
-    const desc = ReflectGetOwnPropertyDescriptor(src, key);
-    if ('get' in desc) {
-      copyAccessor(dest, prefix, newKey, desc);
-    } else {
-      const { value } = desc;
-      if (typeof value === 'function') {
-        desc.value = value.bind(src);
-      }
-
-      const name = `${prefix}${newKey}`;
-      ReflectDefineProperty(dest, name, desc);
-      if (varargsMethods.includes(name)) {
-        ReflectDefineProperty(dest, `${name}Apply`, {
-          value: applyBind(value, src),
-        });
-      }
-    }
-  }
-}
-
-function copyPrototype(src, dest, prefix) {
-  for (const key of ReflectOwnKeys(src)) {
-    const newKey = getNewKey(key);
-    const desc = ReflectGetOwnPropertyDescriptor(src, key);
-    if ('get' in desc) {
-      copyAccessor(dest, prefix, newKey, desc);
-    } else {
-      const { value } = desc;
-      if (typeof value === 'function') {
-        desc.value = uncurryThis(value);
-      }
-
-      const name = `${prefix}${newKey}`;
-      ReflectDefineProperty(dest, name, desc);
-      if (varargsMethods.includes(name)) {
-        ReflectDefineProperty(dest, `${name}Apply`, {
-          value: applyBind(value),
-        });
-      }
-    }
-  }
-}
-
-// Create copies of configurable value properties of the global object
-[
-  'Proxy',
-  'globalThis',
-].forEach((name) => {
-  // eslint-disable-next-line no-restricted-globals
-  primordials[name] = globalThis[name];
-});
-
-// Create copies of URI handling functions
-[
-  decodeURI,
-  decodeURIComponent,
-  encodeURI,
-  encodeURIComponent,
-].forEach((fn) => {
-  primordials[fn.name] = fn;
-});
-
-// Create copies of the namespace objects
-[
-  'JSON',
-  'Math',
-  'Proxy',
-  'Reflect',
-].forEach((name) => {
-  // eslint-disable-next-line no-restricted-globals
-  copyPropsRenamed(global[name], primordials, name);
-});
-
-// Create copies of intrinsic objects
-[
-  'Array',
-  'ArrayBuffer',
-  'BigInt',
-  'BigInt64Array',
-  'BigUint64Array',
-  'Boolean',
-  'DataView',
-  'Date',
-  'Error',
-  'EvalError',
-  'Float32Array',
-  'Float64Array',
-  'Function',
-  'Int16Array',
-  'Int32Array',
-  'Int8Array',
-  'Map',
-  'Number',
-  'Object',
-  'RangeError',
-  'ReferenceError',
-  'RegExp',
-  'Set',
-  'String',
-  'Symbol',
-  'SyntaxError',
-  'TypeError',
-  'URIError',
-  'Uint16Array',
-  'Uint32Array',
-  'Uint8Array',
-  'Uint8ClampedArray',
-  'WeakMap',
-  'WeakSet',
-].forEach((name) => {
-  // eslint-disable-next-line no-restricted-globals
-  const original = global[name];
-  primordials[name] = original;
-  copyPropsRenamed(original, primordials, name);
-  copyPrototype(original.prototype, primordials, `${name}Prototype`);
-});
-
-// Create copies of intrinsic objects that require a valid `this` to call
-// static methods.
-// Refs: https://www.ecma-international.org/ecma-262/#sec-promise.all
-[
-  'Promise',
-].forEach((name) => {
-  // eslint-disable-next-line no-restricted-globals
-  const original = global[name];
-  primordials[name] = original;
-  copyPropsRenamedBound(original, primordials, name);
-  copyPrototype(original.prototype, primordials, `${name}Prototype`);
-});
-
-// Create copies of abstract intrinsic objects that are not directly exposed
-// on the global object.
-// Refs: https://tc39.es/ecma262/#sec-%typedarray%-intrinsic-object
-[
-  { name: 'TypedArray', original: Reflect.getPrototypeOf(Uint8Array) },
-  { name: 'ArrayIterator', original: {
-    prototype: Reflect.getPrototypeOf(Array.prototype[Symbol.iterator]()),
-  } },
-  { name: 'StringIterator', original: {
-    prototype: Reflect.getPrototypeOf(String.prototype[Symbol.iterator]()),
-  } },
-].forEach(({ name, original }) => {
-  primordials[name] = original;
-  // The static %TypedArray% methods require a valid `this`, but can't be bound,
-  // as they need a subclass constructor as the receiver:
-  copyPrototype(original, primordials, name);
-  copyPrototype(original.prototype, primordials, `${name}Prototype`);
-});
-
-/* eslint-enable node-core/prefer-primordials */
-
-const {
-  ArrayPrototypeForEach,
-  FunctionPrototypeCall,
-  Map,
-  ObjectFreeze,
-  ObjectSetPrototypeOf,
-  Set,
-  SymbolIterator,
-  WeakMap,
-  WeakSet,
-} = primordials;
-
-// Because these functions are used by `makeSafe`, which is exposed
-// on the `primordials` object, it's important to use const references
-// to the primordials that they use:
-const createSafeIterator = (factory, next) => {
-  class SafeIterator {
-    constructor(iterable) {
-      this._iterator = factory(iterable);
-    }
-    next() {
-      return next(this._iterator);
-    }
-    [SymbolIterator]() {
-      return this;
-    }
-  }
-  ObjectSetPrototypeOf(SafeIterator.prototype, null);
-  ObjectFreeze(SafeIterator.prototype);
-  ObjectFreeze(SafeIterator);
-  return SafeIterator;
-};
-
-primordials.SafeArrayIterator = createSafeIterator(
-  primordials.ArrayPrototypeSymbolIterator,
-  primordials.ArrayIteratorPrototypeNext
-);
-primordials.SafeStringIterator = createSafeIterator(
-  primordials.StringPrototypeSymbolIterator,
-  primordials.StringIteratorPrototypeNext
-);
-
-const copyProps = (src, dest) => {
-  ArrayPrototypeForEach(ReflectOwnKeys(src), (key) => {
-    if (!ReflectGetOwnPropertyDescriptor(dest, key)) {
-      ReflectDefineProperty(
-        dest,
-        key,
-        ReflectGetOwnPropertyDescriptor(src, key));
-    }
-  });
-};
-
-const makeSafe = (unsafe, safe) => {
-  if (SymbolIterator in unsafe.prototype) {
-    const dummy = new unsafe();
-    let next; // We can reuse the same `next` method.
-
-    ArrayPrototypeForEach(ReflectOwnKeys(unsafe.prototype), (key) => {
-      if (!ReflectGetOwnPropertyDescriptor(safe.prototype, key)) {
-        const desc = ReflectGetOwnPropertyDescriptor(unsafe.prototype, key);
-        if (
-          typeof desc.value === 'function' &&
-          desc.value.length === 0 &&
-          SymbolIterator in (FunctionPrototypeCall(desc.value, dummy) ?? {})
-        ) {
-          const createIterator = uncurryThis(desc.value);
-          next = next ?? uncurryThis(createIterator(dummy).next);
-          const SafeIterator = createSafeIterator(createIterator, next);
-          desc.value = function() {
-            return new SafeIterator(this);
-          };
-        }
-        ReflectDefineProperty(safe.prototype, key, desc);
-      }
-    });
-  } else {
-    copyProps(unsafe.prototype, safe.prototype);
-  }
-  copyProps(unsafe, safe);
-
-  ObjectSetPrototypeOf(safe.prototype, null);
-  ObjectFreeze(safe.prototype);
-  ObjectFreeze(safe);
-  return safe;
-};
-primordials.makeSafe = makeSafe;
-
-// Subclass the constructors because we need to use their prototype
-// methods later.
-// Defining the `constructor` is necessary here to avoid the default
-// constructor which uses the user-mutable `%ArrayIteratorPrototype%.next`.
-primordials.SafeMap = makeSafe(
-  Map,
-  class SafeMap extends Map {
-    constructor(i) { super(i); } // eslint-disable-line no-useless-constructor
-  }
-);
-primordials.SafeWeakMap = makeSafe(
-  WeakMap,
-  class SafeWeakMap extends WeakMap {
-    constructor(i) { super(i); } // eslint-disable-line no-useless-constructor
-  }
-);
-primordials.SafeSet = makeSafe(
-  Set,
-  class SafeSet extends Set {
-    constructor(i) { super(i); } // eslint-disable-line no-useless-constructor
-  }
-);
-primordials.SafeWeakSet = makeSafe(
-  WeakSet,
-  class SafeWeakSet extends WeakSet {
-    constructor(i) { super(i); } // eslint-disable-line no-useless-constructor
-  }
-);
-
-ObjectSetPrototypeOf(primordials, null);
-ObjectFreeze(primordials);
-
-module.exports = primordials;

package/src/generators/node_modules/@pkgjs/parseargs/internal/util.js

@@ -1,14 +0,0 @@
-'use strict';
-
-// This is a placeholder for util.js in node.js land.
-
-const {
-  ObjectCreate,
-  ObjectFreeze,
-} = require('./primordials');
-
-const kEmptyObject = ObjectFreeze(ObjectCreate(null));
-
-module.exports = {
-  kEmptyObject,
-};

package/src/generators/node_modules/@pkgjs/parseargs/internal/validators.js

@@ -1,89 +0,0 @@
-'use strict';
-
-// This file is a proxy of the original file located at:
-// https://github.com/nodejs/node/blob/main/lib/internal/validators.js
-// Every addition or modification to this file must be evaluated
-// during the PR review.
-
-const {
-  ArrayIsArray,
-  ArrayPrototypeIncludes,
-  ArrayPrototypeJoin,
-} = require('./primordials');
-
-const {
-  codes: {
-    ERR_INVALID_ARG_TYPE
-  }
-} = require('./errors');
-
-function validateString(value, name) {
-  if (typeof value !== 'string') {
-    throw new ERR_INVALID_ARG_TYPE(name, 'String', value);
-  }
-}
-
-function validateUnion(value, name, union) {
-  if (!ArrayPrototypeIncludes(union, value)) {
-    throw new ERR_INVALID_ARG_TYPE(name, `('${ArrayPrototypeJoin(union, '|')}')`, value);
-  }
-}
-
-function validateBoolean(value, name) {
-  if (typeof value !== 'boolean') {
-    throw new ERR_INVALID_ARG_TYPE(name, 'Boolean', value);
-  }
-}
-
-function validateArray(value, name) {
-  if (!ArrayIsArray(value)) {
-    throw new ERR_INVALID_ARG_TYPE(name, 'Array', value);
-  }
-}
-
-function validateStringArray(value, name) {
-  validateArray(value, name);
-  for (let i = 0; i < value.length; i++) {
-    validateString(value[i], `${name}[${i}]`);
-  }
-}
-
-function validateBooleanArray(value, name) {
-  validateArray(value, name);
-  for (let i = 0; i < value.length; i++) {
-    validateBoolean(value[i], `${name}[${i}]`);
-  }
-}
-
-/**
- * @param {unknown} value
- * @param {string} name
- * @param {{
- *   allowArray?: boolean,
- *   allowFunction?: boolean,
- *   nullable?: boolean
- * }} [options]
- */
-function validateObject(value, name, options) {
-  const useDefaultOptions = options == null;
-  const allowArray = useDefaultOptions ? false : options.allowArray;
-  const allowFunction = useDefaultOptions ? false : options.allowFunction;
-  const nullable = useDefaultOptions ? false : options.nullable;
-  if ((!nullable && value === null) ||
-      (!allowArray && ArrayIsArray(value)) ||
-      (typeof value !== 'object' && (
-        !allowFunction || typeof value !== 'function'
-      ))) {
-    throw new ERR_INVALID_ARG_TYPE(name, 'Object', value);
-  }
-}
-
-module.exports = {
-  validateArray,
-  validateObject,
-  validateString,
-  validateStringArray,
-  validateUnion,
-  validateBoolean,
-  validateBooleanArray,
-};

package/src/generators/node_modules/@pkgjs/parseargs/package.json

@@ -1,36 +0,0 @@
-{
-  "name": "@pkgjs/parseargs",
-  "version": "0.11.0",
-  "description": "Polyfill of future proposal for `util.parseArgs()`",
-  "engines": {
-    "node": ">=14"
-  },
-  "main": "index.js",
-  "exports": {
-    ".": "./index.js",
-    "./package.json": "./package.json"
-  },
-  "scripts": {
-    "coverage": "c8 --check-coverage tape 'test/*.js'",
-    "test": "c8 tape 'test/*.js'",
-    "posttest": "eslint .",
-    "fix": "npm run posttest -- --fix"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git@github.com:pkgjs/parseargs.git"
-  },
-  "keywords": [],
-  "author": "",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/pkgjs/parseargs/issues"
-  },
-  "homepage": "https://github.com/pkgjs/parseargs#readme",
-  "devDependencies": {
-    "c8": "^7.10.0",
-    "eslint": "^8.2.0",
-    "eslint-plugin-node-core": "iansu/eslint-plugin-node-core",
-    "tape": "^5.2.2"
-  }
-}