create-leo-app 0.7.3 → 0.8.2

package/template-react-ts/node_modules/ts-node/dist-raw/node-internal-modules-package_json_reader.js

@@ -1,44 +0,0 @@
-// copied from https://github.com/nodejs/node/blob/v15.3.0/lib/internal/modules/package_json_reader.js
-'use strict';
-
-const { SafeMap } = require('./node-primordials');
-const { internalModuleReadJSON } = require('./node-internalBinding-fs');
-const { pathToFileURL } = require('url');
-const { toNamespacedPath } = require('path');
-// const { getOptionValue } = require('./node-options');
-
-const cache = new SafeMap();
-
-let manifest;
-
-/**
- * @param {string} jsonPath
- * @return {{string: string, containsKeys: boolean}}
- */
-function read(jsonPath) {
-  if (cache.has(jsonPath)) {
-    return cache.get(jsonPath);
-  }
-
-  const [string, containsKeys] = internalModuleReadJSON(
-    toNamespacedPath(jsonPath)
-  );
-  const result = { string, containsKeys };
-  if (string !== undefined) {
-    if (manifest === undefined) {
-      // manifest = getOptionValue('--experimental-policy') ?
-      //   require('internal/process/policy').manifest :
-      //   null;
-      // disabled for now.  I am not sure if/how we should support this
-      manifest = null;
-    }
-    if (manifest !== null) {
-      const jsonURL = pathToFileURL(jsonPath);
-      manifest.assertIntegrity(jsonURL, string);
-    }
-  }
-  cache.set(jsonPath, result);
-  return result;
-}
-
-module.exports = { read };

package/template-react-ts/node_modules/ts-node/dist-raw/node-internal-repl-await.js

