@bluefly/openstandardagents 0.4.6 → 0.4.9

package/node_modules/fast-uri/benchmark/benchmark.mjs

@@ -1,159 +0,0 @@
-import { Bench } from 'tinybench'
-import { fastUri } from '../index.js'
-import { parse as uriJsParse, serialize as uriJsSerialize, resolve as uriJsResolve, equal as uriJsEqual } from 'uri-js'
-
-const base = 'uri://a/b/c/d;p?q'
-
-const domain = 'https://example.com/foo#bar$fiz'
-const ipv4 = '//10.10.10.10'
-const ipv6 = '//[2001:db8::7]'
-const urn = 'urn:foo:a123,456'
-const urnuuid = 'urn:uuid:f81d4fae-7dec-11d0-a765-00a0c91e6bf6'
-
-const urnuuidComponent = {
-  scheme: 'urn',
-  nid: 'uuid',
-  uuid: 'f81d4fae-7dec-11d0-a765-00a0c91e6bf6'
-}
-
-const {
-  parse: fastUriParse,
-  serialize: fastUriSerialize,
-  resolve: fastUriResolve,
-  equal: fastUriEqual,
-} = fastUri
-
-// Initialization as there is a lot to parse at first
-// eg: regexes
-fastUriParse(domain)
-uriJsParse(domain)
-
-const benchFastUri = new Bench({ name: 'fast-uri benchmark' })
-const benchUriJs = new Bench({ name: 'uri-js benchmark' })
-const benchWHATWG = new Bench({ name: 'WHATWG URL benchmark' })
-
-benchFastUri.add('fast-uri: parse domain', function () {
-  fastUriParse(domain)
-})
-benchUriJs.add('urijs: parse domain', function () {
-  uriJsParse(domain)
-})
-benchWHATWG.add('WHATWG URL: parse domain', function () {
-  // eslint-disable-next-line
-  new URL(domain)
-})
-benchFastUri.add('fast-uri: parse IPv4', function () {
-  fastUriParse(ipv4)
-})
-benchUriJs.add('urijs: parse IPv4', function () {
-  uriJsParse(ipv4)
-})
-benchFastUri.add('fast-uri: parse IPv6', function () {
-  fastUriParse(ipv6)
-})
-benchUriJs.add('urijs: parse IPv6', function () {
-  uriJsParse(ipv6)
-})
-benchFastUri.add('fast-uri: parse URN', function () {
-  fastUriParse(urn)
-})
-benchUriJs.add('urijs: parse URN', function () {
-  uriJsParse(urn)
-})
-benchWHATWG.add('WHATWG URL: parse URN', function () {
-  // eslint-disable-next-line
-  new URL(urn)
-})
-benchFastUri.add('fast-uri: parse URN uuid', function () {
-  fastUriParse(urnuuid)
-})
-benchUriJs.add('urijs: parse URN uuid', function () {
-  uriJsParse(urnuuid)
-})
-benchFastUri.add('fast-uri: serialize URN uuid', function () {
-  fastUriSerialize(urnuuidComponent)
-})
-benchUriJs.add('uri-js: serialize URN uuid', function () {
-  uriJsSerialize(urnuuidComponent)
-})
-benchFastUri.add('fast-uri: serialize uri', function () {
-  fastUriSerialize({
-    scheme: 'uri',
-    userinfo: 'foo:bar',
-    host: 'example.com',
-    port: 1,
-    path: 'path',
-    query: 'query',
-    fragment: 'fragment'
-  })
-})
-benchUriJs.add('urijs: serialize uri', function () {
-  uriJsSerialize({
-    scheme: 'uri',
-    userinfo: 'foo:bar',
-    host: 'example.com',
-    port: 1,
-    path: 'path',
-    query: 'query',
-    fragment: 'fragment'
-  })
-})
-benchFastUri.add('fast-uri: serialize long uri with dots', function () {
-  fastUriSerialize({
-    scheme: 'uri',
-    userinfo: 'foo:bar',
-    host: 'example.com',
-    port: 1,
-    path: './a/./b/c/../.././d/../e/f/.././/',
-    query: 'query',
-    fragment: 'fragment'
-  })
-})
-benchUriJs.add('urijs: serialize long uri with dots', function () {
-  uriJsSerialize({
-    scheme: 'uri',
-    userinfo: 'foo:bar',
-    host: 'example.com',
-    port: 1,
-    path: './a/./b/c/../.././d/../e/f/.././/',
-    query: 'query',
-    fragment: 'fragment'
-  })
-})
-benchFastUri.add('fast-uri: serialize IPv6', function () {
-  fastUriSerialize({ host: '2606:2800:220:1:248:1893:25c8:1946' })
-})
-benchUriJs.add('urijs: serialize IPv6', function () {
-  uriJsSerialize({ host: '2606:2800:220:1:248:1893:25c8:1946' })
-})
-benchFastUri.add('fast-uri: serialize ws', function () {
-  fastUriSerialize({ scheme: 'ws', host: 'example.com', resourceName: '/foo?bar', secure: true })
-})
-benchUriJs.add('urijs: serialize ws', function () {
-  uriJsSerialize({ scheme: 'ws', host: 'example.com', resourceName: '/foo?bar', secure: true })
-})
-benchFastUri.add('fast-uri: resolve', function () {
-  fastUriResolve(base, '../../../g')
-})
-benchUriJs.add('urijs: resolve', function () {
-  uriJsResolve(base, '../../../g')
-})
-
-benchFastUri.add('fast-uri: equal', function () {
-  fastUriEqual('example://a/b/c/%7Bfoo%7D', 'eXAMPLE://a/./b/../b/%63/%7bfoo%7d')
-})
-benchUriJs.add('urijs: equal', function () {
-  uriJsEqual('example://a/b/c/%7Bfoo%7D', 'eXAMPLE://a/./b/../b/%63/%7bfoo%7d')
-})
-
-await benchFastUri.run()
-console.log(benchFastUri.name)
-console.table(benchFastUri.table())
-
-await benchUriJs.run()
-console.log(benchUriJs.name)
-console.table(benchUriJs.table())
-
-await benchWHATWG.run()
-console.log(benchWHATWG.name)
-console.table(benchWHATWG.table())

