toolcraft 0.0.115 → 0.0.116

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

@@ -1,443 +0,0 @@
-'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)
-
-/** @type {(value: string) => boolean} */
-const isHexPair = RegExp.prototype.test.bind(/^[\da-f]{2}$/iu)
-
-/** @type {(value: string) => boolean} */
-const isUnreserved = RegExp.prototype.test.bind(/^[\da-z\-._~]$/iu)
-
-/** @type {(value: string) => boolean} */
-const isPathCharacter = RegExp.prototype.test.bind(/^[\da-z\-._~!$&'()*+,;=:@/]$/iu)
-
-/**
- * @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('')
-}
-
-/**
- * Re-escape RFC 3986 gen-delims that must not appear literally in the host.
- * After the URI regex parses, these characters cannot be literal in the host
- * field, so any that appear after decoding came from percent-encoding and
- * must be restored to prevent authority structure changes.
- *
- * @param {string} host
- * @param {boolean} isIP - true for IPv4/IPv6 hosts (skip colon re-escaping)
- * @returns {string}
- */
-const HOST_DELIMS = { '@': '%40', '/': '%2F', '?': '%3F', '#': '%23', ':': '%3A' }
-const HOST_DELIM_RE = /[@/?#:]/g
-const HOST_DELIM_NO_COLON_RE = /[@/?#]/g
-
-function reescapeHostDelimiters (host, isIP) {
-  const re = isIP ? HOST_DELIM_NO_COLON_RE : HOST_DELIM_RE
-  re.lastIndex = 0
-  return host.replace(re, (ch) => HOST_DELIMS[ch])
-}
-
-/**
- * Normalizes percent escapes and optionally decodes only unreserved ASCII bytes.
- * Reserved delimiters such as `%2F` and `%2E` stay escaped.
- *
- * @param {string} input
- * @param {boolean} [decodeUnreserved=false]
- * @returns {string}
- */
-function normalizePercentEncoding (input, decodeUnreserved = false) {
-  if (input.indexOf('%') === -1) {
-    return input
-  }
-
-  let output = ''
-
-  for (let i = 0; i < input.length; i++) {
-    if (input[i] === '%' && i + 2 < input.length) {
-      const hex = input.slice(i + 1, i + 3)
-      if (isHexPair(hex)) {
-        const normalizedHex = hex.toUpperCase()
-        const decoded = String.fromCharCode(parseInt(normalizedHex, 16))
-
-        if (decodeUnreserved && isUnreserved(decoded)) {
-          output += decoded
-        } else {
-          output += '%' + normalizedHex
-        }
-
-        i += 2
-        continue
-      }
-    }
-
-    output += input[i]
-  }
-
-  return output
-}
-
-/**
- * Normalizes path data without turning reserved escapes into live path syntax.
- * Valid escapes are uppercased, raw unsafe characters are escaped, and only
- * unreserved bytes that are not `.` are decoded.
- *
- * @param {string} input
- * @returns {string}
- */
-function normalizePathEncoding (input) {
-  let output = ''
-
-  for (let i = 0; i < input.length; i++) {
-    if (input[i] === '%' && i + 2 < input.length) {
-      const hex = input.slice(i + 1, i + 3)
-      if (isHexPair(hex)) {
-        const normalizedHex = hex.toUpperCase()
-        const decoded = String.fromCharCode(parseInt(normalizedHex, 16))
-
-        if (decoded !== '.' && isUnreserved(decoded)) {
-          output += decoded
-        } else {
-          output += '%' + normalizedHex
-        }
-
-        i += 2
-        continue
-      }
-    }
-
-    if (isPathCharacter(input[i])) {
-      output += input[i]
-    } else {
-      output += escape(input[i])
-    }
-  }
-
-  return output
-}
-
-/**
- * Escapes a component while preserving existing valid percent escapes.
- *
- * @param {string} input
- * @returns {string}
- */
-function escapePreservingEscapes (input) {
-  let output = ''
-
-  for (let i = 0; i < input.length; i++) {
-    if (input[i] === '%' && i + 2 < input.length) {
-      const hex = input.slice(i + 1, i + 3)
-      if (isHexPair(hex)) {
-        output += '%' + hex.toUpperCase()
-        i += 2
-        continue
-      }
-    }
-
-    output += escape(input[i])
-  }
-
-  return output
-}
-
-/**
- * @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 = reescapeHostDelimiters(host, false)
-      }
-    }
-    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,
-  reescapeHostDelimiters,
-  normalizePercentEncoding,
-  normalizePathEncoding,
-  escapePreservingEscapes,
-  removeDotSegments,
-  isIPv4,
-  isUUID,
-  normalizeIPv6,
-  stringArrayToHexStripped
-}

package/node_modules/fast-uri/package.json

@@ -1,68 +0,0 @@
-{
-  "name": "fast-uri",
-  "description": "Dependency-free RFC 3986 URI toolbox",
-  "version": "3.1.2",
-  "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": {
-    "ajv": "^8.16.0",
-    "eslint": "^9.17.0",
-    "neostandard": "^0.13.0",
-    "playwright-test": "^14.1.12",
-    "tape": "^5.8.1",
-    "tsd": "^0.33.0"
-  }
-}

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

@@ -1,43 +0,0 @@
-'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/node_modules/fast-uri/test/equal.test.js

@@ -1,117 +0,0 @@
-'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()
-})
-
-test('URI Equals tolerates malformed fragments', (t) => {
-  t.equal(
-    fastURI.equal('http://example.com/#%E0%A4A', 'http://example.com/#%E0%A4A'),
-    true,
-    'malformed fragment does not throw during equality checks'
-  )
-  t.end()
-})