@macula-io/martha 0.0.0 → 1.0.1

package/node_modules/@isaacs/nonrecursive-glob-match/src/numeric-range.ts

@@ -0,0 +1,79 @@
+import type { Item } from './index.js'
+
+// One digit, or a class of digits from a to b.
+const digit = (a: number, b: number): Item =>
+  a === b ?
+    { t: 'lit', ch: String(a) }
+  : { t: 'class', re: new RegExp(`^[${a}-${b}]$`) }
+
+const prefix = (d: number, alts: Item[][]) =>
+  alts.map(s => [digit(d, d), ...s])
+
+// The digit strings from a to b, which have the same length.
+const fixed = (a: string, b: string): Item[][] => {
+  if (!a) return [[]]
+  let lo = +a[0]!
+  let hi = +b[0]!
+  const ra = a.slice(1)
+  const rb = b.slice(1)
+  if (lo === hi) return prefix(lo, fixed(ra, rb))
+  const zeros = '0'.repeat(ra.length)
+  const nines = '9'.repeat(ra.length)
+  const out: Item[][] = []
+  if (ra !== zeros) out.push(...prefix(lo++, fixed(ra, nines)))
+  const last = rb === nines ? [] : prefix(hi--, fixed(zeros, rb))
+  if (lo <= hi) {
+    out.push([digit(lo, hi), ...Array.from(ra, () => digit(0, 9))])
+  }
+  out.push(...last)
+  return out
+}
+
+// The numbers from a to b, where 0 <= a <= b. If width is set, each
+// one has leading zeros to make it that many digits.
+const nonneg = (a: number, b: number, width: number): Item[][] => {
+  if (width) {
+    return fixed(
+      String(a).padStart(width, '0'),
+      String(b).padStart(width, '0'),
+    )
+  }
+  const out: Item[][] = []
+  for (let len = String(a).length; len <= String(b).length; len++) {
+    const lo = Math.max(a, len === 1 ? 0 : 10 ** (len - 1))
+    const hi = Math.min(b, 10 ** len - 1)
+    out.push(...fixed(String(lo), String(hi)))
+  }
+  return out
+}
+
+/**
+ * The strings that the bash brace expansion `{lo..hi}` makes, as
+ * the alternatives of an `@(...)` extglob. Each one is a sequence of
+ * digits and digit classes, so there are only a few of them, even for
+ * a large range.
+ *
+ * If either end has a leading zero, such as `{01..10}`, each number
+ * has leading zeros to make it as long as the longer end, counting a
+ * `-` sign. So `{-05..3}` makes `-05` to `-01`, then `000` to `003`.
+ *
+ * Returns undefined if either end is not a safe integer.
+ */
+export const numericRange = (
+  loStr: string,
+  hiStr: string,
+): Item[][] | undefined => {
+  let lo = Number(loStr)
+  let hi = Number(hiStr)
+  if (!Number.isSafeInteger(lo) || !Number.isSafeInteger(hi)) return
+  if (lo > hi) [lo, hi] = [hi, lo]
+  const padded = /^-?0\d/.test(loStr) || /^-?0\d/.test(hiStr)
+  const width = padded ? Math.max(loStr.length, hiStr.length) : 0
+  const out: Item[][] = []
+  if (lo < 0) {
+    const neg = nonneg(Math.max(-hi, 1), -lo, width && width - 1)
+    out.push(...neg.map(s => [{ t: 'lit', ch: '-' } as Item, ...s]))
+  }
+  if (hi >= 0) out.push(...nonneg(Math.max(lo, 0), hi, width))
+  return out
+}

package/node_modules/@isaacs/nonrecursive-glob-match/src/parse-class.ts