@@ -1,254 +0,0 @@
-// copied from https://github.com/nodejs/node/blob/88799930794045795e8abac874730f9eba7e2300/lib/internal/repl/await.js
-'use strict';
-
-const {
-  ArrayFrom,
-  ArrayPrototypeForEach,
-  ArrayPrototypeIncludes,
-  ArrayPrototypeJoin,
-  ArrayPrototypePop,
-  ArrayPrototypePush,
-  FunctionPrototype,
-  ObjectKeys,
-  RegExpPrototypeSymbolReplace,
-  StringPrototypeEndsWith,
-  StringPrototypeIncludes,
-  StringPrototypeIndexOf,
-  StringPrototypeRepeat,
-  StringPrototypeSplit,
-  StringPrototypeStartsWith,
-  SyntaxError,
-} = require('./node-primordials');
-
-const parser = require('acorn').Parser;
-const walk = require('acorn-walk');
-const { Recoverable } = require('repl');
-
-function isTopLevelDeclaration(state) {
-  return state.ancestors[state.ancestors.length - 2] === state.body;
-}
-
-const noop = FunctionPrototype;
-const visitorsWithoutAncestors = {
-  ClassDeclaration(node, state, c) {
-    if (isTopLevelDeclaration(state)) {
-      state.prepend(node, `${node.id.name}=`);
-      ArrayPrototypePush(
-        state.hoistedDeclarationStatements,
-        `let ${node.id.name}; `
-      );
-    }
-
-    walk.base.ClassDeclaration(node, state, c);
-  },
-  ForOfStatement(node, state, c) {
-    if (node.await === true) {
-      state.containsAwait = true;
-    }
-    walk.base.ForOfStatement(node, state, c);
-  },
-  FunctionDeclaration(node, state, c) {
-    state.prepend(node, `${node.id.name}=`);
-    ArrayPrototypePush(
-      state.hoistedDeclarationStatements,
-      `var ${node.id.name}; `
-    );
-  },
-  FunctionExpression: noop,
-  ArrowFunctionExpression: noop,
-  MethodDefinition: noop,
-  AwaitExpression(node, state, c) {
-    state.containsAwait = true;
-    walk.base.AwaitExpression(node, state, c);
-  },
-  ReturnStatement(node, state, c) {
-    state.containsReturn = true;
-    walk.base.ReturnStatement(node, state, c);
-  },
-  VariableDeclaration(node, state, c) {
-    const variableKind = node.kind;
-    const isIterableForDeclaration = ArrayPrototypeIncludes(
-      ['ForOfStatement', 'ForInStatement'],
-      state.ancestors[state.ancestors.length - 2].type
-    );
-
-    if (variableKind === 'var' || isTopLevelDeclaration(state)) {
-      state.replace(
-        node.start,
-        node.start + variableKind.length + (isIterableForDeclaration ? 1 : 0),
-        variableKind === 'var' && isIterableForDeclaration ?
-          '' :
-          'void' + (node.declarations.length === 1 ? '' : ' (')
-      );
-
-      if (!isIterableForDeclaration) {
-        ArrayPrototypeForEach(node.declarations, (decl) => {
-          state.prepend(decl, '(');
-          state.append(decl, decl.init ? ')' : '=undefined)');
-        });
-
-        if (node.declarations.length !== 1) {
-          state.append(node.declarations[node.declarations.length - 1], ')');
-        }
-      }
-
-      const variableIdentifiersToHoist = [
-        ['var', []],
-        ['let', []],
-      ];
-      function registerVariableDeclarationIdentifiers(node) {
-        switch (node.type) {
-          case 'Identifier':
-            ArrayPrototypePush(
-              variableIdentifiersToHoist[variableKind === 'var' ? 0 : 1][1],
-              node.name
-            );
-            break;
-          case 'ObjectPattern':
-            ArrayPrototypeForEach(node.properties, (property) => {
-              registerVariableDeclarationIdentifiers(property.value);
-            });
-            break;
-          case 'ArrayPattern':
-            ArrayPrototypeForEach(node.elements, (element) => {
-              registerVariableDeclarationIdentifiers(element);
-            });
-            break;
-        }
-      }
-
-      ArrayPrototypeForEach(node.declarations, (decl) => {
-        registerVariableDeclarationIdentifiers(decl.id);
-      });
-
-      ArrayPrototypeForEach(
-        variableIdentifiersToHoist,
-        ({ 0: kind, 1: identifiers }) => {
-          if (identifiers.length > 0) {
-            ArrayPrototypePush(
-              state.hoistedDeclarationStatements,
-              `${kind} ${ArrayPrototypeJoin(identifiers, ', ')}; `
-            );
-          }
-        }
-      );
-    }
-
-    walk.base.VariableDeclaration(node, state, c);
-  }
-};
-
-const visitors = {};
-for (const nodeType of ObjectKeys(walk.base)) {
-  const callback = visitorsWithoutAncestors[nodeType] || walk.base[nodeType];
-  visitors[nodeType] = (node, state, c) => {
-    const isNew = node !== state.ancestors[state.ancestors.length - 1];
-    if (isNew) {
-      ArrayPrototypePush(state.ancestors, node);
-    }
-    callback(node, state, c);
-    if (isNew) {
-      ArrayPrototypePop(state.ancestors);
-    }
-  };
-}
-
-function processTopLevelAwait(src) {
-  const wrapPrefix = '(async () => { ';
-  const wrapped = `${wrapPrefix}${src} })()`;
-  const wrappedArray = ArrayFrom(wrapped);
-  let root;
-  try {
-    root = parser.parse(wrapped, { ecmaVersion: 'latest' });
-  } catch (e) {
-    if (StringPrototypeStartsWith(e.message, 'Unterminated '))
-      throw new Recoverable(e);
-    // If the parse error is before the first "await", then use the execution
-    // error. Otherwise we must emit this parse error, making it look like a
-    // proper syntax error.
-    const awaitPos = StringPrototypeIndexOf(src, 'await');
-    const errPos = e.pos - wrapPrefix.length;
-    if (awaitPos > errPos)
-      return null;
-    // Convert keyword parse errors on await into their original errors when
-    // possible.
-    if (errPos === awaitPos + 6 &&
-        StringPrototypeIncludes(e.message, 'Expecting Unicode escape sequence'))
-      return null;
-    if (errPos === awaitPos + 7 &&
-        StringPrototypeIncludes(e.message, 'Unexpected token'))
-      return null;
-    const line = e.loc.line;
-    const column = line === 1 ? e.loc.column - wrapPrefix.length : e.loc.column;
-    let message = '\n' + StringPrototypeSplit(src, '\n')[line - 1] + '\n' +
-        StringPrototypeRepeat(' ', column) +
-        '^\n\n' + RegExpPrototypeSymbolReplace(/ \([^)]+\)/, e.message, '');
-    // V8 unexpected token errors include the token string.
-    if (StringPrototypeEndsWith(message, 'Unexpected token'))
-      message += " '" +
-        // Wrapper end may cause acorn to report error position after the source
-        ((src.length - 1) >= (e.pos - wrapPrefix.length)
-          ? src[e.pos - wrapPrefix.length]
-          : src[src.length - 1]) +
-        "'";
-    // eslint-disable-next-line no-restricted-syntax
-    throw new SyntaxError(message);
-  }
-  const body = root.body[0].expression.callee.body;
-  const state = {
-    body,
-    ancestors: [],
-    hoistedDeclarationStatements: [],
-    replace(from, to, str) {
-      for (let i = from; i < to; i++) {
-        wrappedArray[i] = '';
-      }
-      if (from === to) str += wrappedArray[from];
-      wrappedArray[from] = str;
-    },
-    prepend(node, str) {
-      wrappedArray[node.start] = str + wrappedArray[node.start];
-    },
-    append(node, str) {
-      wrappedArray[node.end - 1] += str;
-    },
-    containsAwait: false,
-    containsReturn: false
-  };
-
-  walk.recursive(body, state, visitors);
-
-  // Do not transform if
-  // 1. False alarm: there isn't actually an await expression.
-  // 2. There is a top-level return, which is not allowed.
-  if (!state.containsAwait || state.containsReturn) {
-    return null;
-  }
-
-  const last = body.body[body.body.length - 1];
-  if (last.type === 'ExpressionStatement') {
-    // For an expression statement of the form
-    // ( expr ) ;
-    // ^^^^^^^^^^   // last
-    //   ^^^^       // last.expression
-    //
-    // We do not want the left parenthesis before the `return` keyword;
-    // therefore we prepend the `return (` to `last`.
-    //
-    // On the other hand, we do not want the right parenthesis after the
-    // semicolon. Since there can only be more right parentheses between
-    // last.expression.end and the semicolon, appending one more to
-    // last.expression should be fine.
-    state.prepend(last, 'return (');
-    state.append(last.expression, ')');
-  }
-
-  return (
-    ArrayPrototypeJoin(state.hoistedDeclarationStatements, '') +
-    ArrayPrototypeJoin(wrappedArray, '')
-  );
-}
-
-module.exports = {
-  processTopLevelAwait
-};

