khabotcli 1.0.0

package/.OLD/Trial-1/node_modules/fast-uri/lib/utils.js

@@ -0,0 +1,336 @@
+'use strict'
+
+/** @type {(value: string) => boolean} */
+const isUUID = RegExp.prototype.test.bind(/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu)
+
+/** @type {(value: string) => boolean} */
+const isIPv4 = RegExp.prototype.test.bind(/^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u)
+
+/**
+ * @param {Array<string>} input
+ * @returns {string}
+ */
+function stringArrayToHexStripped (input) {
+  let acc = ''
+  let code = 0
+  let i = 0
+
+  for (i = 0; i < input.length; i++) {
+    code = input[i].charCodeAt(0)
+    if (code === 48) {
+      continue
+    }
+    if (!((code >= 48 && code <= 57) || (code >= 65 && code <= 70) || (code >= 97 && code <= 102))) {
+      return ''
+    }
+    acc += input[i]
+    break
+  }
+
+  for (i += 1; i < input.length; i++) {
+    code = input[i].charCodeAt(0)
+    if (!((code >= 48 && code <= 57) || (code >= 65 && code <= 70) || (code >= 97 && code <= 102))) {
+      return ''
+    }
+    acc += input[i]
+  }
+  return acc
+}
+
+/**
+ * @typedef {Object} GetIPV6Result
+ * @property {boolean} error - Indicates if there was an error parsing the IPv6 address.
+ * @property {string} address - The parsed IPv6 address.
+ * @property {string} [zone] - The zone identifier, if present.
+ */
+
+/**
+ * @param {string} value
+ * @returns {boolean}
+ */
+const nonSimpleDomain = RegExp.prototype.test.bind(/[^!"$&'()*+,\-.;=_`a-z{}~]/u)
+
+/**
+ * @param {Array<string>} buffer
+ * @returns {boolean}
+ */
+function consumeIsZone (buffer) {
+  buffer.length = 0
+  return true
+}
+
+/**
+ * @param {Array<string>} buffer
+ * @param {Array<string>} address
+ * @param {GetIPV6Result} output
+ * @returns {boolean}
+ */
+function consumeHextets (buffer, address, output) {
+  if (buffer.length) {
+    const hex = stringArrayToHexStripped(buffer)
+    if (hex !== '') {
+      address.push(hex)
+    } else {
+      output.error = true
+      return false
+    }
+    buffer.length = 0
+  }
+  return true
+}
+
+/**
+ * @param {string} input
+ * @returns {GetIPV6Result}
+ */
+function getIPV6 (input) {
+  let tokenCount = 0
+  const output = { error: false, address: '', zone: '' }
+  /** @type {Array<string>} */
+  const address = []
+  /** @type {Array<string>} */
+  const buffer = []
+  let endipv6Encountered = false
+  let endIpv6 = false
+
+  let consume = consumeHextets
+
+  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(buffer, address, output)) { break }
+      if (++tokenCount > 7) {
+        // not valid
+        output.error = true
+        break
+      }
+      if (i > 0 && input[i - 1] === ':') {
+        endipv6Encountered = true
+      }
+      address.push(':')
+      continue
+    } else if (cursor === '%') {
+      if (!consume(buffer, address, output)) { break }
+      // switch to zone detection
+      consume = consumeIsZone
+    } else {
+      buffer.push(cursor)
+      continue
+    }
+  }
+  if (buffer.length) {
+    if (consume === consumeIsZone) {
+      output.zone = buffer.join('')
+    } else if (endIpv6) {
+      address.push(buffer.join(''))
+    } else {
+      address.push(stringArrayToHexStripped(buffer))
+    }
+  }
+  output.address = address.join('')
+  return output
+}
+
+/**
+ * @typedef {Object} NormalizeIPv6Result
+ * @property {string} host - The normalized host.
+ * @property {string} [escapedHost] - The escaped host.
+ * @property {boolean} isIPV6 - Indicates if the host is an IPv6 address.
+ */
+
+/**
+ * @param {string} host
+ * @returns {NormalizeIPv6Result}
+ */
+function normalizeIPv6 (host) {
+  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, isIPV6: true, escapedHost }
+  } else {
+    return { host, isIPV6: false }
+  }
+}
+
+/**
+ * @param {string} str
+ * @param {string} token
+ * @returns {number}
+ */
+function findToken (str, token) {
+  let ind = 0
+  for (let i = 0; i < str.length; i++) {
+    if (str[i] === token) ind++
+  }
+  return ind
+}
+
+/**
+ * @param {string} path
+ * @returns {string}
+ *
+ * @see https://datatracker.ietf.org/doc/html/rfc3986#section-5.2.4
+ */
+function removeDotSegments (path) {
+  let input = path
+  const output = []
+  let nextSlash = -1
+  let len = 0
+
+  // eslint-disable-next-line no-cond-assign
+  while (len = input.length) {
+    if (len === 1) {
+      if (input === '.') {
+        break
+      } else if (input === '/') {
+        output.push('/')
+        break
+      } else {
+        output.push(input)
+        break
+      }
+    } else if (len === 2) {
+      if (input[0] === '.') {
+        if (input[1] === '.') {
+          break
+        } else if (input[1] === '/') {
+          input = input.slice(2)
+          continue
+        }
+      } else if (input[0] === '/') {
+        if (input[1] === '.' || input[1] === '/') {
+          output.push('/')
+          break
+        }
+      }
+    } else if (len === 3) {
+      if (input === '/..') {
+        if (output.length !== 0) {
+          output.pop()
+        }
+        output.push('/')
+        break
+      }
+    }
+    if (input[0] === '.') {
+      if (input[1] === '.') {
+        if (input[2] === '/') {
+          input = input.slice(3)
+          continue
+        }
+      } else if (input[1] === '/') {
+        input = input.slice(2)
+        continue
+      }
+    } else if (input[0] === '/') {
+      if (input[1] === '.') {
+        if (input[2] === '/') {
+          input = input.slice(2)
+          continue
+        } else if (input[2] === '.') {
+          if (input[3] === '/') {
+            input = input.slice(3)
+            if (output.length !== 0) {
+              output.pop()
+            }
+            continue
+          }
+        }
+      }
+    }
+
+    // Rule 2E: Move normal path segment to output
+    if ((nextSlash = input.indexOf('/', 1)) === -1) {
+      output.push(input)
+      break
+    } else {
+      output.push(input.slice(0, nextSlash))
+      input = input.slice(nextSlash)
+    }
+  }
+
+  return output.join('')
+}
+
+/**
+ * @param {import('../types/index').URIComponent} component
+ * @param {boolean} esc
+ * @returns {import('../types/index').URIComponent}
+ */
+function normalizeComponentEncoding (component, esc) {
+  const func = esc !== true ? escape : unescape
+  if (component.scheme !== undefined) {
+    component.scheme = func(component.scheme)
+  }
+  if (component.userinfo !== undefined) {
+    component.userinfo = func(component.userinfo)
+  }
+  if (component.host !== undefined) {
+    component.host = func(component.host)
+  }
+  if (component.path !== undefined) {
+    component.path = func(component.path)
+  }
+  if (component.query !== undefined) {
+    component.query = func(component.query)
+  }
+  if (component.fragment !== undefined) {
+    component.fragment = func(component.fragment)
+  }
+  return component
+}
+
+/**
+ * @param {import('../types/index').URIComponent} component
+ * @returns {string|undefined}
+ */
+function recomposeAuthority (component) {
+  const uriTokens = []
+
+  if (component.userinfo !== undefined) {
+    uriTokens.push(component.userinfo)
+    uriTokens.push('@')
+  }
+
+  if (component.host !== undefined) {
+    let host = unescape(component.host)
+    if (!isIPv4(host)) {
+      const ipV6res = normalizeIPv6(host)
+      if (ipV6res.isIPV6 === true) {
+        host = `[${ipV6res.escapedHost}]`
+      } else {
+        host = component.host
+      }
+    }
+    uriTokens.push(host)
+  }
+
+  if (typeof component.port === 'number' || typeof component.port === 'string') {
+    uriTokens.push(':')
+    uriTokens.push(String(component.port))
+  }
+
+  return uriTokens.length ? uriTokens.join('') : undefined
+};
+
+module.exports = {
+  nonSimpleDomain,
+  recomposeAuthority,
+  normalizeComponentEncoding,
+  removeDotSegments,
+  isIPv4,
+  isUUID,
+  normalizeIPv6,
+  stringArrayToHexStripped
+}

