nexus-agents 14.0.1 → 14.0.2

package/node_modules/fast-uri/test/mailto-field-name-security.test.js

@@ -1,151 +0,0 @@
-'use strict'
-
-const test = require('tape')
-const fastURI = require('..')
-
-function encodeCharacter (value, index, lowercaseHex) {
-  let hex = value.charCodeAt(index).toString(16)
-  if (!lowercaseHex) hex = hex.toUpperCase()
-  return value.slice(0, index) + '%' + hex + value.slice(index + 1)
-}
-
-function mailtoState (component) {
-  return {
-    to: component.to,
-    subject: component.subject,
-    body: component.body,
-    headers: component.headers && { ...component.headers }
-  }
-}
-
-test('mailto parsing classifies decoded, case-insensitive reserved field names', (t) => {
-  const cases = [
-    { name: 'to', value: 'attacker@evil.test', property: 'to' },
-    { name: 'subject', value: 'injected subject', property: 'subject' },
-    { name: 'body', value: 'injected body', property: 'body' }
-  ]
-
-  for (const entry of cases) {
-    const variants = new Set([entry.name.toUpperCase()])
-    for (let i = 0; i < entry.name.length; i++) {
-      variants.add(encodeCharacter(entry.name, i, false))
-      variants.add(encodeCharacter(entry.name, i, true))
-    }
-
-    for (const name of variants) {
-      const parsed = fastURI.parse(`mailto:alice@example.test?${name}=${entry.value}`)
-      if (entry.property === 'to') {
-        t.deepEqual(parsed.to, ['alice@example.test', entry.value], name + ' is classified as a recipient')
-      } else {
-        t.equal(parsed[entry.property], entry.value, name + ' is classified as ' + entry.property)
-      }
-      t.equal(parsed.headers, undefined, name + ' is not exposed as a generic header')
-
-      const reparsed = fastURI.parse(fastURI.serialize(parsed))
-      t.deepEqual(mailtoState(reparsed), mailtoState(parsed), name + ' keeps its meaning after a roundtrip')
-    }
-  }
-
-  t.end()
-})
-
-test('mailto generic field names are decoded exactly once across roundtrips', (t) => {
-  const cases = [
-    ['%2574o', '%74o'],
-    ['%2573ubject', '%73ubject'],
-    ['%2562ody', '%62ody'],
-    ['x%2520y', 'x%20y'],
-    ['%26to', '&to'],
-    ['%25GGto', '%GGto']
-  ]
-
-  for (const [encodedName, decodedName] of cases) {
-    let serialized = `mailto:alice@example.test?${encodedName}=value`
-    for (let round = 0; round < 3; round++) {
-      const parsed = fastURI.parse(serialized)
-      t.deepEqual({ ...parsed.headers }, { [decodedName]: 'value' }, encodedName + ' stays generic in round ' + round)
-      t.deepEqual(parsed.to, ['alice@example.test'], encodedName + ' does not add a recipient in round ' + round)
-      t.equal(parsed.subject, undefined, encodedName + ' does not set a subject in round ' + round)
-      t.equal(parsed.body, undefined, encodedName + ' does not set a body in round ' + round)
-      serialized = fastURI.serialize(parsed)
-    }
-    t.equal(serialized, `mailto:alice@example.test?${encodedName}=value`, encodedName + ' serializes idempotently')
-  }
-
-  t.equal(
-    fastURI.serialize({ scheme: 'mailto', to: ['alice@example.test'], headers: { '%74o': 'value' } }),
-    'mailto:alice@example.test?%2574o=value',
-    'a percent sequence in a decoded component key is encoded as data'
-  )
-  t.end()
-})
-
-test('mailto serialization canonicalizes reserved generic header names', (t) => {
-  const serialized = fastURI.serialize({
-    scheme: 'mailto',
-    to: ['alice@example.test'],
-    subject: 'safe subject',
-    body: 'safe body',
-    headers: {
-      TO: 'attacker@evil.test',
-      Subject: 'hidden subject',
-      BODY: 'hidden body',
-      cc: 'copy@example.test'
-    }
-  })
-
-  t.equal(
-    serialized,
-    'mailto:alice@example.test,attacker@evil.test?subject=safe%20subject&body=safe%20body&cc=copy@example.test',
-    'dedicated properties override header variants and all recipients are visible in the path'
-  )
-
-  const parsed = fastURI.parse(serialized)
-  t.deepEqual(parsed.to, ['alice@example.test', 'attacker@evil.test'], 'canonical recipients are classified consistently')
-  t.equal(parsed.subject, 'safe subject', 'the dedicated subject wins')
-  t.equal(parsed.body, 'safe body', 'the dedicated body wins')
-  t.deepEqual({ ...parsed.headers }, { cc: 'copy@example.test' }, 'only generic headers remain generic')
-
-  const empty = fastURI.serialize({
-    scheme: 'mailto',
-    to: ['alice@example.test'],
-    subject: '',
-    body: '',
-    headers: { Subject: 'hidden subject', BODY: 'hidden body' }
-  })
-  t.equal(empty, 'mailto:alice@example.test?subject=&body=', 'explicit empty properties override header variants')
-  const emptyParsed = fastURI.parse(empty)
-  t.equal(emptyParsed.subject, '', 'an empty subject round-trips')
-  t.equal(emptyParsed.body, '', 'an empty body round-trips')
-  t.end()
-})
-
-test('mailto duplicate reserved fields have deterministic parsing semantics', (t) => {
-  const parsed = fastURI.parse(
-    'mailto:alice@example.test?subject=first&%53UBJECT=last&body=first&%42ODY=last&to=one@example.test&%54O=two@example.test'
-  )
-
-  t.equal(parsed.subject, 'last', 'the last subject wins')
-  t.equal(parsed.body, 'last', 'the last body wins')
-  t.deepEqual(
-    parsed.to,
-    ['alice@example.test', 'one@example.test', 'two@example.test'],
-    'all recipient fields are accumulated'
-  )
-  t.equal(parsed.headers, undefined, 'no reserved spelling remains generic')
-  t.end()
-})
-
-test('encoded reserved field names expose decoded control characters immediately', (t) => {
-  const input = 'mailto:alice@example.test?%73ubject=hello%0D%0Aworld'
-  const parsed = fastURI.parse(input)
-
-  t.equal(parsed.subject, 'hello\r\nworld', 'the first parse exposes CRLF in the dedicated property')
-  t.equal(parsed.headers, undefined, 'the subject is not hidden as a generic header')
-  t.equal(
-    fastURI.parse(fastURI.serialize(parsed)).subject,
-    parsed.subject,
-    'the decoded subject remains stable after a roundtrip'
-  )
-  t.end()
-})

