cdk-common 2.0.861 → 2.0.863

package/node_modules/fast-uri/lib/utils.js

@@ -0,0 +1,236 @@
+'use strict'
+
+const { HEX } = require('./scopedChars')
+
+function normalizeIPv4 (host) {
+  if (findToken(host, '.') < 3) { return { host, isIPV4: false } }
+  const matches = host.match(/^(\b[01]?\d{1,2}|\b2[0-4]\d|\b25[0-5])(\.([01]?\d{1,2}|2[0-4]\d|25[0-5])){3}$/u) || []
+  const [address] = matches
+  if (address) {
+    return { host: stripLeadingZeros(address, '.'), isIPV4: true }
+  } else {
+    return { host, isIPV4: false }
+  }
+}
+
+function stringToHexStripped (input) {
+  let acc = ''
+  let strip = true
+  for (const c of input) {
+    if (c !== '0' && strip === true) strip = false
+    if (HEX[c] === undefined) return undefined
+    if (!strip) acc += c
+  }
+  return acc
+}
+
+function getIPV6 (input) {
+  let tokenCount = 0
+  const output = { error: false, address: '', zone: '' }
+  const address = []
+  const buffer = []
+  let isZone = false
+  let endipv6Encountered = false
+  let endIpv6 = false
+
+  function consume () {
+    if (buffer.length) {
+      if (isZone === false) {
+        const hex = stringToHexStripped(buffer.join(''))
+        if (hex !== undefined) {
+          address.push(hex)
+        } else {
+          output.error = true
+          return false
+        }
+      }
+      buffer.length = 0
+    }
+    return true
+  }
+
+  for (let i = 0; i < input.length; i++) {
+    const cursor = input[i]
+    if (cursor === '[' || cursor === ']') { continue }
+    if (cursor === ':') {
+      if (endipv6Encountered === true) {
+        endIpv6 = true
+      }
+      if (!consume()) { break }
+      tokenCount++
+      address.push(':')
+      if (tokenCount > 7) {
+        // not valid
+        output.error = true
+        break
+      }
+      if (i - 1 >= 0 && input[i - 1] === ':') {
+        endipv6Encountered = true
+      }
+      continue
+    } else if (cursor === '%') {
+      if (!consume()) { break }
+      // switch to zone detection
+      isZone = true
+    } else {
+      buffer.push(cursor)
+      continue
+    }
+  }
+  if (buffer.length) {
+    if (isZone) {
+      output.zone = buffer.join('')
+    } else if (endIpv6) {
+      address.push(buffer.join(''))
+    } else {
+      address.push(stringToHexStripped(buffer.join('')))
+    }
+  }
+  output.address = address.join('')
+  return output
+}
+
+function normalizeIPv6 (host, opts = {}) {
+  if (findToken(host, ':') < 2) { return { host, isIPV6: false } }
+  const ipv6 = getIPV6(host)
+
+  if (!ipv6.error) {
+    let newHost = ipv6.address
+    let escapedHost = ipv6.address
+    if (ipv6.zone) {
+      newHost += '%' + ipv6.zone
+      escapedHost += '%25' + ipv6.zone
+    }
+    return { host: newHost, escapedHost, isIPV6: true }
+  } else {
+    return { host, isIPV6: false }
+  }
+}
+
+function stripLeadingZeros (str, token) {
+  let out = ''
+  let skip = true
+  const l = str.length
+  for (let i = 0; i < l; i++) {
+    const c = str[i]
+    if (c === '0' && skip) {
+      if ((i + 1 <= l && str[i + 1] === token) || i + 1 === l) {
+        out += c
+        skip = false
+      }
+    } else {
+      if (c === token) {
+        skip = true
+      } else {
+        skip = false
+      }
+      out += c
+    }
+  }
+  return out
+}
+
+function findToken (str, token) {
+  let ind = 0
+  for (let i = 0; i < str.length; i++) {
+    if (str[i] === token) ind++
+  }
+  return ind
+}
+
+const RDS1 = /^\.\.?\//u
+const RDS2 = /^\/\.(?:\/|$)/u
+const RDS3 = /^\/\.\.(?:\/|$)/u
+const RDS5 = /^\/?(?:.|\n)*?(?=\/|$)/u
+
+function removeDotSegments (input) {
+  const output = []
+
+  while (input.length) {
+    if (input.match(RDS1)) {
+      input = input.replace(RDS1, '')
+    } else if (input.match(RDS2)) {
+      input = input.replace(RDS2, '/')
+    } else if (input.match(RDS3)) {
+      input = input.replace(RDS3, '/')
+      output.pop()
+    } else if (input === '.' || input === '..') {
+      input = ''
+    } else {
+      const im = input.match(RDS5)
+      if (im) {
+        const s = im[0]
+        input = input.slice(s.length)
+        output.push(s)
+      } else {
+        throw new Error('Unexpected dot segment condition')
+      }
+    }
+  }
+  return output.join('')
+}
+
+function normalizeComponentEncoding (components, esc) {
+  const func = esc !== true ? escape : unescape
+  if (components.scheme !== undefined) {
+    components.scheme = func(components.scheme)
+  }
+  if (components.userinfo !== undefined) {
+    components.userinfo = func(components.userinfo)
+  }
+  if (components.host !== undefined) {
+    components.host = func(components.host)
+  }
+  if (components.path !== undefined) {
+    components.path = func(components.path)
+  }
+  if (components.query !== undefined) {
+    components.query = func(components.query)
+  }
+  if (components.fragment !== undefined) {
+    components.fragment = func(components.fragment)
+  }
+  return components
+}
+
+function recomposeAuthority (components, options) {
+  const uriTokens = []
+
+  if (components.userinfo !== undefined) {
+    uriTokens.push(components.userinfo)
+    uriTokens.push('@')
+  }
+
+  if (components.host !== undefined) {
+    let host = unescape(components.host)
+    const ipV4res = normalizeIPv4(host)
+
+    if (ipV4res.isIPV4) {
+      host = ipV4res.host
+    } else {
+      const ipV6res = normalizeIPv6(ipV4res.host, { isIPV4: false })
+      if (ipV6res.isIPV6 === true) {
+        host = `[${ipV6res.escapedHost}]`
+      } else {
+        host = components.host
+      }
+    }
+    uriTokens.push(host)
+  }
+
+  if (typeof components.port === 'number' || typeof components.port === 'string') {
+    uriTokens.push(':')
+    uriTokens.push(String(components.port))
+  }
+
+  return uriTokens.length ? uriTokens.join('') : undefined
+};
+
+module.exports = {
+  recomposeAuthority,
+  normalizeComponentEncoding,
+  removeDotSegments,
+  normalizeIPv4,
+  normalizeIPv6,
+  stringToHexStripped
+}

