@psnext/slingcli 2.4.20260507-3 → 2.4.20260509-1

package/node_modules/protobufjs/package.json

@@ -1,6 +1,6 @@
 {
   "name": "protobufjs",
-  "version": "7.5.6",
+  "version": "7.5.7",
   "versionScheme": "~",
   "description": "Protocol Buffers for JavaScript (& TypeScript).",
   "author": "Daniel Wirtz <dcode+protobufjs@dcode.io>",

package/node_modules/protobufjs/src/namespace.js

@@ -466,8 +466,10 @@ Namespace.prototype._lookupImpl = function lookup(path, flatPath) {
     // Otherwise try each nested namespace
     } else {
         for (var i = 0; i < this.nestedArray.length; ++i)
-            if (this._nestedArray[i] instanceof Namespace && (found = this._nestedArray[i]._lookupImpl(path, flatPath)))
+            if (this._nestedArray[i] instanceof Namespace && (found = this._nestedArray[i]._lookupImpl(path, flatPath))) {
                 exact = found;
+                break;
+            }
     }
 
     // Set this even when null, so that when we walk up the tree we can quickly bail on repeated checks back down.

package/node_modules/semver/README.md

@@ -56,6 +56,7 @@ const semverCompareLoose = require('semver/functions/compare-loose')
 const semverCompareBuild = require('semver/functions/compare-build')
 const semverSort = require('semver/functions/sort')
 const semverRsort = require('semver/functions/rsort')
+const semverTruncate = require('semver/functions/truncate')
 
 // low-level comparators between versions
 const semverGt = require('semver/functions/gt')
@@ -399,12 +400,19 @@ nr         ::= '0' | ['1'-'9'] ( ['0'-'9'] ) *
 tilde      ::= '~' partial
 caret      ::= '^' partial
 qualifier  ::= ( '-' pre )? ( '+' build )?
-pre        ::= parts
-build      ::= parts
-parts      ::= part ( '.' part ) *
-part       ::= nr | [-0-9A-Za-z]+
+pre        ::= prepart ( '.' prepart ) *
+prepart    ::= nr | alphanumid
+build      ::= buildid ( '.' buildid ) *
+alphanumid ::= ( ['0'-'9'] ) * [-A-Za-z] [-0-9A-Za-z] *
+buildid    ::= [-0-9A-Za-z]+
 ```
 
+Note: Prerelease identifiers (`pre`) use `nr` for numeric parts, which
+disallows leading zeros (e.g., `1.2.3-00` is invalid). Build metadata
+identifiers (`build`) allow any alphanumeric string including leading
+zeros (e.g., `1.2.3+00` is valid). This matches the
+[SemVer 2.0.0 specification](https://semver.org/#spec-item-9).
+
 ## Functions
 
 All methods and classes take a final `options` object argument.  All
@@ -449,6 +457,12 @@ strings that they parse.
   or comparators intersect.
 * `parse(v)`: Attempt to parse a string as a semantic version, returning either
   a `SemVer` object or `null`.
+* `truncate(v, releaseType)`: Return the version with components _lower_
+  than `releaseType` dropped off, e.g.:
+  * `major` removes build & prerelease info and sets minor & patch to 0.
+  * `minor` removes build & prerelease info, and sets patch to 0
+  * `patch` removes build & prerelease info
+  * All prerelease types remove build info only
 
 ### Comparison
 
@@ -650,6 +664,7 @@ The following modules are available:
 * `require('semver/functions/rsort')`
 * `require('semver/functions/satisfies')`
 * `require('semver/functions/sort')`
+* `require('semver/functions/truncate')`
 * `require('semver/functions/valid')`
 * `require('semver/ranges/gtr')`
 * `require('semver/ranges/intersects')`

package/node_modules/semver/bin/semver.js

@@ -46,6 +46,7 @@ const main = () => {
       a = a.slice(0, indexOfEqualSign)
       argv.unshift(value)
     }
+
     switch (a) {
       case '-rv': case '-rev': case '--rev': case '--reverse':
         reverse = true
@@ -60,15 +61,10 @@ const main = () => {
         versions.push(argv.shift())
         break
       case '-i': case '--inc': case '--increment':
-        switch (argv[0]) {
-          case 'major': case 'minor': case 'patch': case 'prerelease':
-          case 'premajor': case 'preminor': case 'prepatch':
-          case 'release':
-            inc = argv.shift()
-            break
-          default:
-            inc = 'patch'
-            break
+        if (semver.RELEASE_TYPES.includes(argv[0]) || (argv[0] === 'release')) {
+          inc = { value: argv.shift(), maybeErrantValue: null, option: a }
+        } else {
+          inc = { value: 'patch', maybeErrantValue: argv[0], option: a }
         }
         break
       case '--preid':
@@ -102,6 +98,14 @@ const main = () => {
 
   options = parseOptions({ loose, includePrerelease, rtl })
 
+  if (
+    inc &&
+    versions.includes(inc.maybeErrantValue) &&
+    !semver.valid(inc.maybeErrantValue, options)
+  ) {
+    console.warn(`Invalid value for ${inc.option}; defaulting to 'patch'. This may become a failure in future major versions.`)
+  }
+
   versions = versions.map((v) => {
     return coerce ? (semver.coerce(v, options) || { version: v }).version : v
   }).filter((v) => {
@@ -125,7 +129,7 @@ const main = () => {
   versions
     .sort((a, b) => semver[reverse ? 'rcompare' : 'compare'](a, b, options))
     .map(v => semver.clean(v, options))
-    .map(v => inc ? semver.inc(v, inc, options, identifier, identifierBase) : v)
+    .map(v => inc ? semver.inc(v, inc.value, options, identifier, identifierBase) : v)
     .forEach(v => console.log(v))
 }
 

package/node_modules/semver/functions/truncate.js

@@ -0,0 +1,48 @@
+'use strict'
+
+const parse = require('./parse')
+const constants = require('../internal/constants')
+const SemVer = require('../classes/semver')
+
+const truncate = (version, truncation, options) => {
+  if (!constants.RELEASE_TYPES.includes(truncation)) {
+    return null
+  }
+
+  const clonedVersion = cloneInputVersion(version, options)
+  return clonedVersion && doTruncation(clonedVersion, truncation)
+}
+
+const cloneInputVersion = (version, options) => {
+  const versionStringToParse = (
+    version instanceof SemVer ? version.version : version
+  )
+
+  return parse(versionStringToParse, options)
+}
+
+const doTruncation = (version, truncation) => {
+  if (isPrerelease(truncation)) {
+    return version.version
+  }
+
+  version.prerelease = []
+
+  switch (truncation) {
+    case 'major':
+      version.minor = 0
+      version.patch = 0
+      break
+    case 'minor':
+      version.patch = 0
+      break
+  }
+
+  return version.format()
+}
+
+const isPrerelease = (type) => {
+  return type.startsWith('pre')
+}
+
+module.exports = truncate

package/node_modules/semver/index.js

@@ -28,6 +28,7 @@ const gte = require('./functions/gte')
 const lte = require('./functions/lte')
 const cmp = require('./functions/cmp')
 const coerce = require('./functions/coerce')
+const truncate = require('./functions/truncate')
 const Comparator = require('./classes/comparator')
 const Range = require('./classes/range')
 const satisfies = require('./functions/satisfies')
@@ -66,6 +67,7 @@ module.exports = {
   lte,
   cmp,
   coerce,
+  truncate,
   Comparator,
   Range,
   satisfies,

package/node_modules/semver/internal/re.js

@@ -136,7 +136,7 @@ createToken('LOOSE', `^${src[t.LOOSEPLAIN]}$`)
 createToken('GTLT', '((?:<|>)?=?)')
 
 // Something like "2.*" or "1.2.x".
-// Note that "x.x" is a valid xRange identifer, meaning "any version"
+// Note that "x.x" is a valid xRange identifier, meaning "any version"
 // Only the first item is strictly required.
 createToken('XRANGEIDENTIFIERLOOSE', `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`)
 createToken('XRANGEIDENTIFIER', `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`)

package/node_modules/semver/package.json

@@ -1,6 +1,6 @@
 {
   "name": "semver",
-  "version": "7.7.4",
+  "version": "7.8.0",
   "description": "The semantic version parser used by npm.",
   "main": "index.js",
   "scripts": {
@@ -15,7 +15,7 @@
   },
   "devDependencies": {
     "@npmcli/eslint-config": "^6.0.0",
-    "@npmcli/template-oss": "4.29.0",
+    "@npmcli/template-oss": "5.0.0",
     "benchmark": "^2.1.4",
     "tap": "^16.0.0"
   },
@@ -52,7 +52,7 @@
   "author": "GitHub Inc.",
   "templateOSS": {
     "//@npmcli/template-oss": "This file is partially managed by @npmcli/template-oss. Edits may be overwritten.",
-    "version": "4.29.0",
+    "version": "5.0.0",
     "engines": ">=10",
     "distPaths": [
       "classes/",

package/node_modules/semver/range.bnf

@@ -10,7 +10,8 @@ nr         ::= '0' | [1-9] ( [0-9] ) *
 tilde      ::= '~' partial
 caret      ::= '^' partial
 qualifier  ::= ( '-' pre )? ( '+' build )?
-pre        ::= parts
-build      ::= parts
-parts      ::= part ( '.' part ) *
-part       ::= nr | [-0-9A-Za-z]+
+pre        ::= prepart ( '.' prepart ) *
+prepart    ::= nr | alphanumid
+build      ::= buildid ( '.' buildid ) *
+alphanumid ::= ( [0-9] ) * [A-Za-z-] [-0-9A-Za-z] *
+buildid    ::= [-0-9A-Za-z]+

package/node_modules/socks/package.json

@@ -1,14 +1,14 @@
 {
   "name": "socks",
   "private": false,
-  "version": "2.8.8",
+  "version": "2.8.9",
   "description": "Fully featured SOCKS proxy client supporting SOCKSv4, SOCKSv4a, and SOCKSv5. Includes Bind and Associate functionality.",
   "main": "build/index.js",
   "typings": "typings/index.d.ts",
   "homepage": "https://github.com/JoshGlazebrook/socks/",
   "repository": {
     "type": "git",
-    "url": "https://github.com/JoshGlazebrook/socks.git"
+    "url": "git+https://github.com/JoshGlazebrook/socks.git"
   },
   "bugs": {
     "url": "https://github.com/JoshGlazebrook/socks/issues"

package/node_modules/xml-naming/README.md

@@ -0,0 +1,189 @@
+# xml-naming
+
+Validates XML name productions as defined in the [XML 1.0](https://www.w3.org/TR/xml/) and [XML 1.1](https://www.w3.org/TR/xml11/) specifications.
+
+Covers all five productions:
+
+| Production | Description | Colon | Digit/hyphen start |
+|---|---|---|---|
+| `Name` | General XML name | ✅ | ❌ |
+| `NCName` | Non-Colonized name | ❌ | ❌ |
+| `QName` | Namespace-qualified name (`prefix:local`) | ✅ (one only) | ❌ |
+| `NMToken` | Name token (relaxed start) | ✅ | ✅ |
+| `NMTokens` | Whitespace-separated NMToken list | ✅ | ✅ |
+
+Used internally by [fast-xml-parser](https://github.com/NaturalIntelligence/fast-xml-parser), [fast-xml-validator](https://github.com/NaturalIntelligence/fast-xml-validator), [@nodable\flexible-xml-parser](https://github.com/nodable/flexible-xml-parser)  and [fast-svg-parser](https://github.com/amitguptagwl/fast-svg-parser).
+
+---
+
+## Install
+
+```bash
+npm install xml-naming
+```
+
+---
+
+## Usage
+
+### Boolean validators
+
+```js
+import { name, ncName, qName, nmToken, nmTokens } from 'xml-naming';
+
+// Name — colon allowed anywhere, used for DOCTYPE entity names
+name('foo')          // true
+name('a:b:c')        // true  ← multiple colons fine for Name
+name('1foo')         // false ← digit start invalid
+
+// NCName — no colon, used for SVG id attributes, namespace prefixes
+ncName('my-id')      // true
+ncName('xlink:href') // false ← colon not allowed
+
+// QName — exactly one colon as prefix separator, used for element/attribute names
+qName('svg:circle')  // true
+qName('foo')         // true  ← unprefixed QName is valid
+qName('a:b:c')       // false ← only one colon allowed
+qName(':foo')        // false ← cannot start with colon
+
+// NMToken — any NameChar at start, used for DTD NMTOKEN attributes
+nmToken('123')       // true  ← digit start is fine
+nmToken('-bar')      // true
+nmToken('foo bar')   // false ← space not allowed
+
+// NMTokens — whitespace-separated NMToken list
+nmTokens('tok1 tok2 -foo 123')  // true
+```
+
+### XML version option
+
+All validators accept an optional `{ xmlVersion }` option:
+
+```js
+import { name } from 'xml-naming';
+
+name('\u0085', { xmlVersion: '1.0' })  // false — NEL (Next Line), not in 1.0 ranges
+name('\u0085', { xmlVersion: '1.1' })  // true  — explicitly allowed in 1.1
+
+name('\uD800\uDC00', { xmlVersion: '1.0' })  // false
+name('\uD800\uDC00', { xmlVersion: '1.1' })  // true
+```
+
+---
+
+### Diagnostic validation
+
+```js
+import { validate } from 'xml-naming';
+
+validate('svg:circle', 'qName')
+// { valid: true, production: 'qName', input: 'svg:circle' }
+
+validate('1foo', 'ncName')
+// {
+//   valid: false,
+//   production: 'ncName',
+//   input: '1foo',
+//   reason: 'First character "1" is not a valid NameStartChar',
+//   position: 0
+// }
+
+validate('foo:bar', 'ncName')
+// {
+//   valid: false,
+//   production: 'ncName',
+//   input: 'foo:bar',
+//   reason: 'Colon is not allowed in NCName',
+//   position: 3
+// }
+
+validate('a:b:c', 'qName')
+// {
+//   valid: false,
+//   production: 'qName',
+//   input: 'a:b:c',
+//   reason: 'QName can have at most one colon',
+//   position: 3
+// }
+```
+
+---
+
+### Batch validation
+
+```js
+import { validateAll } from 'xml-naming';
+
+validateAll(['svg', 'circle', '123bad', 'xlink:href'], 'ncName')
+// [
+//   { valid: true,  production: 'ncName', input: 'svg' },
+//   { valid: true,  production: 'ncName', input: 'circle' },
+//   { valid: false, production: 'ncName', input: '123bad',    reason: '...', position: 0 },
+//   { valid: false, production: 'ncName', input: 'xlink:href',reason: '...', position: 5 }
+// ]
+```
+
+---
+
+### Sanitize / auto-fix
+
+Useful when generating XML/SVG programmatically from user-supplied strings:
+
+```js
+import { sanitize } from 'xml-naming';
+
+sanitize('123abc',    'ncName')  // '_123abc'   ← digit start fixed
+sanitize('my element','name')   // 'my_element' ← space replaced
+sanitize('foo:bar',   'ncName') // 'foobar'     ← colon stripped
+sanitize('hello!',    'name')   // 'hello_'     ← illegal char replaced
+
+// Custom replacement character
+sanitize('my element', 'name', { replacement: '-' })  // 'my-element'
+```
+
+---
+
+## Which production should I use?
+
+| Context | Production |
+|---|---|
+| XML element/attribute names (namespace-aware) | `qName` |
+| SVG `id` attribute values | `ncName` |
+| Namespace prefix alone | `ncName` |
+| DOCTYPE `<!ENTITY name ...>` | `name` |
+| DOCTYPE `<!NOTATION name ...>` | `name` |
+| DTD `NMTOKEN` attribute values | `nmToken` |
+| DTD `NMTOKENS` attribute values | `nmTokens` |
+
+> **Note:** DOCTYPE entity and notation names must use `Name`, not `QName`. Colons carry no namespace meaning in the DTD subset.
+
+---
+
+## API
+
+### `name(str, opts?)` → `boolean`
+### `ncName(str, opts?)` → `boolean`
+### `qName(str, opts?)` → `boolean`
+### `nmToken(str, opts?)` → `boolean`
+### `nmTokens(str, opts?)` → `boolean`
+
+`opts`:
+- `xmlVersion`: `'1.0'` (default) | `'1.1'`
+
+### `validate(str, production, opts?)` → `ValidationResult`
+
+`production`: `'name'` | `'ncName'` | `'qName'` | `'nmToken'` | `'nmTokens'`
+
+### `validateAll(strings[], production, opts?)` → `ValidationResult[]`
+
+### `sanitize(str, production?, opts?)` → `string`
+
+`opts`:
+- `xmlVersion`: `'1.0'` | `'1.1'`
+- `replacement`: string (default `'_'`)
+
+---
+
+## License
+
+MIT

package/node_modules/xml-naming/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "xml-naming",
+  "version": "0.1.0",
+  "description": "Validates XML name productions — Name, NCName, QName, NMToken, NMTokens — for XML 1.0 and 1.1",
+  "type": "module",
+  "main": "./src/index.js",
+  "types": "./src/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./src/index.js",
+      "types": "./src/index.d.ts"
+    }
+  },
+  "files": [
+    "src",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "jasmine specs/*spec.js"
+  },
+  "keywords": [
+    "xml",
+    "xml-name",
+    "ncname",
+    "qname",
+    "nmtoken",
+    "xml-validation",
+    "xml-namespace",
+    "name-validator",
+    "xml-1.0",
+    "xml-1.1"
+  ],
+  "author": "Amit Gupta (https://solothought.com)",
+  "license": "MIT",
+  "funding": [
+    {
+      "type": "github",
+      "url": "https://github.com/sponsors/NaturalIntelligence"
+    }
+  ],
+  "devDependencies": {
+    "jasmine": "^5.0.0"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/NaturalIntelligence/xml-naming"
+  },
+  "bugs": {
+    "url": "https://github.com/NaturalIntelligence/xml-naming/issues"
+  }
+}

package/node_modules/xml-naming/src/index.d.ts

@@ -0,0 +1,74 @@
+export interface ValidationOptions {
+  /** XML specification version to validate against. Defaults to '1.0'. */
+  xmlVersion?: '1.0' | '1.1';
+}
+
+export interface SanitizeOptions extends ValidationOptions {
+  /** Character used to replace invalid characters. Defaults to '_'. */
+  replacement?: string;
+}
+
+export type Production = 'name' | 'ncName' | 'qName' | 'nmToken' | 'nmTokens';
+
+export interface ValidationResult {
+  valid: boolean;
+  production: Production;
+  input: string;
+  /** Present only when valid is false. */
+  reason?: string;
+  /** Index of the first offending character. Present only when valid is false. */
+  position?: number;
+}
+
+/**
+ * Returns true if the string is a valid XML Name.
+ * Colons are permitted anywhere (Name production).
+ * Used for: DOCTYPE entity names, notation names, DTD element declarations.
+ */
+export function name(str: string, opts?: ValidationOptions): boolean;
+
+/**
+ * Returns true if the string is a valid NCName (Non-Colonized Name).
+ * Colons are not permitted.
+ * Used for: namespace prefixes, local names, SVG id attributes.
+ */
+export function ncName(str: string, opts?: ValidationOptions): boolean;
+
+/**
+ * Returns true if the string is a valid QName (Qualified Name).
+ * Allows exactly one colon as a prefix separator: prefix:localName.
+ * Used for: element and attribute names in namespace-aware XML/SVG.
+ */
+export function qName(str: string, opts?: ValidationOptions): boolean;
+
+/**
+ * Returns true if the string is a valid NMToken.
+ * Same character set as Name but no restriction on the first character.
+ * Used for: DTD NMTOKEN attribute values.
+ */
+export function nmToken(str: string, opts?: ValidationOptions): boolean;
+
+/**
+ * Returns true if the string is a valid NMTokens value.
+ * A whitespace-separated list of NMToken values.
+ * Used for: DTD NMTOKENS attribute values.
+ */
+export function nmTokens(str: string, opts?: ValidationOptions): boolean;
+
+/**
+ * Validates a string against a named XML production and returns a detailed result.
+ */
+export function validate(str: string, production: Production, opts?: ValidationOptions): ValidationResult;
+
+/**
+ * Validates an array of strings against a named XML production.
+ */
+export function validateAll(strings: string[], production: Production, opts?: ValidationOptions): ValidationResult[];
+
+/**
+ * Transforms an invalid string into the nearest valid XML name for the given production.
+ * - Strips or replaces illegal characters
+ * - Fixes invalid start characters by prepending the replacement character
+ * - Removes colons for NCName production
+ */
+export function sanitize(str: string, production?: Production, opts?: SanitizeOptions): string;