@teammy/server 0.0.3 → 0.0.5

package/node_modules/fast-uri/test/urn-full-input.test.js

@@ -0,0 +1,47 @@
+'use strict'
+
+const test = require('tape')
+const fastURI = require('..')
+
+test('URN parsing validates the complete scheme-specific input', (t) => {
+  const embedded = fastURI.parse('urn:x|foo:bar')
+  t.equal(embedded.error, 'URN can not be parsed.', 'does not search for a later nid:nss substring')
+  t.equal(embedded.nid, undefined, 'does not adopt the later nid')
+  t.equal(embedded.nss, undefined, 'does not adopt the later nss')
+
+  const trailing = fastURI.parse('urn:foo:bar|ignored')
+  t.equal(trailing.error, 'URN can not be parsed.', 'rejects trailing input outside the RFC 2141 NSS grammar')
+  t.equal(trailing.nid, undefined, 'does not return an nid from a partial match')
+  t.equal(trailing.nss, undefined, 'does not return a truncated nss')
+
+  t.end()
+})
+
+test('URN parsing preserves the complete RFC 2141 NSS', (t) => {
+  const parsed = fastURI.parse('urn:foo:allowed/evil')
+  t.equal(parsed.error, undefined, 'accepts slash in an RFC 2141 NSS')
+  t.equal(parsed.nid, 'foo', 'parses the nid')
+  t.equal(parsed.nss, 'allowed/evil', 'preserves the complete NSS')
+  t.equal(fastURI.normalize('urn:foo:allowed/evil'), 'urn:foo:allowed/evil', 'normalization retains slash data')
+  t.equal(fastURI.equal('urn:foo:allowed/evil', 'urn:foo:allowed'), false, 'distinct NSS values do not compare equal')
+
+  t.end()
+})
+
+test('URN serialization preserves NSS dot segments', (t) => {
+  const urnWithDotSegments = 'urn:example:a/b/../c'
+  const destructiveDotSegments = 'urn:example:../../../etc/passwd'
+
+  t.equal(fastURI.serialize(fastURI.parse(urnWithDotSegments)), urnWithDotSegments, 'parsed NSS round-trips unchanged')
+  t.equal(
+    fastURI.serialize({ scheme: 'urn', nid: 'example', nss: '../../../etc/passwd' }),
+    destructiveDotSegments,
+    'structured NSS retains leading dot segments'
+  )
+  t.equal(fastURI.normalize(urnWithDotSegments), urnWithDotSegments, 'normalization retains interior dot segments')
+  t.equal(fastURI.normalize(destructiveDotSegments), destructiveDotSegments, 'normalization retains leading dot segments')
+  t.equal(fastURI.resolve('', urnWithDotSegments), urnWithDotSegments, 'resolution retains NSS dot segments')
+  t.equal(fastURI.equal(urnWithDotSegments, 'urn:example:a/c'), false, 'distinct NSS values do not compare equal')
+
+  t.end()
+})

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

@@ -0,0 +1,47 @@
+'use strict'
+
+const test = require('tape')
+const {
+  stringArrayToHexStripped,
+  removeDotSegments
+} = require('../lib/utils')
+
+test('stringArrayToHexStripped', (t) => {
+  const testCases = [
+    [['0', '0', '0', '0'], ''],
+    [['0', '0', '0', '1'], '1'],
+    [['0', '0', '1', '0'], '10'],
+    [['0', '1', '0', '0'], '100'],
+    [['1', '0', '0', '0'], '1000'],
+    [['1', '0', '0', '1'], '1001'],
+  ]
+
+  t.plan(testCases.length)
+
+  testCases.forEach(([input, expected]) => {
+    t.same(stringArrayToHexStripped(input), expected)
+  })
+})
+
+// Just fixtures, because this function already tested by resolve
+test('removeDotSegments', (t) => {
+  const testCases = []
+  // https://github.com/fastify/fast-uri/issues/139
+  testCases.push(['WS:/WS://1305G130505:1&%0D:1&C(XXXXX*)))))))XXX130505:UUVUaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa$aaaaaaaaaaaa13a',
+    'WS:/WS://1305G130505:1&%0D:1&C(XXXXX*)))))))XXX130505:UUVUaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa$aaaaaaaaaaaa13a'])
+  // trailing empty segments must be preserved: RFC 3986 5.2.4 only removes
+  // complete "." / ".." segments, never an empty segment
+  testCases.push(['//', '//'])
+  testCases.push(['/foo//', '/foo//'])
+  testCases.push(['/a/b//', '/a/b//'])
+  testCases.push(['/x//y//z', '/x//y//z'])
+  // "." / ".." segments still collapse
+  testCases.push(['/a/b/c/./../../g', '/a/g'])
+  testCases.push(['/.', '/'])
+
+  t.plan(testCases.length)
+
+  testCases.forEach(([input, expected]) => {
+    t.same(removeDotSegments(input), expected)
+  })
+})