package/node_modules/fast-uri/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "fast-uri",
+  "description": "Dependency free RFC 3986 URI toolbox",
+  "version": "2.3.0",
+  "main": "index.js",
+  "type": "commonjs",
+  "types": "types/index.d.ts",
+  "license": "MIT",
+  "author": "Vincent Le Goff <vince.legoff@gmail.com> (https://github.com/zekth)",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/fastify/fast-uri"
+  },
+  "bugs": {
+    "url": "https://github.com/fastify/fast-uri/issues"
+  },
+  "homepage": "https://github.com/fastify/fast-uri",
+  "scripts": {
+    "bench": "node benchmark.js",
+    "lint:fix": "standard --fix",
+    "test:lint": "standard | snazzy",
+    "test:typescript": "tsd",
+    "test:unit": "tap -J test/*.test.js",
+    "test:unit:dev": "tap -J test/*.test.js --coverage-report=html",
+    "test": "npm run test:lint && npm run test:unit && npm run test:typescript",
+    "test:ci": "npm run test:lint && npm run test:unit -- --cov --coverage-report=lcovonly && npm run test:typescript"
+  },
+  "devDependencies": {
+    "benchmark": "^2.1.4",
+    "coveralls": "^3.1.1",
+    "snazzy": "^9.0.0",
+    "standard": "^17.0.0",
+    "tap": "^16.0.0",
+    "tsd": "^0.29.0",
+    "uri-js": "^4.4.1"
+  },
+  "dependencies": {},
+  "tap": {
+    "check-coverage": false
+  }
+}

package/node_modules/fast-uri/test/compatibility.test.js

