@basemaps/lambda-tiler 6.28.1 → 6.29.0

package/dist/node_modules/prebuild-install/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "prebuild-install",
+  "version": "7.1.1",
+  "description": "A command line tool to easily install prebuilt binaries for multiple version of node/iojs on a specific platform",
+  "scripts": {
+    "test": "standard && hallmark && tape test/*-test.js",
+    "hallmark": "hallmark --fix"
+  },
+  "keywords": [
+    "prebuilt",
+    "binaries",
+    "native",
+    "addon",
+    "module",
+    "c",
+    "c++",
+    "bindings",
+    "devops",
+    "napi"
+  ],
+  "dependencies": {
+    "detect-libc": "^2.0.0",
+    "expand-template": "^2.0.3",
+    "github-from-package": "0.0.0",
+    "minimist": "^1.2.3",
+    "mkdirp-classic": "^0.5.3",
+    "napi-build-utils": "^1.0.1",
+    "node-abi": "^3.3.0",
+    "pump": "^3.0.0",
+    "rc": "^1.2.7",
+    "simple-get": "^4.0.0",
+    "tar-fs": "^2.0.0",
+    "tunnel-agent": "^0.6.0"
+  },
+  "devDependencies": {
+    "a-native-module": "^1.0.0",
+    "hallmark": "^4.0.0",
+    "nock": "^10.0.6",
+    "rimraf": "^2.5.2",
+    "standard": "^16.0.4",
+    "tape": "^5.3.1",
+    "tempy": "0.2.1"
+  },
+  "bin": "./bin.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/prebuild/prebuild-install.git"
+  },
+  "author": "Mathias Buus (@mafintosh)",
+  "contributors": [
+    "Julian Gruber <julian@juliangruber.com> (https://github.com/juliangruber)",
+    "Brett Lawson <brett19@gmail.com> (https://github.com/brett19)",
+    "Pieter Hintjens <ph@imatix.com> (https://github.com/hintjens)",
+    "Lars-Magnus Skog <ralphtheninja@riseup.net> (https://github.com/ralphtheninja)",
+    "Jesús Leganés Combarro <piranna@gmail.com> (https://github.com/piranna)",
+    "Mathias Küsel <mathiask@hotmail.de> (https://github.com/mathiask88)",
+    "Lukas Geiger <lukas.geiger94@gmail.com> (https://github.com/lgeiger)"
+  ],
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/prebuild/prebuild-install/issues"
+  },
+  "homepage": "https://github.com/prebuild/prebuild-install",
+  "engines": {
+    "node": ">=10"
+  }
+}

package/dist/node_modules/prebuild-install/proxy.js

@@ -0,0 +1,35 @@
+const url = require('url')
+const tunnel = require('tunnel-agent')
+const util = require('./util')
+
+function applyProxy (reqOpts, opts) {
+  const log = opts.log || util.noopLogger
+
+  const proxy = opts['https-proxy'] || opts.proxy
+
+  if (proxy) {
+    // eslint-disable-next-line node/no-deprecated-api
+    const parsedDownloadUrl = url.parse(reqOpts.url)
+    // eslint-disable-next-line node/no-deprecated-api
+    const parsedProxy = url.parse(proxy)
+    const uriProtocol = (parsedDownloadUrl.protocol === 'https:' ? 'https' : 'http')
+    const proxyProtocol = (parsedProxy.protocol === 'https:' ? 'Https' : 'Http')
+    const tunnelFnName = [uriProtocol, proxyProtocol].join('Over')
+    reqOpts.agent = tunnel[tunnelFnName]({
+      proxy: {
+        host: parsedProxy.hostname,
+        port: +parsedProxy.port,
+        proxyAuth: parsedProxy.auth
+      }
+    })
+    log.http('request', 'Proxy setup detected (Host: ' +
+    parsedProxy.hostname + ', Port: ' +
+      parsedProxy.port + ', Authentication: ' +
+      (parsedProxy.auth ? 'Yes' : 'No') + ')' +
+      ' Tunneling with ' + tunnelFnName)
+  }
+
+  return reqOpts
+}
+
+module.exports = applyProxy

package/dist/node_modules/prebuild-install/rc.js

