flow like the river

VISUALIZACION/node_modules/deasync/.github/FUNDING.yml

@@ -0,0 +1,12 @@
+# These are supported funding model platforms
+
+github: [abbr]
+patreon: # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: # Replace with a single Ko-fi username
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+otechie: # Replace with a single Otechie username
+custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

VISUALIZACION/node_modules/deasync/.github/workflows/npm_test.yml

@@ -0,0 +1,20 @@
+name: npm_test
+on: [pull_request, push]
+jobs:
+  npm_test:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [macos-latest, ubuntu-latest, windows-latest]
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+          node-version: '18'
+      - run: npm install
+      - run: npm test
+      - name: Upload bin folder
+        uses: actions/upload-artifact@v2
+        with:
+          name: bin
+          path: bin/

VISUALIZACION/node_modules/deasync/.travis.yml

@@ -0,0 +1,4 @@
+language: node_js
+
+node_js:
+  - node

VISUALIZACION/node_modules/deasync/LICENSE

@@ -0,0 +1,9 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-present
+
+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.

VISUALIZACION/node_modules/deasync/README.md

@@ -0,0 +1,112 @@
+DeAsync.js
+=======
+[![NPM version](http://img.shields.io/npm/v/deasync.svg)](https://www.npmjs.org/package/deasync)
+
+DeAsync turns async function into sync, implemented with a blocking mechanism by calling Node.js event loop at JavaScript layer. The core of deasync is written in C++.
+
+
+## Motivation
+
+Suppose you maintain a library that exposes a function <code>getData</code>. Your users call it to get actual data:   
+<code>var myData = getData();</code>  
+Under the hood data is saved in a file so you implemented <code>getData</code> using Node.js built-in <code>fs.readFileSync</code>. It's obvious both <code>getData</code> and <code>fs.readFileSync</code> are sync functions. One day you were told to switch the underlying data source to a repo such as MongoDB which can only be accessed asynchronously. You were also told for backward compatibility, <code>getData</code> API cannot be changed to return merely a promise or demand a callback parameter. How do you meet both requirements?
+
+You may tempted to use [node-fibers](https://github.com/laverdet/node-fibers) or a module derived from it, but node fibers can only wrap async function call into a sync function inside a fiber. In the case above you cannot assume all  callers are inside fibers. On the other hand, if you start a fiber in `getData` then `getData` itself will still return immediately without waiting for the async call result. For similar reason ES6 generators introduced in Node v0.11 won't work either. 
+
+What really needed is a way to block subsequent JavaScript from running without blocking entire thread by yielding to allow other events in the event loop to be handled. Ideally the blockage is removed as soon as the result of async function is available. A less ideal but often acceptable alternative is a `sleep` function which you can use to implement the blockage like ```while(!done) sleep(100);```. It is less ideal because sleep duration has to be guessed. It is important the `sleep` function not only shouldn't block entire thread, but also shouldn't incur busy wait that pegs the CPU to 100%. 
+</small>
+
+DeAsync supports both alternatives.
+
+
+
+## Usages
+
+
+* Generic wrapper of async function with conventional API signature `function(p1,...pn,function cb(error,result){})`. Returns `result` and throws `error` as exception if not null:
+
+```javascript
+var deasync = require('deasync');
+var cp = require('child_process');
+var exec = deasync(cp.exec);
+// output result of ls -la
+try{
+    console.log(exec('ls -la'));
+}
+catch(err){
+    console.log(err);
+}
+// done is printed last, as supposed, with cp.exec wrapped in deasync; first without.
+console.log('done');
+```
+
+* For async function with unconventional API, for instance `function asyncFunction(p1,function cb(res){})`, use `loopWhile(predicateFunc)` where `predicateFunc` is a function that returns boolean loop condition
+
+```javascript
+var done = false;
+var data;
+asyncFunction(p1,function cb(res){
+    data = res;
+    done = true;
+});
+require('deasync').loopWhile(function(){return !done;});
+// data is now populated
+```
+
+* Sleep (a wrapper of setTimeout)
+
+```javascript
+function SyncFunction(){
+  var ret;
+  setTimeout(function(){
+      ret = "hello";
+  },3000);
+  while(ret === undefined) {
+    require('deasync').sleep(100);
+  }
+  // returns hello with sleep; undefined without
+  return ret;    
+}
+```
+
+## Installation
+Except on a few [ platforms + Node version combinations](https://github.com/abbr/deasync-bin) where binary distribution is included, DeAsync uses node-gyp to compile C++ source code so you may need the compilers listed in [node-gyp](https://github.com/TooTallNate/node-gyp). You may also need to [update npm's bundled node-gyp](https://github.com/TooTallNate/node-gyp/wiki/Updating-npm's-bundled-node-gyp).
+
+To install, run
+
+```npm install deasync```
+
+
+## Recommendation
+Unlike other (a)sync js packages that mostly have only syntactic impact, DeAsync also changes code execution sequence. As such, it is intended to solve niche cases like the above one. If all you are facing is syntactic problem such as callback hell, using a less drastic package implemented in pure js is recommended.
+
+## Support
+Pull requests and issue reporting are welcome. For issues to be considered by maintainer
+  1. they must be reproducible
+  2. there must be evidence the issue is related to DeAsync
+
+To that end, the issue should contain platform information, error message relevant to DeAsync, and preferably code snippet. If code snippet is supplied, it must be self-contained, i.e. independent from your runtime environment or other modules not explicitly specified via `require` in the code snippet.
+
+## License
+
+The MIT License (MIT)
+
+Copyright (c) 2015
+
+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.

VISUALIZACION/node_modules/deasync/app.code-workspace

@@ -0,0 +1,10 @@
+{
+  "folders": [
+    {
+      "path": "."
+    }
+  ],
+  "settings": {
+    "cSpell.words": ["ldflags", "libstdc", "loongarch"]
+  }
+}

VISUALIZACION/node_modules/deasync/binding.gyp

@@ -0,0 +1,39 @@
+{
+  "targets": [
+    {
+      "target_name": "deasync",
+      "cflags!": [
+        "-fno-exceptions"
+      ],
+      "cflags_cc!": [
+        "-fno-exceptions"
+      ],
+      "xcode_settings": {
+        "GCC_ENABLE_CPP_EXCEPTIONS": "YES",
+        "CLANG_CXX_LIBRARY": "libc++",
+        "MACOSX_DEPLOYMENT_TARGET": "10.7"
+      },
+      "msvs_settings": {
+        "VCCLCompilerTool": {
+          "ExceptionHandling": 1
+        }
+      },
+      "sources": [
+        "src/deasync.cc"
+      ],
+      "include_dirs": [
+        "<!@(node -p \"require('node-addon-api').include.replace(/\\\s/g, \\\"\\\\\\\\\\\\\\\ \\\")\")"
+      ],
+      "conditions": [
+        [
+          "OS=='linux'",
+          {
+            "ldflags": [
+#              "-static-libstdc++",
+            ]
+          }
+        ]
+      ]
+    }
+  ]
+}

VISUALIZACION/node_modules/deasync/build.js

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+
+var cp = require('child_process'),
+  fs = require('fs'),
+  path = require('path');
+
+// Parse args
+var force = false,
+  debug = false;
+var arch = process.arch,
+  platform = process.platform,
+  nodeV = /[0-9]+\.[0-9]+/.exec(process.versions.node)[0],
+  nodeVM = /[0-9]+/.exec(process.versions.node)[0];
+var args = process.argv.slice(2).filter(function (arg) {
+  if (arg === '-f') {
+    force = true;
+    return false;
+  } else if (arg.substring(0, 13) === '--target_arch') {
+    arch = arg.substring(14);
+  } else if (arg === '--debug') {
+    debug = true;
+  }
+  return true;
+});
+if (
+  !{
+    ia32: true,
+    x64: true,
+    arm: true,
+    arm64: true,
+    ppc64: true,
+    ppc: true,
+    s390x: true,
+    mips64el: true,
+    loong64: true,
+  }.hasOwnProperty(arch)
+) {
+  console.error('Unsupported (?) architecture: `' + arch + '`');
+  process.exit(1);
+}
+
+// Test for pre-built library
+var modPath = platform + '-' + arch + '-node-' + nodeV;
+if (!force) {
+  try {
+    try {
+      fs.statSync(path.join(__dirname, 'bin', modPath, 'deasync.node'));
+    } catch (ex) {
+      modPath = platform + '-' + arch + '-node-' + nodeVM;
+      fs.statSync(path.join(__dirname, 'bin', modPath, 'deasync.node'));
+    }
+    console.log('`' + modPath + '` exists; testing');
+    cp.execFile(
+      process.execPath,
+      ['quick-test.js'],
+      function (err, stdout, stderr) {
+        if (err || stderr) {
+          console.log('Problem with the binary; manual build incoming');
+          console.log('stdout=' + stdout);
+          console.log('err=' + err);
+          build();
+        } else {
+          console.log('Binary is fine; exiting');
+        }
+      }
+    );
+  } catch (ex) {
+    // Stat failed
+    build();
+  }
+} else {
+  build();
+}
+
+// Build it
+function build() {
+  cp.spawn(
+    process.platform === 'win32' ? 'node-gyp.cmd' : 'node-gyp',
+    ['rebuild'].concat(args),
+    {
+      stdio: 'inherit',
+    }
+  ).on('exit', function (err) {
+    if (err) {
+      if (err === 127) {
+        console.error(
+          'node-gyp not found! Please upgrade your install of npm! You need at least 1.1.5 (I think) ' +
+            'and preferably 1.1.30.'
+        );
+      } else {
+        console.error('Build failed');
+      }
+      return process.exit(err);
+    }
+    afterBuild();
+  });
+}
+
+// Move it to expected location
+function afterBuild() {
+  var targetPath = path.join(
+    __dirname,
+    'build',
+    debug ? 'Debug' : 'Release',
+    'deasync.node'
+  );
+  var installPath = path.join(__dirname, 'bin', modPath, 'deasync.node');
+
+  try {
+    fs.mkdirSync(path.join(__dirname, 'bin'));
+  } catch (ex) {}
+  try {
+    fs.mkdirSync(path.join(__dirname, 'bin', modPath));
+  } catch (ex) {}
+
+  try {
+    fs.statSync(targetPath);
+  } catch (ex) {
+    console.error('Build succeeded but target not found');
+    process.exit(1);
+  }
+  fs.renameSync(targetPath, installPath);
+  console.log('Installed in `' + installPath + '`');
+}

VISUALIZACION/node_modules/deasync/index.js

@@ -0,0 +1,73 @@
+/*!
+ * deasync
+ * https://github.com/abbr/deasync
+ *
+ * Copyright 2014-present Abbr
+ * Released under the MIT license
+ */
+
+var fs = require('fs'),
+	path = require('path'),
+	binding
+
+// Seed random numbers [gh-82] if on Windows. See https://github.com/laverdet/node-fibers/issues/82
+if (process.platform === 'win32') Math.random()
+
+
+// Look for binary for this platform
+var nodeV = 'node-' + /[0-9]+\.[0-9]+/.exec(process.versions.node)[0]
+var nodeVM = 'node-' + /[0-9]+/.exec(process.versions.node)[0]
+var modPath = path.join(__dirname, 'bin', process.platform + '-' + process.arch + '-' + nodeV, 'deasync')
+try {
+	try {
+		fs.statSync(modPath + '.node')
+	} catch (ex) {
+		modPath = path.join(__dirname, 'bin', process.platform + '-' + process.arch + '-' + nodeVM, 'deasync')
+		fs.statSync(modPath + '.node')
+	}
+	binding = require(modPath)
+} catch (ex) {
+	binding = require('bindings')('deasync')
+}
+
+function deasync(fn) {
+	return function () {
+		var done = false
+		var args = Array.prototype.slice.apply(arguments).concat(cb)
+		var err
+		var res
+
+		fn.apply(this, args)
+		module.exports.loopWhile(function () {
+			return !done
+		})
+		if (err)
+			throw err
+
+		return res
+
+		function cb(e, r) {
+			err = e
+			res = r
+			done = true
+		}
+	}
+}
+
+module.exports = deasync
+
+module.exports.sleep = deasync(function (timeout, done) {
+	setTimeout(done, timeout)
+})
+
+module.exports.runLoopOnce = function () {
+	process._tickCallback()
+	binding.run()
+}
+
+module.exports.loopWhile = function (pred) {
+	while (pred()) {
+		process._tickCallback()
+		if (pred()) binding.run()
+	}
+}

VISUALIZACION/node_modules/deasync/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "deasync",
+  "version": "0.1.28",
+  "description": "Turns async function into sync via JavaScript wrapper of Node event loop",
+  "main": "index.js",
+  "author": "Vladimir Kurchatkin <vladimir.kurchatkin@gmail.com>",
+  "contributors": [
+    "Fred Wen <wenfred@gmail.com> (https://github.com/abbr)"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "install": "node ./build.js",
+    "test": "node spec"
+  },
+  "dependencies": {
+    "bindings": "^1.5.0",
+    "node-addon-api": "^1.7.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/abbr/deasync.git"
+  },
+  "homepage": "https://github.com/abbr/deasync",
+  "keywords": [
+    "async",
+    "sync",
+    "sleep",
+    "async wrapper"
+  ],
+  "engines": {
+    "node": ">=0.11.0"
+  },
+  "devDependencies": {
+    "require-directory": "^2.1.1"
+  }
+}

VISUALIZACION/node_modules/deasync/quick-test.js

@@ -0,0 +1,9 @@
+const assert = require('assert')
+var ret,
+  deasync = require('./index.js')
+setTimeout(function() {
+  ret = 'pass'
+}, 100)
+
+while (ret === undefined) deasync.sleep(10)
+assert.strictEqual(ret, 'pass')

VISUALIZACION/node_modules/deasync/spec/app/exec.js

@@ -0,0 +1,4 @@
+var deasync = require('../../index.js')
+var cp = require('child_process')
+var exec = deasync(cp.exec)
+exec('ls -la')

VISUALIZACION/node_modules/deasync/spec/app/request.js

@@ -0,0 +1,22 @@
+var deasync = require('../../index.js')
+var https = require('https')
+
+
+var request = deasync(function (url, done) {
+  https.get(url, function (res) {
+    res.on('error', done)
+
+    res.setEncoding('utf8')
+
+    var result = ''
+
+    res.on('data', function (data) {
+      result += data
+    })
+    res.on('end', function () {
+      done(null, result)
+    })
+  }).on('error', done)
+})
+
+request('https://nodejs.org/en/')

VISUALIZACION/node_modules/deasync/spec/app/sleep.js

@@ -0,0 +1,5 @@
+var deasync = require('../../index.js')
+var sleep = deasync(function (timeout, done) {
+  setTimeout(done, timeout)
+})
+sleep(2000)

VISUALIZACION/node_modules/deasync/spec/app/worker-threads.js

@@ -0,0 +1,11 @@
+let version = Number(process.version.match(/^v(\d+)/)[1])
+if (version < 12) return
+
+const { Worker, isMainThread } = require('worker_threads')
+
+if (isMainThread) {
+  new Worker(__filename)
+} else {
+  const deasync = require('../../index.js')
+  deasync.sleep(100)
+}

VISUALIZACION/node_modules/deasync/spec/index.js

@@ -0,0 +1,3 @@
+var requireDirectory = require('require-directory')
+require('../quick-test')
+requireDirectory(module)

VISUALIZACION/node_modules/deasync/src/deasync.cc

@@ -0,0 +1,19 @@
+#include <uv.h>
+#include <v8.h>
+#include <napi.h>
+#include <uv.h>
+#include <node.h>
+
+Napi::Value Run(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Napi::HandleScope scope(env);
+  uv_run(node::GetCurrentEventLoop(v8::Isolate::GetCurrent()), UV_RUN_ONCE);
+  return env.Undefined();
+}
+
+static Napi::Object init(Napi::Env env, Napi::Object exports) {
+  exports.Set(Napi::String::New(env, "run"), Napi::Function::New(env, Run));
+  return exports;
+}
+
+NODE_API_MODULE(deasync, init)