package/node_modules/fast-uri/test/websocket-query-preservation.test.js

@@ -0,0 +1,24 @@
+'use strict'
+
+const test = require('tape')
+const fastURI = require('..')
+
+test('WebSocket queries preserve additional question marks', (t) => {
+  for (const scheme of ['ws', 'wss']) {
+    const uri = `${scheme}://example.com/chat?a?b`
+    const truncatedURI = `${scheme}://example.com/chat?a`
+    const parsed = fastURI.parse(uri)
+
+    t.equal(parsed.resourceName, '/chat?a?b', `${scheme} parse preserves the resource name`)
+    t.equal(fastURI.serialize(parsed), uri, `${scheme} parsed components round-trip`)
+    t.equal(
+      fastURI.serialize({ scheme, host: 'example.com', resourceName: '/chat?a?b' }),
+      uri,
+      `${scheme} resource name serializes without truncation`
+    )
+    t.equal(fastURI.normalize(uri), uri, `${scheme} normalization preserves the full query`)
+    t.equal(fastURI.equal(uri, truncatedURI), false, `${scheme} equality distinguishes the full query`)
+  }
+
+  t.end()
+})

package/node_modules/fast-uri/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "allowJs": true,
+    "checkJs": true,
+    "strict": true,
+    "noImplicitAny": true,
+    "target": "es2022",
+    "noEmit": true
+  }
+}

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

@@ -0,0 +1,71 @@
+type FastUri = typeof fastUri
+
+declare namespace fastUri {
+  export interface URIComponent {
+    scheme?: string;
+    userinfo?: string;
+    host?: string;
+    /**
+     * Zone identifier of a zoned IPv6 host, e.g. `"eth0"` or `"25eth0"`. Set by
+     * `parse` for a bracketed IPv6 literal so `serialize`/`normalize` can
+     * reproduce the exact zone without re-deriving it from the ambiguous
+     * single-`%` form. It is validated on use, so a value that does not match
+     * `host` (for example after `host` is reassigned) is ignored.
+     *
+     * When building a component object by hand, set `ipv6Zone` to disambiguate
+     * a single-`%` host whose zone is ambiguous (a zone beginning with `25`
+     * is re-read as a `%25` separator). Without it, `serialize` falls back to
+     * a best-effort heuristic and may reinterpret such a zone, e.g. `{ host:
+     * "fe80::1%25eth0" }` serializes to `[fe80::1%25eth0]` (zone `eth0`), while
+     * `{ host: "fe80::1%25eth0", ipv6Zone: "25eth0" }` serializes to
+     * `[fe80::1%2525eth0]` (zone `25eth0`).
+     */
+    ipv6Zone?: string;
+    port?: number | string;
+    path?: string;
+    query?: string;
+    fragment?: string;
+    reference?: string;
+    nid?: string;
+    nss?: string;
+    resourceName?: string;
+    secure?: boolean;
+    uuid?: string;
+    error?: string;
+    to?: string[];
+    subject?: string;
+    body?: string;
+    headers?: { [hfname: string]: string };
+  }
+  export interface Options {
+    scheme?: string;
+    reference?: string;
+    unicodeSupport?: boolean;
+    domainHost?: boolean;
+    absolutePath?: boolean;
+    tolerant?: boolean;
+    skipEscape?: boolean;
+    nid?: string;
+  }
+
+  export function normalize (uri: string, opts?: Options): string
+  export function normalize (uri: URIComponent, opts?: Options): URIComponent
+  export function normalize (uri: any, opts?: Options): any
+
+  export function resolve (baseURI: string, relativeURI: string, options?: Options): string
+
+  export function resolveComponent (base: URIComponent, relative: URIComponent, options?: Options, skipNormalization?: boolean): URIComponent
+
+  export function parse (uri: string, opts?: Options): URIComponent
+
+  export function serialize (component: URIComponent, opts?: Options): string
+
+  export function equal (uriA: string, uriB: string): boolean
+
+  export function resolve (base: string, path: string): string
+
+  export const fastUri: FastUri
+  export { fastUri as default }
+}
+
+export = fastUri

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

@@ -0,0 +1,31 @@
+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/fastify/.borp.yaml

@@ -0,0 +1,3 @@
+files:
+  - 'test/**/*.test.js'
+  - 'test/**/*.test.mjs'

package/node_modules/fastify/.markdownlint-cli2.yaml

@@ -0,0 +1,22 @@
+# See https://github.com/DavidAnson/markdownlint-cli2
+config:
+  # Disable all rules by default.
+  default: false
+
+  # Enforce line length.
+  MD013:
+    line_length: 80
+    code_block_line_length: 120
+    headings: false
+    tables: false
+    strict: false
+    stern: false
+
+globs:
+  - '**/*.md'
+
+ignores:
+  - 'node_modules/**'
+  - 'test/**/*.md'
+
+noProgress: true

package/node_modules/fastify/.prettierignore

