nexus-agents 14.0.0 → 14.0.2

package/node_modules/hono/dist/types/middleware/jsx-renderer/index.d.ts

@@ -1,8 +1,8 @@
 import { Env, Input, MiddlewareHandler } from "../../types.js";
 import { Context, PropsForRenderer } from "../../context.js";
-import { PropsWithChildren } from "../../jsx/types.js";
-import { Context as Context$1 } from "../../jsx/context.js";
-import { FC } from "../../jsx/base.js";
+import { PropsWithChildren } from "../../jsx/index.js";
+import { Context as Context$1 } from "../../jsx/index.js";
+import { FC } from "../../jsx/index.js";
 //#region src/middleware/jsx-renderer/index.d.ts
 export declare const RequestContext: Context$1<Context<any, any, {}> | null>;
 type RendererOptions = {

package/node_modules/hono/dist/types/utils/ipaddr.d.ts

@@ -1,4 +1,4 @@
-import { AddressType } from "../helper/conninfo/types.js";
+import { AddressType } from "../helper/conninfo/index.js";
 //#region src/utils/ipaddr.d.ts
 /**
  * Expand IPv6 Address

package/node_modules/hono/dist/utils/url.js

@@ -153,16 +153,21 @@ const _getQueryParam = (url, key, multiple) => {
 	if (hashIndex !== -1) url = url.slice(0, hashIndex);
 	let encoded;
 	if (!multiple && key && key.indexOf("%") === -1 && key.indexOf("+") === -1) {
-		let keyIndex = url.indexOf("?", 8);
+		const queryIndex = url.indexOf("?", 8);
+		let keyIndex = queryIndex;
 		if (keyIndex === -1) return;
 		if (!url.startsWith(key, keyIndex + 1)) keyIndex = url.indexOf(`&${key}`, keyIndex + 1);
 		while (keyIndex !== -1) {
 			const trailingKeyCode = url.charCodeAt(keyIndex + key.length + 1);
-			if (trailingKeyCode === 61) {
-				const valueIndex = keyIndex + key.length + 2;
-				const endIndex = url.indexOf("&", valueIndex);
-				return _decodeURI(url.slice(valueIndex, endIndex === -1 ? void 0 : endIndex));
-			} else if (trailingKeyCode == 38 || isNaN(trailingKeyCode)) return "";
+			if (trailingKeyCode === 61 || trailingKeyCode === 38 || isNaN(trailingKeyCode)) {
+				if (keyIndex > queryIndex && /(?:^|&)[^=&]*[%+]/.test(url.slice(queryIndex + 1, keyIndex))) break;
+				if (trailingKeyCode === 61) {
+					const valueIndex = keyIndex + key.length + 2;
+					const endIndex = url.indexOf("&", valueIndex);
+					return _decodeURI(url.slice(valueIndex, endIndex === -1 ? void 0 : endIndex));
+				}
+				return "";
+			}
 			keyIndex = url.indexOf(`&${key}`, keyIndex + 1);
 		}
 		encoded = /[%+]/.test(url);

package/node_modules/hono/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hono",
-  "version": "4.13.13",
+  "version": "4.13.14",
   "description": "Web framework built on Web Standards",
   "main": "dist/cjs/index.js",
   "type": "module",

package/node_modules/ip-address/dist/common.js

@@ -145,10 +145,10 @@ function stringToPaddedHex(numberString) {
  */
 function testBit(binaryValue, position) {
     const { length } = binaryValue;
-    if (position > length) {
+    if (position >= length) {
         return false;
     }
-    const positionInString = length - position;
+    const positionInString = length - position - 1;
     return binaryValue.substring(positionInString, positionInString + 1) === '1';
 }
 //# sourceMappingURL=common.js.map

package/node_modules/ip-address/dist/common.js.map

@@ -1 +1 @@
-{"version":3,"file":"common.js","sourceRoot":"","sources":["../src/common.ts"],"names":[],"mappings":"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","sourcesContent":["import { Address4 } from './ipv4';\nimport { Address6 } from './ipv6';\nimport { AddressError } from './address-error';\n\nexport interface ReverseFormOptions {\n  omitSuffix?: boolean;\n}\n\n/**\n * Returns whether this address's *network* is contained within `address`,\n * i.e. whether every address this one can represent also falls inside\n * `address`. A network wider than `address` is not contained in it, so\n * `10.0.0.0/8` is not in `10.0.0.0/16`.\n *\n * To ask whether the address itself falls inside a range, ignoring any CIDR\n * suffix it was written with, use {@link isHostInSubnet} instead. That is the\n * question the special-use classifiers ask.\n */\nexport function isInSubnet(this: Address4 | Address6, address: Address4 | Address6) {\n  if (this.subnetMask < address.subnetMask) {\n    return false;\n  }\n\n  return isHostInSubnet.call(this, address);\n}\n\n/**\n * Returns whether this address's host bits fall inside `address`, ignoring\n * this address's own subnet mask.\n *\n * This is the primitive the special-use classifiers (`isLoopback`,\n * `isPrivate`, `isLinkLocal`, `getType`, …) are built on: they answer a\n * question about the address, so the answer must not change with the CIDR\n * suffix the caller happened to write. Use this rather than\n * {@link isInSubnet} when classifying a single address — notably when the\n * address came from untrusted input and the result backs a trust-boundary\n * decision such as an SSRF allow/deny filter.\n *\n * An address of one family is never inside a network of the other, so an\n * `Address4` against an `Address6` (or the reverse) is `false`. To compare\n * across families, convert first: `Address6.fromAddress4()`, `to4()`, or\n * `toAddress4Nat64()`.\n */\nexport function isHostInSubnet(this: Address4 | Address6, address: Address4 | Address6) {\n  // mask() is a bit string of the family's width, and the leading bits of a\n  // 32-bit string can coincide with those of a 128-bit one (a00::1 and\n  // 10.0.0.0/8 both mask to 00001010), so the widths must agree before the\n  // strings are compared.\n  if (this.binaryZeroPad().length !== address.binaryZeroPad().length) {\n    return false;\n  }\n\n  return this.mask(address.subnetMask) === address.mask();\n}\n\n/**\n * One parsed row of an IANA special-purpose address registry: the block, and\n * whether the registry marks it globally reachable (`null` when the column is\n * blank, in which case the containing block answers).\n */\nexport interface SpecialPurposeEntry<A extends Address4 | Address6> {\n  subnet: A;\n  reachable: boolean | null;\n}\n\n/**\n * Returns whether the registry marks this address globally reachable: the\n * answer of the most specific entry containing it that has one, or `true`\n * when no entry contains it.\n */\nexport function isGloballyReachable<A extends Address4 | Address6>(\n  this: A,\n  entries: ReadonlyArray<SpecialPurposeEntry<A>>,\n): boolean {\n  let best: SpecialPurposeEntry<A> | null = null;\n\n  for (let i = 0; i < entries.length; i++) {\n    const entry = entries[i];\n\n    if (\n      entry.reachable !== null &&\n      isHostInSubnet.call(this, entry.subnet) &&\n      (best === null || entry.subnet.subnetMask > best.subnet.subnetMask)\n    ) {\n      best = entry;\n    }\n  }\n\n  return best === null ? true : (best.reachable as boolean);\n}\n\n/**\n * Adds `n` to `value` and returns the result, throwing `AddressError` unless\n * `n` is an integer and the result stays within `[0, 2**bits - 1]`.\n */\nexport function offsetBigInt(\n  value: bigint,\n  n: number | bigint,\n  bits: number,\n  family: string,\n): bigint {\n  if (typeof n === 'number' && !Number.isSafeInteger(n)) {\n    throw new AddressError(`${family} offset must be an integer`);\n  }\n\n  if (typeof n !== 'number' && typeof n !== 'bigint') {\n    throw new AddressError(`${family} offset must be an integer`);\n  }\n\n  const result = value + BigInt(n);\n\n  if (result < BigInt(0) || result > (BigInt(1) << BigInt(bits)) - BigInt(1)) {\n    throw new AddressError(`${family} offset leaves the address space`);\n  }\n\n  return result;\n}\n\nexport function isCorrect(defaultBits: number) {\n  return function isCorrectForm(this: Address4 | Address6) {\n    if (this.addressMinusSuffix !== this.correctForm()) {\n      return false;\n    }\n\n    if (this.subnetMask === defaultBits && !this.parsedSubnet) {\n      return true;\n    }\n\n    return this.parsedSubnet === String(this.subnetMask);\n  };\n}\n\n/**\n * Returns the prefix length (number of leading 1 bits) of a contiguous\n * subnet mask. Throws `AddressError` if the mask is non-contiguous (e.g.\n * `255.0.255.0`).\n */\nexport function prefixLengthFromMask(value: bigint, totalBits: number): number {\n  const binary = value.toString(2).padStart(totalBits, '0');\n\n  if (binary.length > totalBits) {\n    throw new AddressError('Invalid subnet mask.');\n  }\n\n  const firstZero = binary.indexOf('0');\n\n  if (firstZero === -1) {\n    return totalBits;\n  }\n\n  if (binary.slice(firstZero).includes('1')) {\n    throw new AddressError('Invalid subnet mask.');\n  }\n\n  return firstZero;\n}\n\n/**\n * Throws `AddressError` unless `bytes` holds exactly `byteCount` integers,\n * each from `minimum` to 255. Pass a `minimum` of `-128` where signed bytes\n * are accepted and folded to unsigned, and `0` where they are not.\n */\nexport function assertByteArray(\n  bytes: number[],\n  byteCount: number,\n  family: 'IPv4' | 'IPv6',\n  minimum: number,\n): void {\n  if (bytes.length !== byteCount) {\n    throw new AddressError(`${family} addresses require exactly ${byteCount} bytes`);\n  }\n\n  for (let i = 0; i < bytes.length; i++) {\n    if (!Number.isInteger(bytes[i]) || bytes[i] < minimum || bytes[i] > 255) {\n      throw new AddressError(`All bytes must be integers between ${minimum} and 255`);\n    }\n  }\n}\n\nexport function numberToPaddedHex(number: number) {\n  return number.toString(16).padStart(2, '0');\n}\n\nexport function stringToPaddedHex(numberString: string) {\n  return numberToPaddedHex(parseInt(numberString, 10));\n}\n\n/**\n * @param binaryValue Binary representation of a value (e.g. `10`)\n * @param position Byte position, where 0 is the least significant bit\n */\nexport function testBit(binaryValue: string, position: number): boolean {\n  const { length } = binaryValue;\n\n  if (position > length) {\n    return false;\n  }\n\n  const positionInString = length - position;\n  return binaryValue.substring(positionInString, positionInString + 1) === '1';\n}\n"]}
+{"version":3,"file":"common.js","sourceRoot":"","sources":["../src/common.ts"],"names":[],"mappings":"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","sourcesContent":["import { Address4 } from './ipv4';\nimport { Address6 } from './ipv6';\nimport { AddressError } from './address-error';\n\nexport interface ReverseFormOptions {\n  omitSuffix?: boolean;\n}\n\n/**\n * Returns whether this address's *network* is contained within `address`,\n * i.e. whether every address this one can represent also falls inside\n * `address`. A network wider than `address` is not contained in it, so\n * `10.0.0.0/8` is not in `10.0.0.0/16`.\n *\n * To ask whether the address itself falls inside a range, ignoring any CIDR\n * suffix it was written with, use {@link isHostInSubnet} instead. That is the\n * question the special-use classifiers ask.\n */\nexport function isInSubnet(this: Address4 | Address6, address: Address4 | Address6) {\n  if (this.subnetMask < address.subnetMask) {\n    return false;\n  }\n\n  return isHostInSubnet.call(this, address);\n}\n\n/**\n * Returns whether this address's host bits fall inside `address`, ignoring\n * this address's own subnet mask.\n *\n * This is the primitive the special-use classifiers (`isLoopback`,\n * `isPrivate`, `isLinkLocal`, `getType`, …) are built on: they answer a\n * question about the address, so the answer must not change with the CIDR\n * suffix the caller happened to write. Use this rather than\n * {@link isInSubnet} when classifying a single address — notably when the\n * address came from untrusted input and the result backs a trust-boundary\n * decision such as an SSRF allow/deny filter.\n *\n * An address of one family is never inside a network of the other, so an\n * `Address4` against an `Address6` (or the reverse) is `false`. To compare\n * across families, convert first: `Address6.fromAddress4()`, `to4()`, or\n * `toAddress4Nat64()`.\n */\nexport function isHostInSubnet(this: Address4 | Address6, address: Address4 | Address6) {\n  // mask() is a bit string of the family's width, and the leading bits of a\n  // 32-bit string can coincide with those of a 128-bit one (a00::1 and\n  // 10.0.0.0/8 both mask to 00001010), so the widths must agree before the\n  // strings are compared.\n  if (this.binaryZeroPad().length !== address.binaryZeroPad().length) {\n    return false;\n  }\n\n  return this.mask(address.subnetMask) === address.mask();\n}\n\n/**\n * One parsed row of an IANA special-purpose address registry: the block, and\n * whether the registry marks it globally reachable (`null` when the column is\n * blank, in which case the containing block answers).\n */\nexport interface SpecialPurposeEntry<A extends Address4 | Address6> {\n  subnet: A;\n  reachable: boolean | null;\n}\n\n/**\n * Returns whether the registry marks this address globally reachable: the\n * answer of the most specific entry containing it that has one, or `true`\n * when no entry contains it.\n */\nexport function isGloballyReachable<A extends Address4 | Address6>(\n  this: A,\n  entries: ReadonlyArray<SpecialPurposeEntry<A>>,\n): boolean {\n  let best: SpecialPurposeEntry<A> | null = null;\n\n  for (let i = 0; i < entries.length; i++) {\n    const entry = entries[i];\n\n    if (\n      entry.reachable !== null &&\n      isHostInSubnet.call(this, entry.subnet) &&\n      (best === null || entry.subnet.subnetMask > best.subnet.subnetMask)\n    ) {\n      best = entry;\n    }\n  }\n\n  return best === null ? true : (best.reachable as boolean);\n}\n\n/**\n * Adds `n` to `value` and returns the result, throwing `AddressError` unless\n * `n` is an integer and the result stays within `[0, 2**bits - 1]`.\n */\nexport function offsetBigInt(\n  value: bigint,\n  n: number | bigint,\n  bits: number,\n  family: string,\n): bigint {\n  if (typeof n === 'number' && !Number.isSafeInteger(n)) {\n    throw new AddressError(`${family} offset must be an integer`);\n  }\n\n  if (typeof n !== 'number' && typeof n !== 'bigint') {\n    throw new AddressError(`${family} offset must be an integer`);\n  }\n\n  const result = value + BigInt(n);\n\n  if (result < BigInt(0) || result > (BigInt(1) << BigInt(bits)) - BigInt(1)) {\n    throw new AddressError(`${family} offset leaves the address space`);\n  }\n\n  return result;\n}\n\nexport function isCorrect(defaultBits: number) {\n  return function isCorrectForm(this: Address4 | Address6) {\n    if (this.addressMinusSuffix !== this.correctForm()) {\n      return false;\n    }\n\n    if (this.subnetMask === defaultBits && !this.parsedSubnet) {\n      return true;\n    }\n\n    return this.parsedSubnet === String(this.subnetMask);\n  };\n}\n\n/**\n * Returns the prefix length (number of leading 1 bits) of a contiguous\n * subnet mask. Throws `AddressError` if the mask is non-contiguous (e.g.\n * `255.0.255.0`).\n */\nexport function prefixLengthFromMask(value: bigint, totalBits: number): number {\n  const binary = value.toString(2).padStart(totalBits, '0');\n\n  if (binary.length > totalBits) {\n    throw new AddressError('Invalid subnet mask.');\n  }\n\n  const firstZero = binary.indexOf('0');\n\n  if (firstZero === -1) {\n    return totalBits;\n  }\n\n  if (binary.slice(firstZero).includes('1')) {\n    throw new AddressError('Invalid subnet mask.');\n  }\n\n  return firstZero;\n}\n\n/**\n * Throws `AddressError` unless `bytes` holds exactly `byteCount` integers,\n * each from `minimum` to 255. Pass a `minimum` of `-128` where signed bytes\n * are accepted and folded to unsigned, and `0` where they are not.\n */\nexport function assertByteArray(\n  bytes: number[],\n  byteCount: number,\n  family: 'IPv4' | 'IPv6',\n  minimum: number,\n): void {\n  if (bytes.length !== byteCount) {\n    throw new AddressError(`${family} addresses require exactly ${byteCount} bytes`);\n  }\n\n  for (let i = 0; i < bytes.length; i++) {\n    if (!Number.isInteger(bytes[i]) || bytes[i] < minimum || bytes[i] > 255) {\n      throw new AddressError(`All bytes must be integers between ${minimum} and 255`);\n    }\n  }\n}\n\nexport function numberToPaddedHex(number: number) {\n  return number.toString(16).padStart(2, '0');\n}\n\nexport function stringToPaddedHex(numberString: string) {\n  return numberToPaddedHex(parseInt(numberString, 10));\n}\n\n/**\n * @param binaryValue Binary representation of a value (e.g. `10`)\n * @param position Byte position, where 0 is the least significant bit\n */\nexport function testBit(binaryValue: string, position: number): boolean {\n  const { length } = binaryValue;\n\n  if (position >= length) {\n    return false;\n  }\n\n  const positionInString = length - position - 1;\n  return binaryValue.substring(positionInString, positionInString + 1) === '1';\n}\n"]}

package/node_modules/ip-address/package.json

@@ -16,7 +16,7 @@
     "bigint",
     "browser"
   ],
-  "version": "10.7.4",
+  "version": "10.7.5",
   "author": "Beau Gunderson <beau@beaugunderson.com> (https://beaugunderson.com/)",
   "license": "MIT",
   "main": "dist/ip-address.js",
@@ -80,7 +80,7 @@
     "eslint-plugin-import": "^2.32.0",
     "eslint-plugin-prettier": "^5.5.5",
     "eslint-plugin-sort-imports-es6-autofix": "^0.6.0",
-    "mocha": "^11.7.5",
+    "mocha": "^12.0.3",
     "monocart-coverage-reports": "^2.12.11",
     "prettier": "^3.8.3",
     "source-map-support": "^0.5.21",

package/node_modules/path-to-regexp/Readme.md

@@ -17,7 +17,13 @@ npm install path-to-regexp --save
 ## Usage
 
 ```js
-import { match, pathToRegexp, compile, parse, stringify } from "path-to-regexp";
+const {
+  match,
+  pathToRegexp,
+  compile,
+  parse,
+  stringify,
+} = require("path-to-regexp");
 ```
 
 ### Parameters

package/node_modules/path-to-regexp/dist/index.d.ts

@@ -72,12 +72,16 @@ export interface Wildcard {
  */
 export interface Group {
     type: "group";
-    tokens: readonly Token[];
+    tokens: Token[];
 }
 /**
- * Tokens that corresponds with a regexp capture.
+ * A token that corresponds with a regexp capture.
  */
 export type Key = Parameter | Wildcard;
+/**
+ * A sequence of `path-to-regexp` keys that match capturing groups.
+ */
+export type Keys = Array<Key>;
 /**
  * A sequence of path match characters.
  */
@@ -85,9 +89,10 @@ export type Token = Text | Parameter | Wildcard | Group;
 /**
  * Tokenized path instance.
  */
-export interface TokenData {
-    tokens: readonly Token[];
-    originalPath?: string;
+export declare class TokenData {
+    readonly tokens: Token[];
+    readonly originalPath?: string | undefined;
+    constructor(tokens: Token[], originalPath?: string | undefined);
 }
 /**
  * ParseError is thrown when there is an error processing the path.
@@ -122,7 +127,7 @@ export type Match<P extends ParamData> = false | MatchResult<P>;
  */
 export type MatchFunction<P extends ParamData> = (path: string) => Match<P>;
 /**
- * Supported path inputs.
+ * Supported path types.
  */
 export type Path = string | TokenData;
 /**
@@ -134,7 +139,7 @@ export declare function match<P extends ParamData>(path: Path | Path[], options?
  */
 export declare function pathToRegexp(path: Path | Path[], options?: PathToRegexpOptions & ParseOptions): {
     regexp: RegExp;
-    keys: Key[];
+    keys: Keys;
 };
 /**
  * Stringify token data into a path string.

package/node_modules/path-to-regexp/dist/index.js

@@ -1,3 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathError = exports.TokenData = void 0;
+exports.parse = parse;
+exports.compile = compile;
+exports.match = match;
+exports.pathToRegexp = pathToRegexp;
+exports.stringify = stringify;
 const DEFAULT_DELIMITER = "/";
 const NOOP_VALUE = (value) => value;
 const ID_START = /^[$_\p{ID_Start}]$/u;
@@ -15,22 +23,34 @@ function escapeText(str) {
 function escape(str) {
     return str.replace(/[.+*?^${}()[\]|/\\]/g, "\\$&");
 }
+/**
+ * Tokenized path instance.
+ */
+class TokenData {
+    constructor(tokens, originalPath) {
+        this.tokens = tokens;
+        this.originalPath = originalPath;
+    }
+}
+exports.TokenData = TokenData;
 /**
  * ParseError is thrown when there is an error processing the path.
  */
-export class PathError extends TypeError {
-    originalPath;
+class PathError extends TypeError {
     constructor(message, originalPath) {
-        super(message +
-            (originalPath ? `: ${originalPath}` : "") +
-            "; visit https://git.new/pathToRegexpError for info");
+        let text = message;
+        if (originalPath)
+            text += `: ${originalPath}`;
+        text += `; visit https://git.new/pathToRegexpError for info`;
+        super(text);
         this.originalPath = originalPath;
     }
 }
+exports.PathError = PathError;
 /**
  * Parse a string for the raw tokens.
  */
-export function parse(str, options = {}) {
+function parse(str, options = {}) {
     const { encodePath = NOOP_VALUE } = options;
     const chars = [...str];
     let index = 0;
@@ -47,20 +67,20 @@ export function parse(str, options = {}) {
             path = "";
         }
         while (index < chars.length) {
-            const char = chars[index++];
-            if (char === end) {
+            const value = chars[index++];
+            if (value === end) {
                 writePath();
                 return output;
             }
-            if (char === "\\") {
+            if (value === "\\") {
                 if (index === chars.length) {
                     throw new PathError(`Unexpected end after \\ at index ${index}`, str);
                 }
                 path += chars[index++];
                 continue;
             }
-            if (char === ":" || char === "*") {
-                const type = char === ":" ? "param" : "wildcard";
+            if (value === ":" || value === "*") {
+                const type = value === ":" ? "param" : "wildcard";
                 let name = "";
                 if (ID_START.test(chars[index])) {
                     do {
@@ -91,7 +111,7 @@ export function parse(str, options = {}) {
                 output.push({ type, name });
                 continue;
             }
-            if (char === "{") {
+            if (value === "{") {
                 writePath();
                 output.push({
                     type: "group",
@@ -99,10 +119,17 @@ export function parse(str, options = {}) {
                 });
                 continue;
             }
-            if ("}()[]+?!".includes(char)) {
-                throw new PathError(`Unexpected ${char} at index ${index - 1}`, str);
+            if (value === "}" ||
+                value === "(" ||
+                value === ")" ||
+                value === "[" ||
+                value === "]" ||
+                value === "+" ||
+                value === "?" ||
+                value === "!") {
+                throw new PathError(`Unexpected ${value} at index ${index - 1}`, str);
             }
-            path += char;
+            path += value;
         }
         if (end) {
             throw new PathError(`Unexpected end at index ${index}, expected ${end}`, str);
@@ -110,15 +137,12 @@ export function parse(str, options = {}) {
         writePath();
         return output;
     }
-    return {
-        tokens: consumeUntil(""),
-        originalPath: str,
-    };
+    return new TokenData(consumeUntil(""), str);
 }
 /**
  * Compile a string to a template function for the path.
  */
-export function compile(path, options = {}) {
+function compile(path, options = {}) {
     const { encode = encodeURIComponent, delimiter = DEFAULT_DELIMITER } = options;
     const data = typeof path === "object" ? path : parse(path, options);
     const fn = tokensToFunction(data.tokens, delimiter, encode);
@@ -178,9 +202,6 @@ function tokenToFunction(token, delimiter, encode) {
                     result += delimiter;
                 result += encodeValue(value[i]);
             }
-            if (!result) {
-                throw new TypeError(`Expected "${token.name}" to be a non-empty array`);
-            }
             return result;
         };
     }
@@ -190,8 +211,8 @@ function tokenToFunction(token, delimiter, encode) {
             missing.push(token.name);
             return "";
         }
-        if (typeof value !== "string" || value.length === 0) {
-            throw new TypeError(`Expected "${token.name}" to be a non-empty string`);
+        if (typeof value !== "string") {
+            throw new TypeError(`Expected "${token.name}" to be a string`);
         }
         return encodeValue(value);
     };
@@ -199,7 +220,7 @@ function tokenToFunction(token, delimiter, encode) {
 /**
  * Transform a path into a match function.
  */
-export function match(path, options = {}) {
+function match(path, options = {}) {
     const { decode = decodeURIComponent, delimiter = DEFAULT_DELIMITER } = options;
     const { regexp, keys } = pathToRegexp(path, options);
     const decoders = keys.map((key) => {
@@ -228,7 +249,7 @@ export function match(path, options = {}) {
 /**
  * Transform a path into a regular expression and capture keys.
  */
-export function pathToRegexp(path, options = {}) {
+function pathToRegexp(path, options = {}) {
     const { delimiter = DEFAULT_DELIMITER, end = true, sensitive = false, trailing = true, } = options;
     const keys = [];
     let source = "";
@@ -246,12 +267,14 @@ export function pathToRegexp(path, options = {}) {
             }
             if (combinations > 0)
                 source += "|";
-            source += toRegExpSource(tokens, delimiter, keys, data.originalPath, trailing);
+            source += toRegExpSource(tokens, delimiter, keys, data.originalPath);
             combinations++;
         });
     }
     process(path);
     let pattern = `^(?:${source})`;
+    if (trailing)
+        pattern += "(?:" + escape(delimiter) + "$)?";
     pattern += end ? "$" : "(?=" + escape(delimiter) + "|$)";
     return { regexp: new RegExp(pattern, sensitive ? "" : "i"), keys };
 }
@@ -274,82 +297,77 @@ function flatten(tokens, index, result, callback) {
 /**
  * Transform a flat sequence of tokens into a regular expression.
  */
-function toRegExpSource(tokens, delimiter, keys, originalPath, trailing) {
+function toRegExpSource(tokens, delimiter, keys, originalPath) {
     let result = "";
-    let prefix = "";
-    let hasWildcardAhead = false;
-    let hasSegmentWildcard = false;
+    let backtrack = "";
     let wildcardBacktrack = "";
+    let prevCaptureType = 0;
+    let hasSegmentCapture = 0;
     let index = 0;
-    function seekWildcard(index) {
+    function hasInSegment(index, type) {
         while (index < tokens.length) {
             const token = tokens[index++];
-            if (token.type === "wildcard")
+            if (token.type === type)
                 return true;
+            if (token.type === "text") {
+                if (token.value.includes(delimiter))
+                    break;
+            }
         }
         return false;
     }
-    function textRemaining(index) {
+    function peekText(index) {
         let result = "";
         while (index < tokens.length) {
             const token = tokens[index++];
             if (token.type !== "text")
-                return result;
-            if (token.value.includes(delimiter))
                 break;
             result += token.value;
         }
+        return result;
     }
     while (index < tokens.length) {
         const token = tokens[index++];
         if (token.type === "text") {
-            const value = escape(token.value);
-            result += value;
-            wildcardBacktrack += value;
-            prefix += token.value;
+            result += escape(token.value);
+            backtrack += token.value;
+            if (prevCaptureType === 2)
+                wildcardBacktrack += token.value;
             if (token.value.includes(delimiter))
-                hasSegmentWildcard = false;
+                hasSegmentCapture = 0;
             continue;
         }
         if (token.type === "param" || token.type === "wildcard") {
-            if (result && !prefix) {
+            if (prevCaptureType && !backtrack) {
                 throw new PathError(`Missing text before "${token.name}" ${token.type}`, originalPath);
             }
-            keys.push(token);
             if (token.type === "param") {
-                if (hasSegmentWildcard) {
-                    const value = negate(delimiter, prefix);
-                    result += `(${value}+?|${value}*${escape(prefix)})`;
-                }
-                else {
-                    const text = textRemaining(index);
-                    if (text) {
-                        result += `(?=(${negate(delimiter, "")}+?)${escape(text)})(?:\\${keys.length})`;
-                    }
-                    else {
-                        result += `(${negate(delimiter, "")}+)`;
-                    }
-                }
+                result +=
+                    hasSegmentCapture & 2 // Seen wildcard in segment.
+                        ? `(${negate(delimiter, backtrack)}+)`
+                        : hasInSegment(index, "wildcard") // See wildcard later in segment.
+                            ? `(${negate(delimiter, peekText(index))}+)`
+                            : hasSegmentCapture & 1 // Seen parameter in segment.
+                                ? `(${negate(delimiter, backtrack)}+|${escape(backtrack)})`
+                                : `(${negate(delimiter, "")}+)`;
+                hasSegmentCapture |= prevCaptureType = 1;
             }
             else {
-                // If we had a wildcard, close lookahead and reset.
-                if (hasWildcardAhead)
-                    result += `)${wildcardBacktrack}`;
-                hasWildcardAhead = seekWildcard(index);
-                // Lock earlier wildcards; leave the last one greedy.
-                result += hasWildcardAhead ? "(?=([^]+?)" : "([^]+)";
-                hasSegmentWildcard = true;
+                result +=
+                    hasSegmentCapture & 2 // Seen wildcard in segment.
+                        ? `(${negate(backtrack, "")}+)`
+                        : wildcardBacktrack // No capture in segment, seen wildcard in path.
+                            ? `(${negate(wildcardBacktrack, "")}+|${negate(delimiter, "")}+)`
+                            : `([^]+)`;
                 wildcardBacktrack = "";
+                hasSegmentCapture |= prevCaptureType = 2;
             }
-            wildcardBacktrack += `(?:\\${keys.length})`;
-            prefix = "";
+            keys.push(token);
+            backtrack = "";
             continue;
         }
         throw new TypeError(`Unknown token type: ${token.type}`);
     }
-    if (trailing && !prefix.endsWith(delimiter)) {
-        result += "(?:" + escape(delimiter) + "$)?";
-    }
     return result;
 }
 /**
@@ -367,11 +385,9 @@ function negate(a, b) {
     return `[^${escape(a + b)}]`;
 }
 /**
- * Stringify token data into a path string.
+ * Stringify an array of tokens into a path string.
  */
-export function stringify(data) {
-    const { tokens } = data;
-    let index = 0;
+function stringifyTokens(tokens, index) {
     let value = "";
     while (index < tokens.length) {
         const token = tokens[index++];
@@ -380,15 +396,15 @@ export function stringify(data) {
             continue;
         }
         if (token.type === "group") {
-            value += "{" + stringify(token) + "}";
+            value += "{" + stringifyTokens(token.tokens, 0) + "}";
             continue;
         }
         if (token.type === "param") {
-            value += ":" + stringifyName(token.name, tokens, index);
+            value += ":" + stringifyName(token.name, tokens[index]);
             continue;
         }
         if (token.type === "wildcard") {
-            value += "*" + stringifyName(token.name, tokens, index);
+            value += "*" + stringifyName(token.name, tokens[index]);
             continue;
         }
         throw new TypeError(`Unknown token type: ${token.type}`);
@@ -396,35 +412,19 @@ export function stringify(data) {
     return value;
 }
 /**
- * Wrap a parameter name in quotes, escaping only the characters the parser
- * treats specially inside a quoted name (`"` and `\`). `JSON.stringify` can't
- * be used here because it emits escapes like `\n` that the parser reads back as
- * the literal character `n`, so names with control characters wouldn't survive
- * a `parse` -> `stringify` -> `parse` round trip.
+ * Stringify token data into a path string.
  */
-function quoteName(name) {
-    return `"${name.replace(/["\\]/g, "\\$&")}"`;
+function stringify(data) {
+    return stringifyTokens(data.tokens, 0);
 }
 /**
  * Stringify a parameter name, escaping when it cannot be emitted directly.
  */
-function stringifyName(name, tokens, index) {
+function stringifyName(name, next) {
     if (!ID.test(name))
-        return quoteName(name);
-    while (index < tokens.length) {
-        const token = tokens[index++];
-        if (token.type === "text") {
-            if (!token.value)
-                continue;
-            // Destructuring reads the first *code point*, matching `parse`, which
-            // iterates the path with `[...str]`. Indexing with `[0]` would read only the
-            // leading surrogate of an astral character, missing that the parser treats
-            // the whole character as `ID_Continue` and absorbs it into the name.
-            const [first] = token.value;
-            if (ID_CONTINUE.test(first))
-                return quoteName(name);
-        }
-        break;
+        return JSON.stringify(name);
+    if ((next === null || next === void 0 ? void 0 : next.type) === "text" && ID_CONTINUE.test(next.value[0])) {
+        return JSON.stringify(name);
     }
     return name;
 }