@@ -0,0 +1,64 @@
+const path = require('path')
+const minimist = require('minimist')
+const getAbi = require('node-abi').getAbi
+const detectLibc = require('detect-libc')
+const napi = require('napi-build-utils')
+
+const env = process.env
+
+const libc = env.LIBC || process.env.npm_config_libc ||
+  (detectLibc.isNonGlibcLinuxSync() && detectLibc.familySync()) || ''
+
+// Get the configuration
+module.exports = function (pkg) {
+  const pkgConf = pkg.config || {}
+  const buildFromSource = env.npm_config_build_from_source
+
+  const rc = require('rc')('prebuild-install', {
+    target: pkgConf.target || env.npm_config_target || process.versions.node,
+    runtime: pkgConf.runtime || env.npm_config_runtime || 'node',
+    arch: pkgConf.arch || env.npm_config_arch || process.arch,
+    libc: libc,
+    platform: env.npm_config_platform || process.platform,
+    debug: env.npm_config_debug === 'true',
+    force: false,
+    verbose: env.npm_config_verbose === 'true',
+    buildFromSource: buildFromSource === pkg.name || buildFromSource === 'true',
+    path: '.',
+    proxy: env.npm_config_proxy || env.http_proxy || env.HTTP_PROXY,
+    'https-proxy': env.npm_config_https_proxy || env.https_proxy || env.HTTPS_PROXY,
+    'local-address': env.npm_config_local_address,
+    'local-prebuilds': 'prebuilds',
+    'tag-prefix': 'v',
+    download: env.npm_config_download
+  }, minimist(process.argv, {
+    alias: {
+      target: 't',
+      runtime: 'r',
+      help: 'h',
+      arch: 'a',
+      path: 'p',
+      version: 'v',
+      download: 'd',
+      buildFromSource: 'build-from-source',
+      token: 'T'
+    }
+  }))
+
+  rc.path = path.resolve(rc.path === true ? '.' : rc.path || '.')
+
+  if (napi.isNapiRuntime(rc.runtime) && rc.target === process.versions.node) {
+    rc.target = napi.getBestNapiBuildVersion()
+  }
+
+  rc.abi = napi.isNapiRuntime(rc.runtime) ? rc.target : getAbi(rc.target, rc.runtime)
+
+  rc.libc = rc.platform !== 'linux' || rc.libc === detectLibc.GLIBC ? '' : rc.libc
+
+  return rc
+}
+
+// Print the configuration values when executed standalone for testing purposses
+if (!module.parent) {
+  console.log(JSON.stringify(module.exports({}), null, 2))
+}

package/dist/node_modules/prebuild-install/util.js