package/node_modules/fast-uri/test/scheme-normalization.test.js

@@ -1,16 +0,0 @@
-'use strict'
-
-const test = require('tape')
-const fastURI = require('..')
-
-test('scheme is normalized to lowercase (RFC 3986 §6.2.2.1)', (t) => {
-  // parse lowercases the scheme, consistent with how it already lowercases the host
-  t.equal(fastURI.parse('HTTP://EXAMPLE.com/Path').scheme, 'http', 'parse lowercases an uppercase scheme')
-  t.equal(fastURI.parse('HtTpS://example.com').scheme, 'https', 'parse lowercases a mixed-case scheme')
-
-  // normalize emits a lowercase scheme (matches the already-lowercased host)
-  t.equal(fastURI.normalize('HTTP://EXAMPLE.com/p'), 'http://example.com/p', 'normalize lowercases the scheme')
-  t.equal(fastURI.normalize('HtTp://Example.COM/'), 'http://example.com/', 'normalize lowercases a mixed-case scheme')
-
-  t.end()
-})

package/node_modules/fast-uri/types/index.tst.ts

@@ -1,31 +0,0 @@
-import uri, {
-  type URIComponent,
-} from '..'
-import { expect } from 'tstyche'
-
-const parsed = uri.parse('foo')
-expect(parsed).type.toBe<URIComponent>()
-
-const parsed2 = uri.parse('foo', {
-  domainHost: true,
-  scheme: 'https',
-  unicodeSupport: false
-})
-
-expect(parsed2).type.toBe<URIComponent>()
-
-const mailtoComponent: URIComponent = {
-  scheme: 'mailto',
-  to: ['user@example.org'],
-  subject: 'Hello',
-  body: 'Message',
-  headers: { cc: 'other@example.org' }
-}
-
-expect(uri.serialize(mailtoComponent, { unicodeSupport: true })).type.toBe<string>()
-
-const parsedMailto = uri.parse('mailto:user@example.org')
-expect(parsedMailto.to).type.toBe<string[] | undefined>()
-expect(parsedMailto.subject).type.toBe<string | undefined>()
-expect(parsedMailto.body).type.toBe<string | undefined>()
-expect(parsedMailto.headers).type.toBe<{ [hfname: string]: string } | undefined>()