@@ -0,0 +1,158 @@
+// translate the various posix character classes into unicode properties
+// this works across all unicode locales
+
+// { <posix class>: [<translation>, negated]
+const posixClasses: { [k: string]: [e: string, n?: boolean] } = {
+  '[:alnum:]': ['\\p{L}\\p{Nl}\\p{Nd}'],
+  '[:alpha:]': ['\\p{L}\\p{Nl}'],
+  '[:ascii:]': ['\\x' + '00-\\x' + '7f'],
+  '[:blank:]': ['\\p{Zs}\\t'],
+  '[:cntrl:]': ['\\p{Cc}'],
+  '[:digit:]': ['\\p{Nd}'],
+  '[:graph:]': ['\\p{Z}\\p{C}', true],
+  '[:lower:]': ['\\p{Ll}'],
+  '[:print:]': ['\\p{C}', true],
+  '[:punct:]': ['\\p{P}\\p{S}'],
+  '[:space:]': ['\\p{Z}\\t\\r\\n\\v\\f'],
+  '[:upper:]': ['\\p{Lu}'],
+  '[:word:]': ['\\p{L}\\p{Nl}\\p{Nd}\\p{Pc}'],
+  '[:xdigit:]': ['A-Fa-f0-9'],
+}
+
+// only need to escape a few things inside of brace expressions
+// escapes: [ \ ] -
+const braceEscape = (s: string) => s.replace(/[[\]\\-]/g, '\\$&')
+
+export type ParseClassResult = [re: RegExp, consumed: number]
+
+export type Form = 'NFC' | 'NFD' | 'NFKC' | 'NFKD'
+
+const noMatch = /$./
+
+// Takes a glob string at a posix brace expression. Returns a RegExp
+// that tests one character, and the number of glob chars consumed.
+// If the class is not closed, consumed is 0, and the `[` must be
+// treated as a literal character.
+// Out of order ranges are removed. If nothing is left, the RegExp
+// is `/$./`, and the rest of the glob is consumed, so that the
+// whole glob cannot match.
+export const parseClass = (
+  glob: string,
+  position: number,
+  nocase: boolean = false,
+  form?: Form,
+): ParseClassResult => {
+  // normalize one class member, if it stays one code point
+  const norm = (c: string) => {
+    const n = form ? c.normalize(form) : c
+    return [...n].length === 1 ? n : c
+  }
+  const pos = position
+  /* c8 ignore start */
+  if (glob.charAt(pos) !== '[') {
+    throw new Error('not in a brace expression')
+  }
+  /* c8 ignore stop */
+  const ranges: string[] = []
+  const negs: string[] = []
+
+  let i = pos + 1
+  let sawStart = false
+  let escaping = false
+  let negate = false
+  let endPos = pos
+  let rangeStart = ''
+  WHILE: while (i < glob.length) {
+    const c = String.fromCodePoint(glob.codePointAt(i)!)
+    if ((c === '!' || c === '^') && i === pos + 1) {
+      negate = true
+      i++
+      continue
+    }
+
+    if (c === ']' && sawStart && !escaping) {
+      endPos = i + 1
+      break
+    }
+
+    sawStart = true
+    if (c === '\\') {
+      if (!escaping) {
+        escaping = true
+        i++
+        continue
+      }
+      // escaped \ char, fall through and treat like normal char
+    }
+    if (c === '[' && !escaping) {
+      // either a posix class, a collation equivalent, or just a [
+      for (const [cls, [unip, neg]] of Object.entries(posixClasses)) {
+        if (glob.startsWith(cls, i)) {
+          // invalid, [a-[] is fine, but not [a-[:alpha]]
+          if (rangeStart) {
+            return [noMatch, glob.length - pos]
+          }
+          i += cls.length
+          if (neg) negs.push(unip)
+          else ranges.push(unip)
+          continue WHILE
+        }
+      }
+    }
+
+    // now it's just a normal character, effectively
+    escaping = false
+    const n = norm(c)
+    if (rangeStart) {
+      // throw this range away if it's not valid, but others
+      // can still match.
+      if (n.codePointAt(0)! > rangeStart.codePointAt(0)!) {
+        ranges.push(braceEscape(rangeStart) + '-' + braceEscape(n))
+      } else if (n === rangeStart) {
+        ranges.push(braceEscape(n))
+      }
+      rangeStart = ''
+      i += c.length
+      continue
+    }
+
+    // now might be the start of a range.
+    // can be either c-d or c-] or c<more...>] or c] at this point
+    if (glob.startsWith('-]', i + c.length)) {
+      ranges.push(braceEscape(n + '-'))
+      i += c.length + 1
+      continue
+    }
+    if (glob.startsWith('-', i + c.length)) {
+      rangeStart = n
+      i += c.length + 1
+      continue
+    }
+
+    // not the start of a range, just a single character
+    ranges.push(braceEscape(n))
+    i += c.length
+  }
+
+  if (endPos < i) {
+    // didn't see the end of the class, not a valid class,
+    // but might still be valid as a literal match.
+    return [noMatch, 0]
+  }
+
+  // if we got no ranges and no negates, then we have a range that
+  // cannot possibly match anything, and that poisons the whole glob
+  if (!ranges.length && !negs.length) {
+    return [noMatch, glob.length - pos]
+  }
+
+  const sranges = '[' + (negate ? '^' : '') + ranges.join('') + ']'
+  const snegs = '[' + (negate ? '' : '^') + negs.join('') + ']'
+  const comb =
+    '^' +
+    (ranges.length && negs.length ? '(' + sranges + '|' + snegs + ')'
+    : ranges.length ? sranges
+    : snegs)
+
+  return [new RegExp(comb, nocase ? 'iu' : 'u'), endPos - pos]
+}