package/template-react-ts/node_modules/ts-node/dist-raw/node-internalBinding-fs.js

@@ -1,58 +0,0 @@
-const fs = require('fs');
-const {versionGteLt} = require('../dist/util');
-
-// In node's core, this is implemented in C
-// https://github.com/nodejs/node/blob/v15.3.0/src/node_file.cc#L891-L985
-/**
- * @param {string} path
- * @returns {[] | [string, boolean]}
- */
-function internalModuleReadJSON(path) {
-  let string
-  try {
-    string = fs.readFileSync(path, 'utf8')
-  } catch (e) {
-    if (e.code === 'ENOENT') return []
-    throw e
-  }
-  // Node's implementation checks for the presence of relevant keys: main, name, type, exports, imports
-  // Node does this for performance to skip unnecessary parsing.
-  // This would slow us down and, based on our usage, we can skip it.
-  const containsKeys = true
-  return [string, containsKeys]
-}
-
-// In node's core, this is implemented in C
-// https://github.com/nodejs/node/blob/63e7dc1e5c71b70c80ed9eda230991edb00811e2/src/node_file.cc#L987-L1005
-/**
- * @param {string} path
- * @returns {number} 0 = file, 1 = dir, negative = error
- */
-function internalModuleStat(path) {
-  const stat = fs.statSync(path, { throwIfNoEntry: false });
-  if(!stat) return -1;
-  if(stat.isFile()) return 0;
-  if(stat.isDirectory()) return 1;
-}
-
-/**
- * @param {string} path
- * @returns {number} 0 = file, 1 = dir, negative = error
- */
-function internalModuleStatInefficient(path) {
-  try {
-    const stat = fs.statSync(path);
-    if(stat.isFile()) return 0;
-    if(stat.isDirectory()) return 1;
-  } catch(e) {
-    return -e.errno || -1;
-  }
-}
-
-const statSupportsThrowIfNoEntry = versionGteLt(process.versions.node, '15.3.0') ||
-  versionGteLt(process.versions.node, '14.17.0', '15.0.0');
-
-module.exports = {
-  internalModuleReadJSON,
-  internalModuleStat: statSupportsThrowIfNoEntry ? internalModuleStat : internalModuleStatInefficient
-};

package/template-react-ts/node_modules/ts-node/dist-raw/node-nativemodule.js

@@ -1,9 +0,0 @@
-
-// Node imports this from 'internal/bootstrap/loaders'
-const Module = require('module');
-const NativeModule = {
-  canBeRequiredByUsers(specifier) {
-    return Module.builtinModules.includes(specifier)
-  }
-};
-exports.NativeModule = NativeModule;