package/node_modules/protobufjs/ext/README.md

@@ -1,70 +0,0 @@
-# protobuf.js Extensions
-
-## descriptor
-
-Optional `descriptor.proto` support for converting reflected protobuf.js roots and objects to and from descriptor messages.
-
-```js
-import protobuf from "protobufjs";
-import descriptor from "protobufjs/ext/descriptor.js";
-
-// Convert an existing root to a FileDescriptorSet message.
-const root = ...;
-const set = root.toDescriptor("proto2");
-
-// Encode descriptor buffers.
-const buffer = descriptor.FileDescriptorSet.encode(set).finish();
-
-// Convert a FileDescriptorSet message or buffer back to a root.
-const decodedRoot = protobuf.Root.fromDescriptor(buffer);
-```
-
-The extension requires reflection metadata and also works with `protobufjs/light.js` when schemas are loaded from JSON or otherwise provided as reflection objects.
-
-Importing the extension adds `.fromDescriptor(descriptor[, editionOrContext])` and `#toDescriptor([syntaxOrEdition])` methods to reflection objects and exports the bundled descriptor types from `google.protobuf`. Descriptor inputs can be decoded messages, readers, or buffers of the corresponding descriptor messages. Direct object descriptor imports accept either an edition string or a descriptor context with `edition`, `features` and `keepCase`.
-
-The conversion covers descriptor messages that correspond to protobuf.js reflection objects: files and file sets, messages, fields and map fields, oneofs, enums, services and methods. Descriptor-only metadata such as source locations, generated-code annotations and uninterpreted options remains available through the exported descriptor message types, but is not mapped onto reflection objects. File names are inferred when generating descriptors because roots do not retain exact file/package boundaries.
-
-## protojson
-
-Optional ProtoJSON support for reflected message types.
-
-> [!NOTE]
-> Specialized code generation for the `pbjs` static-module target is a potential future extension. If you need this for high-throughput JSON transcoding or REST fallbacks in production, consider getting in touch and supporting the codegen and conformance work.
-
-```js
-import protobuf from "protobufjs";
-import protojson from "protobufjs/ext/protojson.js";
-
-const root = ...;
-const MyType = root.lookupType("MyType");
-const message = protojson.fromJson(MyType, { value: 1 });
-const json = protojson.toJson(MyType, message);
-```
-
-```js
-const messageFromString = protojson.fromJsonString(MyType, '{"value":1}');
-const jsonString = protojson.toJsonString(MyType, messageFromString);
-```
-
-Importing the extension has no prototype side effects. Calling `protojson.install()` installs `fromJson`, `fromJsonString`, `toJson` and `toJsonString` convenience methods on `protobuf.Type.prototype`. It works with `protobufjs/light.js` when schemas are loaded from JSON or otherwise provided as reflection objects.
-
-Unknown fields can be ignored while parsing by passing `{ ignoreUnknownFields: true }` to `fromJson` or `fromJsonString`.
-
-## textformat
-
-Optional Text Format support for reflected message types.
-
-```js
-import protobuf from "protobufjs";
-import textformat from "protobufjs/ext/textformat.js";
-
-const root = ...;
-const MyType = root.lookupType("MyType");
-const message = textformat.fromText(MyType, "value: 1");
-const text = textformat.toText(MyType, message);
-```
-
-Importing the extension has no prototype side effects. Calling `textformat.install()` installs `fromText` and `toText` convenience methods on `protobuf.Type.prototype`. It works with `protobufjs/light.js` when schemas are loaded from JSON or otherwise provided as reflection objects.
-
-Unknown fields can be printed with numeric field names by passing `{ unknowns: true }` to `toText`.