package/.OLD/Trial-1/node_modules/fast-uri/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "fast-uri",
+  "description": "Dependency-free RFC 3986 URI toolbox",
+  "version": "3.1.0",
+  "main": "index.js",
+  "type": "commonjs",
+  "types": "types/index.d.ts",
+  "license": "BSD-3-Clause",
+  "author": "Vincent Le Goff <vince.legoff@gmail.com> (https://github.com/zekth)",
+  "contributors": [
+    {
+      "name": "Matteo Collina",
+      "email": "hello@matteocollina.com"
+    },
+    {
+      "name": "Gürgün Dayıoğlu",
+      "email": "hey@gurgun.day",
+      "url": "https://heyhey.to/G"
+    },
+    {
+      "name": "Aras Abbasi",
+      "email": "aras.abbasi@gmail.com"
+    },
+    {
+      "name": "Frazer Smith",
+      "email": "frazer.dev@icloud.com",
+      "url": "https://github.com/fdawgs"
+    }
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fastify/fast-uri.git"
+  },
+  "bugs": {
+    "url": "https://github.com/fastify/fast-uri/issues"
+  },
+  "homepage": "https://github.com/fastify/fast-uri",
+  "funding": [
+    {
+      "type": "github",
+      "url": "https://github.com/sponsors/fastify"
+    },
+    {
+      "type": "opencollective",
+      "url": "https://opencollective.com/fastify"
+    }
+  ],
+  "scripts": {
+    "lint": "eslint",
+    "lint:fix": "eslint --fix",
+    "test": "npm run test:unit && npm run test:typescript",
+    "test:browser:chromium": "playwright-test ./test/* --runner tape --browser=chromium",
+    "test:browser:firefox": "playwright-test ./test/* --runner tape --browser=firefox",
+    "test:browser:webkit": "playwright-test ./test/* --runner tape --browser=webkit",
+    "test:browser": "npm run test:browser:chromium && npm run test:browser:firefox && npm run test:browser:webkit",
+    "test:unit": "tape test/**/*.js",
+    "test:unit:dev": "npm run test:unit -- --coverage-report=html",
+    "test:typescript": "tsd"
+  },
+  "devDependencies": {
+    "@fastify/pre-commit": "^2.1.0",
+    "ajv": "^8.16.0",
+    "eslint": "^9.17.0",
+    "neostandard": "^0.12.0",
+    "playwright-test": "^14.1.12",
+    "tape": "^5.8.1",
+    "tsd": "^0.32.0"
+  }
+}