@@ -0,0 +1 @@
+*

package/node_modules/fastify/GOVERNANCE.md

@@ -0,0 +1,4 @@
+# Fastify Project Governance
+
+Please see Fastify's [organization-wide governance
+](https://github.com/fastify/.github/blob/main/GOVERNANCE.md) document.

package/node_modules/fastify/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016-present The Fastify team <https://github.com/fastify/fastify#team>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/fastify/PROJECT_CHARTER.md

@@ -0,0 +1,126 @@
+# Fastify Charter
+
+The Fastify project aims to build a fast and low-overhead web framework for
+Node.js.
+
+
+## Section 0: Guiding Principles
+
+The Fastify project is part of the [OpenJS Foundation][openjs foundation]. It
+operates transparently, openly, collaboratively, and ethically. Project
+proposals, timelines, and status must not merely be open, but also easily
+visible to outsiders.
+
+
+## Section 1: Scope
+
+Fastify is a web framework highly focused on providing the best developer
+experience with the least overhead and a plugin architecture.
+
+### 1.1: In-scope
+
++ Develop a web framework for Node.js with a focus on developer experience,
+  performance, and extensibility.
++ Plugin Architecture
++ Support web protocols
++ Official plugins for common user requirements
++ Documentation:
+  + Project (policies, processes, and releases)
+  + Guides and Tutorials
+  + Framework API
+  + Website
++ Write easier APIs for developers
++ Tools:
+  + CI services
+  + Bots to improve overall efficiency
+  + Releases
++ Support:
+  + Community
+  + Users's issues and questions
++ Contributors's pull request review
+
+### 1.2: Out-of-Scope
+
++ Support versions of Node.js at EOL (end of life) stage
++ Support serverless architecture
++ Contributions that violate the [Code of Conduct](CODE_OF_CONDUCT.md)
+
+
+## Section 2: Relationship with OpenJS Foundation CPC.
+
+Technical leadership for the projects within the [OpenJS Foundation][openjs
+foundation] is delegated to the projects through their project charters by the
+[OpenJS Foundation Cross-Project Council](https://openjsf.org/governance)
+(CPC). In the case of the Fastify project, it is delegated to the [Fastify
+Collaborators](README.md#team). The OpenJS Foundation's business leadership is
+the Board of Directors (the "Board").
+
+This Fastify Charter reflects a carefully constructed balanced role for the
+Collaborators and the CPC in the governance of the OpenJS Foundation. The
+charter amendment process is for the Fastify Collaborators to propose change
+using a majority of the full Fastify Organization, the proposed changes
+being subject to review and approval by the CPC. The CPC may additionally make
+amendments to the Collaborators charter at any time, though the CPC will not
+interfere with day-to-day discussions, votes, or meetings of the Fastify
+Organization.
+
+
+### 2.1 Other Formal Project Relationships
+
+Section Intentionally Left Blank
+
+
+## Section 3: Fastify Governing Body
+
+Fastify is governed by its [maintainers](README.md#team). See [how it is
+structured](GOVERNANCE.md) for more information.
+
+
+## Section 4: Roles & Responsibilities
+
+The roles and responsibilities of Fastify's maintainers are described in [the
+project organization](GOVERNANCE.md).
+
+### Section 4.1 Project Operations & Management
+
+Section Intentionally Left Blank
+
+### Section 4.2: Decision-making, Voting, and/or Elections
+
+**Decision-making**
+
+Fastify's features can be discussed in GitHub issues and/or projects. Consensus
+on a discussion is reached when there is no objection by any collaborators.
+
+When there is no consensus, Lead Maintainers will have the final say on the
+topic.
+
+**Voting, and/or Elections**
+
+These processes are described in the [GOVERNANCE](GOVERNANCE.md) document.
+
+### Section 4.3: Other Project Roles
+
+Section Intentionally Left Blank
+
+## Section 5: Definitions
+
++ *Contributors*: contribute code or other artifacts, but do not have the right
+  to commit to the code base. Contributors work with the project’s Collaborators
+  to have code committed to the code base. Contributors should rarely be
+  encumbered by the Fastify Collaborators and never by the CPC or OpenJS
+  Foundation Board.
+
++ *Collaborators*: contribute code and other artifacts, have the right to commit
+  to the code base, and release plugin projects. Collaborators follow the
+  [CONTRIBUTING](CONTRIBUTING.md) guidelines to manage the project. A
+  Collaborator could be encumbered by other Fastify Collaborators and never by
+  the CPC or OpenJS Foundation Board.
+
++ *Lead Maintainers*: founders of the project, contribute code and other
+  artifacts, have the right to commit to the code base and release the project.
+  Lead Maintainers follow the [CONTRIBUTING](CONTRIBUTING.md) guidelines to
+  manage the project. A Lead Maintainer will be encumbered by the Fastify
+  Collaborators and by the CPC or OpenJS Foundation Board.
+
+[openjs foundation]: https://openjsf.org