@highstate/designer 0.4.5 → 0.4.6

package/.output/server/node_modules/fast-redact/lib/parse.js

@@ -1,44 +0,0 @@
-'use strict'
-
-const rx = require('./rx')
-
-module.exports = parse
-
-function parse ({ paths }) {
-  const wildcards = []
-  var wcLen = 0
-  const secret = paths.reduce(function (o, strPath, ix) {
-    var path = strPath.match(rx).map((p) => p.replace(/'|"|`/g, ''))
-    const leadingBracket = strPath[0] === '['
-    path = path.map((p) => {
-      if (p[0] === '[') return p.substr(1, p.length - 2)
-      else return p
-    })
-    const star = path.indexOf('*')
-    if (star > -1) {
-      const before = path.slice(0, star)
-      const beforeStr = before.join('.')
-      const after = path.slice(star + 1, path.length)
-      const nested = after.length > 0
-      wcLen++
-      wildcards.push({
-        before,
-        beforeStr,
-        after,
-        nested
-      })
-    } else {
-      o[strPath] = {
-        path: path,
-        val: undefined,
-        precensored: false,
-        circle: '',
-        escPath: JSON.stringify(strPath),
-        leadingBracket: leadingBracket
-      }
-    }
-    return o
-  }, {})
-
-  return { wildcards, wcLen, secret }
-}

package/.output/server/node_modules/fast-redact/lib/redactor.js

@@ -1,108 +0,0 @@
-'use strict'
-
-const rx = require('./rx')
-
-module.exports = redactor
-
-function redactor ({ secret, serialize, wcLen, strict, isCensorFct, censorFctTakesPath }, state) {
-  /* eslint-disable-next-line */
-  const redact = Function('o', `
-    if (typeof o !== 'object' || o == null) {
-      ${strictImpl(strict, serialize)}
-    }
-    const { censor, secret } = this
-    const originalSecret = {}
-    const secretKeys = Object.keys(secret)
-    for (var i = 0; i < secretKeys.length; i++) {
-      originalSecret[secretKeys[i]] = secret[secretKeys[i]]
-    }
-
-    ${redactTmpl(secret, isCensorFct, censorFctTakesPath)}
-    this.compileRestore()
-    ${dynamicRedactTmpl(wcLen > 0, isCensorFct, censorFctTakesPath)}
-    this.secret = originalSecret
-    ${resultTmpl(serialize)}
-  `).bind(state)
-
-  redact.state = state
-
-  if (serialize === false) {
-    redact.restore = (o) => state.restore(o)
-  }
-
-  return redact
-}
-
-function redactTmpl (secret, isCensorFct, censorFctTakesPath) {
-  return Object.keys(secret).map((path) => {
-    const { escPath, leadingBracket, path: arrPath } = secret[path]
-    const skip = leadingBracket ? 1 : 0
-    const delim = leadingBracket ? '' : '.'
-    const hops = []
-    var match
-    while ((match = rx.exec(path)) !== null) {
-      const [ , ix ] = match
-      const { index, input } = match
-      if (index > skip) hops.push(input.substring(0, index - (ix ? 0 : 1)))
-    }
-    var existence = hops.map((p) => `o${delim}${p}`).join(' && ')
-    if (existence.length === 0) existence += `o${delim}${path} != null`
-    else existence += ` && o${delim}${path} != null`
-
-    const circularDetection = `
-      switch (true) {
-        ${hops.reverse().map((p) => `
-          case o${delim}${p} === censor:
-            secret[${escPath}].circle = ${JSON.stringify(p)}
-            break
-        `).join('\n')}
-      }
-    `
-
-    const censorArgs = censorFctTakesPath
-      ? `val, ${JSON.stringify(arrPath)}`
-      : `val`
-
-    return `
-      if (${existence}) {
-        const val = o${delim}${path}
-        if (val === censor) {
-          secret[${escPath}].precensored = true
-        } else {
-          secret[${escPath}].val = val
-          o${delim}${path} = ${isCensorFct ? `censor(${censorArgs})` : 'censor'}
-          ${circularDetection}
-        }
-      }
-    `
-  }).join('\n')
-}
-
-function dynamicRedactTmpl (hasWildcards, isCensorFct, censorFctTakesPath) {
-  return hasWildcards === true ? `
-    {
-      const { wildcards, wcLen, groupRedact, nestedRedact } = this
-      for (var i = 0; i < wcLen; i++) {
-        const { before, beforeStr, after, nested } = wildcards[i]
-        if (nested === true) {
-          secret[beforeStr] = secret[beforeStr] || []
-          nestedRedact(secret[beforeStr], o, before, after, censor, ${isCensorFct}, ${censorFctTakesPath})
-        } else secret[beforeStr] = groupRedact(o, before, censor, ${isCensorFct}, ${censorFctTakesPath})
-      }
-    }
-  ` : ''
-}
-
-function resultTmpl (serialize) {
-  return serialize === false ? `return o` : `
-    var s = this.serialize(o)
-    this.restore(o)
-    return s
-  `
-}
-
-function strictImpl (strict, serialize) {
-  return strict === true
-    ? `throw Error('fast-redact: primitives cannot be redacted')`
-    : serialize === false ? `return o` : `return this.serialize(o)`
-}

package/.output/server/node_modules/fast-redact/lib/restorer.js

@@ -1,92 +0,0 @@
-'use strict'
-
-const { groupRestore, nestedRestore } = require('./modifiers')
-
-module.exports = restorer
-
-function restorer () {
-  return function compileRestore () {
-    if (this.restore) {
-      this.restore.state.secret = this.secret
-      return
-    }
-    const { secret, wcLen } = this
-    const paths = Object.keys(secret)
-    const resetters = resetTmpl(secret, paths)
-    const hasWildcards = wcLen > 0
-    const state = hasWildcards ? { secret, groupRestore, nestedRestore } : { secret }
-    /* eslint-disable-next-line */
-    this.restore = Function(
-      'o',
-      restoreTmpl(resetters, paths, hasWildcards)
-    ).bind(state)
-    this.restore.state = state
-  }
-}
-
-/**
- * Mutates the original object to be censored by restoring its original values
- * prior to censoring.
- *
- * @param {object} secret Compiled object describing which target fields should
- * be censored and the field states.
- * @param {string[]} paths The list of paths to censor as provided at
- * initialization time.
- *
- * @returns {string} String of JavaScript to be used by `Function()`. The
- * string compiles to the function that does the work in the description.
- */
-function resetTmpl (secret, paths) {
-  return paths.map((path) => {
-    const { circle, escPath, leadingBracket } = secret[path]
-    const delim = leadingBracket ? '' : '.'
-    const reset = circle
-      ? `o.${circle} = secret[${escPath}].val`
-      : `o${delim}${path} = secret[${escPath}].val`
-    const clear = `secret[${escPath}].val = undefined`
-    return `
-      if (secret[${escPath}].val !== undefined) {
-        try { ${reset} } catch (e) {}
-        ${clear}
-      }
-    `
-  }).join('')
-}
-
-/**
- * Creates the body of the restore function
- *
- * Restoration of the redacted object happens
- * backwards, in reverse order of redactions,
- * so that repeated redactions on the same object
- * property can be eventually rolled back to the
- * original value.
- *
- * This way dynamic redactions are restored first,
- * starting from the last one working backwards and
- * followed by the static ones.
- *
- * @returns {string} the body of the restore function
- */
-function restoreTmpl (resetters, paths, hasWildcards) {
-  const dynamicReset = hasWildcards === true ? `
-    const keys = Object.keys(secret)
-    const len = keys.length
-    for (var i = len - 1; i >= ${paths.length}; i--) {
-      const k = keys[i]
-      const o = secret[k]
-      if (o) {
-        if (o.flat === true) this.groupRestore(o)
-        else this.nestedRestore(o)
-        secret[k] = null
-      }
-    }
-  ` : ''
-
-  return `
-    const secret = this.secret
-    ${dynamicReset}
-    ${resetters}
-    return o
-  `
-}

package/.output/server/node_modules/fast-redact/lib/rx.js

@@ -1,16 +0,0 @@
-'use strict'
-
-module.exports = /[^.[\]]+|\[((?:.)*?)\]/g
-
-/*
-Regular expression explanation:
-
-Alt 1: /[^.[\]]+/ - Match one or more characters that are *not* a dot (.)
-                    opening square bracket ([) or closing square bracket (])
-
-Alt 2: /\[((?:.)*?)\]/ - If the char IS dot or square bracket, then create a capture
-                         group (which will be capture group $1) that matches anything
-                         within square brackets. Expansion is lazy so it will
-                         stop matching as soon as the first closing bracket is met `]`
-                         (rather than continuing to match until the final closing bracket).
-*/

package/.output/server/node_modules/fast-redact/lib/state.js

@@ -1,20 +0,0 @@
-'use strict'
-
-module.exports = state
-
-function state (o) {
-  const {
-    secret,
-    censor,
-    compileRestore,
-    serialize,
-    groupRedact,
-    nestedRedact,
-    wildcards,
-    wcLen
-  } = o
-  const builder = [{ secret, censor, compileRestore }]
-  if (serialize !== false) builder.push({ serialize })
-  if (wcLen > 0) builder.push({ groupRedact, nestedRedact, wildcards, wcLen })
-  return Object.assign(...builder)
-}

package/.output/server/node_modules/fast-redact/lib/validator.js

@@ -1,33 +0,0 @@
-'use strict'
-
-module.exports = validator
-
-function validator (opts = {}) {
-  const {
-    ERR_PATHS_MUST_BE_STRINGS = () => 'fast-redact - Paths must be (non-empty) strings',
-    ERR_INVALID_PATH = (s) => `fast-redact – Invalid path (${s})`
-  } = opts
-
-  return function validate ({ paths }) {
-    paths.forEach((s) => {
-      if (typeof s !== 'string') {
-        throw Error(ERR_PATHS_MUST_BE_STRINGS())
-      }
-      try {
-        if (/〇/.test(s)) throw Error()
-        const expr = (s[0] === '[' ? '' : '.') + s.replace(/^\*/, '〇').replace(/\.\*/g, '.〇').replace(/\[\*\]/g, '[〇]')
-        if (/\n|\r|;/.test(expr)) throw Error()
-        if (/\/\*/.test(expr)) throw Error()
-        /* eslint-disable-next-line */
-        Function(`
-            'use strict'
-            const o = new Proxy({}, { get: () => o, set: () => { throw Error() } });
-            const 〇 = null;
-            o${expr}
-            if ([o${expr}].length !== 1) throw Error()`)()
-      } catch (e) {
-        throw Error(ERR_INVALID_PATH(s))
-      }
-    })
-  }
-}

package/.output/server/node_modules/fast-redact/package.json

@@ -1,50 +0,0 @@
-{
-  "name": "fast-redact",
-  "version": "3.5.0",
-  "description": "very fast object redaction",
-  "main": "index.js",
-  "scripts": {
-    "test": "tap test",
-    "posttest": "standard index.js 'lib/*.js' 'example/*.js' benchmark/index.js test/index.js | snazzy",
-    "cov": "tap --cov test",
-    "cov-ui": "tap --coverage-report=html test",
-    "ci": "tap --cov --100 test",
-    "bench": "node benchmark"
-  },
-  "keywords": [
-    "redact",
-    "censor",
-    "performance",
-    "performant",
-    "gdpr",
-    "fast",
-    "speed",
-    "serialize",
-    "stringify"
-  ],
-  "author": "David Mark Clements <david.clements@nearform.com>",
-  "license": "MIT",
-  "devDependencies": {
-    "fastbench": "^1.0.1",
-    "pino-noir": "^2.2.1",
-    "snazzy": "^8.0.0",
-    "standard": "^12.0.1",
-    "tap": "^12.5.2"
-  },
-  "engines": {
-    "node": ">=6"
-  },
-  "directories": {
-    "example": "example",
-    "lib": "lib",
-    "test": "test"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/davidmarkclements/fast-redact.git"
-  },
-  "bugs": {
-    "url": "https://github.com/davidmarkclements/fast-redact/issues"
-  },
-  "homepage": "https://github.com/davidmarkclements/fast-redact#readme"
-}

package/.output/server/node_modules/fast-uri/index.js

@@ -1,303 +0,0 @@
-'use strict'
-
-const { normalizeIPv6, normalizeIPv4, removeDotSegments, recomposeAuthority, normalizeComponentEncoding } = require('./lib/utils')
-const SCHEMES = require('./lib/schemes')
-
-function normalize (uri, options) {
-  if (typeof uri === 'string') {
-    uri = serialize(parse(uri, options), options)
-  } else if (typeof uri === 'object') {
-    uri = parse(serialize(uri, options), options)
-  }
-  return uri
-}
-
-function resolve (baseURI, relativeURI, options) {
-  const schemelessOptions = Object.assign({ scheme: 'null' }, options)
-  const resolved = resolveComponents(parse(baseURI, schemelessOptions), parse(relativeURI, schemelessOptions), schemelessOptions, true)
-  return serialize(resolved, { ...schemelessOptions, skipEscape: true })
-}
-
-function resolveComponents (base, relative, options, skipNormalization) {
-  const target = {}
-  if (!skipNormalization) {
-    base = parse(serialize(base, options), options) // normalize base components
-    relative = parse(serialize(relative, options), options) // normalize relative components
-  }
-  options = options || {}
-
-  if (!options.tolerant && relative.scheme) {
-    target.scheme = relative.scheme
-    // target.authority = relative.authority;
-    target.userinfo = relative.userinfo
-    target.host = relative.host
-    target.port = relative.port
-    target.path = removeDotSegments(relative.path || '')
-    target.query = relative.query
-  } else {
-    if (relative.userinfo !== undefined || relative.host !== undefined || relative.port !== undefined) {
-      // target.authority = relative.authority;
-      target.userinfo = relative.userinfo
-      target.host = relative.host
-      target.port = relative.port
-      target.path = removeDotSegments(relative.path || '')
-      target.query = relative.query
-    } else {
-      if (!relative.path) {
-        target.path = base.path
-        if (relative.query !== undefined) {
-          target.query = relative.query
-        } else {
-          target.query = base.query
-        }
-      } else {
-        if (relative.path.charAt(0) === '/') {
-          target.path = removeDotSegments(relative.path)
-        } else {
-          if ((base.userinfo !== undefined || base.host !== undefined || base.port !== undefined) && !base.path) {
-            target.path = '/' + relative.path
-          } else if (!base.path) {
-            target.path = relative.path
-          } else {
-            target.path = base.path.slice(0, base.path.lastIndexOf('/') + 1) + relative.path
-          }
-          target.path = removeDotSegments(target.path)
-        }
-        target.query = relative.query
-      }
-      // target.authority = base.authority;
-      target.userinfo = base.userinfo
-      target.host = base.host
-      target.port = base.port
-    }
-    target.scheme = base.scheme
-  }
-
-  target.fragment = relative.fragment
-
-  return target
-}
-
-function equal (uriA, uriB, options) {
-  if (typeof uriA === 'string') {
-    uriA = unescape(uriA)
-    uriA = serialize(normalizeComponentEncoding(parse(uriA, options), true), { ...options, skipEscape: true })
-  } else if (typeof uriA === 'object') {
-    uriA = serialize(normalizeComponentEncoding(uriA, true), { ...options, skipEscape: true })
-  }
-
-  if (typeof uriB === 'string') {
-    uriB = unescape(uriB)
-    uriB = serialize(normalizeComponentEncoding(parse(uriB, options), true), { ...options, skipEscape: true })
-  } else if (typeof uriB === 'object') {
-    uriB = serialize(normalizeComponentEncoding(uriB, true), { ...options, skipEscape: true })
-  }
-
-  return uriA.toLowerCase() === uriB.toLowerCase()
-}
-
-function serialize (cmpts, opts) {
-  const components = {
-    host: cmpts.host,
-    scheme: cmpts.scheme,
-    userinfo: cmpts.userinfo,
-    port: cmpts.port,
-    path: cmpts.path,
-    query: cmpts.query,
-    nid: cmpts.nid,
-    nss: cmpts.nss,
-    uuid: cmpts.uuid,
-    fragment: cmpts.fragment,
-    reference: cmpts.reference,
-    resourceName: cmpts.resourceName,
-    secure: cmpts.secure,
-    error: ''
-  }
-  const options = Object.assign({}, opts)
-  const uriTokens = []
-
-  // find scheme handler
-  const schemeHandler = SCHEMES[(options.scheme || components.scheme || '').toLowerCase()]
-
-  // perform scheme specific serialization
-  if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(components, options)
-
-  if (components.path !== undefined) {
-    if (!options.skipEscape) {
-      components.path = escape(components.path)
-
-      if (components.scheme !== undefined) {
-        components.path = components.path.split('%3A').join(':')
-      }
-    } else {
-      components.path = unescape(components.path)
-    }
-  }
-
-  if (options.reference !== 'suffix' && components.scheme) {
-    uriTokens.push(components.scheme, ':')
-  }
-
-  const authority = recomposeAuthority(components)
-  if (authority !== undefined) {
-    if (options.reference !== 'suffix') {
-      uriTokens.push('//')
-    }
-
-    uriTokens.push(authority)
-
-    if (components.path && components.path.charAt(0) !== '/') {
-      uriTokens.push('/')
-    }
-  }
-  if (components.path !== undefined) {
-    let s = components.path
-
-    if (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) {
-      s = removeDotSegments(s)
-    }
-
-    if (authority === undefined) {
-      s = s.replace(/^\/\//u, '/%2F') // don't allow the path to start with "//"
-    }
-
-    uriTokens.push(s)
-  }
-
-  if (components.query !== undefined) {
-    uriTokens.push('?', components.query)
-  }
-
-  if (components.fragment !== undefined) {
-    uriTokens.push('#', components.fragment)
-  }
-  return uriTokens.join('')
-}
-
-const hexLookUp = Array.from({ length: 127 }, (_v, k) => /[^!"$&'()*+,\-.;=_`a-z{}~]/u.test(String.fromCharCode(k)))
-
-function nonSimpleDomain (value) {
-  let code = 0
-  for (let i = 0, len = value.length; i < len; ++i) {
-    code = value.charCodeAt(i)
-    if (code > 126 || hexLookUp[code]) {
-      return true
-    }
-  }
-  return false
-}
-
-const URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u
-
-function parse (uri, opts) {
-  const options = Object.assign({}, opts)
-  const parsed = {
-    scheme: undefined,
-    userinfo: undefined,
-    host: '',
-    port: undefined,
-    path: '',
-    query: undefined,
-    fragment: undefined
-  }
-  const gotEncoding = uri.indexOf('%') !== -1
-  let isIP = false
-  if (options.reference === 'suffix') uri = (options.scheme ? options.scheme + ':' : '') + '//' + uri
-
-  const matches = uri.match(URI_PARSE)
-
-  if (matches) {
-    // store each component
-    parsed.scheme = matches[1]
-    parsed.userinfo = matches[3]
-    parsed.host = matches[4]
-    parsed.port = parseInt(matches[5], 10)
-    parsed.path = matches[6] || ''
-    parsed.query = matches[7]
-    parsed.fragment = matches[8]
-
-    // fix port number
-    if (isNaN(parsed.port)) {
-      parsed.port = matches[5]
-    }
-    if (parsed.host) {
-      const ipv4result = normalizeIPv4(parsed.host)
-      if (ipv4result.isIPV4 === false) {
-        const ipv6result = normalizeIPv6(ipv4result.host)
-        parsed.host = ipv6result.host.toLowerCase()
-        isIP = ipv6result.isIPV6
-      } else {
-        parsed.host = ipv4result.host
-        isIP = true
-      }
-    }
-    if (parsed.scheme === undefined && parsed.userinfo === undefined && parsed.host === undefined && parsed.port === undefined && parsed.query === undefined && !parsed.path) {
-      parsed.reference = 'same-document'
-    } else if (parsed.scheme === undefined) {
-      parsed.reference = 'relative'
-    } else if (parsed.fragment === undefined) {
-      parsed.reference = 'absolute'
-    } else {
-      parsed.reference = 'uri'
-    }
-
-    // check for reference errors
-    if (options.reference && options.reference !== 'suffix' && options.reference !== parsed.reference) {
-      parsed.error = parsed.error || 'URI is not a ' + options.reference + ' reference.'
-    }
-
-    // find scheme handler
-    const schemeHandler = SCHEMES[(options.scheme || parsed.scheme || '').toLowerCase()]
-
-    // check if scheme can't handle IRIs
-    if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) {
-      // if host component is a domain name
-      if (parsed.host && (options.domainHost || (schemeHandler && schemeHandler.domainHost)) && isIP === false && nonSimpleDomain(parsed.host)) {
-        // convert Unicode IDN -> ASCII IDN
-        try {
-          parsed.host = URL.domainToASCII(parsed.host.toLowerCase())
-        } catch (e) {
-          parsed.error = parsed.error || "Host's domain name can not be converted to ASCII: " + e
-        }
-      }
-      // convert IRI -> URI
-    }
-
-    if (!schemeHandler || (schemeHandler && !schemeHandler.skipNormalize)) {
-      if (gotEncoding && parsed.scheme !== undefined) {
-        parsed.scheme = unescape(parsed.scheme)
-      }
-      if (gotEncoding && parsed.host !== undefined) {
-        parsed.host = unescape(parsed.host)
-      }
-      if (parsed.path) {
-        parsed.path = escape(unescape(parsed.path))
-      }
-      if (parsed.fragment) {
-        parsed.fragment = encodeURI(decodeURIComponent(parsed.fragment))
-      }
-    }
-
-    // perform scheme specific parsing
-    if (schemeHandler && schemeHandler.parse) {
-      schemeHandler.parse(parsed, options)
-    }
-  } else {
-    parsed.error = parsed.error || 'URI can not be parsed.'
-  }
-  return parsed
-}
-
-const fastUri = {
-  SCHEMES,
-  normalize,
-  resolve,
-  resolveComponents,
-  equal,
-  serialize,
-  parse
-}
-
-module.exports = fastUri
-module.exports.default = fastUri
-module.exports.fastUri = fastUri