@@ -0,0 +1,143 @@
+const path = require('path')
+const github = require('github-from-package')
+const home = require('os').homedir
+const crypto = require('crypto')
+const expandTemplate = require('expand-template')()
+
+function getDownloadUrl (opts) {
+  const pkgName = opts.pkg.name.replace(/^@[a-zA-Z0-9_\-.~]+\//, '')
+  return expandTemplate(urlTemplate(opts), {
+    name: pkgName,
+    package_name: pkgName,
+    version: opts.pkg.version,
+    major: opts.pkg.version.split('.')[0],
+    minor: opts.pkg.version.split('.')[1],
+    patch: opts.pkg.version.split('.')[2],
+    prerelease: opts.pkg.version.split('-')[1],
+    build: opts.pkg.version.split('+')[1],
+    abi: opts.abi || process.versions.modules,
+    node_abi: process.versions.modules,
+    runtime: opts.runtime || 'node',
+    platform: opts.platform,
+    arch: opts.arch,
+    libc: opts.libc || '',
+    configuration: (opts.debug ? 'Debug' : 'Release'),
+    module_name: opts.pkg.binary && opts.pkg.binary.module_name,
+    tag_prefix: opts['tag-prefix']
+  })
+}
+
+function getApiUrl (opts) {
+  return github(opts.pkg).replace('github.com', 'api.github.com/repos') + '/releases'
+}
+
+function getAssetUrl (opts, assetId) {
+  return getApiUrl(opts) + '/assets/' + assetId
+}
+
+function urlTemplate (opts) {
+  if (typeof opts.download === 'string') {
+    return opts.download
+  }
+
+  const packageName = '{name}-v{version}-{runtime}-v{abi}-{platform}{libc}-{arch}.tar.gz'
+  const hostMirrorUrl = getHostMirrorUrl(opts)
+
+  if (hostMirrorUrl) {
+    return hostMirrorUrl + '/{tag_prefix}{version}/' + packageName
+  }
+
+  if (opts.pkg.binary && opts.pkg.binary.host) {
+    return [
+      opts.pkg.binary.host,
+      opts.pkg.binary.remote_path,
+      opts.pkg.binary.package_name || packageName
+    ].map(function (path) {
+      return trimSlashes(path)
+    }).filter(Boolean).join('/')
+  }
+
+  return github(opts.pkg) + '/releases/download/{tag_prefix}{version}/' + packageName
+}
+
+function getEnvPrefix (pkgName) {
+  return 'npm_config_' + (pkgName || '').replace(/[^a-zA-Z0-9]/g, '_').replace(/^_/, '')
+}
+
+function getHostMirrorUrl (opts) {
+  const propName = getEnvPrefix(opts.pkg.name) + '_binary_host'
+  return process.env[propName] || process.env[propName + '_mirror']
+}
+
+function trimSlashes (str) {
+  if (str) return str.replace(/^\.\/|^\/|\/$/g, '')
+}
+
+function cachedPrebuild (url) {
+  const digest = crypto.createHash('md5').update(url).digest('hex').slice(0, 6)
+  return path.join(prebuildCache(), digest + '-' + path.basename(url).replace(/[^a-zA-Z0-9.]+/g, '-'))
+}
+
+function npmCache () {
+  const env = process.env
+  return env.npm_config_cache || (env.APPDATA ? path.join(env.APPDATA, 'npm-cache') : path.join(home(), '.npm'))
+}
+
+function prebuildCache () {
+  return path.join(npmCache(), '_prebuilds')
+}
+
+function tempFile (cached) {
+  return cached + '.' + process.pid + '-' + Math.random().toString(16).slice(2) + '.tmp'
+}
+
+function packageOrigin (env, pkg) {
+  // npm <= 6: metadata is stored on disk in node_modules
+  if (pkg._from) {
+    return pkg._from
+  }
+
+  // npm 7: metadata is exposed to environment by arborist
+  if (env.npm_package_from) {
+    // NOTE: seems undefined atm (npm 7.0.2)
+    return env.npm_package_from
+  }
+
+  if (env.npm_package_resolved) {
+    // NOTE: not sure about the difference with _from, but it's all we have
+    return env.npm_package_resolved
+  }
+}
+
+function localPrebuild (url, opts) {
+  const propName = getEnvPrefix(opts.pkg.name) + '_local_prebuilds'
+  const prefix = process.env[propName] || opts['local-prebuilds'] || 'prebuilds'
+  return path.join(prefix, path.basename(url))
+}
+
+const noopLogger = {
+  http: function () {},
+  silly: function () {},
+  debug: function () {},
+  info: function () {},
+  warn: function () {},
+  error: function () {},
+  critical: function () {},
+  alert: function () {},
+  emergency: function () {},
+  notice: function () {},
+  verbose: function () {},
+  fatal: function () {}
+}
+
+exports.getDownloadUrl = getDownloadUrl
+exports.getApiUrl = getApiUrl
+exports.getAssetUrl = getAssetUrl
+exports.urlTemplate = urlTemplate
+exports.cachedPrebuild = cachedPrebuild
+exports.localPrebuild = localPrebuild
+exports.prebuildCache = prebuildCache
+exports.npmCache = npmCache
+exports.tempFile = tempFile
+exports.packageOrigin = packageOrigin
+exports.noopLogger = noopLogger

package/dist/node_modules/pump/.travis.yml

@@ -0,0 +1,5 @@
+language: node_js
+node_js:
+  - "0.10"
+
+script: "npm test"

package/dist/node_modules/pump/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Mathias Buus
+
+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.

package/dist/node_modules/pump/README.md

@@ -0,0 +1,65 @@
+# pump
+
+pump is a small node module that pipes streams together and destroys all of them if one of them closes.
+
+```
+npm install pump
+```
+
+[![build status](http://img.shields.io/travis/mafintosh/pump.svg?style=flat)](http://travis-ci.org/mafintosh/pump)
+
+## What problem does it solve?
+
+When using standard `source.pipe(dest)` source will _not_ be destroyed if dest emits close or an error.
+You are also not able to provide a callback to tell when then pipe has finished.
+
+pump does these two things for you
+
+## Usage
+
+Simply pass the streams you want to pipe together to pump and add an optional callback
+
+``` js
+var pump = require('pump')
+var fs = require('fs')
+
+var source = fs.createReadStream('/dev/random')
+var dest = fs.createWriteStream('/dev/null')
+
+pump(source, dest, function(err) {
+  console.log('pipe finished', err)
+})
+
+setTimeout(function() {
+  dest.destroy() // when dest is closed pump will destroy source
+}, 1000)
+```
+
+You can use pump to pipe more than two streams together as well
+
+``` js
+var transform = someTransformStream()
+
+pump(source, transform, anotherTransform, dest, function(err) {
+  console.log('pipe finished', err)
+})
+```
+
+If `source`, `transform`, `anotherTransform` or `dest` closes all of them will be destroyed.
+
+Similarly to `stream.pipe()`, `pump()` returns the last stream passed in, so you can do:
+
+```
+return pump(s1, s2) // returns s2
+```
+
+If you want to return a stream that combines *both* s1 and s2 to a single stream use
+[pumpify](https://github.com/mafintosh/pumpify) instead.
+
+## License
+
+MIT
+
+## Related
+
+`pump` is part of the [mississippi stream utility collection](https://github.com/maxogden/mississippi) which includes more useful stream modules similar to this one.

package/dist/node_modules/pump/index.js

@@ -0,0 +1,82 @@
+var once = require('once')
+var eos = require('end-of-stream')
+var fs = require('fs') // we only need fs to get the ReadStream and WriteStream prototypes
+
+var noop = function () {}
+var ancient = /^v?\.0/.test(process.version)
+
+var isFn = function (fn) {
+  return typeof fn === 'function'
+}
+
+var isFS = function (stream) {
+  if (!ancient) return false // newer node version do not need to care about fs is a special way
+  if (!fs) return false // browser
+  return (stream instanceof (fs.ReadStream || noop) || stream instanceof (fs.WriteStream || noop)) && isFn(stream.close)
+}
+
+var isRequest = function (stream) {
+  return stream.setHeader && isFn(stream.abort)
+}
+
+var destroyer = function (stream, reading, writing, callback) {
+  callback = once(callback)
+
+  var closed = false
+  stream.on('close', function () {
+    closed = true
+  })
+
+  eos(stream, {readable: reading, writable: writing}, function (err) {
+    if (err) return callback(err)
+    closed = true
+    callback()
+  })
+
+  var destroyed = false
+  return function (err) {
+    if (closed) return
+    if (destroyed) return
+    destroyed = true
+
+    if (isFS(stream)) return stream.close(noop) // use close for fs streams to avoid fd leaks
+    if (isRequest(stream)) return stream.abort() // request.destroy just do .end - .abort is what we want
+
+    if (isFn(stream.destroy)) return stream.destroy()
+
+    callback(err || new Error('stream was destroyed'))
+  }
+}
+
+var call = function (fn) {
+  fn()
+}
+
+var pipe = function (from, to) {
+  return from.pipe(to)
+}
+
+var pump = function () {
+  var streams = Array.prototype.slice.call(arguments)
+  var callback = isFn(streams[streams.length - 1] || noop) && streams.pop() || noop
+
+  if (Array.isArray(streams[0])) streams = streams[0]
+  if (streams.length < 2) throw new Error('pump requires two streams per minimum')
+
+  var error
+  var destroys = streams.map(function (stream, i) {
+    var reading = i < streams.length - 1
+    var writing = i > 0
+    return destroyer(stream, reading, writing, function (err) {
+      if (!error) error = err
+      if (err) destroys.forEach(call)
+      if (reading) return
+      destroys.forEach(call)
+      callback(error)
+    })
+  })
+
+  return streams.reduce(pipe)
+}
+
+module.exports = pump

package/dist/node_modules/pump/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "pump",
+  "version": "3.0.0",
+  "repository": "git://github.com/mafintosh/pump.git",
+  "license": "MIT",
+  "description": "pipe streams together and close all of them if one of them closes",
+  "browser": {
+    "fs": false
+  },
+  "keywords": [
+    "streams",
+    "pipe",
+    "destroy",
+    "callback"
+  ],
+  "author": "Mathias Buus Madsen <mathiasbuus@gmail.com>",
+  "dependencies": {
+    "end-of-stream": "^1.1.0",
+    "once": "^1.3.1"
+  },
+  "scripts": {
+    "test": "node test-browser.js && node test-node.js"
+  }
+}

package/dist/node_modules/pump/test-browser.js

@@ -0,0 +1,66 @@
+var stream = require('stream')
+var pump = require('./index')
+
+var rs = new stream.Readable()
+var ws = new stream.Writable()
+
+rs._read = function (size) {
+  this.push(Buffer(size).fill('abc'))
+}
+
+ws._write = function (chunk, encoding, cb) {
+  setTimeout(function () {
+    cb()
+  }, 100)
+}
+
+var toHex = function () {
+  var reverse = new (require('stream').Transform)()
+
+  reverse._transform = function (chunk, enc, callback) {
+    reverse.push(chunk.toString('hex'))
+    callback()
+  }
+
+  return reverse
+}
+
+var wsClosed = false
+var rsClosed = false
+var callbackCalled = false
+
+var check = function () {
+  if (wsClosed && rsClosed && callbackCalled) {
+    console.log('test-browser.js passes')
+    clearTimeout(timeout)
+  }
+}
+
+ws.on('finish', function () {
+  wsClosed = true
+  check()
+})
+
+rs.on('end', function () {
+  rsClosed = true
+  check()
+})
+
+var res = pump(rs, toHex(), toHex(), toHex(), ws, function () {
+  callbackCalled = true
+  check()
+})
+
+if (res !== ws) {
+  throw new Error('should return last stream')
+}
+
+setTimeout(function () {
+  rs.push(null)
+  rs.emit('close')
+}, 1000)
+
+var timeout = setTimeout(function () {
+  check()
+  throw new Error('timeout')
+}, 5000)

package/dist/node_modules/pump/test-node.js

@@ -0,0 +1,53 @@
+var pump = require('./index')
+
+var rs = require('fs').createReadStream('/dev/random')
+var ws = require('fs').createWriteStream('/dev/null')
+
+var toHex = function () {
+  var reverse = new (require('stream').Transform)()
+
+  reverse._transform = function (chunk, enc, callback) {
+    reverse.push(chunk.toString('hex'))
+    callback()
+  }
+
+  return reverse
+}
+
+var wsClosed = false
+var rsClosed = false
+var callbackCalled = false
+
+var check = function () {
+  if (wsClosed && rsClosed && callbackCalled) {
+    console.log('test-node.js passes')
+    clearTimeout(timeout)
+  }
+}
+
+ws.on('close', function () {
+  wsClosed = true
+  check()
+})
+
+rs.on('close', function () {
+  rsClosed = true
+  check()
+})
+
+var res = pump(rs, toHex(), toHex(), toHex(), ws, function () {
+  callbackCalled = true
+  check()
+})
+
+if (res !== ws) {
+  throw new Error('should return last stream')
+}
+
+setTimeout(function () {
+  rs.destroy()
+}, 1000)
+
+var timeout = setTimeout(function () {
+  throw new Error('timeout')
+}, 5000)

package/dist/node_modules/rc/LICENSE.APACHE2

@@ -0,0 +1,15 @@
+Apache License, Version 2.0
+
+Copyright (c) 2011 Dominic Tarr
+
+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/dist/node_modules/rc/LICENSE.BSD

@@ -0,0 +1,26 @@
+Copyright (c) 2013, Dominic Tarr
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met: 
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer. 
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution. 
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+The views and conclusions contained in the software and documentation are those
+of the authors and should not be interpreted as representing official policies, 
+either expressed or implied, of the FreeBSD Project.