package/node_modules/fast-uri/benchmark/equal.mjs

@@ -1,51 +0,0 @@
-import { Bench } from 'tinybench'
-import { fastUri } from '../index.js'
-
-const {
-  equal: fastUriEqual,
-  parse: fastUriParse,
-} = fastUri
-
-const stringA = 'example://a/b/c/%7Bfoo%7D'
-const stringB = 'eXAMPLE://a/./b/../b/%63/%7bfoo%7d'
-
-const componentA = fastUriParse(stringA)
-const componentB = fastUriParse(stringB)
-
-const benchFastUri = new Bench({ name: 'fast-uri equal' })
-
-benchFastUri.add('equal string with string', function () {
-  fastUriEqual(stringA, stringA)
-})
-
-benchFastUri.add('equal component with component', function () {
-  fastUriEqual(componentA, componentA)
-})
-
-benchFastUri.add('equal component with string', function () {
-  fastUriEqual(componentA, stringA)
-})
-
-benchFastUri.add('equal string with component', function () {
-  fastUriEqual(stringA, componentA)
-})
-
-benchFastUri.add('not equal string with string', function () {
-  fastUriEqual(stringA, stringB)
-})
-
-benchFastUri.add('not equal component with component', function () {
-  fastUriEqual(componentA, componentB)
-})
-
-benchFastUri.add('not equal component with string', function () {
-  fastUriEqual(componentA, stringB)
-})
-
-benchFastUri.add('not equal string with component', function () {
-  fastUriEqual(stringA, componentB)
-})
-
-await benchFastUri.run()
-console.log(benchFastUri.name)
-console.table(benchFastUri.table())

package/node_modules/fast-uri/benchmark/non-simple-domain.mjs

@@ -1,22 +0,0 @@
-import { Bench } from 'tinybench'
-import { nonSimpleDomain } from '../lib/utils.js'
-
-const benchNonSimpleDomain = new Bench({ name: 'nonSimpleDomain' })
-
-const exampleCom = 'example.com'
-const exaumlmpleCom = 'exämple.com'
-const longDomain = 'abc'.repeat(100) + '.com'
-
-console.assert(nonSimpleDomain(exampleCom) === false, 'example.com should be a simple domain')
-console.assert(nonSimpleDomain(exaumlmpleCom) === true, 'exämple.com should not be a simple domain')
-console.assert(nonSimpleDomain(longDomain) === false, `${longDomain} should be a simple domain?`)
-
-benchNonSimpleDomain.add('nonSimpleDomain', function () {
-  nonSimpleDomain(exampleCom)
-  nonSimpleDomain(exaumlmpleCom)
-  nonSimpleDomain(longDomain)
-})
-
-await benchNonSimpleDomain.run()
-console.log(benchNonSimpleDomain.name)
-console.table(benchNonSimpleDomain.table())

package/node_modules/fast-uri/benchmark/package.json

@@ -1,17 +0,0 @@
-{
-  "name": "benchmark",
-  "version": "1.0.0",
-  "description": "",
-  "main": "index.js",
-  "private": true,
-  "scripts": {
-    "bench": "node benchmark.mjs"
-  },
-  "keywords": [],
-  "author": "",
-  "license": "ISC",
-  "dependencies": {
-    "tinybench": "^5.0.0",
-    "uri-js": "^4.4.1"
-  }
-}

