@zuplo/cli 7.4.7 → 7.5.0

package/node_modules/@zuplo/editor/node_modules/pino/lib/redaction.js

@@ -1,114 +0,0 @@
-'use strict'
-
-const slowRedact = require('slow-redact')
-const { redactFmtSym, wildcardFirstSym } = require('./symbols')
-
-// Custom rx regex equivalent to fast-redact's rx
-const rx = /[^.[\]]+|\[([^[\]]*?)\]/g
-
-const CENSOR = '[Redacted]'
-const strict = false // TODO should this be configurable?
-
-function redaction (opts, serialize) {
-  const { paths, censor, remove } = handle(opts)
-
-  const shape = paths.reduce((o, str) => {
-    rx.lastIndex = 0
-    const first = rx.exec(str)
-    const next = rx.exec(str)
-
-    // ns is the top-level path segment, brackets + quoting removed.
-    let ns = first[1] !== undefined
-      ? first[1].replace(/^(?:"|'|`)(.*)(?:"|'|`)$/, '$1')
-      : first[0]
-
-    if (ns === '*') {
-      ns = wildcardFirstSym
-    }
-
-    // top level key:
-    if (next === null) {
-      o[ns] = null
-      return o
-    }
-
-    // path with at least two segments:
-    // if ns is already redacted at the top level, ignore lower level redactions
-    if (o[ns] === null) {
-      return o
-    }
-
-    const { index } = next
-    const nextPath = `${str.substr(index, str.length - 1)}`
-
-    o[ns] = o[ns] || []
-
-    // shape is a mix of paths beginning with literal values and wildcard
-    // paths [ "a.b.c", "*.b.z" ] should reduce to a shape of
-    // { "a": [ "b.c", "b.z" ], *: [ "b.z" ] }
-    // note: "b.z" is in both "a" and * arrays because "a" matches the wildcard.
-    // (* entry has wildcardFirstSym as key)
-    if (ns !== wildcardFirstSym && o[ns].length === 0) {
-      // first time ns's get all '*' redactions so far
-      o[ns].push(...(o[wildcardFirstSym] || []))
-    }
-
-    if (ns === wildcardFirstSym) {
-      // new * path gets added to all previously registered literal ns's.
-      Object.keys(o).forEach(function (k) {
-        if (o[k]) {
-          o[k].push(nextPath)
-        }
-      })
-    }
-
-    o[ns].push(nextPath)
-    return o
-  }, {})
-
-  // the redactor assigned to the format symbol key
-  // provides top level redaction for instances where
-  // an object is interpolated into the msg string
-  const result = {
-    [redactFmtSym]: slowRedact({ paths, censor, serialize, strict, remove })
-  }
-
-  const topCensor = (...args) => {
-    return typeof censor === 'function' ? serialize(censor(...args)) : serialize(censor)
-  }
-
-  return [...Object.keys(shape), ...Object.getOwnPropertySymbols(shape)].reduce((o, k) => {
-    // top level key:
-    if (shape[k] === null) {
-      o[k] = (value) => topCensor(value, [k])
-    } else {
-      const wrappedCensor = typeof censor === 'function'
-        ? (value, path) => {
-            return censor(value, [k, ...path])
-          }
-        : censor
-      o[k] = slowRedact({
-        paths: shape[k],
-        censor: wrappedCensor,
-        serialize,
-        strict,
-        remove
-      })
-    }
-    return o
-  }, result)
-}
-
-function handle (opts) {
-  if (Array.isArray(opts)) {
-    opts = { paths: opts, censor: CENSOR }
-    return opts
-  }
-  let { paths, censor = CENSOR, remove } = opts
-  if (Array.isArray(paths) === false) { throw Error('pino – redact must contain an array of strings') }
-  if (remove === true) censor = undefined
-
-  return { paths, censor, remove }
-}
-
-module.exports = redaction

package/node_modules/@zuplo/editor/node_modules/pino/lib/symbols.js

@@ -1,74 +0,0 @@
-'use strict'
-
-const setLevelSym = Symbol('pino.setLevel')
-const getLevelSym = Symbol('pino.getLevel')
-const levelValSym = Symbol('pino.levelVal')
-const levelCompSym = Symbol('pino.levelComp')
-const useLevelLabelsSym = Symbol('pino.useLevelLabels')
-const useOnlyCustomLevelsSym = Symbol('pino.useOnlyCustomLevels')
-const mixinSym = Symbol('pino.mixin')
-
-const lsCacheSym = Symbol('pino.lsCache')
-const chindingsSym = Symbol('pino.chindings')
-
-const asJsonSym = Symbol('pino.asJson')
-const writeSym = Symbol('pino.write')
-const redactFmtSym = Symbol('pino.redactFmt')
-
-const timeSym = Symbol('pino.time')
-const timeSliceIndexSym = Symbol('pino.timeSliceIndex')
-const streamSym = Symbol('pino.stream')
-const stringifySym = Symbol('pino.stringify')
-const stringifySafeSym = Symbol('pino.stringifySafe')
-const stringifiersSym = Symbol('pino.stringifiers')
-const endSym = Symbol('pino.end')
-const formatOptsSym = Symbol('pino.formatOpts')
-const messageKeySym = Symbol('pino.messageKey')
-const errorKeySym = Symbol('pino.errorKey')
-const nestedKeySym = Symbol('pino.nestedKey')
-const nestedKeyStrSym = Symbol('pino.nestedKeyStr')
-const mixinMergeStrategySym = Symbol('pino.mixinMergeStrategy')
-const msgPrefixSym = Symbol('pino.msgPrefix')
-
-const wildcardFirstSym = Symbol('pino.wildcardFirst')
-
-// public symbols, no need to use the same pino
-// version for these
-const serializersSym = Symbol.for('pino.serializers')
-const formattersSym = Symbol.for('pino.formatters')
-const hooksSym = Symbol.for('pino.hooks')
-const needsMetadataGsym = Symbol.for('pino.metadata')
-
-module.exports = {
-  setLevelSym,
-  getLevelSym,
-  levelValSym,
-  levelCompSym,
-  useLevelLabelsSym,
-  mixinSym,
-  lsCacheSym,
-  chindingsSym,
-  asJsonSym,
-  writeSym,
-  serializersSym,
-  redactFmtSym,
-  timeSym,
-  timeSliceIndexSym,
-  streamSym,
-  stringifySym,
-  stringifySafeSym,
-  stringifiersSym,
-  endSym,
-  formatOptsSym,
-  messageKeySym,
-  errorKeySym,
-  nestedKeySym,
-  wildcardFirstSym,
-  needsMetadataGsym,
-  useOnlyCustomLevelsSym,
-  formattersSym,
-  hooksSym,
-  nestedKeyStrSym,
-  mixinMergeStrategySym,
-  msgPrefixSym
-}

package/node_modules/@zuplo/editor/node_modules/pino/lib/time.js

@@ -1,39 +0,0 @@
-'use strict'
-
-const nullTime = () => ''
-
-const epochTime = () => `,"time":${Date.now()}`
-
-const unixTime = () => `,"time":${Math.round(Date.now() / 1000.0)}`
-
-const isoTime = () => `,"time":"${new Date(Date.now()).toISOString()}"` // using Date.now() for testability
-
-const NS_PER_MS = 1_000_000n
-const NS_PER_SEC = 1_000_000_000n
-
-const startWallTimeNs = BigInt(Date.now()) * NS_PER_MS
-const startHrTime = process.hrtime.bigint()
-
-const isoTimeNano = () => {
-  const elapsedNs = process.hrtime.bigint() - startHrTime
-  const currentTimeNs = startWallTimeNs + elapsedNs
-
-  const secondsSinceEpoch = currentTimeNs / NS_PER_SEC
-  const nanosWithinSecond = currentTimeNs % NS_PER_SEC
-
-  const msSinceEpoch = Number(secondsSinceEpoch * 1000n + nanosWithinSecond / 1_000_000n)
-  const date = new Date(msSinceEpoch)
-
-  const year = date.getUTCFullYear()
-  const month = (date.getUTCMonth() + 1).toString().padStart(2, '0')
-  const day = date.getUTCDate().toString().padStart(2, '0')
-  const hours = date.getUTCHours().toString().padStart(2, '0')
-  const minutes = date.getUTCMinutes().toString().padStart(2, '0')
-  const seconds = date.getUTCSeconds().toString().padStart(2, '0')
-
-  return `,"time":"${year}-${month}-${day}T${hours}:${minutes}:${seconds}.${nanosWithinSecond
-    .toString()
-    .padStart(9, '0')}Z"`
-}
-
-module.exports = { nullTime, epochTime, unixTime, isoTime, isoTimeNano }

package/node_modules/@zuplo/editor/node_modules/pino/lib/tools.js

@@ -1,424 +0,0 @@
-'use strict'
-
-/* eslint no-prototype-builtins: 0 */
-
-const diagChan = require('node:diagnostics_channel')
-const format = require('quick-format-unescaped')
-const { mapHttpRequest, mapHttpResponse } = require('pino-std-serializers')
-const SonicBoom = require('sonic-boom')
-const onExit = require('on-exit-leak-free')
-const {
-  lsCacheSym,
-  chindingsSym,
-  writeSym,
-  serializersSym,
-  formatOptsSym,
-  endSym,
-  stringifiersSym,
-  stringifySym,
-  stringifySafeSym,
-  wildcardFirstSym,
-  nestedKeySym,
-  formattersSym,
-  messageKeySym,
-  errorKeySym,
-  nestedKeyStrSym,
-  msgPrefixSym
-} = require('./symbols')
-const { isMainThread } = require('worker_threads')
-const transport = require('./transport')
-
-const asJsonChan = diagChan.tracingChannel('pino_asJson')
-
-function noop () {
-}
-
-function genLog (level, hook) {
-  if (!hook) return LOG
-
-  return function hookWrappedLog (...args) {
-    hook.call(this, args, LOG, level)
-  }
-
-  function LOG (o, ...n) {
-    if (typeof o === 'object') {
-      let msg = o
-      if (o !== null) {
-        if (o.method && o.headers && o.socket) {
-          o = mapHttpRequest(o)
-        } else if (typeof o.setHeader === 'function') {
-          o = mapHttpResponse(o)
-        }
-      }
-      let formatParams
-      if (msg === null && n.length === 0) {
-        formatParams = [null]
-      } else {
-        msg = n.shift()
-        formatParams = n
-      }
-      // We do not use a coercive check for `msg` as it is
-      // measurably slower than the explicit checks.
-      if (typeof this[msgPrefixSym] === 'string' && msg !== undefined && msg !== null) {
-        msg = this[msgPrefixSym] + msg
-      }
-      this[writeSym](o, format(msg, formatParams, this[formatOptsSym]), level)
-    } else {
-      let msg = o === undefined ? n.shift() : o
-
-      // We do not use a coercive check for `msg` as it is
-      // measurably slower than the explicit checks.
-      if (typeof this[msgPrefixSym] === 'string' && msg !== undefined && msg !== null) {
-        msg = this[msgPrefixSym] + msg
-      }
-      this[writeSym](null, format(msg, n, this[formatOptsSym]), level)
-    }
-  }
-}
-
-// magically escape strings for json
-// relying on their charCodeAt
-// everything below 32 needs JSON.stringify()
-// 34 and 92 happens all the time, so we
-// have a fast case for them
-function asString (str) {
-  let result = ''
-  let last = 0
-  let found = false
-  let point = 255
-  const l = str.length
-  if (l > 100) {
-    return JSON.stringify(str)
-  }
-  for (var i = 0; i < l && point >= 32; i++) {
-    point = str.charCodeAt(i)
-    if (point === 34 || point === 92) {
-      result += str.slice(last, i) + '\\'
-      last = i
-      found = true
-    }
-  }
-  if (!found) {
-    result = str
-  } else {
-    result += str.slice(last)
-  }
-  return point < 32 ? JSON.stringify(str) : '"' + result + '"'
-}
-
-/**
- * `asJson` wraps `_asJson` in order to facilitate generating diagnostics.
- *
- * @param {object} obj The merging object passed to the log method.
- * @param {string} msg The log message passed to the log method.
- * @param {number} num The log level number.
- * @param {number} time The log time in milliseconds.
- *
- * @returns {string}
- */
-function asJson (obj, msg, num, time) {
-  if (asJsonChan.hasSubscribers === false) {
-    return _asJson.call(this, obj, msg, num, time)
-  }
-
-  const store = { instance: this, arguments }
-  return asJsonChan.traceSync(_asJson, store, this, obj, msg, num, time)
-}
-
-/**
- * `_asJson` parses all collected data and generates the finalized newline
- * delimited JSON string.
- *
- * @param {object} obj The merging object passed to the log method.
- * @param {string} msg The log message passed to the log method.
- * @param {number} num The log level number.
- * @param {number} time The log time in milliseconds.
- *
- * @returns {string} The finalized log string terminated with a newline.
- * @private
- */
-function _asJson (obj, msg, num, time) {
-  const stringify = this[stringifySym]
-  const stringifySafe = this[stringifySafeSym]
-  const stringifiers = this[stringifiersSym]
-  const end = this[endSym]
-  const chindings = this[chindingsSym]
-  const serializers = this[serializersSym]
-  const formatters = this[formattersSym]
-  const messageKey = this[messageKeySym]
-  const errorKey = this[errorKeySym]
-  let data = this[lsCacheSym][num] + time
-
-  // we need the child bindings added to the output first so instance logged
-  // objects can take precedence when JSON.parse-ing the resulting log line
-  data = data + chindings
-
-  let value
-  if (formatters.log) {
-    obj = formatters.log(obj)
-  }
-  const wildcardStringifier = stringifiers[wildcardFirstSym]
-  let propStr = ''
-  for (const key in obj) {
-    value = obj[key]
-    if (Object.prototype.hasOwnProperty.call(obj, key) && value !== undefined) {
-      if (serializers[key]) {
-        value = serializers[key](value)
-      } else if (key === errorKey && serializers.err) {
-        value = serializers.err(value)
-      }
-
-      const stringifier = stringifiers[key] || wildcardStringifier
-
-      switch (typeof value) {
-        case 'undefined':
-        case 'function':
-          continue
-        case 'number':
-          /* eslint no-fallthrough: "off" */
-          if (Number.isFinite(value) === false) {
-            value = null
-          }
-        // this case explicitly falls through to the next one
-        case 'boolean':
-          if (stringifier) value = stringifier(value)
-          break
-        case 'string':
-          value = (stringifier || asString)(value)
-          break
-        default:
-          value = (stringifier || stringify)(value, stringifySafe)
-      }
-      if (value === undefined) continue
-      const strKey = asString(key)
-      propStr += ',' + strKey + ':' + value
-    }
-  }
-
-  let msgStr = ''
-  if (msg !== undefined) {
-    value = serializers[messageKey] ? serializers[messageKey](msg) : msg
-    const stringifier = stringifiers[messageKey] || wildcardStringifier
-
-    switch (typeof value) {
-      case 'function':
-        break
-      case 'number':
-        /* eslint no-fallthrough: "off" */
-        if (Number.isFinite(value) === false) {
-          value = null
-        }
-      // this case explicitly falls through to the next one
-      case 'boolean':
-        if (stringifier) value = stringifier(value)
-        msgStr = ',"' + messageKey + '":' + value
-        break
-      case 'string':
-        value = (stringifier || asString)(value)
-        msgStr = ',"' + messageKey + '":' + value
-        break
-      default:
-        value = (stringifier || stringify)(value, stringifySafe)
-        msgStr = ',"' + messageKey + '":' + value
-    }
-  }
-
-  if (this[nestedKeySym] && propStr) {
-    // place all the obj properties under the specified key
-    // the nested key is already formatted from the constructor
-    return data + this[nestedKeyStrSym] + propStr.slice(1) + '}' + msgStr + end
-  } else {
-    return data + propStr + msgStr + end
-  }
-}
-
-function asChindings (instance, bindings) {
-  let value
-  let data = instance[chindingsSym]
-  const stringify = instance[stringifySym]
-  const stringifySafe = instance[stringifySafeSym]
-  const stringifiers = instance[stringifiersSym]
-  const wildcardStringifier = stringifiers[wildcardFirstSym]
-  const serializers = instance[serializersSym]
-  const formatter = instance[formattersSym].bindings
-  bindings = formatter(bindings)
-
-  for (const key in bindings) {
-    value = bindings[key]
-    const valid = (key.length < 5 || (key !== 'level' &&
-      key !== 'serializers' &&
-      key !== 'formatters' &&
-      key !== 'customLevels')) &&
-      bindings.hasOwnProperty(key) &&
-      value !== undefined
-    if (valid === true) {
-      value = serializers[key] ? serializers[key](value) : value
-      value = (stringifiers[key] || wildcardStringifier || stringify)(value, stringifySafe)
-      if (value === undefined) continue
-      data += ',"' + key + '":' + value
-    }
-  }
-  return data
-}
-
-function hasBeenTampered (stream) {
-  return stream.write !== stream.constructor.prototype.write
-}
-
-function buildSafeSonicBoom (opts) {
-  const stream = new SonicBoom(opts)
-  stream.on('error', filterBrokenPipe)
-  // If we are sync: false, we must flush on exit
-  if (!opts.sync && isMainThread) {
-    onExit.register(stream, autoEnd)
-
-    stream.on('close', function () {
-      onExit.unregister(stream)
-    })
-  }
-  return stream
-
-  function filterBrokenPipe (err) {
-    // Impossible to replicate across all operating systems
-    /* istanbul ignore next */
-    if (err.code === 'EPIPE') {
-      // If we get EPIPE, we should stop logging here
-      // however we have no control to the consumer of
-      // SonicBoom, so we just overwrite the write method
-      stream.write = noop
-      stream.end = noop
-      stream.flushSync = noop
-      stream.destroy = noop
-      return
-    }
-    stream.removeListener('error', filterBrokenPipe)
-    stream.emit('error', err)
-  }
-}
-
-function autoEnd (stream, eventName) {
-  // This check is needed only on some platforms
-  /* istanbul ignore next */
-  if (stream.destroyed) {
-    return
-  }
-
-  if (eventName === 'beforeExit') {
-    // We still have an event loop, let's use it
-    stream.flush()
-    stream.on('drain', function () {
-      stream.end()
-    })
-  } else {
-    // For some reason istanbul is not detecting this, but it's there
-    /* istanbul ignore next */
-    // We do not have an event loop, so flush synchronously
-    stream.flushSync()
-  }
-}
-
-function createArgsNormalizer (defaultOptions) {
-  return function normalizeArgs (instance, caller, opts = {}, stream) {
-    // support stream as a string
-    if (typeof opts === 'string') {
-      stream = buildSafeSonicBoom({ dest: opts })
-      opts = {}
-    } else if (typeof stream === 'string') {
-      if (opts && opts.transport) {
-        throw Error('only one of option.transport or stream can be specified')
-      }
-      stream = buildSafeSonicBoom({ dest: stream })
-    } else if (opts instanceof SonicBoom || opts.writable || opts._writableState) {
-      stream = opts
-      opts = {}
-    } else if (opts.transport) {
-      if (opts.transport instanceof SonicBoom || opts.transport.writable || opts.transport._writableState) {
-        throw Error('option.transport do not allow stream, please pass to option directly. e.g. pino(transport)')
-      }
-      if (opts.transport.targets && opts.transport.targets.length && opts.formatters && typeof opts.formatters.level === 'function') {
-        throw Error('option.transport.targets do not allow custom level formatters')
-      }
-
-      let customLevels
-      if (opts.customLevels) {
-        customLevels = opts.useOnlyCustomLevels ? opts.customLevels : Object.assign({}, opts.levels, opts.customLevels)
-      }
-      stream = transport({ caller, ...opts.transport, levels: customLevels })
-    }
-    opts = Object.assign({}, defaultOptions, opts)
-    opts.serializers = Object.assign({}, defaultOptions.serializers, opts.serializers)
-    opts.formatters = Object.assign({}, defaultOptions.formatters, opts.formatters)
-
-    if (opts.prettyPrint) {
-      throw new Error('prettyPrint option is no longer supported, see the pino-pretty package (https://github.com/pinojs/pino-pretty)')
-    }
-
-    const { enabled, onChild } = opts
-    if (enabled === false) opts.level = 'silent'
-    if (!onChild) opts.onChild = noop
-    if (!stream) {
-      if (!hasBeenTampered(process.stdout)) {
-        // If process.stdout.fd is undefined, it means that we are running
-        // in a worker thread. Let's assume we are logging to file descriptor 1.
-        stream = buildSafeSonicBoom({ fd: process.stdout.fd || 1 })
-      } else {
-        stream = process.stdout
-      }
-    }
-    return { opts, stream }
-  }
-}
-
-function stringify (obj, stringifySafeFn) {
-  try {
-    return JSON.stringify(obj)
-  } catch (_) {
-    try {
-      const stringify = stringifySafeFn || this[stringifySafeSym]
-      return stringify(obj)
-    } catch (_) {
-      return '"[unable to serialize, circular reference is too complex to analyze]"'
-    }
-  }
-}
-
-function buildFormatters (level, bindings, log) {
-  return {
-    level,
-    bindings,
-    log
-  }
-}
-
-/**
- * Convert a string integer file descriptor to a proper native integer
- * file descriptor.
- *
- * @param {string} destination The file descriptor string to attempt to convert.
- *
- * @returns {Number}
- */
-function normalizeDestFileDescriptor (destination) {
-  const fd = Number(destination)
-  if (typeof destination === 'string' && Number.isFinite(fd)) {
-    return fd
-  }
-  // destination could be undefined if we are in a worker
-  if (destination === undefined) {
-    // This is stdout in UNIX systems
-    return 1
-  }
-  return destination
-}
-
-module.exports = {
-  noop,
-  buildSafeSonicBoom,
-  asChindings,
-  asJson,
-  genLog,
-  createArgsNormalizer,
-  stringify,
-  buildFormatters,
-  normalizeDestFileDescriptor
-}

package/node_modules/@zuplo/editor/node_modules/pino/lib/transport-stream.js

@@ -1,56 +0,0 @@
-'use strict'
-
-const { realImport, realRequire } = require('real-require')
-
-module.exports = loadTransportStreamBuilder
-
-/**
- * Loads & returns a function to build transport streams
- * @param {string} target
- * @returns {Promise<function(object): Promise<import('node:stream').Writable>>}
- * @throws {Error} In case the target module does not export a function
- */
-async function loadTransportStreamBuilder (target) {
-  let fn
-  try {
-    const toLoad = target.startsWith('file://') ? target : 'file://' + target
-
-    if (toLoad.endsWith('.ts') || toLoad.endsWith('.cts')) {
-      // TODO: add support for the TSM modules loader ( https://github.com/lukeed/tsm ).
-      if (process[Symbol.for('ts-node.register.instance')]) {
-        realRequire('ts-node/register')
-      } else if (process.env && process.env.TS_NODE_DEV) {
-        realRequire('ts-node-dev')
-      }
-      // TODO: Support ES imports once tsc, tap & ts-node provide better compatibility guarantees.
-      fn = realRequire(decodeURIComponent(target))
-    } else {
-      fn = (await realImport(toLoad))
-    }
-  } catch (error) {
-    // See this PR for details: https://github.com/pinojs/thread-stream/pull/34
-    if ((error.code === 'ENOTDIR' || error.code === 'ERR_MODULE_NOT_FOUND')) {
-      fn = realRequire(target)
-    } else if (error.code === undefined || error.code === 'ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING') {
-      // When bundled with pkg, an undefined error is thrown when called with realImport
-      // When bundled with pkg and using node v20, an ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING error is thrown when called with realImport
-      // More info at: https://github.com/pinojs/thread-stream/issues/143
-      try {
-        fn = realRequire(decodeURIComponent(target))
-      } catch {
-        throw error
-      }
-    } else {
-      throw error
-    }
-  }
-
-  // Depending on how the default export is performed, and on how the code is
-  // transpiled, we may find cases of two nested "default" objects.
-  // See https://github.com/pinojs/pino/issues/1243#issuecomment-982774762
-  if (typeof fn === 'object') fn = fn.default
-  if (typeof fn === 'object') fn = fn.default
-  if (typeof fn !== 'function') throw Error('exported worker is not a function')
-
-  return fn
-}