@openclaw/whatsapp 2026.9.1-beta.1 → 2026.9.2

package/node_modules/baileys/node_modules/process-warning/README.md

@@ -4,7 +4,7 @@
 [![NPM version](https://img.shields.io/npm/v/process-warning.svg?style=flat)](https://www.npmjs.com/package/process-warning)
 [![neostandard javascript style](https://img.shields.io/badge/code_style-neostandard-brightgreen?style=flat)](https://github.com/neostandard/neostandard)
 
-A small utility for generating consistent warning objects across your codebase.
+A small utility for generating consistent [warning objects](https://nodejs.org/api/process.html#event-warning) across your codebase.
 It also exposes a utility for emitting those warnings, guaranteeing that they are issued only once (unless configured otherwise).
 
 _This module is used by the [Fastify](https://fastify.dev) framework and it was called `fastify-warning` prior to version 1.0.0._
@@ -31,7 +31,7 @@ const warning = createWarning({
   message: 'Hello %s',
   unlimited: true
 })
-warning('world')
+const emitted = warning('world')
 ```
 
 #### Methods
@@ -101,6 +101,45 @@ FST_ERROR_CODE('world') // will be emitted
 FST_ERROR_CODE('world') // will be emitted again
 ```
 
+#### `spyWarning(warning)`
+
+Spy the created warning function for testing purpose.
+
+```js
+const { test } = require('node:test')
+const { createWarning, spyWarning } = require('process-warning')
+const FST_ERROR_CODE = createWarning({ name: 'MyAppWarning', code: 'FST_ERROR_CODE', message: 'Hello %s' })
+
+test('spy warning', t => {
+  const spyData = spyWarning(FST_ERROR_CODE)
+
+  // call after spy
+  const emitted = FST_ERROR_CODE('world')
+  t.assert.strictEqual(emitted, true)
+
+  // restore the warning function
+  // it must be called when you do not need to spy anymore
+  // otherwise, the calls data will accumulates.
+  t.after(() => spyData.restore())
+
+  t.assert.strictEqual(FST_ERROR_CODE.emitted, true)
+  // calls return the arguments and result.
+  // result indicate whether warning is emitted through process.emitWarning
+  console.log(spyData.calls) // [{ arguments: ['world'], result: true }]
+  t.assert.deepStrictEqual(spyData.calls[0].arguments, ['world'])
+  t.assert.strictEqual(spyData.calls[0].result,  true)
+  // number of times called the function
+  console.log(spyData.callCount()) // 1
+  t.assert.strictEqual(spyData.callCount(),  1)
+
+  // reset the spy stat and warning state
+  spyData.reset()
+  t.assert.strictEqual(FST_ERROR_CODE.emitted, false)
+  t.assert.deepStrictEqual(spyData.calls, [])
+  t.assert.strictEqual(spyData.callCount(),  0)
+})
+```
+
 #### Suppressing warnings
 
 It is possible to suppress warnings by utilizing one of node's built-in warning suppression mechanisms.

package/node_modules/baileys/node_modules/process-warning/index.js

@@ -17,6 +17,7 @@ const { format } = require('node:util')
  * @property {string} message - The warning message.
  * @property {boolean} emitted - Indicates if the warning has been emitted.
  * @property {function} format - Formats the warning message.
+ * @returns {boolean} emit - Indicates if the warning has been emitted by this call.
  */
 
 /**
@@ -33,8 +34,69 @@ const { format } = require('node:util')
  * @typedef {Object} ProcessWarning
  * @property {function} createWarning - Creates a warning item.
  * @property {function} createDeprecation - Creates a deprecation warning item.
+ * @property {function} spyWarning - Spy a warning item.
  */
 
+/**
+ * Represents the spy data.
+ * @typedef {Object} WarningSpyData
+ * @property {object} calls - Arguments of WarningItem calls with.
+ * @property {function} callCount - Number of counts called the WarningItem.
+ * @property {function} reset - Reset the calls data and state of WarningItem.
+ * @property {function} restore - Remove spy from WarningItem.
+ */
+
+const kWarningFn = Symbol('process-warning.fn')
+const kWarningSpyData = Symbol('process-warning.spyData')
+
+/**
+ * Spy a warning item.
+ * @function
+ * @memberof processWarning
+ * @param {WarningItem} warning - The warning item to spy.
+ * @returns {WarningSpyData} The created spy data.
+ */
+function spyWarning (warning) {
+  // Do not double spy the same warning
+  if (warning[kWarningSpyData] === null) {
+    const warningFn = warning[kWarningFn]
+    warning[kWarningFn] = function (a, b, c) {
+      const args = []
+      // since warning always call by fn(a, b, c)
+      // it need to remove the trailing undefined arguments
+      if (c) {
+        args.push(a, b, c)
+      } else if (b) {
+        args.push(a, b)
+      } else if (a) {
+        args.push(a)
+      }
+      warning[kWarningSpyData].calls.push({
+        arguments: args,
+        result: warningFn(a, b, c)
+      })
+    }
+    const spyData = {
+      calls: [],
+      callCount () {
+        return spyData.calls.length
+      },
+      reset () {
+        warning.emitted = false
+        spyData.calls.length = 0
+      },
+      restore () {
+        spyData.reset()
+        warning[kWarningFn] = warningFn
+        warning[kWarningSpyData] = null
+      }
+    }
+    warning[kWarningSpyData] = spyData
+  }
+
+  return warning[kWarningSpyData]
+}
+
 /**
  * Creates a deprecation warning item.
  * @function
@@ -62,21 +124,24 @@ function createWarning ({ name, code, message, unlimited = false } = {}) {
 
   code = code.toUpperCase()
 
-  let warningContainer = {
-    [name]: function (a, b, c) {
+  const warningFn = unlimited === true
+    ? function (a, b, c) {
+      warning.emitted = true
+      process.emitWarning(warning.format(a, b, c), warning.name, warning.code)
+      return true
+    }
+    : function (a, b, c) {
       if (warning.emitted === true && warning.unlimited !== true) {
-        return
+        return false
       }
       warning.emitted = true
       process.emitWarning(warning.format(a, b, c), warning.name, warning.code)
+      return true
     }
-  }
-  if (unlimited) {
-    warningContainer = {
-      [name]: function (a, b, c) {
-        warning.emitted = true
-        process.emitWarning(warning.format(a, b, c), warning.name, warning.code)
-      }
+
+  const warningContainer = {
+    [name]: function (a, b, c) {
+      return warning[kWarningFn](a, b, c)
     }
   }
 
@@ -86,14 +151,16 @@ function createWarning ({ name, code, message, unlimited = false } = {}) {
   warning.message = message
   warning.unlimited = unlimited
   warning.code = code
+  warning[kWarningFn] = warningFn
+  warning[kWarningSpyData] = null
 
   /**
-   * Formats the warning message.
-   * @param {*} [a] Possible message interpolation value.
-   * @param {*} [b] Possible message interpolation value.
-   * @param {*} [c] Possible message interpolation value.
-   * @returns {string} The formatted warning message.
-   */
+ * Formats the warning message.
+ * @param {*} [a] Possible message interpolation value.
+ * @param {*} [b] Possible message interpolation value.
+ * @param {*} [c] Possible message interpolation value.
+ * @returns {string} The formatted warning message.
+ */
   warning.format = function (a, b, c) {
     let formatted
     if (a && b && c) {
@@ -116,9 +183,10 @@ function createWarning ({ name, code, message, unlimited = false } = {}) {
  * @namespace
  * @property {function} createWarning - Creates a warning item.
  * @property {function} createDeprecation - Creates a deprecation warning item.
+ * @property {function} spyWarning - Spy a warning item.
  * @property {ProcessWarning} processWarning - Represents the process warning functionality.
  */
-const out = { createWarning, createDeprecation }
+const out = { createWarning, createDeprecation, spyWarning }
 module.exports = out
 module.exports.default = out
 module.exports.processWarning = out

package/node_modules/baileys/node_modules/process-warning/package.json

@@ -1,6 +1,6 @@
 {
   "name": "process-warning",
-  "version": "5.0.0",
+  "version": "5.1.0",
   "description": "A small utility for creating warnings and emitting them.",
   "main": "index.js",
   "type": "commonjs",
@@ -11,7 +11,7 @@
     "test": "npm run test:unit && npm run test:jest && npm run test:typescript",
     "test:jest": "jest jest.test.js",
     "test:unit": "c8 --100 node --test",
-    "test:typescript": "tsd"
+    "test:typescript": "tstyche"
   },
   "repository": {
     "type": "git",
@@ -62,12 +62,11 @@
     }
   ],
   "devDependencies": {
-    "@fastify/pre-commit": "^2.1.0",
     "benchmark": "^2.1.4",
-    "c8": "^10.1.3",
+    "c8": "^12.0.0",
     "eslint": "^9.17.0",
-    "jest": "^29.7.0",
-    "neostandard": "^0.12.0",
-    "tsd": "^0.31.0"
+    "jest": "^30.0.3",
+    "neostandard": "^0.13.0",
+    "tstyche": "^7.0.0"
   }
 }

package/node_modules/baileys/node_modules/process-warning/test/emit-once-only.test.js

@@ -5,7 +5,7 @@ const { createWarning } = require('..')
 const { withResolvers } = require('./promise')
 
 test('emit should emit a given code only once', t => {
-  t.plan(4)
+  t.plan(6)
 
   const { promise, resolve } = withResolvers()
 
@@ -22,8 +22,8 @@ test('emit should emit a given code only once', t => {
     code: 'CODE',
     message: 'Hello world'
   })
-  warn()
-  warn()
+  t.assert.strictEqual(warn(), true)
+  t.assert.strictEqual(warn(), false)
   setImmediate(() => {
     process.removeListener('warning', onWarning)
     resolve()

package/node_modules/baileys/node_modules/process-warning/test/emit-reset.test.js

@@ -5,7 +5,7 @@ const { createWarning } = require('../')
 const { withResolvers } = require('./promise')
 
 test('a limited warning can be re-set', t => {
-  t.plan(4)
+  t.plan(7)
 
   const { promise, resolve } = withResolvers()
   let count = 0
@@ -20,14 +20,14 @@ test('a limited warning can be re-set', t => {
     message: 'Hello world'
   })
 
-  warn()
+  t.assert.strictEqual(warn(), true)
   t.assert.ok(warn.emitted)
 
-  warn()
+  t.assert.strictEqual(warn(), false)
   t.assert.ok(warn.emitted)
 
   warn.emitted = false
-  warn()
+  t.assert.strictEqual(warn(), true)
   t.assert.ok(warn.emitted)
 
   setImmediate(() => {

package/node_modules/baileys/node_modules/process-warning/test/emit-unlimited.test.js

@@ -5,7 +5,7 @@ const { createWarning } = require('..')
 const { withResolvers } = require('./promise')
 
 test('emit should emit a given code unlimited times', t => {
-  t.plan(50)
+  t.plan(60)
 
   let runs = 0
   const expectedRun = []
@@ -31,7 +31,7 @@ test('emit should emit a given code unlimited times', t => {
 
   for (let i = 0; i < times; i++) {
     expectedRun.push(i)
-    warn()
+    t.assert.strictEqual(warn(), true)
   }
   setImmediate(() => {
     process.removeListener('warning', onWarning)

package/node_modules/baileys/node_modules/process-warning/test/spy-warning.test.js

@@ -0,0 +1,143 @@
+'use strict'
+
+const { test } = require('node:test')
+const { createWarning } = require('..')
+const { spyWarning } = require('..')
+
+test('Spy ProcessWarning - unlimited: false', t => {
+  const warning = createWarning({
+    name: 'Warning',
+    code: 'WRN',
+    message: 'Hello %s'
+  })
+  const spyData = spyWarning(warning)
+
+  t.assert.strictEqual(warning.emitted, false)
+  t.assert.deepStrictEqual(spyData.calls, [])
+  t.assert.strictEqual(spyData.callCount(), 0)
+
+  warning('World')
+  t.assert.strictEqual(warning.emitted, true)
+  t.assert.deepStrictEqual(spyData.calls[0].arguments, ['World'])
+  t.assert.strictEqual(spyData.calls[0].result, true)
+  t.assert.strictEqual(spyData.callCount(), 1)
+
+  warning('World')
+  t.assert.strictEqual(warning.emitted, true)
+  t.assert.deepStrictEqual(spyData.calls[0].arguments, ['World'])
+  t.assert.strictEqual(spyData.calls[0].result, true)
+  t.assert.deepStrictEqual(spyData.calls[1].arguments, ['World'])
+  t.assert.strictEqual(spyData.calls[1].result, false)
+  t.assert.strictEqual(spyData.callCount(), 2)
+
+  spyData.reset()
+  t.assert.strictEqual(warning.emitted, false)
+  t.assert.deepStrictEqual(spyData.calls, [])
+  t.assert.strictEqual(spyData.callCount(), 0)
+
+  warning('World')
+  t.assert.strictEqual(warning.emitted, true)
+  t.assert.deepStrictEqual(spyData.calls[0].arguments, ['World'])
+  t.assert.strictEqual(spyData.calls[0].result, true)
+  t.assert.strictEqual(spyData.callCount(), 1)
+
+  spyData.restore()
+  t.assert.strictEqual(warning.emitted, false)
+  t.assert.deepStrictEqual(spyData.calls, [])
+  t.assert.strictEqual(spyData.callCount(), 0)
+
+  warning('World')
+  t.assert.strictEqual(warning.emitted, true)
+  t.assert.deepStrictEqual(spyData.calls, [])
+  t.assert.strictEqual(spyData.callCount(), 0)
+})
+
+test('Spy ProcessWarning - unlimited: true', t => {
+  const warning = createWarning({
+    name: 'Warning',
+    code: 'WRN',
+    message: 'Hello %s',
+    unlimited: true
+  })
+  const spyData = spyWarning(warning)
+
+  t.assert.strictEqual(warning.emitted, false)
+  t.assert.deepStrictEqual(spyData.calls, [])
+  t.assert.strictEqual(spyData.callCount(), 0)
+
+  warning('World')
+  t.assert.strictEqual(warning.emitted, true)
+  t.assert.deepStrictEqual(spyData.calls[0].arguments, ['World'])
+  t.assert.strictEqual(spyData.calls[0].result, true)
+  t.assert.strictEqual(spyData.callCount(), 1)
+
+  warning('World')
+  t.assert.strictEqual(warning.emitted, true)
+  t.assert.deepStrictEqual(spyData.calls[0].arguments, ['World'])
+  t.assert.strictEqual(spyData.calls[0].result, true)
+  t.assert.deepStrictEqual(spyData.calls[1].arguments, ['World'])
+  t.assert.strictEqual(spyData.calls[1].result, true)
+  t.assert.strictEqual(spyData.callCount(), 2)
+
+  spyData.reset()
+  t.assert.strictEqual(warning.emitted, false)
+  t.assert.deepStrictEqual(spyData.calls, [])
+  t.assert.strictEqual(spyData.callCount(), 0)
+
+  warning('World')
+  t.assert.strictEqual(warning.emitted, true)
+  t.assert.deepStrictEqual(spyData.calls[0].arguments, ['World'])
+  t.assert.strictEqual(spyData.calls[0].result, true)
+  t.assert.strictEqual(spyData.callCount(), 1)
+
+  spyData.restore()
+  t.assert.strictEqual(warning.emitted, false)
+  t.assert.deepStrictEqual(spyData.calls, [])
+  t.assert.strictEqual(spyData.callCount(), 0)
+
+  warning('World')
+  t.assert.strictEqual(warning.emitted, true)
+  t.assert.deepStrictEqual(spyData.calls, [])
+  t.assert.strictEqual(spyData.callCount(), 0)
+})
+
+test('Spy ProcessWarning - calls[].arguments', t => {
+  const warning = createWarning({
+    name: 'Warning',
+    code: 'WRN',
+    message: 'Hello %s'
+  })
+  const spyData = spyWarning(warning)
+
+  warning(undefined)
+  t.assert.deepStrictEqual(spyData.calls[0].arguments, [])
+  spyData.reset()
+
+  warning()
+  t.assert.deepStrictEqual(spyData.calls[0].arguments, [])
+  spyData.reset()
+
+  warning('World')
+  t.assert.deepStrictEqual(spyData.calls[0].arguments, ['World'])
+  spyData.reset()
+
+  warning('World', 'Hello')
+  t.assert.deepStrictEqual(spyData.calls[0].arguments, ['World', 'Hello'])
+  spyData.reset()
+
+  warning(undefined, 'Hello')
+  t.assert.deepStrictEqual(spyData.calls[0].arguments, [undefined, 'Hello'])
+  spyData.reset()
+
+  warning('World', 'Hello', 'World')
+  t.assert.deepStrictEqual(spyData.calls[0].arguments, ['World', 'Hello', 'World'])
+  spyData.reset()
+
+  warning('World', undefined, 'World')
+  t.assert.deepStrictEqual(spyData.calls[0].arguments, ['World', undefined, 'World'])
+  spyData.reset()
+
+  warning(undefined, 'Hello', 'World')
+  t.assert.deepStrictEqual(spyData.calls[0].arguments, [undefined, 'Hello', 'World'])
+  spyData.reset()
+})

package/node_modules/baileys/node_modules/process-warning/types/index.d.ts

@@ -1,6 +1,6 @@
 declare namespace processWarning {
   export interface WarningItem {
-    (a?: any, b?: any, c?: any): void;
+    (a?: any, b?: any, c?: any): boolean;
     name: string;
     code: string;
     message: string;
@@ -22,13 +22,27 @@ declare namespace processWarning {
     unlimited?: boolean;
   }
 
+  export type WarningSpyData = {
+    calls: WarningCallData[],
+    callCount(): number
+    reset(): void
+    restore(): void
+  }
+
+  export type WarningCallData = {
+    arguments: unknown[]
+    result: boolean
+  }
+
   export type ProcessWarning = {
     createWarning(params: WarningOptions): WarningItem;
     createDeprecation(params: DeprecationOptions): WarningItem;
+    spyWarning(warning: WarningItem): WarningSpyData
   }
 
   export function createWarning (params: WarningOptions): WarningItem
   export function createDeprecation (params: DeprecationOptions): WarningItem
+  export function spyWarning (warning: WarningItem): WarningSpyData
 
   const processWarning: ProcessWarning
   export { processWarning as default }

package/node_modules/baileys/node_modules/process-warning/types/index.tst.ts

@@ -0,0 +1,48 @@
+import { expect } from 'tstyche'
+import { createDeprecation, createWarning, spyWarning, WarningCallData, WarningSpyData } from '..'
+
+const WarnInstance = createWarning({
+  name: 'TypeScriptWarning',
+  code: 'CODE',
+  message: 'message'
+})
+
+expect(WarnInstance.code).type.toBe<string>()
+expect(WarnInstance.message).type.toBe<string>()
+expect(WarnInstance.name).type.toBe<string>()
+expect(WarnInstance.emitted).type.toBe<boolean>()
+expect(WarnInstance.unlimited).type.toBe<boolean>()
+
+expect(WarnInstance()).type.toBe<boolean>()
+expect(WarnInstance('foo')).type.toBe<boolean>()
+expect(WarnInstance('foo', 'bar')).type.toBe<boolean>()
+
+const buildWarnUnlimited = createWarning({
+  name: 'TypeScriptWarning',
+  code: 'CODE',
+  message: 'message',
+  unlimited: true
+})
+
+expect(buildWarnUnlimited.unlimited).type.toBe<boolean>()
+
+const DeprecationInstance = createDeprecation({
+  code: 'CODE',
+  message: 'message'
+})
+
+expect(DeprecationInstance.code).type.toBe<string>()
+
+expect(DeprecationInstance()).type.toBe<boolean>()
+expect(DeprecationInstance('foo')).type.toBe<boolean>()
+expect(DeprecationInstance('foo', 'bar')).type.toBe<boolean>()
+
+const spyData = spyWarning(WarnInstance)
+expect(spyData).type.toBe<WarningSpyData>()
+expect(spyData.calls).type.toBe<WarningCallData[]>()
+expect(spyData.callCount).type.toBe<(() => number)>()
+expect(spyData.callCount()).type.toBe<number>()
+expect(spyData.reset).type.toBe<(() => void)>()
+expect(spyData.reset()).type.toBe<void>()
+expect(spyData.restore).type.toBe<(() => void)>()
+expect(spyData.restore()).type.toBe<void>()

package/node_modules/baileys/node_modules/ws/lib/permessage-deflate.js

@@ -167,7 +167,9 @@ class PerMessageDeflate {
             (typeof opts.serverMaxWindowBits === 'number' &&
               opts.serverMaxWindowBits > params.server_max_window_bits))) ||
         (typeof opts.clientMaxWindowBits === 'number' &&
-          !params.client_max_window_bits)
+          (typeof params.client_max_window_bits === 'number'
+            ? opts.clientMaxWindowBits > params.client_max_window_bits
+            : !params.client_max_window_bits))
       ) {
         return false;
       }

package/node_modules/baileys/node_modules/ws/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ws",
-  "version": "8.21.1",
+  "version": "8.21.3",
   "description": "Simple to use, blazing fast and thoroughly tested websocket client and server for Node.js",
   "keywords": [
     "HyBi",

package/node_modules/typebox/build/format/email.mjs

@@ -1,4 +1,4 @@
-const Email = /^(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[^"\\]|\\.)*")@(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*|\[(?:IPv6:[a-f0-9:]+|(?:25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(?:\.(?:25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3})\])$/i;
+const Email = /^(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[^"\\]|\\[\x20-\x7e])*")@(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*|\[(?:IPv6:[a-f0-9:]+|(?:25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(?:\.(?:25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3})\])$/i;
 /**
  * Returns true if the value is an Email
  * @specification https://datatracker.ietf.org/doc/html/rfc5322

package/node_modules/typebox/build/format/idna/idn-hostname.mjs

@@ -1,6 +1,9 @@
 import * as FormatBidi from './format/bidi.mjs';
 import * as LabelUnicode from './label/unicode.mjs';
 import * as LabelPuny from './label/puny.mjs';
+// ------------------------------------------------------------------
+// IsLabel
+// ------------------------------------------------------------------
 function IsValidLabelLength(value) {
     return value.length > 0 && value.length <= 63;
 }
@@ -8,9 +11,24 @@ function IsLabel(value) {
     return IsValidLabelLength(value) && (LabelPuny.IsPunyLabel(value) ||
         LabelUnicode.IsUnicodeLabel(value));
 }
+// ------------------------------------------------------------------
+// NormalizeHostname
+//
+// Normalizes a hostname for label validation. Normalizes for NFC
+// such that equivalent codepoint sequences can be uniformly
+// compared. It also removes codepoints that IDNA mapping ignores,
+// and converts full stop variants to ASCII '.' so the hostname can
+// be split into labels.
+// ------------------------------------------------------------------
 function NormalizeHostname(value) {
-    return value.normalize('NFC').replace(/[\u002E\u3002\uFF0E\uFF61]/g, '.');
+    return value
+        .normalize('NFC')
+        .replace(/[\u00ad\u034f\u180b-\u180d\u200b\ufe00-\ufe0f\u{e0100}-\u{e01ef}]/gu, '') // RE_IGNORED_MAPPING
+        .replace(/[\u002E\u3002\uFF0E\uFF61]/g, '.'); // RE_FULL_STOP_MAPPING
 }
+// ------------------------------------------------------------------
+// IsIdnHostname
+// ------------------------------------------------------------------
 export function IsIdnHostname(value) {
     if (value.length === 0 || value.includes(' '))
         return false;

package/node_modules/typebox/build/format/json_pointer.d.mts

@@ -1,6 +1,6 @@
 /**
  * Returns true if the value is a json pointer
- * @specification
- * @source ajv-formats
+ * @specification https://datatracker.ietf.org/doc/html/rfc6901
+ * @source https://github.com/ajv-validator/ajv-formats
  */
 export declare function IsJsonPointer(value: string): boolean;

package/node_modules/typebox/build/format/json_pointer.mjs

@@ -1,8 +1,8 @@
 const JsonPointer = /^(?:\/(?:[^~/]|~0|~1)*)*$/;
 /**
  * Returns true if the value is a json pointer
- * @specification
- * @source ajv-formats
+ * @specification https://datatracker.ietf.org/doc/html/rfc6901
+ * @source https://github.com/ajv-validator/ajv-formats
  */
 export function IsJsonPointer(value) {
     return JsonPointer.test(value);

package/node_modules/typebox/build/format/json_pointer_uri_fragment.d.mts

@@ -1,6 +1,6 @@
 /**
  * Returns true if the value is a json pointer uri fragment
- * @specification
- * @source ajv-formats
+ * @specification https://datatracker.ietf.org/doc/html/rfc6901
+ * @source https://github.com/ajv-validator/ajv-formats
  */
 export declare function IsJsonPointerUriFragment(value: string): boolean;

package/node_modules/typebox/build/format/json_pointer_uri_fragment.mjs

@@ -1,8 +1,8 @@
 const JsonPointerUriFragment = /^#(?:\/(?:[a-z0-9_\-.!$&'()*+,;:=@]|%[0-9a-f]{2}|~0|~1)*)*$/i;
 /**
  * Returns true if the value is a json pointer uri fragment
- * @specification
- * @source ajv-formats
+ * @specification https://datatracker.ietf.org/doc/html/rfc6901
+ * @source https://github.com/ajv-validator/ajv-formats
  */
 export function IsJsonPointerUriFragment(value) {
     return JsonPointerUriFragment.test(value);

package/node_modules/typebox/build/format/relative_json_pointer.d.mts

@@ -1,6 +1,6 @@
 /**
  * Returns true if the value is a relative json pointer
- * @specification
- * @source ajv-formats
+ * @specification https://datatracker.ietf.org/doc/html/rfc6901
+ * @source https://github.com/ajv-validator/ajv-formats
  */
 export declare function IsRelativeJsonPointer(value: string): boolean;

package/node_modules/typebox/build/format/relative_json_pointer.mjs

@@ -1,8 +1,8 @@
 const RelativeJsonPointer = /^(?:0|[1-9][0-9]*)(?:#|(?:\/(?:[^~/]|~0|~1)*)*)$/;
 /**
  * Returns true if the value is a relative json pointer
- * @specification
- * @source ajv-formats
+ * @specification https://datatracker.ietf.org/doc/html/rfc6901
+ * @source https://github.com/ajv-validator/ajv-formats
  */
 export function IsRelativeJsonPointer(value) {
     return RelativeJsonPointer.test(value);