package/node_modules/fast-uri/benchmark/string-array-to-hex-stripped.mjs

@@ -1,24 +0,0 @@
-import { Bench } from 'tinybench'
-import { stringArrayToHexStripped } from '../lib/utils.js'
-
-const benchStringArrayToHexStripped = new Bench({ name: 'stringArrayToHexStripped' })
-
-const case1 = ['0', '0', '0', '0']
-const case2 = ['0', '0', '0', '1']
-const case3 = ['0', '0', '1', '0']
-const case4 = ['0', '1', '0', '0']
-const case5 = ['1', '0', '0', '0']
-const case6 = ['1', '0', '0', '1']
-
-benchStringArrayToHexStripped.add('stringArrayToHexStripped', function () {
-  stringArrayToHexStripped(case1)
-  stringArrayToHexStripped(case2)
-  stringArrayToHexStripped(case3)
-  stringArrayToHexStripped(case4)
-  stringArrayToHexStripped(case5)
-  stringArrayToHexStripped(case6)
-})
-
-await benchStringArrayToHexStripped.run()
-console.log(benchStringArrayToHexStripped.name)
-console.table(benchStringArrayToHexStripped.table())

package/node_modules/fast-uri/benchmark/ws-is-secure.mjs

@@ -1,65 +0,0 @@
-import { Bench } from 'tinybench'
-import { wsIsSecure } from '../lib/schemes.js'
-
-const benchWsIsSecure = new Bench({ name: 'wsIsSecure' })
-
-const wsComponentAttributeSecureTrue = {
-  scheme: 'ws',
-  secure: true,
-}
-
-const wsComponentAttributeSecureFalse = {
-  scheme: 'ws',
-  secure: false,
-}
-
-const wssComponent = {
-  scheme: 'wss',
-}
-
-const wssComponentMixedCase = {
-  scheme: 'Wss',
-}
-
-const wssComponentUpperCase = {
-  scheme: 'WSS',
-}
-
-const httpComponent = {
-  scheme: 'http',
-}
-
-console.assert(wsIsSecure(wsComponentAttributeSecureTrue) === true, 'wsComponentAttributeSecureTrue should be secure')
-console.assert(wsIsSecure(wsComponentAttributeSecureFalse) === false, 'wsComponentAttributeSecureFalse should not be secure')
-console.assert(wsIsSecure(wssComponent) === true, 'wssComponent should be secure')
-console.assert(wsIsSecure(wssComponentMixedCase) === true, 'wssComponentMixedCase should be secure')
-console.assert(wsIsSecure(wssComponentUpperCase) === true, 'wssComponentUpperCase should be secure')
-console.assert(wsIsSecure(httpComponent) === false, 'httpComponent should not be secure')
-
-benchWsIsSecure.add(JSON.stringify(wsComponentAttributeSecureFalse), function () {
-  wsIsSecure(wsComponentAttributeSecureFalse)
-})
-
-benchWsIsSecure.add(JSON.stringify(wsComponentAttributeSecureTrue), function () {
-  wsIsSecure(wsComponentAttributeSecureTrue)
-})
-
-benchWsIsSecure.add(JSON.stringify(wssComponent), function () {
-  wsIsSecure(wssComponent)
-})
-
-benchWsIsSecure.add(JSON.stringify(wssComponentMixedCase), function () {
-  wsIsSecure(wssComponentMixedCase)
-})
-
-benchWsIsSecure.add(JSON.stringify(wssComponentUpperCase), function () {
-  wsIsSecure(wssComponentUpperCase)
-})
-
-benchWsIsSecure.add(JSON.stringify(httpComponent), function () {
-  wsIsSecure(httpComponent)
-})
-
-await benchWsIsSecure.run()
-console.log(benchWsIsSecure.name)
-console.table(benchWsIsSecure.table())

package/node_modules/fast-uri/eslint.config.js

@@ -1,6 +0,0 @@
-'use strict'
-
-module.exports = require('neostandard')({
-  ignores: require('neostandard').resolveIgnoresFromGitignore(),
-  ts: true
-})

package/node_modules/fast-uri/index.js

