@mininglamp-oss/octo-runtime 1.0.1 → 1.1.0

package/node_modules/fast-uri/package.json

@@ -1,68 +0,0 @@
-{
-  "name": "fast-uri",
-  "description": "Dependency-free RFC 3986 URI toolbox",
-  "version": "3.1.8",
-  "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/component-safe-serialization.test.js

@@ -1,163 +0,0 @@
-'use strict'
-
-const test = require('tape')
-const fastURI = require('..')
-
-test('userinfo serialization cannot terminate the authority', (t) => {
-  const uri = fastURI.serialize({
-    scheme: 'http',
-    userinfo: 'attacker.example/',
-    host: 'trusted.example',
-    path: '/'
-  })
-
-  t.equal(uri, 'http://attacker.example%2F@trusted.example/', 'slash is encoded as userinfo data')
-
-  const reparsed = fastURI.parse(uri)
-  t.equal(reparsed.host, 'trusted.example', 'reparsing retains the supplied host')
-  t.equal(reparsed.userinfo, 'attacker.example%2F', 'encoded slash remains in userinfo')
-  t.equal(
-    fastURI.serialize({ userinfo: 'user@/?:#[]\\', host: 'example.test' }),
-    '//user%40%2F%3F:%23%5B%5D%5C@example.test',
-    'all userinfo component delimiters are encoded as data'
-  )
-  t.end()
-})
-
-test('port serialization rejects non-digit values', (t) => {
-  const malformedPorts = [
-    '@127.0.0.1:8124',
-    '8080@evil.example',
-    '8080/path',
-    '8080?query',
-    '8080#fragment',
-    '8080:9000',
-    '-1',
-    '1.5',
-    1.5,
-    NaN,
-    Infinity,
-    '\u0661'
-  ]
-
-  for (const port of malformedPorts) {
-    t.throws(
-      () => fastURI.serialize({ scheme: 'http', host: 'trusted.example', port, path: '/app' }),
-      /URI port is malformed\./,
-      String(port)
-    )
-  }
-
-  t.throws(
-    () => fastURI.normalize({ scheme: 'http', host: 'trusted.example', port: '@evil.example' }),
-    /URI port is malformed\./,
-    'object normalization rejects a malformed port'
-  )
-  t.equal(
-    fastURI.equal(
-      { scheme: 'http', host: 'trusted.example', port: '@evil.example' },
-      { scheme: 'http', host: 'trusted.example', port: '@evil.example' }
-    ),
-    false,
-    'object equality fails closed for a malformed port'
-  )
-  t.end()
-})
-
-test('port serialization preserves RFC 3986 digit values', (t) => {
-  const validPorts = [
-    [8080, '8080'],
-    ['8080', '8080'],
-    ['00080', '00080'],
-    ['', '']
-  ]
-
-  for (const [port, expected] of validPorts) {
-    t.equal(
-      fastURI.serialize({ scheme: 'uri', host: 'example.test', port }),
-      `uri://example.test:${expected}`,
-      JSON.stringify(port)
-    )
-  }
-  t.end()
-})
-
-test('query and fragment serialization cannot inject component delimiters', (t) => {
-  const uri = fastURI.serialize({
-    scheme: 'x',
-    path: '/resource',
-    query: 'key=value#still-query',
-    fragment: 'first#still-fragment'
-  })
-
-  t.equal(
-    uri,
-    'x:/resource?key=value%23still-query#first%23still-fragment',
-    'raw hashes are encoded within their supplied components'
-  )
-
-  const reparsed = fastURI.parse(uri)
-  t.equal(reparsed.query, 'key=value%23still-query', 'hash remains query data')
-  t.equal(reparsed.fragment, 'first%23still-fragment', 'hash remains fragment data')
-  t.end()
-})
-
-test('component serializers preserve each RFC 3986 literal character set', (t) => {
-  const unreservedAndSubDelims = "AZaz09-._~!$&'()*+,;="
-  const userinfo = unreservedAndSubDelims + ':'
-  const queryOrFragment = unreservedAndSubDelims + ':@/?'
-
-  t.equal(
-    fastURI.serialize({ userinfo, host: 'example.test' }),
-    '//' + userinfo + '@example.test',
-    'userinfo literals are preserved'
-  )
-  t.equal(
-    fastURI.serialize({ query: queryOrFragment }),
-    '?' + queryOrFragment,
-    'query literals are preserved'
-  )
-  t.equal(
-    fastURI.serialize({ fragment: queryOrFragment }),
-    '#' + queryOrFragment,
-    'fragment literals are preserved'
-  )
-  t.end()
-})
-
-test('component serializers preserve escapes and encode Unicode as UTF-8', (t) => {
-  t.equal(
-    fastURI.serialize({ userinfo: 'café/%2f%GG', host: 'example.test' }),
-    '//caf%C3%A9%2F%2F%25GG@example.test',
-    'userinfo preserves valid escapes, uppercases hex, and escapes malformed percent data'
-  )
-  t.equal(
-    fastURI.serialize({ query: '日本/%2f#%GG' }),
-    '?%E6%97%A5%E6%9C%AC/%2F%23%25GG',
-    'query uses UTF-8 and does not double encode valid escapes'
-  )
-  t.equal(
-    fastURI.serialize({ fragment: '😀/%3f#%GG' }),
-    '#%F0%9F%98%80/%3F%23%25GG',
-    'fragment uses UTF-8 and does not double encode valid escapes'
-  )
-  t.equal(
-    fastURI.serialize({ query: 'Kſ' }),
-    '?%E2%84%AA%C5%BF',
-    'Unicode characters that case-fold to ASCII are still UTF-8 encoded'
-  )
-  t.end()
-})
-
-test('parsed URI serialization remains stable', (t) => {
-  const input = 'x://user:pass@example.test/a%2Fb?x=a/b?c&y=%23#frag/a?b%23'
-  const serialized = fastURI.serialize(fastURI.parse(input))
-
-  t.equal(serialized, input, 'an already normalized parsed URI round-trips unchanged')
-  t.equal(
-    fastURI.serialize(fastURI.parse(serialized)),
-    serialized,
-    'repeated parse and serialize cycles are stable'
-  )
-  t.end()
-})

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

@@ -1,145 +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('URI Equals rejects malformed object input even when identical', (t) => {
-  const malformed = { scheme: 'http', host: 'example.com', port: 99999, path: '/x' }
-  t.equal(fn(malformed, malformed), false)
-  t.end()
-})
-
-test('URI Equals preserves case-sensitive components', (t) => {
-  const suite = [
-    { pair: ['http://example.com/Admin', 'http://example.com/admin'], result: false },
-    { pair: ['http://example.com/?token=SECRET', 'http://example.com/?token=secret'], result: false },
-    { pair: ['http://example.com/#Section', 'http://example.com/#section'], result: false },
-    { pair: ['http://User@example.com/', 'http://user@example.com/'], result: false },
-    { pair: ['urn:foo:CaseSensitive', 'urn:foo:casesensitive'], result: false },
-    { pair: ['ws://example.com/Chat', 'ws://example.com/chat'], result: false },
-    { pair: ['ws://example.com/?token=SECRET', 'ws://example.com/?token=secret'], result: false },
-    { pair: [{ scheme: 'http', host: 'example.com', path: '/Admin' }, { scheme: 'http', host: 'example.com', path: '/admin' }], result: false }
-  ]
-  runTest(t, suite)
-  t.end()
-})
-
-test('URI Equals folds normalized scheme and host case', (t) => {
-  const suite = [
-    { pair: ['HTTP://EXAMPLE.COM/resource', 'http://example.com/resource'], result: true },
-    { pair: [{ scheme: 'HTTP', host: 'EXAMPLE.COM', path: '/resource' }, { scheme: 'http', host: 'example.com', path: '/resource' }], result: true }
-  ]
-  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.equal(fn('urn:', 'urn:FOO:a123,456'), false, 'malformed URN fails equality safely')
-
-  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()
-})