@@ -0,0 +1,129 @@
+'use strict'
+
+const tap = require('tap')
+const test = tap.test
+const fastifyURI = require('../')
+const urijs = require('uri-js')
+
+test('compatibility Parse', (t) => {
+  const toParse = [
+    '//www.g.com/error\n/bleh/bleh',
+    'https://fastify.org',
+    '//10.10.10.10',
+    '//10.10.000.10',
+    '//[2001:db8::7%en0]',
+    '//[2001:dbZ::1]:80',
+    '//[2001:db8::1]:80',
+    '//[2001:db8::001]:80',
+    'uri://user:pass@example.com:123/one/two.three?q1=a1&q2=a2#body',
+    'http://user:pass@example.com:123/one/space in.url?q1=a1&q2=a2#body',
+    '//[::ffff:129.144.52.38]',
+    'uri://10.10.10.10.example.com/en/process',
+    '//[2606:2800:220:1:248:1893:25c8:1946]/test',
+    'ws://example.com/chat',
+    'ws://example.com/foo?bar=baz',
+    'wss://example.com/?bar=baz',
+    'wss://example.com/chat',
+    'wss://example.com/foo?bar=baz',
+    'wss://example.com/?bar=baz',
+    'urn:uuid:f81d4fae-7dec-11d0-a765-00a0c91e6bf6',
+    'urn:uuid:notauuid-7dec-11d0-a765-00a0c91e6bf6',
+    'urn:example:%D0%B0123,z456',
+    '//[2606:2800:220:1:248:1893:25c8:1946:43209]',
+    'http://foo.bar',
+    'http://',
+    '#/$defs/stringMap',
+    '#/$defs/string%20Map',
+    '#/$defs/string Map',
+    '//?json=%7B%22foo%22%3A%22bar%22%7D'
+    //  'mailto:chris@example.com'-203845,
+    //  'mailto:infobot@example.com?subject=current-issue',
+    //  'mailto:infobot@example.com?body=send%20current-issue',
+    //  'mailto:infobot@example.com?body=send%20current-issue%0D%0Asend%20index',
+    //  'mailto:list@example.org?In-Reply-To=%3C3469A91.D10AF4C@example.com%3E',
+    //  'mailto:majordomo@example.com?body=subscribe%20bamboo-l',
+    //  'mailto:joe@example.com?cc=bob@example.com&body=hello',
+    //  'mailto:gorby%25kremvax@example.com',
+    //  'mailto:unlikely%3Faddress@example.com?blat=foop',
+    //  'mailto:Mike%26family@example.org',
+    //  'mailto:%22not%40me%22@example.org',
+    //  'mailto:%22oh%5C%5Cno%22@example.org',
+    //  'mailto:%22%5C%5C%5C%22it\'s%5C%20ugly%5C%5C%5C%22%22@example.org',
+    //  'mailto:user@example.org?subject=caf%C3%A9',
+    //  'mailto:user@example.org?subject=%3D%3Futf-8%3FQ%3Fcaf%3DC3%3DA9%3F%3D',
+    //  'mailto:user@example.org?subject=%3D%3Fiso-8859-1%3FQ%3Fcaf%3DE9%3F%3D',
+    //  'mailto:user@example.org?subject=caf%C3%A9&body=caf%C3%A9',
+    //  'mailto:user@%E7%B4%8D%E8%B1%86.example.org?subject=Test&body=NATTO'
+  ]
+  toParse.forEach((x) => {
+    t.same(fastifyURI.parse(x), urijs.parse(x), 'Compatibility parse: ' + x)
+  })
+  t.end()
+})
+
+test('compatibility serialize', (t) => {
+  const toSerialize = [
+    { host: '10.10.10.10.example.com' },
+    { host: '2001:db8::7' },
+    { host: '::ffff:129.144.52.38' },
+    { host: '2606:2800:220:1:248:1893:25c8:1946' },
+    { host: '10.10.10.10.example.com' },
+    { host: '10.10.10.10' },
+    { path: '?query' },
+    { path: 'foo:bar' },
+    { path: '//path' },
+    {
+      scheme: 'uri',
+      host: 'example.com',
+      port: '9000'
+    },
+    {
+      scheme: 'uri',
+      userinfo: 'foo:bar',
+      host: 'example.com',
+      port: 1,
+      path: 'path',
+      query: 'query',
+      fragment: 'fragment'
+    },
+    {
+      scheme: '',
+      userinfo: '',
+      host: '',
+      port: 0,
+      path: '',
+      query: '',
+      fragment: ''
+    },
+    {
+      scheme: undefined,
+      userinfo: undefined,
+      host: undefined,
+      port: undefined,
+      path: undefined,
+      query: undefined,
+      fragment: undefined
+    },
+    { host: 'fe80::a%en1' },
+    { host: 'fe80::a%25en1' },
+    {
+      scheme: 'ws',
+      host: 'example.com',
+      resourceName: '/foo?bar',
+      secure: true
+    },
+    {
+      scheme: 'scheme',
+      path: 'with:colon'
+    }
+  ]
+  toSerialize.forEach((x) => {
+    const r = JSON.stringify(x)
+    t.same(
+      fastifyURI.serialize(x),
+      urijs.serialize(x),
+      'Compatibility serialize: ' + JSON.stringify(r)
+    )
+  })
+  t.end()
+})

package/node_modules/fast-uri/test/equal.test.js