package/template-react-ts/node_modules/ts-node/dist-raw/node-options.js

@@ -1,103 +0,0 @@
-// Replacement for node's internal 'internal/options' module
-
-exports.getOptionValue = getOptionValue;
-function getOptionValue(opt) {
-  parseOptions();
-  return options[opt];
-}
-
-let options;
-function parseOptions() {
-  if (!options) {
-    options = {
-      '--preserve-symlinks': false,
-      '--preserve-symlinks-main': false,
-      '--input-type': undefined,
-      '--experimental-specifier-resolution': 'explicit',
-      '--experimental-policy': undefined,
-      '--conditions': [],
-      '--pending-deprecation': false,
-      ...parseArgv(getNodeOptionsEnvArgv()),
-      ...parseArgv(process.execArgv),
-      ...getOptionValuesFromOtherEnvVars()
-    }
-  }
-}
-
-function parseArgv(argv) {
-  return require('arg')({
-    '--preserve-symlinks': Boolean,
-    '--preserve-symlinks-main': Boolean,
-    '--input-type': String,
-    '--experimental-specifier-resolution': String,
-    // Legacy alias for node versions prior to 12.16
-    '--es-module-specifier-resolution': '--experimental-specifier-resolution',
-    '--experimental-policy': String,
-    '--conditions': [String],
-    '--pending-deprecation': Boolean,
-    '--experimental-json-modules': Boolean,
-    '--experimental-wasm-modules': Boolean,
-  }, {
-    argv,
-    permissive: true
-  });
-}
-
-function getNodeOptionsEnvArgv() {
-  const errors = [];
-  const envArgv = ParseNodeOptionsEnvVar(process.env.NODE_OPTIONS || '', errors);
-  if (errors.length !== 0) {
-    // TODO: handle errors somehow
-  }
-  return envArgv;
-}
-
-// Direct JS port of C implementation: https://github.com/nodejs/node/blob/67ba825037b4082d5d16f922fb9ce54516b4a869/src/node_options.cc#L1024-L1063
-function ParseNodeOptionsEnvVar(node_options, errors) {
-  const env_argv = [];
-
-  let is_in_string = false;
-  let will_start_new_arg = true;
-  for (let index = 0; index < node_options.length; ++index) {
-      let c = node_options[index];
-
-      // Backslashes escape the following character
-      if (c === '\\' && is_in_string) {
-          if (index + 1 === node_options.length) {
-              errors.push("invalid value for NODE_OPTIONS " +
-                  "(invalid escape)\n");
-              return env_argv;
-          } else {
-              c = node_options[++index];
-          }
-      } else if (c === ' ' && !is_in_string) {
-          will_start_new_arg = true;
-          continue;
-      } else if (c === '"') {
-          is_in_string = !is_in_string;
-          continue;
-      }
-
-      if (will_start_new_arg) {
-          env_argv.push(c);
-          will_start_new_arg = false;
-      } else {
-          env_argv[env_argv.length - 1] += c;
-      }
-  }
-
-  if (is_in_string) {
-      errors.push("invalid value for NODE_OPTIONS " +
-          "(unterminated string)\n");
-  }
-  return env_argv;
-}
-
-// Get option values that can be specified via env vars besides NODE_OPTIONS
-function getOptionValuesFromOtherEnvVars() {
-  const options = {};
-  if(process.env.NODE_PENDING_DEPRECATION === '1') {
-    options['--pending-deprecation'] = true;
-  }
-  return options;
-}

package/template-react-ts/node_modules/ts-node/dist-raw/node-primordials.js