package/.OLD/Trial-1/node_modules/fast-uri/test/ajv.test.js

@@ -0,0 +1,43 @@
+'use strict'
+
+const test = require('tape')
+const fastURI = require('..')
+
+const AJV = require('ajv')
+
+const ajv = new AJV({
+  uriResolver: fastURI // comment this line to see it works with uri-js
+})
+
+test('ajv', t => {
+  t.plan(1)
+  const schema = {
+    $ref: '#/definitions/Record%3Cstring%2CPerson%3E',
+    definitions: {
+      Person: {
+        type: 'object',
+        properties: {
+          firstName: {
+            type: 'string'
+          }
+        }
+      },
+      'Record<string,Person>': {
+        type: 'object',
+        additionalProperties: {
+          $ref: '#/definitions/Person'
+        }
+      }
+    }
+  }
+
+  const data = {
+    joe: {
+      firstName: 'Joe'
+    }
+
+  }
+
+  const validate = ajv.compile(schema)
+  t.ok(validate(data))
+})

package/.OLD/Trial-1/node_modules/fast-uri/test/equal.test.js

@@ -0,0 +1,108 @@
+'use strict'
+
+const test = require('tape')
+const fastURI = require('..')
+
+const fn = fastURI.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.throws(() => {
+    fn('urn:', 'urn:FOO:a123,456')
+  }, 'URN without nid cannot be serialized')
+
+  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()
+})