@@ -1,340 +0,0 @@
-'use strict'
-
-const { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizeComponentEncoding, isIPv4, nonSimpleDomain } = require('./lib/utils')
-const { SCHEMES, getSchemeHandler } = require('./lib/schemes')
-
-/**
- * @template {import('./types/index').URIComponent|string} T
- * @param {T} uri
- * @param {import('./types/index').Options} [options]
- * @returns {T}
- */
-function normalize (uri, options) {
-  if (typeof uri === 'string') {
-    uri = /** @type {T} */ (serialize(parse(uri, options), options))
-  } else if (typeof uri === 'object') {
-    uri = /** @type {T} */ (parse(serialize(uri, options), options))
-  }
-  return uri
-}
-
-/**
- * @param {string} baseURI
- * @param {string} relativeURI
- * @param {import('./types/index').Options} [options]
- * @returns {string}
- */
-function resolve (baseURI, relativeURI, options) {
-  const schemelessOptions = options ? Object.assign({ scheme: 'null' }, options) : { scheme: 'null' }
-  const resolved = resolveComponent(parse(baseURI, schemelessOptions), parse(relativeURI, schemelessOptions), schemelessOptions, true)
-  schemelessOptions.skipEscape = true
-  return serialize(resolved, schemelessOptions)
-}
-
-/**
- * @param {import ('./types/index').URIComponent} base
- * @param {import ('./types/index').URIComponent} relative
- * @param {import('./types/index').Options} [options]
- * @param {boolean} [skipNormalization=false]
- * @returns {import ('./types/index').URIComponent}
- */
-function resolveComponent (base, relative, options, skipNormalization) {
-  /** @type {import('./types/index').URIComponent} */
-  const target = {}
-  if (!skipNormalization) {
-    base = parse(serialize(base, options), options) // normalize base component
-    relative = parse(serialize(relative, options), options) // normalize relative component
-  }
-  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[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
-}
-
-/**
- * @param {import ('./types/index').URIComponent|string} uriA
- * @param {import ('./types/index').URIComponent|string} uriB
- * @param {import ('./types/index').Options} options
- * @returns {boolean}
- */
-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()
-}
-
-/**
- * @param {Readonly<import('./types/index').URIComponent>} cmpts
- * @param {import('./types/index').Options} [opts]
- * @returns {string}
- */
-function serialize (cmpts, opts) {
-  const component = {
-    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 = getSchemeHandler(options.scheme || component.scheme)
-
-  // perform scheme specific serialization
-  if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(component, options)
-
-  if (component.path !== undefined) {
-    if (!options.skipEscape) {
-      component.path = escape(component.path)
-
-      if (component.scheme !== undefined) {
-        component.path = component.path.split('%3A').join(':')
-      }
-    } else {
-      component.path = unescape(component.path)
-    }
-  }
-
-  if (options.reference !== 'suffix' && component.scheme) {
-    uriTokens.push(component.scheme, ':')
-  }
-
-  const authority = recomposeAuthority(component)
-  if (authority !== undefined) {
-    if (options.reference !== 'suffix') {
-      uriTokens.push('//')
-    }
-
-    uriTokens.push(authority)
-
-    if (component.path && component.path[0] !== '/') {
-      uriTokens.push('/')
-    }
-  }
-  if (component.path !== undefined) {
-    let s = component.path
-
-    if (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) {
-      s = removeDotSegments(s)
-    }
-
-    if (
-      authority === undefined &&
-      s[0] === '/' &&
-      s[1] === '/'
-    ) {
-      // don't allow the path to start with "//"
-      s = '/%2F' + s.slice(2)
-    }
-
-    uriTokens.push(s)
-  }
-
-  if (component.query !== undefined) {
-    uriTokens.push('?', component.query)
-  }
-
-  if (component.fragment !== undefined) {
-    uriTokens.push('#', component.fragment)
-  }
-  return uriTokens.join('')
-}
-
-const URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u
-
-/**
- * @param {string} uri
- * @param {import('./types/index').Options} [opts]
- * @returns
- */
-function parse (uri, opts) {
-  const options = Object.assign({}, opts)
-  /** @type {import('./types/index').URIComponent} */
-  const parsed = {
-    scheme: undefined,
-    userinfo: undefined,
-    host: '',
-    port: undefined,
-    path: '',
-    query: undefined,
-    fragment: undefined
-  }
-
-  let isIP = false
-  if (options.reference === 'suffix') {
-    if (options.scheme) {
-      uri = options.scheme + ':' + uri
-    } else {
-      uri = '//' + 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 = isIPv4(parsed.host)
-      if (ipv4result === false) {
-        const ipv6result = normalizeIPv6(parsed.host)
-        parsed.host = ipv6result.host.toLowerCase()
-        isIP = ipv6result.isIPV6
-      } else {
-        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 = getSchemeHandler(options.scheme || parsed.scheme)
-
-    // 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 (uri.indexOf('%') !== -1) {
-        if (parsed.scheme !== undefined) {
-          parsed.scheme = unescape(parsed.scheme)
-        }
-        if (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,
-  resolveComponent,
-  equal,
-  serialize,
-  parse
-}
-
-module.exports = fastUri
-module.exports.default = fastUri
-module.exports.fastUri = fastUri