package/node_modules/protobufjs/ext/descriptor.d.ts

@@ -1,87 +0,0 @@
-import * as $protobuf from "..";
-import {
-    IDescriptorProto,
-    IDescriptorContext,
-    IEnumDescriptorProto,
-    IFieldDescriptorProto,
-    IFileDescriptorSet,
-    IMethodDescriptorProto,
-    IOneofDescriptorProto,
-    IServiceDescriptorProto
-} from "./descriptor.generated";
-
-export * from "./descriptor.generated";
-
-type DescriptorInput<T> = T | $protobuf.Reader | Uint8Array;
-
-declare module ".." {
-    namespace Root {
-        /** Creates a root from a descriptor set. */
-        function fromDescriptor(descriptor: DescriptorInput<IFileDescriptorSet>, options?: { keepCase?: boolean }): $protobuf.Root;
-    }
-
-    interface Root {
-        /** Converts this root to a descriptor set. */
-        toDescriptor(edition?: string): $protobuf.Message<IFileDescriptorSet> & IFileDescriptorSet;
-    }
-
-    namespace Type {
-        /** Creates a type from a descriptor. */
-        function fromDescriptor(descriptor: DescriptorInput<IDescriptorProto>, editionOrContext?: string | IDescriptorContext): $protobuf.Type;
-    }
-
-    interface Type {
-        /** Converts this type to a descriptor. */
-        toDescriptor(edition?: string): $protobuf.Message<IDescriptorProto> & IDescriptorProto;
-    }
-
-    namespace Field {
-        /** Creates a field from a descriptor. */
-        function fromDescriptor(descriptor: DescriptorInput<IFieldDescriptorProto>, editionOrContext?: string | IDescriptorContext): $protobuf.Field;
-    }
-
-    interface Field {
-        /** Converts this field to a descriptor. */
-        toDescriptor(edition?: string): $protobuf.Message<IFieldDescriptorProto> & IFieldDescriptorProto;
-    }
-
-    namespace Enum {
-        /** Creates an enum from a descriptor. */
-        function fromDescriptor(descriptor: DescriptorInput<IEnumDescriptorProto>, editionOrContext?: string | IDescriptorContext): $protobuf.Enum;
-    }
-
-    interface Enum {
-        /** Converts this enum to a descriptor. */
-        toDescriptor(): $protobuf.Message<IEnumDescriptorProto> & IEnumDescriptorProto;
-    }
-
-    namespace OneOf {
-        /** Creates a oneof from a descriptor. */
-        function fromDescriptor(descriptor: DescriptorInput<IOneofDescriptorProto>, editionOrContext?: string | IDescriptorContext): $protobuf.OneOf;
-    }
-
-    interface OneOf {
-        /** Converts this oneof to a descriptor. */
-        toDescriptor(): $protobuf.Message<IOneofDescriptorProto> & IOneofDescriptorProto;
-    }
-
-    namespace Service {
-        /** Creates a service from a descriptor. */
-        function fromDescriptor(descriptor: DescriptorInput<IServiceDescriptorProto>, editionOrContext?: string | IDescriptorContext): $protobuf.Service;
-    }
-
-    interface Service {
-        /** Converts this service to a descriptor. */
-        toDescriptor(): $protobuf.Message<IServiceDescriptorProto> & IServiceDescriptorProto;
-    }
-
-    namespace Method {
-        /** Creates a method from a descriptor. */
-        function fromDescriptor(descriptor: DescriptorInput<IMethodDescriptorProto>, editionOrContext?: string | IDescriptorContext): $protobuf.Method;
-    }
-
-    interface Method {
-        /** Converts this method to a descriptor. */
-        toDescriptor(): $protobuf.Message<IMethodDescriptorProto> & IMethodDescriptorProto;
-    }
-}