package/node_modules/@npmcli/agent/README.md

@@ -0,0 +1,40 @@
+## @npmcli/agent
+
+A pair of Agent implementations for nodejs that provide consistent keep-alives, granular timeouts, dns caching, and proxy support.
+
+### Usage
+
+```js
+const { getAgent, HttpAgent } = require('@npmcli/agent')
+const fetch = require('minipass-fetch')
+
+const main = async () => {
+    // if you know what agent you need, you can create one directly
+    const agent = new HttpAgent(agentOptions)
+    // or you can use the getAgent helper, it will determine and create an Agent
+    // instance for you as well as reuse that agent for new requests as appropriate
+    const agent = getAgent('https://registry.npmjs.org/npm', agentOptions)
+    // minipass-fetch is just an example, this will work for any http client that
+    // supports node's Agents
+    const res = await fetch('https://registry.npmjs.org/npm', { agent })
+}
+
+main()
+```
+
+### Options
+
+All options supported by the node Agent implementations are supported here, see [the docs](https://nodejs.org/api/http.html#new-agentoptions) for those.
+
+Options that have been added by this module include:
+
+- `family`: what tcp family to use, can be `4` for IPv4, `6` for IPv6 or `0` for both.
+- `proxy`: a URL to a supported proxy, currently supports `HTTP CONNECT` based http/https proxies as well as socks4 and 5.
+- `dns`: configuration for the built-in dns cache
+    - `ttl`: how long (in milliseconds) to keep cached dns entries, defaults to `5 * 60 * 100 (5 minutes)`
+    - `lookup`: optional function to override how dns lookups are performed, defaults to `require('dns').lookup`
+- `timeouts`: a set of granular timeouts, all default to `0`
+    - `connection`: time between initiating connection and actually connecting
+    - `idle`: time between data packets (if a top level `timeout` is provided, it will be copied here)
+    - `response`: time between sending a request and receiving a response
+    - `transfer`: time between starting to receive a request and consuming the response fully

package/node_modules/@npmcli/agent/lib/agents.js

@@ -0,0 +1,268 @@
+'use strict'
+
+const net = require('net')
+const tls = require('tls')
+const { once } = require('events')
+const timers = require('timers/promises')
+const { normalizeOptions, cacheOptions } = require('./options')
+const { getProxy, getProxyAgent, proxyCache } = require('./proxy.js')
+const Errors = require('./errors.js')
+const { Agent: AgentBase } = require('agent-base')
+
+module.exports = class Agent extends AgentBase {
+  #options
+  #timeouts
+  #proxy
+  #noProxy
+  #ProxyAgent
+
+  constructor (options = {}) {
+    const { timeouts, proxy, noProxy, ...normalizedOptions } = normalizeOptions(options)
+
+    super(normalizedOptions)
+
+    this.#options = normalizedOptions
+    this.#timeouts = timeouts
+
+    if (proxy) {
+      this.#proxy = new URL(proxy)
+      this.#noProxy = noProxy
+      this.#ProxyAgent = getProxyAgent(proxy)
+    }
+  }
+
+  get proxy () {
+    return this.#proxy ? { url: this.#proxy } : {}
+  }
+
+  #getProxy (options) {
+    if (!this.#proxy) {
+      return
+    }
+
+    const proxy = getProxy(`${options.protocol}//${options.host}:${options.port}`, {
+      proxy: this.#proxy,
+      noProxy: this.#noProxy,
+    })
+
+    if (!proxy) {
+      return
+    }
+
+    const cacheKey = cacheOptions({
+      ...options,
+      ...this.#options,
+      timeouts: this.#timeouts,
+      proxy,
+    })
+
+    if (proxyCache.has(cacheKey)) {
+      return proxyCache.get(cacheKey)
+    }
+
+    let ProxyAgent = this.#ProxyAgent
+    if (Array.isArray(ProxyAgent)) {
+      ProxyAgent = this.isSecureEndpoint(options) ? ProxyAgent[1] : ProxyAgent[0]
+    }
+
+    const proxyAgent = new ProxyAgent(proxy, {
+      ...this.#options,
+      socketOptions: { family: this.#options.family },
+    })
+    proxyCache.set(cacheKey, proxyAgent)
+
+    return proxyAgent
+  }
+
+  // takes an array of promises and races them against the connection timeout
+  // which will throw the necessary error if it is hit. This will return the
+  // result of the promise race.
+  async #timeoutConnection ({ promises, options, timeout }, ac = new AbortController()) {
+    if (timeout) {
+      const connectionTimeout = timers.setTimeout(timeout, null, { signal: ac.signal })
+        .then(() => {
+          throw new Errors.ConnectionTimeoutError(`${options.host}:${options.port}`)
+        }).catch((err) => {
+          if (err.name === 'AbortError') {
+            return
+          }
+          throw err
+        })
+      promises.push(connectionTimeout)
+    }
+
+    let result
+    try {
+      result = await Promise.race(promises)
+      ac.abort()
+    } catch (err) {
+      ac.abort()
+      throw err
+    }
+    return result
+  }
+
+  async connect (request, options) {
+    // if the connection does not have its own lookup function
+    // set, then use the one from our options
+    options.lookup ??= this.#options.lookup
+
+    let socket
+    let timeout = this.#timeouts.connection
+    const isSecureEndpoint = this.isSecureEndpoint(options)
+
+    const proxy = this.#getProxy(options)
+    if (proxy) {
+      // some of the proxies will wait for the socket to fully connect before
+      // returning so we have to await this while also racing it against the
+      // connection timeout.
+      const start = Date.now()
+      socket = await this.#timeoutConnection({
+        options,
+        timeout,
+        promises: [proxy.connect(request, options)],
+      })
+      // see how much time proxy.connect took and subtract it from
+      // the timeout
+      if (timeout) {
+        timeout = timeout - (Date.now() - start)
+      }
+    } else {
+      socket = (isSecureEndpoint ? tls : net).connect(options)
+    }
+
+    socket.setKeepAlive(this.keepAlive, this.keepAliveMsecs)
+    socket.setNoDelay(this.keepAlive)
+
+    const abortController = new AbortController()
+    const { signal } = abortController
+
+    const connectPromise = socket[isSecureEndpoint ? 'secureConnecting' : 'connecting']
+      ? once(socket, isSecureEndpoint ? 'secureConnect' : 'connect', { signal })
+      : Promise.resolve()
+
+    await this.#timeoutConnection({
+      options,
+      timeout,
+      promises: [
+        connectPromise,
+        once(socket, 'error', { signal }).then((err) => {
+          throw err[0]
+        }),
+      ],
+    }, abortController)
+
+    if (this.#timeouts.idle) {
+      socket.setTimeout(this.#timeouts.idle, () => {
+        socket.destroy(new Errors.IdleTimeoutError(`${options.host}:${options.port}`))
+      })
+    }
+
+    return socket
+  }
+
+  keepSocketAlive (socket) {
+    const keepAlive = super.keepSocketAlive(socket)
+
+    if (keepAlive && this.#timeouts.idle) {
+      socket.setTimeout(this.#timeouts.idle)
+    }
+
+    return keepAlive
+  }
+
+  addRequest (request, options) {
+    const proxy = this.#getProxy(options)
+    // it would be better to call proxy.addRequest here but this causes the
+    // http-proxy-agent to call its super.addRequest which causes the request
+    // to be added to the agent twice. since we only support 3 agents
+    // currently (see the required agents in proxy.js) we have manually
+    // checked that the only public methods we need to call are called in the
+    // next block. this could change in the future and presumably we would get
+    // failing tests until we have properly called the necessary methods on
+    // each of our proxy agents
+    if (proxy?.setRequestProps) {
+      proxy.setRequestProps(request, options)
+    }
+
+    request.setHeader('connection', this.keepAlive ? 'keep-alive' : 'close')
+
+    if (this.#timeouts.response) {
+      let responseTimeout
+      request.once('finish', () => {
+        setTimeout(() => {
+          request.destroy(new Errors.ResponseTimeoutError(request, this.#proxy))
+        }, this.#timeouts.response)
+      })
+      request.once('response', () => {
+        clearTimeout(responseTimeout)
+      })
+    }
+
+    if (this.#timeouts.transfer) {
+      let transferTimeout
+      request.once('response', (res) => {
+        setTimeout(() => {
+          res.destroy(new Errors.TransferTimeoutError(request, this.#proxy))
+        }, this.#timeouts.transfer)
+        res.once('close', () => {
+          clearTimeout(transferTimeout)
+        })
+      })
+    }
+
+    return super.addRequest(request, options)
+  }
+
+  // When connect() rejects, agent-base removes only its placeholder socket, so Node never drains this.requests[name] and requests queued past maxSockets hang forever.
+  // On a failure we dispatch the next queued request ourselves.
+  // See npm/cli#9386 and TooTallNate/proxy-agents#427.
+  createSocket (req, options, cb) {
+    super.createSocket(req, options, (err, socket) => {
+      if (err) {
+        this.#drainPendingRequests(req, options)
+      }
+      cb(err, socket)
+    })
+  }
+
+  // Dispatch the next request queued behind maxSockets, reusing the slot the failed connection freed.
+  #drainPendingRequests (failedReq, options) {
+    const name = this.getName(options)
+    const queue = this.requests[name]
+    if (!queue || queue.length === 0) {
+      return
+    }
+
+    // Node's removeSocket() picks a queued request without shifting it off, so drop the failed one to avoid dispatching it twice.
+    const failedIndex = queue.indexOf(failedReq)
+    if (failedIndex !== -1) {
+      queue.splice(failedIndex, 1)
+    }
+    if (queue.length === 0) {
+      delete this.requests[name]
+      return
+    }
+
+    // Safety belt: only dispatch if a socket slot is genuinely free.
+    const socketCount = this.sockets[name] ? this.sockets[name].length : 0
+    if (socketCount >= this.maxSockets || this.totalSocketCount >= this.maxTotalSockets) {
+      return
+    }
+
+    const nextReq = queue.shift()
+    if (queue.length === 0) {
+      delete this.requests[name]
+    }
+
+    // All queued requests share this origin, so the failed request's options suit the next one.
+    // createSocket() recurses here if this connection also fails, draining the whole queue.
+    this.createSocket(nextReq, options, (err, socket) => {
+      if (err) {
+        nextReq.onSocket(null, err)
+      } else {
+        nextReq.onSocket(socket)
+      }
+    })
+  }
+}

package/node_modules/@npmcli/agent/lib/dns.js

@@ -0,0 +1,53 @@
+'use strict'
+
+const { LRUCache } = require('lru-cache')
+const dns = require('dns')
+
+// this is a factory so that each request can have its own opts (i.e. ttl)
+// while still sharing the cache across all requests
+const cache = new LRUCache({ max: 50 })
+
+const getOptions = ({
+  family = 0,
+  hints = dns.ADDRCONFIG,
+  all = false,
+  verbatim = undefined,
+  ttl = 5 * 60 * 1000,
+  lookup = dns.lookup,
+}) => ({
+  // hints and lookup are returned since both are top level properties to (net|tls).connect
+  hints,
+  lookup: (hostname, ...args) => {
+    const callback = args.pop() // callback is always last arg
+    const lookupOptions = args[0] ?? {}
+
+    const options = {
+      family,
+      hints,
+      all,
+      verbatim,
+      ...(typeof lookupOptions === 'number' ? { family: lookupOptions } : lookupOptions),
+    }
+
+    const key = JSON.stringify({ hostname, ...options })
+
+    if (cache.has(key)) {
+      const cached = cache.get(key)
+      return process.nextTick(callback, null, ...cached)
+    }
+
+    lookup(hostname, options, (err, ...result) => {
+      if (err) {
+        return callback(err)
+      }
+
+      cache.set(key, result, { ttl })
+      return callback(null, ...result)
+    })
+  },
+})
+
+module.exports = {
+  cache,
+  getOptions,
+}

package/node_modules/@npmcli/agent/lib/errors.js

@@ -0,0 +1,61 @@
+'use strict'
+
+class InvalidProxyProtocolError extends Error {
+  constructor (url) {
+    super(`Invalid protocol \`${url.protocol}\` connecting to proxy \`${url.host}\``)
+    this.code = 'EINVALIDPROXY'
+    this.proxy = url
+  }
+}
+
+class ConnectionTimeoutError extends Error {
+  constructor (host) {
+    super(`Timeout connecting to host \`${host}\``)
+    this.code = 'ECONNECTIONTIMEOUT'
+    this.host = host
+  }
+}
+
+class IdleTimeoutError extends Error {
+  constructor (host) {
+    super(`Idle timeout reached for host \`${host}\``)
+    this.code = 'EIDLETIMEOUT'
+    this.host = host
+  }
+}
+
+class ResponseTimeoutError extends Error {
+  constructor (request, proxy) {
+    let msg = 'Response timeout '
+    if (proxy) {
+      msg += `from proxy \`${proxy.host}\` `
+    }
+    msg += `connecting to host \`${request.host}\``
+    super(msg)
+    this.code = 'ERESPONSETIMEOUT'
+    this.proxy = proxy
+    this.request = request
+  }
+}
+
+class TransferTimeoutError extends Error {
+  constructor (request, proxy) {
+    let msg = 'Transfer timeout '
+    if (proxy) {
+      msg += `from proxy \`${proxy.host}\` `
+    }
+    msg += `for \`${request.host}\``
+    super(msg)
+    this.code = 'ETRANSFERTIMEOUT'
+    this.proxy = proxy
+    this.request = request
+  }
+}
+
+module.exports = {
+  InvalidProxyProtocolError,
+  ConnectionTimeoutError,
+  IdleTimeoutError,
+  ResponseTimeoutError,
+  TransferTimeoutError,
+}