@@ -1,37 +0,0 @@
-module.exports = {
-  ArrayFrom: Array.from,
-  ArrayIsArray: Array.isArray,
-  ArrayPrototypeShift: (obj) => Array.prototype.shift.call(obj),
-  ArrayPrototypeForEach: (arr, ...rest) => Array.prototype.forEach.apply(arr, rest),
-  ArrayPrototypeIncludes: (arr, ...rest) => Array.prototype.includes.apply(arr, rest),
-  ArrayPrototypeJoin: (arr, ...rest) => Array.prototype.join.apply(arr, rest),
-  ArrayPrototypePop: (arr, ...rest) => Array.prototype.pop.apply(arr, rest),
-  ArrayPrototypePush: (arr, ...rest) => Array.prototype.push.apply(arr, rest),
-  FunctionPrototype: Function.prototype,
-  JSONParse: JSON.parse,
-  JSONStringify: JSON.stringify,
-  ObjectFreeze: Object.freeze,
-  ObjectKeys: Object.keys,
-  ObjectGetOwnPropertyNames: Object.getOwnPropertyNames,
-  ObjectDefineProperty: Object.defineProperty,
-  ObjectPrototypeHasOwnProperty: (obj, prop) => Object.prototype.hasOwnProperty.call(obj, prop),
-  RegExpPrototypeExec: (obj, string) => RegExp.prototype.exec.call(obj, string),
-  RegExpPrototypeTest: (obj, string) => RegExp.prototype.test.call(obj, string),
-  RegExpPrototypeSymbolReplace: (obj, ...rest) => RegExp.prototype[Symbol.replace].apply(obj, rest),
-  SafeMap: Map,
-  SafeSet: Set,
-  SafeWeakMap: WeakMap,
-  StringPrototypeEndsWith: (str, ...rest) => String.prototype.endsWith.apply(str, rest),
-  StringPrototypeIncludes: (str, ...rest) => String.prototype.includes.apply(str, rest),
-  StringPrototypeLastIndexOf: (str, ...rest) => String.prototype.lastIndexOf.apply(str, rest),
-  StringPrototypeIndexOf: (str, ...rest) => String.prototype.indexOf.apply(str, rest),
-  StringPrototypeRepeat: (str, ...rest) => String.prototype.repeat.apply(str, rest),
-  StringPrototypeReplace: (str, ...rest) => String.prototype.replace.apply(str, rest),
-  StringPrototypeSlice: (str, ...rest) => String.prototype.slice.apply(str, rest),
-  StringPrototypeSplit: (str, ...rest) => String.prototype.split.apply(str, rest),
-  StringPrototypeStartsWith: (str, ...rest) => String.prototype.startsWith.apply(str, rest),
-  StringPrototypeSubstr: (str, ...rest) => String.prototype.substr.apply(str, rest),
-  StringPrototypeCharCodeAt: (str, ...rest) => String.prototype.charCodeAt.apply(str, rest),
-  StringPrototypeMatch: (str, ...rest) => String.prototype.match.apply(str, rest),
-  SyntaxError: SyntaxError
-};

package/template-react-ts/node_modules/ts-node/dist-raw/runmain-hack.js

@@ -1,9 +0,0 @@
-const {pathToFileURL} = require('url');
-
-// Hack to avoid Module.runMain on node 18.6.0
-// Keeping it simple for now, isolated in this file.
-// Could theoretically probe `getFormat` impl to determine if `import()` or `Module._load()` is best
-// Note that I attempted a try-catch around `Module._load`, but it poisons some sort of cache such that subsequent `import()` is impossible.
-exports.run = function(entryPointPath) {
-  import(pathToFileURL(entryPointPath));
-}

package/template-react-ts/node_modules/ts-node/esm/transpile-only.mjs

@@ -1,8 +0,0 @@
-import { fileURLToPath } from 'url';
-import { createRequire } from 'module';
-const require = createRequire(fileURLToPath(import.meta.url));
-
-/** @type {import('../dist/esm')} */
-const esm = require('../dist/esm');
-export const { resolve, load, getFormat, transformSource } =
-  esm.registerAndCreateEsmHooks({ transpileOnly: true });

package/template-react-ts/node_modules/ts-node/esm.mjs

@@ -1,8 +0,0 @@
-import { fileURLToPath } from 'url';
-import { createRequire } from 'module';
-const require = createRequire(fileURLToPath(import.meta.url));
-
-/** @type {import('./dist/esm')} */
-const esm = require('./dist/esm');
-export const { resolve, load, getFormat, transformSource } =
-  esm.registerAndCreateEsmHooks();

package/template-react-ts/node_modules/ts-node/node10/tsconfig.json

@@ -1,3 +0,0 @@
-{
-  "extends": "@tsconfig/node10/tsconfig.json"
-}

package/template-react-ts/node_modules/ts-node/node12/tsconfig.json

@@ -1,3 +0,0 @@
-{
-  "extends": "@tsconfig/node12/tsconfig.json",
-}

package/template-react-ts/node_modules/ts-node/node14/tsconfig.json

@@ -1,3 +0,0 @@
-{
-  "extends": "@tsconfig/node14/tsconfig.json"
-}

package/template-react-ts/node_modules/ts-node/node16/tsconfig.json

@@ -1,3 +0,0 @@
-{
-  "extends": "@tsconfig/node16/tsconfig.json"
-}