pokeedex 0.1.0

data/node_modules/playwright/lib/common/fixtures.js

@@ -0,0 +1,323 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FixturePool = void 0;
+exports.fixtureParameterNames = fixtureParameterNames;
+exports.formatPotentiallyInternalLocation = formatPotentiallyInternalLocation;
+exports.inheritFixtureNames = inheritFixtureNames;
+var _util = require("../util");
+var crypto = _interopRequireWildcard(require("crypto"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+/**
+ * Copyright Microsoft Corporation. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+const kScopeOrder = ['test', 'worker'];
+function isFixtureTuple(value) {
+  return Array.isArray(value) && typeof value[1] === 'object';
+}
+function isFixtureOption(value) {
+  return isFixtureTuple(value) && !!value[1].option;
+}
+class FixturePool {
+  constructor(fixturesList, onLoadError, parentPool, disallowWorkerFixtures, optionOverrides) {
+    var _optionOverrides$over;
+    this.digest = void 0;
+    this._registrations = void 0;
+    this._onLoadError = void 0;
+    this._registrations = new Map(parentPool ? parentPool._registrations : []);
+    this._onLoadError = onLoadError;
+    const allOverrides = (_optionOverrides$over = optionOverrides === null || optionOverrides === void 0 ? void 0 : optionOverrides.overrides) !== null && _optionOverrides$over !== void 0 ? _optionOverrides$over : {};
+    const overrideKeys = new Set(Object.keys(allOverrides));
+    for (const list of fixturesList) {
+      this._appendFixtureList(list, !!disallowWorkerFixtures, false);
+
+      // Process option overrides immediately after original option definitions,
+      // so that any test.use() override it.
+      const selectedOverrides = {};
+      for (const [key, value] of Object.entries(list.fixtures)) {
+        if (isFixtureOption(value) && overrideKeys.has(key)) selectedOverrides[key] = [allOverrides[key], value[1]];
+      }
+      if (Object.entries(selectedOverrides).length) this._appendFixtureList({
+        fixtures: selectedOverrides,
+        location: optionOverrides.location
+      }, !!disallowWorkerFixtures, true);
+    }
+    this.digest = this.validate();
+  }
+  _appendFixtureList(list, disallowWorkerFixtures, isOptionsOverride) {
+    const {
+      fixtures,
+      location
+    } = list;
+    for (const entry of Object.entries(fixtures)) {
+      const name = entry[0];
+      let value = entry[1];
+      let options;
+      if (isFixtureTuple(value)) {
+        var _value$1$auto;
+        options = {
+          auto: (_value$1$auto = value[1].auto) !== null && _value$1$auto !== void 0 ? _value$1$auto : false,
+          scope: value[1].scope || 'test',
+          option: !!value[1].option,
+          timeout: value[1].timeout,
+          customTitle: value[1].title,
+          box: value[1].box
+        };
+        value = value[0];
+      }
+      let fn = value;
+      const previous = this._registrations.get(name);
+      if (previous && options) {
+        if (previous.scope !== options.scope) {
+          this._addLoadError(`Fixture "${name}" has already been registered as a { scope: '${previous.scope}' } fixture defined in ${(0, _util.formatLocation)(previous.location)}.`, location);
+          continue;
+        }
+        if (previous.auto !== options.auto) {
+          this._addLoadError(`Fixture "${name}" has already been registered as a { auto: '${previous.scope}' } fixture defined in ${(0, _util.formatLocation)(previous.location)}.`, location);
+          continue;
+        }
+      } else if (previous) {
+        options = {
+          auto: previous.auto,
+          scope: previous.scope,
+          option: previous.option,
+          timeout: previous.timeout,
+          customTitle: previous.customTitle,
+          box: previous.box
+        };
+      } else if (!options) {
+        options = {
+          auto: false,
+          scope: 'test',
+          option: false,
+          timeout: undefined
+        };
+      }
+      if (!kScopeOrder.includes(options.scope)) {
+        this._addLoadError(`Fixture "${name}" has unknown { scope: '${options.scope}' }.`, location);
+        continue;
+      }
+      if (options.scope === 'worker' && disallowWorkerFixtures) {
+        this._addLoadError(`Cannot use({ ${name} }) in a describe group, because it forces a new worker.\nMake it top-level in the test file or put in the configuration file.`, location);
+        continue;
+      }
+
+      // Overriding option with "undefined" value means setting it to the default value
+      // from the config or from the original declaration of the option.
+      if (fn === undefined && options.option && previous) {
+        let original = previous;
+        while (!original.optionOverride && original.super) original = original.super;
+        fn = original.fn;
+      }
+      const deps = fixtureParameterNames(fn, location, e => this._onLoadError(e));
+      const registration = {
+        id: '',
+        name,
+        location,
+        scope: options.scope,
+        fn,
+        auto: options.auto,
+        option: options.option,
+        timeout: options.timeout,
+        customTitle: options.customTitle,
+        box: options.box,
+        deps,
+        super: previous,
+        optionOverride: isOptionsOverride
+      };
+      registrationId(registration);
+      this._registrations.set(name, registration);
+    }
+  }
+  validate() {
+    const markers = new Map();
+    const stack = [];
+    let hasDependencyErrors = false;
+    const addDependencyError = (message, location) => {
+      hasDependencyErrors = true;
+      this._addLoadError(message, location);
+    };
+    const visit = (registration, boxedOnly) => {
+      markers.set(registration, 'visiting');
+      stack.push(registration);
+      for (const name of registration.deps) {
+        const dep = this.resolve(name, registration);
+        if (!dep) {
+          if (name === registration.name) addDependencyError(`Fixture "${registration.name}" references itself, but does not have a base implementation.`, registration.location);else addDependencyError(`Fixture "${registration.name}" has unknown parameter "${name}".`, registration.location);
+          continue;
+        }
+        if (kScopeOrder.indexOf(registration.scope) > kScopeOrder.indexOf(dep.scope)) {
+          addDependencyError(`${registration.scope} fixture "${registration.name}" cannot depend on a ${dep.scope} fixture "${name}" defined in ${formatPotentiallyInternalLocation(dep.location)}.`, registration.location);
+          continue;
+        }
+        if (!markers.has(dep)) {
+          visit(dep, boxedOnly);
+        } else if (markers.get(dep) === 'visiting') {
+          const index = stack.indexOf(dep);
+          const allRegs = stack.slice(index, stack.length);
+          const filteredRegs = allRegs.filter(r => !r.box);
+          const regs = boxedOnly ? filteredRegs : allRegs;
+          const names = regs.map(r => `"${r.name}"`);
+          addDependencyError(`Fixtures ${names.join(' -> ')} -> "${dep.name}" form a dependency cycle: ${regs.map(r => formatPotentiallyInternalLocation(r.location)).join(' -> ')} -> ${formatPotentiallyInternalLocation(dep.location)}`, dep.location);
+          continue;
+        }
+      }
+      markers.set(registration, 'visited');
+      stack.pop();
+    };
+    const names = Array.from(this._registrations.keys()).sort();
+
+    // First iterate over non-boxed fixtures to provide clear error messages.
+    for (const name of names) {
+      const registration = this._registrations.get(name);
+      if (!registration.box) visit(registration, true);
+    }
+
+    // If no errors found, iterate over boxed fixtures
+    if (!hasDependencyErrors) {
+      for (const name of names) {
+        const registration = this._registrations.get(name);
+        if (registration.box) visit(registration, false);
+      }
+    }
+    const hash = crypto.createHash('sha1');
+    for (const name of names) {
+      const registration = this._registrations.get(name);
+      if (registration.scope === 'worker') hash.update(registration.id + ';');
+    }
+    return hash.digest('hex');
+  }
+  validateFunction(fn, prefix, location) {
+    for (const name of fixtureParameterNames(fn, location, e => this._onLoadError(e))) {
+      const registration = this._registrations.get(name);
+      if (!registration) this._addLoadError(`${prefix} has unknown parameter "${name}".`, location);
+    }
+  }
+  resolve(name, forFixture) {
+    if (name === (forFixture === null || forFixture === void 0 ? void 0 : forFixture.name)) return forFixture.super;
+    return this._registrations.get(name);
+  }
+  autoFixtures() {
+    return [...this._registrations.values()].filter(r => r.auto !== false);
+  }
+  _addLoadError(message, location) {
+    this._onLoadError({
+      message,
+      location
+    });
+  }
+}
+exports.FixturePool = FixturePool;
+const signatureSymbol = Symbol('signature');
+function formatPotentiallyInternalLocation(location) {
+  const isUserFixture = location && (0, _util.filterStackFile)(location.file);
+  return isUserFixture ? (0, _util.formatLocation)(location) : '<builtin>';
+}
+function fixtureParameterNames(fn, location, onError) {
+  if (typeof fn !== 'function') return [];
+  if (!fn[signatureSymbol]) fn[signatureSymbol] = innerFixtureParameterNames(fn, location, onError);
+  return fn[signatureSymbol];
+}
+function inheritFixtureNames(from, to) {
+  to[signatureSymbol] = from[signatureSymbol];
+}
+function innerFixtureParameterNames(fn, location, onError) {
+  const text = filterOutComments(fn.toString());
+  const match = text.match(/(?:async)?(?:\s+function)?[^(]*\(([^)]*)/);
+  if (!match) return [];
+  const trimmedParams = match[1].trim();
+  if (!trimmedParams) return [];
+  const [firstParam] = splitByComma(trimmedParams);
+  if (firstParam[0] !== '{' || firstParam[firstParam.length - 1] !== '}') {
+    onError({
+      message: 'First argument must use the object destructuring pattern: ' + firstParam,
+      location
+    });
+    return [];
+  }
+  const props = splitByComma(firstParam.substring(1, firstParam.length - 1)).map(prop => {
+    const colon = prop.indexOf(':');
+    return colon === -1 ? prop.trim() : prop.substring(0, colon).trim();
+  });
+  const restProperty = props.find(prop => prop.startsWith('...'));
+  if (restProperty) {
+    onError({
+      message: `Rest property "${restProperty}" is not supported. List all used fixtures explicitly, separated by comma.`,
+      location
+    });
+    return [];
+  }
+  return props;
+}
+function filterOutComments(s) {
+  const result = [];
+  let commentState = 'none';
+  for (let i = 0; i < s.length; ++i) {
+    if (commentState === 'singleline') {
+      if (s[i] === '\n') commentState = 'none';
+    } else if (commentState === 'multiline') {
+      if (s[i - 1] === '*' && s[i] === '/') commentState = 'none';
+    } else if (commentState === 'none') {
+      if (s[i] === '/' && s[i + 1] === '/') {
+        commentState = 'singleline';
+      } else if (s[i] === '/' && s[i + 1] === '*') {
+        commentState = 'multiline';
+        i += 2;
+      } else {
+        result.push(s[i]);
+      }
+    }
+  }
+  return result.join('');
+}
+function splitByComma(s) {
+  const result = [];
+  const stack = [];
+  let start = 0;
+  for (let i = 0; i < s.length; i++) {
+    if (s[i] === '{' || s[i] === '[') {
+      stack.push(s[i] === '{' ? '}' : ']');
+    } else if (s[i] === stack[stack.length - 1]) {
+      stack.pop();
+    } else if (!stack.length && s[i] === ',') {
+      const token = s.substring(start, i).trim();
+      if (token) result.push(token);
+      start = i + 1;
+    }
+  }
+  const lastToken = s.substring(start).trim();
+  if (lastToken) result.push(lastToken);
+  return result;
+}
+
+// name + superId, fn -> id
+const registrationIdMap = new Map();
+let lastId = 0;
+function registrationId(registration) {
+  if (registration.id) return registration.id;
+  const key = registration.name + '@@@' + (registration.super ? registrationId(registration.super) : '');
+  let map = registrationIdMap.get(key);
+  if (!map) {
+    map = new Map();
+    registrationIdMap.set(key, map);
+  }
+  if (!map.has(registration.fn)) map.set(registration.fn, String(lastId++));
+  registration.id = map.get(registration.fn);
+  return registration.id;
+}

data/node_modules/playwright/lib/common/globals.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.currentTestInfo = currentTestInfo;
+exports.currentlyLoadingFileSuite = currentlyLoadingFileSuite;
+exports.isWorkerProcess = isWorkerProcess;
+exports.setCurrentTestInfo = setCurrentTestInfo;
+exports.setCurrentlyLoadingFileSuite = setCurrentlyLoadingFileSuite;
+exports.setIsWorkerProcess = setIsWorkerProcess;
+/**
+ * Copyright Microsoft Corporation. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+let currentTestInfoValue = null;
+function setCurrentTestInfo(testInfo) {
+  currentTestInfoValue = testInfo;
+}
+function currentTestInfo() {
+  return currentTestInfoValue;
+}
+let currentFileSuite;
+function setCurrentlyLoadingFileSuite(suite) {
+  currentFileSuite = suite;
+}
+function currentlyLoadingFileSuite() {
+  return currentFileSuite;
+}
+let _isWorkerProcess = false;
+function setIsWorkerProcess() {
+  _isWorkerProcess = true;
+}
+function isWorkerProcess() {
+  return _isWorkerProcess;
+}

data/node_modules/playwright/lib/common/ipc.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.serializeConfig = serializeConfig;
+exports.stdioChunkToParams = stdioChunkToParams;
+var _util = _interopRequireDefault(require("util"));
+var _compilationCache = require("../transform/compilationCache");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * Copyright Microsoft Corporation. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+function serializeConfig(config, passCompilationCache) {
+  const result = {
+    location: {
+      configDir: config.configDir,
+      resolvedConfigFile: config.config.configFile
+    },
+    configCLIOverrides: config.configCLIOverrides,
+    compilationCache: passCompilationCache ? (0, _compilationCache.serializeCompilationCache)() : undefined
+  };
+  return result;
+}
+function stdioChunkToParams(chunk) {
+  if (chunk instanceof Uint8Array) return {
+    buffer: Buffer.from(chunk).toString('base64')
+  };
+  if (typeof chunk !== 'string') return {
+    text: _util.default.inspect(chunk)
+  };
+  return {
+    text: chunk
+  };
+}

data/node_modules/playwright/lib/common/poolBuilder.js

@@ -0,0 +1,79 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PoolBuilder = void 0;
+var _fixtures = require("./fixtures");
+var _util = require("../util");
+/**
+ * Copyright Microsoft Corporation. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class PoolBuilder {
+  static createForLoader() {
+    return new PoolBuilder('loader');
+  }
+  static createForWorker(project) {
+    return new PoolBuilder('worker', project);
+  }
+  constructor(type, project) {
+    this._project = void 0;
+    this._testTypePools = new Map();
+    this._type = void 0;
+    this._type = type;
+    this._project = project;
+  }
+  buildPools(suite, testErrors) {
+    suite.forEachTest(test => {
+      const pool = this._buildPoolForTest(test, testErrors);
+      if (this._type === 'loader') test._poolDigest = pool.digest;
+      if (this._type === 'worker') test._pool = pool;
+    });
+  }
+  _buildPoolForTest(test, testErrors) {
+    let pool = this._buildTestTypePool(test._testType, testErrors);
+    const parents = [];
+    for (let parent = test.parent; parent; parent = parent.parent) parents.push(parent);
+    parents.reverse();
+    for (const parent of parents) {
+      if (parent._use.length) pool = new _fixtures.FixturePool(parent._use, e => this._handleLoadError(e, testErrors), pool, parent._type === 'describe');
+      for (const hook of parent._hooks) pool.validateFunction(hook.fn, hook.type + ' hook', hook.location);
+      for (const modifier of parent._modifiers) pool.validateFunction(modifier.fn, modifier.type + ' modifier', modifier.location);
+    }
+    pool.validateFunction(test.fn, 'Test', test.location);
+    return pool;
+  }
+  _buildTestTypePool(testType, testErrors) {
+    if (!this._testTypePools.has(testType)) {
+      var _this$_project$projec, _this$_project, _this$_project2;
+      const optionOverrides = {
+        overrides: (_this$_project$projec = (_this$_project = this._project) === null || _this$_project === void 0 || (_this$_project = _this$_project.project) === null || _this$_project === void 0 ? void 0 : _this$_project.use) !== null && _this$_project$projec !== void 0 ? _this$_project$projec : {},
+        location: {
+          file: `project#${(_this$_project2 = this._project) === null || _this$_project2 === void 0 ? void 0 : _this$_project2.id}`,
+          line: 1,
+          column: 1
+        }
+      };
+      const pool = new _fixtures.FixturePool(testType.fixtures, e => this._handleLoadError(e, testErrors), undefined, undefined, optionOverrides);
+      this._testTypePools.set(testType, pool);
+    }
+    return this._testTypePools.get(testType);
+  }
+  _handleLoadError(e, testErrors) {
+    if (testErrors) testErrors.push(e);else throw new Error(`${(0, _util.formatLocation)(e.location)}: ${e.message}`);
+  }
+}
+exports.PoolBuilder = PoolBuilder;

data/node_modules/playwright/lib/common/process.js

@@ -0,0 +1,140 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ProcessRunner = void 0;
+var _utils = require("playwright-core/lib/utils");
+var _util = require("../util");
+var _esmLoaderHost = require("./esmLoaderHost");
+var _esmUtils = require("../transform/esmUtils");
+/**
+ * Copyright Microsoft Corporation. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class ProcessRunner {
+  async gracefullyClose() {}
+  dispatchEvent(method, params) {
+    const response = {
+      method,
+      params
+    };
+    sendMessageToParent({
+      method: '__dispatch__',
+      params: response
+    });
+  }
+}
+exports.ProcessRunner = ProcessRunner;
+let gracefullyCloseCalled = false;
+let forceExitInitiated = false;
+sendMessageToParent({
+  method: 'ready'
+});
+process.on('disconnect', () => gracefullyCloseAndExit(true));
+process.on('SIGINT', () => {});
+process.on('SIGTERM', () => {});
+
+// Clear execArgv immediately, so that the user-code does not inherit our loader.
+process.execArgv = (0, _esmUtils.execArgvWithoutExperimentalLoaderOptions)();
+
+// Node.js >= 20
+if (process.env.PW_TS_ESM_LOADER_ON) (0, _esmLoaderHost.registerESMLoader)();
+let processRunner;
+let processName;
+const startingEnv = {
+  ...process.env
+};
+process.on('message', async message => {
+  if (message.method === '__init__') {
+    const {
+      processParams,
+      runnerParams,
+      runnerScript
+    } = message.params;
+    void (0, _utils.startProfiling)();
+    const {
+      create
+    } = require(runnerScript);
+    processRunner = create(runnerParams);
+    processName = processParams.processName;
+    return;
+  }
+  if (message.method === '__stop__') {
+    const keys = new Set([...Object.keys(process.env), ...Object.keys(startingEnv)]);
+    const producedEnv = [...keys].filter(key => startingEnv[key] !== process.env[key]).map(key => {
+      var _process$env$key;
+      return [key, (_process$env$key = process.env[key]) !== null && _process$env$key !== void 0 ? _process$env$key : null];
+    });
+    sendMessageToParent({
+      method: '__env_produced__',
+      params: producedEnv
+    });
+    await gracefullyCloseAndExit(false);
+    return;
+  }
+  if (message.method === '__dispatch__') {
+    const {
+      id,
+      method,
+      params
+    } = message.params;
+    try {
+      const result = await processRunner[method](params);
+      const response = {
+        id,
+        result
+      };
+      sendMessageToParent({
+        method: '__dispatch__',
+        params: response
+      });
+    } catch (e) {
+      const response = {
+        id,
+        error: (0, _util.serializeError)(e)
+      };
+      sendMessageToParent({
+        method: '__dispatch__',
+        params: response
+      });
+    }
+  }
+});
+const kForceExitTimeout = +(process.env.PWTEST_FORCE_EXIT_TIMEOUT || 30000);
+async function gracefullyCloseAndExit(forceExit) {
+  if (forceExit && !forceExitInitiated) {
+    forceExitInitiated = true;
+    // Force exit after 30 seconds.
+    // eslint-disable-next-line no-restricted-properties
+    setTimeout(() => process.exit(0), kForceExitTimeout);
+  }
+  if (!gracefullyCloseCalled) {
+    var _processRunner;
+    gracefullyCloseCalled = true;
+    // Meanwhile, try to gracefully shutdown.
+    await ((_processRunner = processRunner) === null || _processRunner === void 0 ? void 0 : _processRunner.gracefullyClose().catch(() => {}));
+    if (processName) await (0, _utils.stopProfiling)(processName).catch(() => {});
+    // eslint-disable-next-line no-restricted-properties
+    process.exit(0);
+  }
+}
+function sendMessageToParent(message) {
+  try {
+    process.send(message);
+  } catch (e) {
+    // Can throw when closing.
+  }
+}