@@ -0,0 +1,104 @@
+'use strict'
+
+const tap = require('tap')
+const test = tap.test
+const URI = require('../')
+
+const fn = URI.equal
+const runTest = (t, suite) => {
+  suite.forEach(s => {
+    const operator = s.result ? '==' : '!='
+    t.equal(fn(s.pair[0], s.pair[1]), s.result, `${s.pair[0]} ${operator} ${s.pair[1]}`)
+    t.equal(fn(s.pair[1], s.pair[0]), s.result, `${s.pair[1]} ${operator} ${s.pair[0]}`)
+  })
+}
+
+test('URI Equals', (t) => {
+  const suite = [
+    { pair: ['example://a/b/c/%7Bfoo%7D', 'eXAMPLE://a/./b/../b/%63/%7bfoo%7d'], result: true }, // test from RFC 3986
+    { pair: ['http://example.org/~user', 'http://example.org/%7euser'], result: true } // test from RFC 3987
+  ]
+  runTest(t, suite)
+  t.end()
+})
+
+//   test('IRI Equals', (t) => {
+//     // example from RFC 3987
+//     t.equal(URI.equal('example://a/b/c/%7Bfoo%7D/ros\xE9', 'eXAMPLE://a/./b/../b/%63/%7bfoo%7d/ros%C3%A9', IRI_OPTION), true)
+//     t.end()
+//   })
+
+test('HTTP Equals', (t) => {
+  const suite = [
+    // test from RFC 2616
+    { pair: ['http://abc.com:80/~smith/home.html', 'http://abc.com/~smith/home.html'], result: true },
+    { pair: [{ scheme: 'http', host: 'abc.com', port: 80, path: '/~smith/home.html' }, 'http://abc.com/~smith/home.html'], result: true },
+    { pair: ['http://ABC.com/%7Esmith/home.html', 'http://abc.com/~smith/home.html'], result: true },
+    { pair: ['http://ABC.com:/%7esmith/home.html', 'http://abc.com/~smith/home.html'], result: true },
+    { pair: ['HTTP://ABC.COM', 'http://abc.com/'], result: true },
+    // test from RFC 3986
+    { pair: ['http://example.com:/', 'http://example.com:80/'], result: true }
+  ]
+  runTest(t, suite)
+  t.end()
+})
+
+test('HTTPS Equals', (t) => {
+  const suite = [
+    { pair: ['https://example.com', 'https://example.com:443/'], result: true },
+    { pair: ['https://example.com:/', 'https://example.com:443/'], result: true }
+  ]
+  runTest(t, suite)
+  t.end()
+})
+
+test('URN Equals', (t) => {
+  const suite = [
+    // test from RFC 2141
+    { pair: ['urn:foo:a123,456', 'urn:foo:a123,456'], result: true },
+    { pair: ['urn:foo:a123,456', 'URN:foo:a123,456'], result: true },
+    { pair: ['urn:foo:a123,456', 'urn:FOO:a123,456'], result: true }
+  ]
+
+  // Disabling for now as the whole equal logic might need
+  // to be refactored
+  // t.equal(URI.equal('urn:foo:a123,456', 'urn:foo:A123,456'), false)
+  // t.equal(URI.equal('urn:foo:a123%2C456', 'URN:FOO:a123%2c456'), true)
+
+  runTest(t, suite)
+  t.end()
+})
+
+test('UUID Equals', (t) => {
+  const suite = [
+    { pair: ['URN:UUID:F81D4FAE-7DEC-11D0-A765-00A0C91E6BF6', 'urn:uuid:f81d4fae-7dec-11d0-a765-00a0c91e6bf6'], result: true }
+  ]
+
+  runTest(t, suite)
+  t.end()
+})
+
+// test('Mailto Equals', (t) => {
+//   // tests from RFC 6068
+//   t.equal(URI.equal('mailto:addr1@an.example,addr2@an.example', 'mailto:?to=addr1@an.example,addr2@an.example'), true)
+//   t.equal(URI.equal('mailto:?to=addr1@an.example,addr2@an.example', 'mailto:addr1@an.example?to=addr2@an.example'), true)
+//   t.end()
+// })
+
+test('WS Equal', (t) => {
+  const suite = [
+    { pair: ['WS://ABC.COM:80/chat#one', 'ws://abc.com/chat'], result: true }
+  ]
+
+  runTest(t, suite)
+  t.end()
+})
+
+test('WSS Equal', (t) => {
+  const suite = [
+    { pair: ['WSS://ABC.COM:443/chat#one', 'wss://abc.com/chat'], result: true }
+  ]
+
+  runTest(t, suite)
+  t.end()
+})