+// Definitions: https://github.com/Marak/colors.js
+
+export const enabled: boolean;
+export function enable(): void;
+export function disable(): void;
+export function setTheme(theme: any): void;
+
+export function strip(str: string): string;
+export function stripColors(str: string): string;
+
+export function black(str: string): string;
+export function red(str: string): string;
+export function green(str: string): string;
+export function yellow(str: string): string;
+export function blue(str: string): string;
+export function magenta(str: string): string;
+export function cyan(str: string): string;
+export function white(str: string): string;
+export function gray(str: string): string;
+export function grey(str: string): string;
+
+export function brightRed(str: string): string;
+export function brightGreen(str: string): string;
+export function brightYellow(str: string): string;
+export function brightBlue(str: string): string;
+export function brightMagenta(str: string): string;
+export function brightCyan(str: string): string;
+export function brightWhite(str: string): string;
+
+export function bgBlack(str: string): string;
+export function bgRed(str: string): string;
+export function bgGreen(str: string): string;
+export function bgYellow(str: string): string;
+export function bgBlue(str: string): string;
+export function bgMagenta(str: string): string;
+export function bgCyan(str: string): string;
+export function bgWhite(str: string): string;
+
+export function bgBrightRed(str: string): string;
+export function bgBrightGreen(str: string): string;
+export function bgBrightYellow(str: string): string;
+export function bgBrightBlue(str: string): string;
+export function bgBrightMagenta(str: string): string;
+export function bgBrightCyan(str: string): string;
+export function bgBrightWhite(str: string): string;
+
+export function reset(str: string): string;
+export function bold(str: string): string;
+export function dim(str: string): string;
+export function italic(str: string): string;
+export function underline(str: string): string;
+export function inverse(str: string): string;
+export function hidden(str: string): string;
+export function strikethrough(str: string): string;
+
+export function rainbow(str: string): string;
+export function zebra(str: string): string;
+export function america(str: string): string;
+export function trap(str: string): string;
+export function random(str: string): string;
+export function zalgo(str: string): string;
diff --git a/sdk/node_modules/@colors/colors/safe.js b/sdk/node_modules/@colors/colors/safe.js
new file mode 100644
index 00000000..a013d542
--- /dev/null
+++ b/sdk/node_modules/@colors/colors/safe.js
@@ -0,0 +1,10 @@
+//
+// Remark: Requiring this file will use the "safe" colors API,
+// which will not touch String.prototype.
+//
+// var colors = require('colors/safe');
+// colors.red("foo")
+//
+//
+var colors = require('./lib/colors');
+module['exports'] = colors;
diff --git a/sdk/node_modules/@colors/colors/themes/generic-logging.js b/sdk/node_modules/@colors/colors/themes/generic-logging.js
new file mode 100644
index 00000000..63adfe4a
--- /dev/null
+++ b/sdk/node_modules/@colors/colors/themes/generic-logging.js
@@ -0,0 +1,12 @@
+module['exports'] = {
+ silly: 'rainbow',
+ input: 'grey',
+ verbose: 'cyan',
+ prompt: 'grey',
+ info: 'green',
+ data: 'grey',
+ help: 'cyan',
+ warn: 'yellow',
+ debug: 'blue',
+ error: 'red',
+};
diff --git a/sdk/node_modules/@dabh/diagnostics/CHANGELOG.md b/sdk/node_modules/@dabh/diagnostics/CHANGELOG.md
new file mode 100644
index 00000000..b04af38b
--- /dev/null
+++ b/sdk/node_modules/@dabh/diagnostics/CHANGELOG.md
@@ -0,0 +1,26 @@
+# CHANGELOG
+
+### 2.0.2
+
+- Bump to kuler 2.0, which removes colornames as dependency, which we
+ never used. So smaller install size, less dependencies for all.
+
+### 2.0.1
+
+- Use `storag-engine@3.0` which will automatically detect the correct
+ AsyncStorage implementation.
+- The upgrade also fixes a bug where it the `debug` and `diagnostics` values
+ to be JSON encoded instead of regular plain text.
+
+### 2.0.0
+
+- Documentation improvements.
+- Fixed a issue where async adapters were incorrectly detected.
+- Correctly inherit colors after applying colors the browser's console.
+
+### 2.0.0-alpha
+
+- Complete rewrite of all internals, now comes with separate builds for `browser`
+ `node` and `react-native` as well as dedicated builds for `production` and
+ `development` environments. Various utility methods and properties have
+ been added to the returned logger to make your lives even easier.
diff --git a/sdk/node_modules/@dabh/diagnostics/LICENSE b/sdk/node_modules/@dabh/diagnostics/LICENSE
new file mode 100644
index 00000000..9beaab11
--- /dev/null
+++ b/sdk/node_modules/@dabh/diagnostics/LICENSE
@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Arnout Kazemier, Martijn Swaagman, the Contributors.
+
+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.
diff --git a/sdk/node_modules/@dabh/diagnostics/README.md b/sdk/node_modules/@dabh/diagnostics/README.md
new file mode 100644
index 00000000..0cd25195
--- /dev/null
+++ b/sdk/node_modules/@dabh/diagnostics/README.md
@@ -0,0 +1,473 @@
+# `diagnostics`
+
+Diagnostics in the evolution of debug pattern that is used in the Node.js core,
+this extremely small but powerful technique can best be compared as feature
+flags for loggers. The created debug logger is disabled by default but can be
+enabled without changing a line of code, using flags.
+
+- Allows debugging in multiple JavaScript environments such as Node.js, browsers
+ and React-Native.
+- Separated development and production builds to minimize impact on your
+ application when bundled.
+- Allows for customization of logger, messages, and much more.
+
+
+
+## Installation
+
+The module is released in the public npm registry and can be installed by
+running:
+
+```
+npm install --save @dabh/diagnostics
+```
+
+## Usage
+
+- [Introduction](#introduction)
+- [Advanced usage](#advanced-usage)
+ - [Production and development builds](#production-and-development-builds)
+ - [WebPack](#webpack)
+ - [Node.js](#nodejs)
+- [API](#api)
+ - [.enabled](#enabled)
+ - [.namespace](#namespace)
+ - [.dev/prod](#devprod)
+ - [set](#set)
+ - [modify](#modify)
+ - [use](#use)
+- [Modifiers](#modifiers)
+ - [namespace](#namespace-1)
+- [Adapters](#adapters)
+ - [process.env](#process-env)
+ - [hash](#hash)
+ - [localStorage](#localstorage)
+ - [AsyncStorage](#asyncstorage)
+- [Loggers](#loggers)
+
+### Introduction
+
+To create a new logger simply `require` the `@dabh/diagnostics` module and call
+the returned function. It accepts 2 arguments:
+
+1. `namespace` **Required** This is the namespace of your logger so we know if we need to
+ enable your logger when a debug flag is used. Generally you use the name of
+ your library or application as first root namespace. For example if you're
+ building a parser in a library (example) you would set namespace
+ `example:parser`.
+2. `options` An object with additional configuration for the logger.
+ following keys are recognized:
+ - `force` Force the logger to be enabled.
+ - `colors` Colors are enabled by default for the logs, but you can set this
+ option to `false` to disable it.
+
+```js
+const debug = require('@dabh/diagnostics')('foo:bar:baz');
+const debug = require('@dabh/diagnostics')('foo:bar:baz', { options });
+
+debug('this is a log message %s', 'that will only show up when enabled');
+debug('that is pretty neat', { log: 'more', data: 1337 });
+```
+
+Unlike `console.log` statements that add and remove during your development
+lifecycle you create meaningful log statements that will give you insight in
+the library or application that you're developing.
+
+The created debugger uses different "adapters" to extract the debug flag
+out of the JavaScript environment. To learn more about enabling the debug flag
+in your specific environment click on one of the enabled adapters below.
+
+- **browser**: [localStorage](#localstorage), [hash](#hash)
+- **node.js**: [environment variables](#processenv)
+- **react-native**: [AsyncStorage](#asyncstorage)
+
+Please note that the returned logger is fully configured out of the box, you
+do not need to set any of the adapters/modifiers your self, they are there
+for when you want more advanced control over the process. But if you want to
+learn more about that, read the next section.
+
+### Advanced usage
+
+There are 2 specific usage patterns for `diagnostic`, library developers who
+implement it as part of their modules and applications developers who either
+use it in their application or are searching for ways to consume the messages.
+
+With the simple log interface as discussed in the [introduction](#introduction)
+section we make it easy for developers to add it as part of their libraries
+and applications, and with powerful [API](#api) we allow infinite customization
+by allowing custom adapters, loggers and modifiers to ensure that this library
+maintains relevant. These methods not only allow introduction of new loggers,
+but allow you think outside the box. For example you can maintain a history
+of past log messages, and output those when an uncaught exception happens in
+your application so you have additional context
+
+```js
+const diagnostics = require('@dabh/diagnostics');
+
+let index = 0;
+const limit = 200;
+const history = new Array(limit);
+
+//
+// Force all `diagnostic` loggers to be enabled.
+//
+diagnostics.force = process.env.NODE_ENV === 'prod';
+diagnostics.set(function customLogger(meta, message) {
+ history[index]= { meta, message, now: Date.now() };
+ if (index++ === limit) index = 0;
+
+ //
+ // We're running a development build, so output.
+ //
+ if (meta.dev) console.log.apply(console, message);
+});
+
+process.on('uncaughtException', async function (err) {
+ await saveErrorToDisk(err, history);
+ process.exit(1);
+});
+```
+
+The small snippet above will maintain a 200 limited FIFO (First In First Out)
+queue of all debug messages that can be referenced when your application crashes
+
+#### Production and development builds
+
+When you `require` the `@dabh/diagnostics` module you will be given a logger that is
+optimized for `development` so it can provide the best developer experience
+possible.
+
+The development logger enables all the [adapters](#adapters) for your
+JavaScript environment, adds a logger that outputs the messages to `console.log`
+and registers our message modifiers so log messages will be prefixed with the
+supplied namespace so you know where the log messages originates from.
+
+The development logger does not have any adapter, modifier and logger enabled
+by default. This ensures that your log messages never accidentally show up in
+production. However this does not mean that it's not possible to get debug
+messages in production. You can `force` the debugger to be enabled, and
+supply a [custom logger](#loggers).
+
+```js
+const diagnostics = require('@dabh/diagnostics');
+const debug = debug('foo:bar', { force: true });
+
+//
+// Or enable _every_ diagnostic instance:
+//
+diagnostics.force = true;
+```
+
+##### WebPack
+
+WebPack has the concept of [mode](https://webpack.js.org/concepts/mode/#usage)'s
+which creates different
+
+```js
+module.exports = {
+ mode: 'development' // 'production'
+}
+```
+
+When you are building your app using the WebPack CLI you can use the `--mode`
+flag:
+
+```
+webpack --mode=production app.js -o /dist/bundle.js
+```
+
+##### Node.js
+
+When you are running your app using `Node.js` you should the `NODE_ENV`
+environment variable to `production` to ensure that you libraries that you
+import are optimized for production.
+
+```
+NODE_ENV=production node app.js
+```
+
+### API
+
+The returned logger exposes some addition properties that can be used used in
+your application or library:
+
+#### .enabled
+
+The returned logger will have a `.enabled` property assigned to it. This boolean
+can be used to check if the logger was enabled:
+
+```js
+const debug = require('@dabh/diagnostics')('foo:bar');
+
+if (debug.enabled) {
+ //
+ // Do something special
+ //
+}
+```
+
+This property is exposed as:
+
+- Property on the logger.
+- Property on the meta/options object.
+
+#### .namespace
+
+This is the namespace that you originally provided to the function.
+
+```js
+const debug = require('@dabh/diagnostics')('foo:bar');
+
+console.log(debug.namespace); // foo:bar
+```
+
+This property is exposed as:
+
+- Property on the logger.
+- Property on the meta/options object.
+
+#### .dev/prod
+
+There are different builds available of `diagnostics`, when you create a
+production build of your application using `NODE_ENV=production` you will be
+given an optimized, smaller build of `diagnostics` to reduce your bundle size.
+The `dev` and `prod` booleans on the returned logger indicate if you have a
+production or development version of the logger.
+
+```js
+const debug = require('@dabh/diagnostics')('foo:bar');
+
+if (debug.prod) {
+ // do stuff
+}
+```
+
+This property is exposed as:
+
+- Property on the logger.
+- Property on the meta/options object.
+
+#### set
+
+Sets a new logger as default for **all** `diagnostic` instances. The passed
+argument should be a function that write the log messages to where ever you
+want. It receives 2 arguments:
+
+1. `meta` An object with all the options that was provided to the original
+ logger that wants to write the log message as well as properties of the
+ debugger such as `prod`, `dev`, `namespace`, `enabled`. See [API](#api) for
+ all exposed properties.
+2. `args` An array of the log messages that needs to be written.
+
+```js
+const debug = require('@dabh/diagnostics')('foo:more:namespaces');
+
+debug.use(function logger(meta, args) {
+ console.log(meta);
+ console.debug(...args);
+});
+```
+
+This method is exposed as:
+
+- Method on the logger.
+- Method on the meta/options object.
+- Method on `diagnostics` module.
+
+#### modify
+
+The modify method allows you add a new message modifier to **all** `diagnostic`
+instances. The passed argument should be a function that returns the passed
+message after modification. The function receives 2 arguments:
+
+1. `message`, Array, the log message.
+2. `options`, Object, the options that were passed into the logger when it was
+ initially created.
+
+```js
+const debug = require('@dabh/diagnostics')('example:modifiers');
+
+debug.modify(function (message, options) {
+ return messages;
+});
+```
+
+This method is exposed as:
+
+- Method on the logger.
+- Method on the meta/options object.
+- Method on `diagnostics` module.
+
+See [modifiers](#modifiers) for more information.
+
+#### use
+
+Adds a new `adapter` to **all** `diagnostic` instances. The passed argument
+should be a function returns a boolean that indicates if the passed in
+`namespace` is allowed to write log messages.
+
+```js
+const diagnostics = require('@dabh/diagnostics');
+const debug = diagnostics('foo:bar');
+
+debug.use(function (namespace) {
+ return namespace === 'foo:bar';
+});
+```
+
+This method is exposed as:
+
+- Method on the logger.
+- Method on the meta/options object.
+- Method on `diagnostics` module.
+
+See [adapters](#adapters) for more information.
+
+### Modifiers
+
+To be as flexible as possible when it comes to transforming messages we've
+come up with the concept of `modifiers` which can enhance the debug messages.
+This allows you to introduce functionality or details that you find important
+for debug messages, and doesn't require us to add additional bloat to the
+`diagnostic` core.
+
+For example, you want the messages to be prefixed with the date-time of when
+the log message occured:
+
+```js
+const diagnostics = require('@dabh/diagnostics');
+
+diagnostics.modify(function datetime(args, options) {
+ args.unshift(new Date());
+ return args;
+});
+```
+
+Now all messages will be prefixed with date that is outputted by `new Date()`.
+The following modifiers are shipped with `diagnostics` and are enabled in
+**development** mode only:
+
+- [namespace](#namespace)
+
+#### namespace
+
+This modifier is enabled for all debug instances and prefixes the messages
+with the name of namespace under which it is logged. The namespace is colored
+using the `colorspace` module which groups similar namespaces under the same
+colorspace. You can have multiple namespaces for the debuggers where each
+namespace should be separated by a `:`
+
+```
+foo
+foo:bar
+foo:bar:baz
+```
+
+For console based output the `namespace-ansi` is used.
+
+### Adapters
+
+Adapters allows `diagnostics` to pull the `DEBUG` and `DIAGNOSTICS` environment
+variables from different sources. Not every JavaScript environment has a
+`process.env` that we can leverage. Adapters allows us to have different
+adapters for different environments. It means you can write your own custom
+adapter if needed as well.
+
+The `adapter` function should be passed a function as argument, this function
+will receive the `namespace` of a logger as argument and it should return a
+boolean that indicates if that logger should be enabled or not.
+
+```js
+const debug = require('@dabh/diagnostics')('example:namespace');
+
+debug.adapter(require('@dabh/diagnostics/adapters/localstorage'));
+```
+
+The modifiers are only enabled for `development`. The following adapters are
+available are available:
+
+#### process.env
+
+This adapter is enabled for `node.js`.
+
+Uses the `DEBUG` or `DIAGNOSTICS` (both are recognized) environment variables to
+pass in debug flag:
+
+**UNIX/Linux/Mac**
+```
+DEBUG=foo* node index.js
+```
+
+Using environment variables on Windows is a bit different, and also depends on
+toolchain you are using:
+
+**Windows**
+```
+set DEBUG=foo* & node index.js
+```
+
+**Powershell**
+```
+$env:DEBUG='foo*';node index.js
+```
+
+#### hash
+
+This adapter is enabled for `browsers`.
+
+This adapter uses the `window.location.hash` of as source for the environment
+variables. It assumes that hash is formatted using the same syntax as query
+strings:
+
+```js
+http://example.com/foo/bar#debug=foo*
+```
+
+It triggers on both the `debug=` and `diagnostics=` names.
+
+#### localStorage
+
+This adapter is enabled for `browsers`.
+
+This adapter uses the `localStorage` of the browser to store the debug flags.
+You can set the debug flag your self in your application code, but you can
+also open browser WebInspector and enable it through the console.
+
+```js
+localStorage.setItem('debug', 'foo*');
+```
+
+It triggers on both the `debug` and `diagnostics` storage items. (Please note
+that these keys should be entered in lowercase)
+
+#### AsyncStorage
+
+This adapter is enabled for `react-native`.
+
+This adapter uses the `AsyncStorage` API that is exposed by the `react-native`
+library to store and read the `debug` or `diagnostics` storage items.
+
+```js
+import { AsyncStorage } from 'react-native';
+
+AsyncStorage.setItem('debug', 'foo*');
+```
+
+Unlike other adapters, this is the only adapter that is `async` so that means
+that we're not able to instantly determine if a created logger should be
+enabled or disabled. So when a logger is created in `react-native` we initially
+assume it's disabled, any message that send during period will be queued
+internally.
+
+Once we've received the data from the `AsyncStorage` API we will determine
+if the logger should be enabled, flush the queued messages if needed and set
+all `enabled` properties accordingly on the returned logger.
+
+### Loggers
+
+By default it will log all messages to `console.log` in when the logger is
+enabled using the debug flag that is set using one of the adapters.
+
+## License
+
+[MIT](LICENSE)
diff --git a/sdk/node_modules/@dabh/diagnostics/adapters/hash.js b/sdk/node_modules/@dabh/diagnostics/adapters/hash.js
new file mode 100644
index 00000000..a41aae5c
--- /dev/null
+++ b/sdk/node_modules/@dabh/diagnostics/adapters/hash.js
@@ -0,0 +1,11 @@
+var adapter = require('./');
+
+/**
+ * Extracts the values from process.env.
+ *
+ * @type {Function}
+ * @public
+ */
+module.exports = adapter(function hash() {
+ return /(debug|diagnostics)=([^&]+)/i.exec(window.location.hash)[2];
+});
diff --git a/sdk/node_modules/@dabh/diagnostics/adapters/index.js b/sdk/node_modules/@dabh/diagnostics/adapters/index.js
new file mode 100644
index 00000000..d60aaea5
--- /dev/null
+++ b/sdk/node_modules/@dabh/diagnostics/adapters/index.js
@@ -0,0 +1,18 @@
+var enabled = require('enabled');
+
+/**
+ * Creates a new Adapter.
+ *
+ * @param {Function} fn Function that returns the value.
+ * @returns {Function} The adapter logic.
+ * @public
+ */
+module.exports = function create(fn) {
+ return function adapter(namespace) {
+ try {
+ return enabled(namespace, fn());
+ } catch (e) { /* Any failure means that we found nothing */ }
+
+ return false;
+ };
+}
diff --git a/sdk/node_modules/@dabh/diagnostics/adapters/localstorage.js b/sdk/node_modules/@dabh/diagnostics/adapters/localstorage.js
new file mode 100644
index 00000000..bb889875
--- /dev/null
+++ b/sdk/node_modules/@dabh/diagnostics/adapters/localstorage.js
@@ -0,0 +1,11 @@
+var adapter = require('./');
+
+/**
+ * Extracts the values from process.env.
+ *
+ * @type {Function}
+ * @public
+ */
+module.exports = adapter(function storage() {
+ return localStorage.getItem('debug') || localStorage.getItem('diagnostics');
+});
diff --git a/sdk/node_modules/@dabh/diagnostics/adapters/process.env.js b/sdk/node_modules/@dabh/diagnostics/adapters/process.env.js
new file mode 100644
index 00000000..5ab166a4
--- /dev/null
+++ b/sdk/node_modules/@dabh/diagnostics/adapters/process.env.js
@@ -0,0 +1,11 @@
+var adapter = require('./');
+
+/**
+ * Extracts the values from process.env.
+ *
+ * @type {Function}
+ * @public
+ */
+module.exports = adapter(function processenv() {
+ return process.env.DEBUG || process.env.DIAGNOSTICS;
+});
diff --git a/sdk/node_modules/@dabh/diagnostics/browser/development.js b/sdk/node_modules/@dabh/diagnostics/browser/development.js
new file mode 100644
index 00000000..e36dfaa5
--- /dev/null
+++ b/sdk/node_modules/@dabh/diagnostics/browser/development.js
@@ -0,0 +1,35 @@
+var create = require('../diagnostics');
+
+/**
+ * Create a new diagnostics logger.
+ *
+ * @param {String} namespace The namespace it should enable.
+ * @param {Object} options Additional options.
+ * @returns {Function} The logger.
+ * @public
+ */
+var diagnostics = create(function dev(namespace, options) {
+ options = options || {};
+ options.namespace = namespace;
+ options.prod = false;
+ options.dev = true;
+
+ if (!dev.enabled(namespace) && !(options.force || dev.force)) {
+ return dev.nope(options);
+ }
+
+ return dev.yep(options);
+});
+
+//
+// Configure the logger for the given environment.
+//
+diagnostics.modify(require('../modifiers/namespace'));
+diagnostics.use(require('../adapters/localstorage'));
+diagnostics.use(require('../adapters/hash'));
+diagnostics.set(require('../logger/console'));
+
+//
+// Expose the diagnostics logger.
+//
+module.exports = diagnostics;
diff --git a/sdk/node_modules/@dabh/diagnostics/browser/index.js b/sdk/node_modules/@dabh/diagnostics/browser/index.js
new file mode 100644
index 00000000..ae0f2f80
--- /dev/null
+++ b/sdk/node_modules/@dabh/diagnostics/browser/index.js
@@ -0,0 +1,8 @@
+//
+// Select the correct build version depending on the environment.
+//
+if (process.env.NODE_ENV === 'production') {
+ module.exports = require('./production.js');
+} else {
+ module.exports = require('./development.js');
+}
diff --git a/sdk/node_modules/@dabh/diagnostics/browser/override.js b/sdk/node_modules/@dabh/diagnostics/browser/override.js
new file mode 100644
index 00000000..8f363772
--- /dev/null
+++ b/sdk/node_modules/@dabh/diagnostics/browser/override.js
@@ -0,0 +1,6 @@
+var diagnostics = require('./');
+
+//
+// No way to override `debug` with `diagnostics` in the browser.
+//
+module.exports = diagnostics;
diff --git a/sdk/node_modules/@dabh/diagnostics/browser/production.js b/sdk/node_modules/@dabh/diagnostics/browser/production.js
new file mode 100644
index 00000000..1a19ce39
--- /dev/null
+++ b/sdk/node_modules/@dabh/diagnostics/browser/production.js
@@ -0,0 +1,24 @@
+var create = require('../diagnostics');
+
+/**
+ * Create a new diagnostics logger.
+ *
+ * @param {String} namespace The namespace it should enable.
+ * @param {Object} options Additional options.
+ * @returns {Function} The logger.
+ * @public
+ */
+var diagnostics = create(function prod(namespace, options) {
+ options = options || {};
+ options.namespace = namespace;
+ options.prod = true;
+ options.dev = false;
+
+ if (!(options.force || prod.force)) return prod.nope(options);
+ return prod.yep(options);
+});
+
+//
+// Expose the diagnostics logger.
+//
+module.exports = diagnostics;
diff --git a/sdk/node_modules/@dabh/diagnostics/diagnostics.js b/sdk/node_modules/@dabh/diagnostics/diagnostics.js
new file mode 100644
index 00000000..12dc1f35
--- /dev/null
+++ b/sdk/node_modules/@dabh/diagnostics/diagnostics.js
@@ -0,0 +1,212 @@
+/**
+ * Contains all configured adapters for the given environment.
+ *
+ * @type {Array}
+ * @public
+ */
+var adapters = [];
+
+/**
+ * Contains all modifier functions.
+ *
+ * @typs {Array}
+ * @public
+ */
+var modifiers = [];
+
+/**
+ * Our default logger.
+ *
+ * @public
+ */
+var logger = function devnull() {};
+
+/**
+ * Register a new adapter that will used to find environments.
+ *
+ * @param {Function} adapter A function that will return the possible env.
+ * @returns {Boolean} Indication of a successful add.
+ * @public
+ */
+function use(adapter) {
+ if (~adapters.indexOf(adapter)) return false;
+
+ adapters.push(adapter);
+ return true;
+}
+
+/**
+ * Assign a new log method.
+ *
+ * @param {Function} custom The log method.
+ * @public
+ */
+function set(custom) {
+ logger = custom;
+}
+
+/**
+ * Check if the namespace is allowed by any of our adapters.
+ *
+ * @param {String} namespace The namespace that needs to be enabled
+ * @returns {Boolean|Promise} Indication if the namespace is enabled by our adapters.
+ * @public
+ */
+function enabled(namespace) {
+ var async = [];
+
+ for (var i = 0; i < adapters.length; i++) {
+ if (adapters[i].async) {
+ async.push(adapters[i]);
+ continue;
+ }
+
+ if (adapters[i](namespace)) return true;
+ }
+
+ if (!async.length) return false;
+
+ //
+ // Now that we know that we Async functions, we know we run in an ES6
+ // environment and can use all the API's that they offer, in this case
+ // we want to return a Promise so that we can `await` in React-Native
+ // for an async adapter.
+ //
+ return new Promise(function pinky(resolve) {
+ Promise.all(
+ async.map(function prebind(fn) {
+ return fn(namespace);
+ })
+ ).then(function resolved(values) {
+ resolve(values.some(Boolean));
+ });
+ });
+}
+
+/**
+ * Add a new message modifier to the debugger.
+ *
+ * @param {Function} fn Modification function.
+ * @returns {Boolean} Indication of a successful add.
+ * @public
+ */
+function modify(fn) {
+ if (~modifiers.indexOf(fn)) return false;
+
+ modifiers.push(fn);
+ return true;
+}
+
+/**
+ * Write data to the supplied logger.
+ *
+ * @param {Object} meta Meta information about the log.
+ * @param {Array} args Arguments for console.log.
+ * @public
+ */
+function write() {
+ logger.apply(logger, arguments);
+}
+
+/**
+ * Process the message with the modifiers.
+ *
+ * @param {Mixed} message The message to be transformed by modifers.
+ * @returns {String} Transformed message.
+ * @public
+ */
+function process(message) {
+ for (var i = 0; i < modifiers.length; i++) {
+ message = modifiers[i].apply(modifiers[i], arguments);
+ }
+
+ return message;
+}
+
+/**
+ * Introduce options to the logger function.
+ *
+ * @param {Function} fn Calback function.
+ * @param {Object} options Properties to introduce on fn.
+ * @returns {Function} The passed function
+ * @public
+ */
+function introduce(fn, options) {
+ var has = Object.prototype.hasOwnProperty;
+
+ for (var key in options) {
+ if (has.call(options, key)) {
+ fn[key] = options[key];
+ }
+ }
+
+ return fn;
+}
+
+/**
+ * Nope, we're not allowed to write messages.
+ *
+ * @returns {Boolean} false
+ * @public
+ */
+function nope(options) {
+ options.enabled = false;
+ options.modify = modify;
+ options.set = set;
+ options.use = use;
+
+ return introduce(function diagnopes() {
+ return false;
+ }, options);
+}
+
+/**
+ * Yep, we're allowed to write debug messages.
+ *
+ * @param {Object} options The options for the process.
+ * @returns {Function} The function that does the logging.
+ * @public
+ */
+function yep(options) {
+ /**
+ * The function that receives the actual debug information.
+ *
+ * @returns {Boolean} indication that we're logging.
+ * @public
+ */
+ function diagnostics() {
+ var args = Array.prototype.slice.call(arguments, 0);
+
+ write.call(write, options, process(args, options));
+ return true;
+ }
+
+ options.enabled = true;
+ options.modify = modify;
+ options.set = set;
+ options.use = use;
+
+ return introduce(diagnostics, options);
+}
+
+/**
+ * Simple helper function to introduce various of helper methods to our given
+ * diagnostics function.
+ *
+ * @param {Function} diagnostics The diagnostics function.
+ * @returns {Function} diagnostics
+ * @public
+ */
+module.exports = function create(diagnostics) {
+ diagnostics.introduce = introduce;
+ diagnostics.enabled = enabled;
+ diagnostics.process = process;
+ diagnostics.modify = modify;
+ diagnostics.write = write;
+ diagnostics.nope = nope;
+ diagnostics.yep = yep;
+ diagnostics.set = set;
+ diagnostics.use = use;
+
+ return diagnostics;
+}
diff --git a/sdk/node_modules/@dabh/diagnostics/logger/console.js b/sdk/node_modules/@dabh/diagnostics/logger/console.js
new file mode 100644
index 00000000..7423eff9
--- /dev/null
+++ b/sdk/node_modules/@dabh/diagnostics/logger/console.js
@@ -0,0 +1,19 @@
+/**
+ * An idiot proof logger to be used as default. We've wrapped it in a try/catch
+ * statement to ensure the environments without the `console` API do not crash
+ * as well as an additional fix for ancient browsers like IE8 where the
+ * `console.log` API doesn't have an `apply`, so we need to use the Function's
+ * apply functionality to apply the arguments.
+ *
+ * @param {Object} meta Options of the logger.
+ * @param {Array} messages The actuall message that needs to be logged.
+ * @public
+ */
+module.exports = function (meta, messages) {
+ //
+ // So yea. IE8 doesn't have an apply so we need a work around to puke the
+ // arguments in place.
+ //
+ try { Function.prototype.apply.call(console.log, console, messages); }
+ catch (e) {}
+}
diff --git a/sdk/node_modules/@dabh/diagnostics/modifiers/namespace-ansi.js b/sdk/node_modules/@dabh/diagnostics/modifiers/namespace-ansi.js
new file mode 100644
index 00000000..a1f7353d
--- /dev/null
+++ b/sdk/node_modules/@dabh/diagnostics/modifiers/namespace-ansi.js
@@ -0,0 +1,20 @@
+var colorspace = require('@so-ric/colorspace');
+var kuler = require('kuler');
+
+/**
+ * Prefix the messages with a colored namespace.
+ *
+ * @param {Array} args The messages array that is getting written.
+ * @param {Object} options Options for diagnostics.
+ * @returns {Array} Altered messages array.
+ * @public
+ */
+module.exports = function ansiModifier(args, options) {
+ var namespace = options.namespace;
+ var ansi = options.colors !== false
+ ? kuler(namespace +':', colorspace(namespace))
+ : namespace +':';
+
+ args[0] = ansi +' '+ args[0];
+ return args;
+};
diff --git a/sdk/node_modules/@dabh/diagnostics/modifiers/namespace.js b/sdk/node_modules/@dabh/diagnostics/modifiers/namespace.js
new file mode 100644
index 00000000..5a9dd876
--- /dev/null
+++ b/sdk/node_modules/@dabh/diagnostics/modifiers/namespace.js
@@ -0,0 +1,32 @@
+var colorspace = require('@so-ric/colorspace');
+
+/**
+ * Prefix the messages with a colored namespace.
+ *
+ * @param {Array} messages The messages array that is getting written.
+ * @param {Object} options Options for diagnostics.
+ * @returns {Array} Altered messages array.
+ * @public
+ */
+module.exports = function colorNamespace(args, options) {
+ var namespace = options.namespace;
+
+ if (options.colors === false) {
+ args[0] = namespace +': '+ args[0];
+ return args;
+ }
+
+ var color = colorspace(namespace);
+
+ //
+ // The console API supports a special %c formatter in browsers. This is used
+ // to style console messages with any CSS styling, in our case we want to
+ // use colorize the namespace for clarity. As these are formatters, and
+ // we need to inject our CSS string as second messages argument so it
+ // gets picked up correctly.
+ //
+ args[0] = '%c'+ namespace +':%c '+ args[0];
+ args.splice(1, 0, 'color:'+ color, 'color:inherit');
+
+ return args;
+};
diff --git a/sdk/node_modules/@dabh/diagnostics/node/development.js b/sdk/node_modules/@dabh/diagnostics/node/development.js
new file mode 100644
index 00000000..51dc51b6
--- /dev/null
+++ b/sdk/node_modules/@dabh/diagnostics/node/development.js
@@ -0,0 +1,36 @@
+var create = require('../diagnostics');
+var tty = require('tty').isatty(1);
+
+/**
+ * Create a new diagnostics logger.
+ *
+ * @param {String} namespace The namespace it should enable.
+ * @param {Object} options Additional options.
+ * @returns {Function} The logger.
+ * @public
+ */
+var diagnostics = create(function dev(namespace, options) {
+ options = options || {};
+ options.colors = 'colors' in options ? options.colors : tty;
+ options.namespace = namespace;
+ options.prod = false;
+ options.dev = true;
+
+ if (!dev.enabled(namespace) && !(options.force || dev.force)) {
+ return dev.nope(options);
+ }
+
+ return dev.yep(options);
+});
+
+//
+// Configure the logger for the given environment.
+//
+diagnostics.modify(require('../modifiers/namespace-ansi'));
+diagnostics.use(require('../adapters/process.env'));
+diagnostics.set(require('../logger/console'));
+
+//
+// Expose the diagnostics logger.
+//
+module.exports = diagnostics;
diff --git a/sdk/node_modules/@dabh/diagnostics/node/index.js b/sdk/node_modules/@dabh/diagnostics/node/index.js
new file mode 100644
index 00000000..ae0f2f80
--- /dev/null
+++ b/sdk/node_modules/@dabh/diagnostics/node/index.js
@@ -0,0 +1,8 @@
+//
+// Select the correct build version depending on the environment.
+//
+if (process.env.NODE_ENV === 'production') {
+ module.exports = require('./production.js');
+} else {
+ module.exports = require('./development.js');
+}
diff --git a/sdk/node_modules/@dabh/diagnostics/node/override.js b/sdk/node_modules/@dabh/diagnostics/node/override.js
new file mode 100644
index 00000000..936e28be
--- /dev/null
+++ b/sdk/node_modules/@dabh/diagnostics/node/override.js
@@ -0,0 +1,21 @@
+const diagnostics = require('./');
+
+//
+// Override the existing `debug` call so it will use `diagnostics` instead
+// of the `debug` module.
+//
+try {
+ var key = require.resolve('debug');
+
+ require.cache[key] = {
+ exports: diagnostics,
+ filename: key,
+ loaded: true,
+ id: key
+ };
+} catch (e) { /* We don't really care if it fails */ }
+
+//
+// Export the default import as exports again.
+//
+module.exports = diagnostics;
diff --git a/sdk/node_modules/@dabh/diagnostics/node/production.js b/sdk/node_modules/@dabh/diagnostics/node/production.js
new file mode 100644
index 00000000..1a19ce39
--- /dev/null
+++ b/sdk/node_modules/@dabh/diagnostics/node/production.js
@@ -0,0 +1,24 @@
+var create = require('../diagnostics');
+
+/**
+ * Create a new diagnostics logger.
+ *
+ * @param {String} namespace The namespace it should enable.
+ * @param {Object} options Additional options.
+ * @returns {Function} The logger.
+ * @public
+ */
+var diagnostics = create(function prod(namespace, options) {
+ options = options || {};
+ options.namespace = namespace;
+ options.prod = true;
+ options.dev = false;
+
+ if (!(options.force || prod.force)) return prod.nope(options);
+ return prod.yep(options);
+});
+
+//
+// Expose the diagnostics logger.
+//
+module.exports = diagnostics;
diff --git a/sdk/node_modules/@dabh/diagnostics/package.json b/sdk/node_modules/@dabh/diagnostics/package.json
new file mode 100644
index 00000000..89f86508
--- /dev/null
+++ b/sdk/node_modules/@dabh/diagnostics/package.json
@@ -0,0 +1,64 @@
+{
+ "name": "@dabh/diagnostics",
+ "version": "2.0.8",
+ "description": "Tools for debugging your node.js modules and event loop",
+ "main": "./node",
+ "browser": "./browser",
+ "scripts": {
+ "test:basic": "mocha --require test/mock.js test/*.test.js",
+ "test:node": "mocha --require test/mock test/node.js",
+ "test:browser": "mocha --require test/mock test/browser.js",
+ "test:runner": "npm run test:basic && npm run test:node && npm run test:browser",
+ "webpack:node:prod": "webpack --mode=production node/index.js -o /dev/null --json | webpack-bundle-size-analyzer",
+ "webpack:node:dev": "webpack --mode=development node/index.js -o /dev/null --json | webpack-bundle-size-analyzer",
+ "webpack:browser:prod": "webpack --mode=production browser/index.js -o /dev/null --json | webpack-bundle-size-analyzer",
+ "webpack:browser:dev": "webpack --mode=development browser/index.js -o /dev/null --json | webpack-bundle-size-analyzer",
+ "test": "nyc --reporter=text --reporter=lcov npm run test:runner"
+ },
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/DABH/diagnostics.git"
+ },
+ "keywords": [
+ "debug",
+ "debugger",
+ "debugging",
+ "diagnostic",
+ "diagnostics",
+ "event",
+ "loop",
+ "metrics",
+ "stats"
+ ],
+ "author": "Arnout Kazemier",
+ "license": "MIT",
+ "bugs": {
+ "url": "https://github.com/DABH/diagnostics/issues"
+ },
+ "homepage": "https://github.com/DABH/diagnostics",
+ "devDependencies": {
+ "assume": "2.3.x",
+ "asyncstorageapi": "^1.0.2",
+ "mocha": "^11.7.2",
+ "nyc": "^17.1.0",
+ "objstorage": "^1.0.0",
+ "pre-commit": "github:metcalfc/pre-commit#b36c649fd5348d7604a86b7b2f3429c780d1478f",
+ "require-poisoning": "^2.0.0",
+ "webpack": "5.x",
+ "webpack-bundle-size-analyzer": "^3.0.0",
+ "webpack-cli": "6.x"
+ },
+ "dependencies": {
+ "@so-ric/colorspace": "^1.1.6",
+ "enabled": "2.0.x",
+ "kuler": "^2.0.0"
+ },
+ "contributors": [
+ "Martijn Swaagman (https://github.com/swaagie)",
+ "Jarrett Cruger (https://github.com/jcrugzz)",
+ "Sevastos (https://github.com/sevastos)"
+ ],
+ "directories": {
+ "test": "test"
+ }
+}
diff --git a/sdk/node_modules/@esbuild/darwin-arm64/README.md b/sdk/node_modules/@esbuild/darwin-arm64/README.md
new file mode 100644
index 00000000..c2c0398d
--- /dev/null
+++ b/sdk/node_modules/@esbuild/darwin-arm64/README.md
@@ -0,0 +1,3 @@
+# esbuild
+
+This is the macOS ARM 64-bit binary for esbuild, a JavaScript bundler and minifier. See https://github.com/evanw/esbuild for details.
diff --git a/sdk/node_modules/@esbuild/darwin-arm64/bin/esbuild b/sdk/node_modules/@esbuild/darwin-arm64/bin/esbuild
new file mode 100755
index 00000000..5b2a9793
Binary files /dev/null and b/sdk/node_modules/@esbuild/darwin-arm64/bin/esbuild differ
diff --git a/sdk/node_modules/@esbuild/darwin-arm64/package.json b/sdk/node_modules/@esbuild/darwin-arm64/package.json
new file mode 100644
index 00000000..8a825f37
--- /dev/null
+++ b/sdk/node_modules/@esbuild/darwin-arm64/package.json
@@ -0,0 +1,17 @@
+{
+ "name": "@esbuild/darwin-arm64",
+ "version": "0.18.20",
+ "description": "The macOS ARM 64-bit binary for esbuild, a JavaScript bundler.",
+ "repository": "https://github.com/evanw/esbuild",
+ "license": "MIT",
+ "preferUnplugged": true,
+ "engines": {
+ "node": ">=12"
+ },
+ "os": [
+ "darwin"
+ ],
+ "cpu": [
+ "arm64"
+ ]
+}
diff --git a/sdk/node_modules/@fastify/ajv-compiler/.gitattributes b/sdk/node_modules/@fastify/ajv-compiler/.gitattributes
new file mode 100644
index 00000000..a0e7df93
--- /dev/null
+++ b/sdk/node_modules/@fastify/ajv-compiler/.gitattributes
@@ -0,0 +1,2 @@
+# Set default behavior to automatically convert line endings
+* text=auto eol=lf
diff --git a/sdk/node_modules/@fastify/ajv-compiler/.github/.stale.yml b/sdk/node_modules/@fastify/ajv-compiler/.github/.stale.yml
new file mode 100644
index 00000000..2ee12691
--- /dev/null
+++ b/sdk/node_modules/@fastify/ajv-compiler/.github/.stale.yml
@@ -0,0 +1,21 @@
+# Number of days of inactivity before an issue becomes stale
+daysUntilStale: 15
+# Number of days of inactivity before a stale issue is closed
+daysUntilClose: 7
+# Issues with these labels will never be considered stale
+exemptLabels:
+ - "discussion"
+ - "feature request"
+ - "bug"
+ - "help wanted"
+ - "plugin suggestion"
+ - "good first issue"
+# Label to use when marking an issue as stale
+staleLabel: stale
+# Comment to post when marking an issue as stale. Set to `false` to disable
+markComment: >
+ This issue has been automatically marked as stale because it has not had
+ recent activity. It will be closed if no further activity occurs. Thank you
+ for your contributions.
+# Comment to post when closing a stale issue. Set to `false` to disable
+closeComment: false
\ No newline at end of file
diff --git a/sdk/node_modules/@fastify/ajv-compiler/.github/dependabot.yml b/sdk/node_modules/@fastify/ajv-compiler/.github/dependabot.yml
new file mode 100644
index 00000000..dfa7fa6c
--- /dev/null
+++ b/sdk/node_modules/@fastify/ajv-compiler/.github/dependabot.yml
@@ -0,0 +1,13 @@
+version: 2
+updates:
+ - package-ecosystem: "github-actions"
+ directory: "/"
+ schedule:
+ interval: "monthly"
+ open-pull-requests-limit: 10
+
+ - package-ecosystem: "npm"
+ directory: "/"
+ schedule:
+ interval: "weekly"
+ open-pull-requests-limit: 10
diff --git a/sdk/node_modules/@fastify/ajv-compiler/.github/tests_checker.yml b/sdk/node_modules/@fastify/ajv-compiler/.github/tests_checker.yml
new file mode 100644
index 00000000..769469b2
--- /dev/null
+++ b/sdk/node_modules/@fastify/ajv-compiler/.github/tests_checker.yml
@@ -0,0 +1,8 @@
+comment: |
+ Hello! Thank you for contributing!
+ It appears that you have changed the code, but the tests that verify your change are missing. Could you please add them?
+fileExtensions:
+ - '.ts'
+ - '.js'
+
+testDir: 'test'
\ No newline at end of file
diff --git a/sdk/node_modules/@fastify/ajv-compiler/.github/workflows/ci.yml b/sdk/node_modules/@fastify/ajv-compiler/.github/workflows/ci.yml
new file mode 100644
index 00000000..f3df83a4
--- /dev/null
+++ b/sdk/node_modules/@fastify/ajv-compiler/.github/workflows/ci.yml
@@ -0,0 +1,26 @@
+name: Continuous Integration
+
+on:
+ push:
+ branches:
+ - main
+ - master
+ - next
+ - 'v*'
+ paths-ignore:
+ - 'docs/**'
+ - '*.md'
+ pull_request:
+ paths-ignore:
+ - 'docs/**'
+ - '*.md'
+
+env:
+ TZ: 'UTC'
+
+jobs:
+ test:
+ uses: fastify/workflows/.github/workflows/plugins-ci.yml@v3
+ with:
+ lint: true
+ license-check: true
diff --git a/sdk/node_modules/@fastify/ajv-compiler/.taprc b/sdk/node_modules/@fastify/ajv-compiler/.taprc
new file mode 100644
index 00000000..7695d35c
--- /dev/null
+++ b/sdk/node_modules/@fastify/ajv-compiler/.taprc
@@ -0,0 +1,2 @@
+files:
+ - test/**/*.test.js
\ No newline at end of file
diff --git a/sdk/node_modules/@fastify/ajv-compiler/LICENSE b/sdk/node_modules/@fastify/ajv-compiler/LICENSE
new file mode 100644
index 00000000..7f6f4824
--- /dev/null
+++ b/sdk/node_modules/@fastify/ajv-compiler/LICENSE
@@ -0,0 +1,24 @@
+MIT License
+
+Copyright (c) The Fastify Team
+
+The Fastify team members are listed at https://github.com/fastify/fastify#team
+and in the README file.
+
+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.
diff --git a/sdk/node_modules/@fastify/ajv-compiler/README.md b/sdk/node_modules/@fastify/ajv-compiler/README.md
new file mode 100644
index 00000000..bb62ca3a
--- /dev/null
+++ b/sdk/node_modules/@fastify/ajv-compiler/README.md
@@ -0,0 +1,236 @@
+# @fastify/ajv-compiler
+
+[](http://standardjs.com/)
+[](https://github.com/fastify/ajv-compiler/actions/workflows/ci.yml)
+
+This module manages the [`ajv`](https://www.npmjs.com/package/ajv) instances for the Fastify framework.
+It isolates the `ajv` dependency so that the AJV version is not tightly coupled to the Fastify version.
+This allows the user to decide which version of AJV to use in their Fastify based application.
+
+
+## Versions
+
+| `@fastify/ajv-compiler` | `ajv` | Default in `fastify` |
+|------------------------:|------:|---------------------:|
+| v1.x | v6.x | ^3.14 |
+| v2.x | v8.x | - |
+| v3.x | v8.x | ^4.x |
+
+
+### AJV Configuration
+
+The Fastify's default [`ajv` options](https://github.com/ajv-validator/ajv/tree/v6#options) are:
+
+```js
+{
+ coerceTypes: 'array',
+ useDefaults: true,
+ removeAdditional: true,
+ uriResolver: require('fast-uri'),
+ addUsedSchema: false,
+ // Explicitly set allErrors to `false`.
+ // When set to `true`, a DoS attack is possible.
+ allErrors: false
+}
+```
+
+Moreover, the [`ajv-formats`](https://www.npmjs.com/package/ajv-formats) module is included by default.
+If you need to customize it, check the _usage_ section below.
+
+To customize the `ajv`'s options, see how in the [Fastify official docs](https://fastify.dev/docs/latest/Reference/Server/#ajv).
+
+
+## Usage
+
+This module is already used as default by Fastify.
+If you need to provide to your server instance a different version, refer to [the official doc](https://fastify.dev/docs/latest/Reference/Server/#schemacontroller).
+
+### Customize the `ajv-formats` plugin
+
+The `format` keyword is not part of the official `ajv` module since v7. To use it, you need to install the `ajv-formats` module and this module
+does it for you with the default configuration.
+
+If you need to configure the `ajv-formats` plugin you can do it using the standard Fastify configuration:
+
+```js
+const app = fastify({
+ ajv: {
+ plugins: [[require('ajv-formats'), { mode: 'fast' }]]
+ }
+})
+```
+
+In this way, your setup will have precendence over the `@fastify/ajv-compiler` default configuration.
+
+### Customize the `ajv` instance
+
+If you need to customize the `ajv` instance and take full control of its configuration, you can do it by
+using the `onCreate` option in the Fastify configuration that accepts a syncronous function that receives the `ajv` instance:
+
+```js
+const app = fastify({
+ ajv: {
+ onCreate: (ajv) => {
+ // Modify the ajv instance as you need.
+ ajv.addFormat('myFormat', (data) => typeof data === 'string')
+ }
+ }
+})
+```
+
+### Fastify with JTD
+
+The [JSON Type Definition](https://jsontypedef.com/) feature is supported by AJV v8.x and you can benefit from it in your Fastify application.
+
+With Fastify v3.20.x and higher, you can use the `@fastify/ajv-compiler` module to load JSON Type Definitions like so:
+
+```js
+const factory = require('@fastify/ajv-compiler')()
+
+const app = fastify({
+ jsonShorthand: false,
+ ajv: {
+ customOptions: { }, // additional JTD options
+ mode: 'JTD'
+ },
+ schemaController: {
+ compilersFactory: {
+ buildValidator: factory
+ }
+ }
+})
+```
+
+The defaults AJV JTD options are the same as the [Fastify's default options](#AJV-Configuration).
+
+#### Fastify with JTD and serialization
+
+You can use JTD Schemas to serialize your response object too:
+
+```js
+const factoryValidator = require('@fastify/ajv-compiler')()
+const factorySerializer = require('@fastify/ajv-compiler')({ jtdSerializer: true })
+
+const app = fastify({
+ jsonShorthand: false,
+ ajv: {
+ customOptions: { }, // additional JTD options
+ mode: 'JTD'
+ },
+ schemaController: {
+ compilersFactory: {
+ buildValidator: factoryValidator,
+ buildSerializer: factorySerializer
+ }
+ }
+})
+```
+
+
+### AJV Standalone
+
+AJV v8 introduces the [standalone feature](https://ajv.js.org/standalone.html) that let you to pre-compile your schemas and use them in your application for a faster startup.
+
+To use this feature, you must be aware of the following:
+
+1. You must generate and save the application's compiled schemas.
+2. Read the compiled schemas from the file and provide them back to your Fastify application.
+
+
+#### Generate and save the compiled schemas
+
+Fastify helps you to generate the validation schemas functions and it is your choice to save them where you want.
+To accomplish this, you must use a new compiler: `StandaloneValidator`.
+
+You must provide 2 parameters to this compiler:
+
+- `readMode: false`: a boolean to indicate that you want generate the schemas functions string.
+- `storeFunction`" a sync function that must store the source code of the schemas functions. You may provide an async function too, but you must manage errors.
+
+When `readMode: false`, **the compiler is meant to be used in development ONLY**.
+
+
+```js
+const { StandaloneValidator } = require('@fastify/ajv-compiler')
+const factory = StandaloneValidator({
+ readMode: false,
+ storeFunction (routeOpts, schemaValidationCode) {
+ // routeOpts is like: { schema, method, url, httpPart }
+ // schemaValidationCode is a string source code that is the compiled schema function
+ const fileName = generateFileName(routeOpts)
+ fs.writeFileSync(path.join(__dirname, fileName), schemaValidationCode)
+ }
+})
+
+const app = fastify({
+ jsonShorthand: false,
+ schemaController: {
+ compilersFactory: {
+ buildValidator: factory
+ }
+ }
+})
+
+// ... add all your routes with schemas ...
+
+app.ready().then(() => {
+ // at this stage all your schemas are compiled and stored in the file system
+ // now it is important to turn off the readMode
+})
+```
+
+#### Read the compiled schemas functions
+
+At this stage, you should have a file for every route's schema.
+To use them, you must use the `StandaloneValidator` with the parameters:
+
+- `readMode: true`: a boolean to indicate that you want read and use the schemas functions string.
+- `restoreFunction`" a sync function that must return a function to validate the route.
+
+Important keep away before you continue reading the documentation:
+
+- when you use the `readMode: true`, the application schemas are not compiled (they are ignored). So, if you change your schemas, you must recompile them!
+- as you can see, you must relate the route's schema to the file name using the `routeOpts` object. You may use the `routeOpts.schema.$id` field to do so, it is up to you to define a unique schema identifier.
+
+```js
+const { StandaloneValidator } = require('@fastify/ajv-compiler')
+const factory = StandaloneValidator({
+ readMode: true,
+ restoreFunction (routeOpts) {
+ // routeOpts is like: { schema, method, url, httpPart }
+ const fileName = generateFileName(routeOpts)
+ return require(path.join(__dirname, fileName))
+ }
+})
+
+const app = fastify({
+ jsonShorthand: false,
+ schemaController: {
+ compilersFactory: {
+ buildValidator: factory
+ }
+ }
+})
+
+// ... add all your routes with schemas as before...
+
+app.listen({ port: 3000 })
+```
+
+### How it works
+
+This module provide a factory function to produce [Validator Compilers](https://fastify.dev/docs/latest/Reference/Server/#validatorcompiler) functions.
+
+The Fastify factory function is just one per server instance and it is called for every encapsulated context created by the application through the `fastify.register()` call.
+
+Every Validator Compiler produced, has a dedicated AJV instance, so, this factory will try to produce as less as possible AJV instances to reduce the memory footprint and the startup time.
+
+The variables involved to choose if a Validator Compiler can be reused are:
+
+- the AJV configuration: it is [one per server](https://fastify.dev/docs/latest/Reference/Server/#ajv)
+- the external JSON schemas: once a new schema is added to a fastify's context, calling `fastify.addSchema()`, it will cause a new AJV inizialization
+
+
+## License
+
+Licensed under [MIT](./LICENSE).
diff --git a/sdk/node_modules/@fastify/ajv-compiler/benchmark/small-object.mjs b/sdk/node_modules/@fastify/ajv-compiler/benchmark/small-object.mjs
new file mode 100644
index 00000000..a2065823
--- /dev/null
+++ b/sdk/node_modules/@fastify/ajv-compiler/benchmark/small-object.mjs
@@ -0,0 +1,37 @@
+import cronometro from 'cronometro'
+
+import fjs from 'fast-json-stringify'
+import AjvCompiler from '../index.js'
+
+const fjsSerialize = buildFJSSerializerFunction({
+ type: 'object',
+ properties: {
+ hello: { type: 'string' },
+ name: { type: 'string' }
+ }
+})
+const ajvSerialize = buildAJVSerializerFunction({
+ properties: {
+ hello: { type: 'string' },
+ name: { type: 'string' }
+ }
+})
+
+await cronometro({
+ 'fast-json-stringify': function () {
+ fjsSerialize({ hello: 'Ciao', name: 'Manuel' })
+ },
+ 'ajv serializer': function () {
+ ajvSerialize({ hello: 'Ciao', name: 'Manuel' })
+ }
+})
+
+function buildFJSSerializerFunction (schema) {
+ return fjs(schema)
+}
+
+function buildAJVSerializerFunction (schema) {
+ const factory = AjvCompiler({ jtdSerializer: true })
+ const compiler = factory({}, { customOptions: {} })
+ return compiler({ schema })
+}
diff --git a/sdk/node_modules/@fastify/ajv-compiler/index.js b/sdk/node_modules/@fastify/ajv-compiler/index.js
new file mode 100644
index 00000000..2274766b
--- /dev/null
+++ b/sdk/node_modules/@fastify/ajv-compiler/index.js
@@ -0,0 +1,53 @@
+'use strict'
+
+const AjvReference = Symbol.for('fastify.ajv-compiler.reference')
+const ValidatorCompiler = require('./lib/validator-compiler')
+const SerializerCompiler = require('./lib/serializer-compiler')
+
+function AjvCompiler (opts) {
+ const validatorPool = new Map()
+ const serializerPool = new Map()
+
+ if (opts && opts.jtdSerializer === true) {
+ return function buildSerializerFromPool (externalSchemas, serializerOpts) {
+ const uniqueAjvKey = getPoolKey({}, serializerOpts)
+ if (serializerPool.has(uniqueAjvKey)) {
+ return serializerPool.get(uniqueAjvKey)
+ }
+
+ const compiler = new SerializerCompiler(externalSchemas, serializerOpts)
+ const ret = compiler.buildSerializerFunction.bind(compiler)
+ serializerPool.set(uniqueAjvKey, ret)
+
+ return ret
+ }
+ }
+
+ return function buildCompilerFromPool (externalSchemas, options) {
+ const uniqueAjvKey = getPoolKey(externalSchemas, options.customOptions)
+ if (validatorPool.has(uniqueAjvKey)) {
+ return validatorPool.get(uniqueAjvKey)
+ }
+
+ const compiler = new ValidatorCompiler(externalSchemas, options)
+ const ret = compiler.buildValidatorFunction.bind(compiler)
+ validatorPool.set(uniqueAjvKey, ret)
+
+ if (options.customOptions.code !== undefined) {
+ ret[AjvReference] = compiler
+ }
+
+ return ret
+ }
+}
+
+function getPoolKey (externalSchemas, options) {
+ const externals = JSON.stringify(externalSchemas)
+ const ajvConfig = JSON.stringify(options)
+ return `${externals}${ajvConfig}`
+}
+module.exports = AjvCompiler
+module.exports.default = AjvCompiler
+module.exports.AjvCompiler = AjvCompiler
+module.exports.AjvReference = AjvReference
+module.exports.StandaloneValidator = require('./standalone')
diff --git a/sdk/node_modules/@fastify/ajv-compiler/lib/default-ajv-options.js b/sdk/node_modules/@fastify/ajv-compiler/lib/default-ajv-options.js
new file mode 100644
index 00000000..57c1fd8b
--- /dev/null
+++ b/sdk/node_modules/@fastify/ajv-compiler/lib/default-ajv-options.js
@@ -0,0 +1,14 @@
+'use strict'
+
+const fastUri = require('fast-uri')
+
+module.exports = Object.freeze({
+ coerceTypes: 'array',
+ useDefaults: true,
+ removeAdditional: true,
+ uriResolver: fastUri,
+ addUsedSchema: false,
+ // Explicitly set allErrors to `false`.
+ // When set to `true`, a DoS attack is possible.
+ allErrors: false
+})
diff --git a/sdk/node_modules/@fastify/ajv-compiler/lib/serializer-compiler.js b/sdk/node_modules/@fastify/ajv-compiler/lib/serializer-compiler.js
new file mode 100644
index 00000000..9d1298ca
--- /dev/null
+++ b/sdk/node_modules/@fastify/ajv-compiler/lib/serializer-compiler.js
@@ -0,0 +1,27 @@
+'use strict'
+
+const AjvJTD = require('ajv/dist/jtd')
+
+const defaultAjvOptions = require('./default-ajv-options')
+
+class SerializerCompiler {
+ constructor (externalSchemas, options) {
+ this.ajv = new AjvJTD(Object.assign({}, defaultAjvOptions, options))
+
+ /**
+ * https://ajv.js.org/json-type-definition.html#ref-form
+ * Unlike JSON Schema, JTD does not allow to reference:
+ * - any schema fragment other than root level definitions member
+ * - root of the schema - there is another way to define a self-recursive schema (see Example 2)
+ * - another schema file (but you can still combine schemas from multiple files using JavaScript).
+ *
+ * So we ignore the externalSchemas parameter.
+ */
+ }
+
+ buildSerializerFunction ({ schema/*, method, url, httpStatus */ }) {
+ return this.ajv.compileSerializer(schema)
+ }
+}
+
+module.exports = SerializerCompiler
diff --git a/sdk/node_modules/@fastify/ajv-compiler/lib/validator-compiler.js b/sdk/node_modules/@fastify/ajv-compiler/lib/validator-compiler.js
new file mode 100644
index 00000000..890d0041
--- /dev/null
+++ b/sdk/node_modules/@fastify/ajv-compiler/lib/validator-compiler.js
@@ -0,0 +1,58 @@
+'use strict'
+
+const Ajv = require('ajv').default
+const AjvJTD = require('ajv/dist/jtd')
+
+const defaultAjvOptions = require('./default-ajv-options')
+
+class ValidatorCompiler {
+ constructor (externalSchemas, options) {
+ // This instance of Ajv is private
+ // it should not be customized or used
+ if (options.mode === 'JTD') {
+ this.ajv = new AjvJTD(Object.assign({}, defaultAjvOptions, options.customOptions))
+ } else {
+ this.ajv = new Ajv(Object.assign({}, defaultAjvOptions, options.customOptions))
+ }
+
+ let addFormatPlugin = true
+ if (options.plugins && options.plugins.length > 0) {
+ for (const plugin of options.plugins) {
+ if (Array.isArray(plugin)) {
+ addFormatPlugin = addFormatPlugin && plugin[0].name !== 'formatsPlugin'
+ plugin[0](this.ajv, plugin[1])
+ } else {
+ addFormatPlugin = addFormatPlugin && plugin.name !== 'formatsPlugin'
+ plugin(this.ajv)
+ }
+ }
+ }
+
+ if (addFormatPlugin) {
+ require('ajv-formats')(this.ajv)
+ }
+
+ options.onCreate?.(this.ajv)
+
+ const sourceSchemas = Object.values(externalSchemas)
+ for (const extSchema of sourceSchemas) {
+ this.ajv.addSchema(extSchema)
+ }
+ }
+
+ buildValidatorFunction ({ schema/*, method, url, httpPart */ }) {
+ // Ajv does not support compiling two schemas with the same
+ // id inside the same instance. Therefore if we have already
+ // compiled the schema with the given id, we just return it.
+ if (schema.$id) {
+ const stored = this.ajv.getSchema(schema.$id)
+ if (stored) {
+ return stored
+ }
+ }
+
+ return this.ajv.compile(schema)
+ }
+}
+
+module.exports = ValidatorCompiler
diff --git a/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/.gitattributes b/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/.gitattributes
new file mode 100644
index 00000000..a0e7df93
--- /dev/null
+++ b/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/.gitattributes
@@ -0,0 +1,2 @@
+# Set default behavior to automatically convert line endings
+* text=auto eol=lf
diff --git a/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/.github/.stale.yml b/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/.github/.stale.yml
new file mode 100644
index 00000000..2ee12691
--- /dev/null
+++ b/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/.github/.stale.yml
@@ -0,0 +1,21 @@
+# Number of days of inactivity before an issue becomes stale
+daysUntilStale: 15
+# Number of days of inactivity before a stale issue is closed
+daysUntilClose: 7
+# Issues with these labels will never be considered stale
+exemptLabels:
+ - "discussion"
+ - "feature request"
+ - "bug"
+ - "help wanted"
+ - "plugin suggestion"
+ - "good first issue"
+# Label to use when marking an issue as stale
+staleLabel: stale
+# Comment to post when marking an issue as stale. Set to `false` to disable
+markComment: >
+ This issue has been automatically marked as stale because it has not had
+ recent activity. It will be closed if no further activity occurs. Thank you
+ for your contributions.
+# Comment to post when closing a stale issue. Set to `false` to disable
+closeComment: false
\ No newline at end of file
diff --git a/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/.github/dependabot.yml b/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/.github/dependabot.yml
new file mode 100644
index 00000000..dfa7fa6c
--- /dev/null
+++ b/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/.github/dependabot.yml
@@ -0,0 +1,13 @@
+version: 2
+updates:
+ - package-ecosystem: "github-actions"
+ directory: "/"
+ schedule:
+ interval: "monthly"
+ open-pull-requests-limit: 10
+
+ - package-ecosystem: "npm"
+ directory: "/"
+ schedule:
+ interval: "weekly"
+ open-pull-requests-limit: 10
diff --git a/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/.github/tests_checker.yml b/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/.github/tests_checker.yml
new file mode 100644
index 00000000..769469b2
--- /dev/null
+++ b/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/.github/tests_checker.yml
@@ -0,0 +1,8 @@
+comment: |
+ Hello! Thank you for contributing!
+ It appears that you have changed the code, but the tests that verify your change are missing. Could you please add them?
+fileExtensions:
+ - '.ts'
+ - '.js'
+
+testDir: 'test'
\ No newline at end of file
diff --git a/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/.github/workflows/ci.yml b/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/.github/workflows/ci.yml
new file mode 100644
index 00000000..babd56de
--- /dev/null
+++ b/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/.github/workflows/ci.yml
@@ -0,0 +1,22 @@
+name: CI
+
+on:
+ push:
+ branches:
+ - main
+ - master
+ - next
+ - 'v*'
+ paths-ignore:
+ - 'docs/**'
+ - '*.md'
+ pull_request:
+ paths-ignore:
+ - 'docs/**'
+ - '*.md'
+
+jobs:
+ test:
+ uses: fastify/workflows/.github/workflows/plugins-ci.yml@v3
+ with:
+ license-check: true
diff --git a/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/.github/workflows/package-manager-ci.yml b/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/.github/workflows/package-manager-ci.yml
new file mode 100644
index 00000000..89d450f7
--- /dev/null
+++ b/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/.github/workflows/package-manager-ci.yml
@@ -0,0 +1,20 @@
+name: package-manager-ci
+
+on:
+ push:
+ branches:
+ - main
+ - master
+ - next
+ - 'v*'
+ paths-ignore:
+ - 'docs/**'
+ - '*.md'
+ pull_request:
+ paths-ignore:
+ - 'docs/**'
+ - '*.md'
+
+jobs:
+ test:
+ uses: fastify/workflows/.github/workflows/plugins-ci-package-manager.yml@v3
diff --git a/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/.taprc b/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/.taprc
new file mode 100644
index 00000000..d51127c4
--- /dev/null
+++ b/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/.taprc
@@ -0,0 +1 @@
+check-coverage: false
diff --git a/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/LICENSE b/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/LICENSE
new file mode 100644
index 00000000..a8d3465e
--- /dev/null
+++ b/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/LICENSE
@@ -0,0 +1,30 @@
+Copyright (c) 2021 The Fastify Team
+Copyright (c) 2011-2021, Gary Court until https://github.com/garycourt/uri-js/commit/a1acf730b4bba3f1097c9f52e7d9d3aba8cdcaae
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+ * The names of any contributors may not be used to endorse or promote
+ products derived from this software without specific prior written
+ permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS AND CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ * * *
+
+The complete list of contributors can be found at:
+- https://github.com/garycourt/uri-js/graphs/contributors
\ No newline at end of file
diff --git a/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/README.md b/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/README.md
new file mode 100644
index 00000000..fe12d92c
--- /dev/null
+++ b/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/README.md
@@ -0,0 +1,125 @@
+# fast-uri
+
+
+
+[](https://github.com/fastify/fast-uri/actions/workflows/ci.yml)
+[](https://standardjs.com/)
+
+
+
+Dependency free RFC 3986 URI toolbox.
+
+## Usage
+
+## Options
+
+All of the above functions can accept an additional options argument that is an object that can contain one or more of the following properties:
+
+* `scheme` (string)
+ Indicates the scheme that the URI should be treated as, overriding the URI's normal scheme parsing behavior.
+
+* `reference` (string)
+ If set to `"suffix"`, it indicates that the URI is in the suffix format and the parser will use the option's `scheme` property to determine the URI's scheme.
+
+* `tolerant` (boolean, false)
+ If set to `true`, the parser will relax URI resolving rules.
+
+* `absolutePath` (boolean, false)
+ If set to `true`, the serializer will not resolve a relative `path` component.
+
+* `unicodeSupport` (boolean, false)
+ If set to `true`, the parser will unescape non-ASCII characters in the parsed output as per [RFC 3987](http://www.ietf.org/rfc/rfc3987.txt).
+
+* `domainHost` (boolean, false)
+ If set to `true`, the library will treat the `host` component as a domain name, and convert IDNs (International Domain Names) as per [RFC 5891](http://www.ietf.org/rfc/rfc5891.txt).
+
+### Parse
+
+```js
+const uri = require('fast-uri')
+uri.parse('uri://user:pass@example.com:123/one/two.three?q1=a1&q2=a2#body')
+// Output
+{
+ scheme : "uri",
+ userinfo : "user:pass",
+ host : "example.com",
+ port : 123,
+ path : "/one/two.three",
+ query : "q1=a1&q2=a2",
+ fragment : "body"
+}
+```
+
+### Serialize
+
+```js
+const uri = require('fast-uri')
+uri.serialize({scheme : "http", host : "example.com", fragment : "footer"})
+// Output
+"http://example.com/#footer"
+
+```
+
+### Resolve
+
+```js
+const uri = require('fast-uri')
+uri.resolve("uri://a/b/c/d?q", "../../g")
+// Output
+"uri://a/g"
+```
+
+### Equal
+
+```js
+const uri = require('fast-uri')
+uri.equal("example://a/b/c/%7Bfoo%7D", "eXAMPLE://a/./b/../b/%63/%7bfoo%7d")
+// Output
+true
+```
+
+## Scheme supports
+
+fast-uri supports inserting custom [scheme](http://en.wikipedia.org/wiki/URI_scheme) dependent processing rules. Currently, fast-uri has built in support for the following schemes:
+
+* http \[[RFC 2616](http://www.ietf.org/rfc/rfc2616.txt)\]
+* https \[[RFC 2818](http://www.ietf.org/rfc/rfc2818.txt)\]
+* ws \[[RFC 6455](http://www.ietf.org/rfc/rfc6455.txt)\]
+* wss \[[RFC 6455](http://www.ietf.org/rfc/rfc6455.txt)\]
+* urn \[[RFC 2141](http://www.ietf.org/rfc/rfc2141.txt)\]
+* urn:uuid \[[RFC 4122](http://www.ietf.org/rfc/rfc4122.txt)\]
+
+
+## Benchmarks
+
+```
+fast-uri: parse domain x 1,306,864 ops/sec ±0.31% (100 runs sampled)
+urijs: parse domain x 483,001 ops/sec ±0.09% (99 runs sampled)
+WHATWG URL: parse domain x 862,461 ops/sec ±0.18% (97 runs sampled)
+fast-uri: parse IPv4 x 2,381,452 ops/sec ±0.26% (96 runs sampled)
+urijs: parse IPv4 x 384,705 ops/sec ±0.34% (99 runs sampled)
+WHATWG URL: parse IPv4 NOT SUPPORTED
+fast-uri: parse IPv6 x 923,519 ops/sec ±0.09% (100 runs sampled)
+urijs: parse IPv6 x 289,070 ops/sec ±0.07% (95 runs sampled)
+WHATWG URL: parse IPv6 NOT SUPPORTED
+fast-uri: parse URN x 2,596,395 ops/sec ±0.42% (98 runs sampled)
+urijs: parse URN x 1,152,412 ops/sec ±0.09% (97 runs sampled)
+WHATWG URL: parse URN x 1,183,307 ops/sec ±0.38% (100 runs sampled)
+fast-uri: parse URN uuid x 1,666,861 ops/sec ±0.10% (98 runs sampled)
+urijs: parse URN uuid x 852,724 ops/sec ±0.17% (95 runs sampled)
+WHATWG URL: parse URN uuid NOT SUPPORTED
+fast-uri: serialize uri x 1,741,499 ops/sec ±0.57% (95 runs sampled)
+urijs: serialize uri x 389,014 ops/sec ±0.28% (93 runs sampled)
+fast-uri: serialize IPv6 x 441,095 ops/sec ±0.37% (97 runs sampled)
+urijs: serialize IPv6 x 255,443 ops/sec ±0.58% (94 runs sampled)
+fast-uri: serialize ws x 1,448,667 ops/sec ±0.25% (97 runs sampled)
+urijs: serialize ws x 352,884 ops/sec ±0.08% (96 runs sampled)
+fast-uri: resolve x 340,084 ops/sec ±0.98% (98 runs sampled)
+urijs: resolve x 225,759 ops/sec ±0.37% (95 runs sampled)
+```
+
+## TODO
+
+- [ ] Support MailTo
+- [ ] Be 100% iso compatible with uri-js
+- [ ] Add browser test stack
diff --git a/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/benchmark.js b/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/benchmark.js
new file mode 100644
index 00000000..5eed73e0
--- /dev/null
+++ b/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/benchmark.js
@@ -0,0 +1,105 @@
+'use strict'
+
+const benchmark = require('benchmark')
+const suite = new benchmark.Suite()
+const fasturi = require('./')
+const urijs = require('uri-js')
+
+const base = 'uri://a/b/c/d;p?q'
+
+const domain = 'https://example.com/foo#bar$fiz'
+const ipv4 = '//10.10.10.10'
+const ipv6 = '//[2001:db8::7]'
+const urn = 'urn:foo:a123,456'
+const urnuuid = 'urn:uuid:f81d4fae-7dec-11d0-a765-00a0c91e6bf6'
+
+// Initialization as there is a lot to parse at first
+// eg: regexes
+fasturi.parse(domain)
+urijs.parse(domain)
+
+suite.add('fast-uri: parse domain', function () {
+ fasturi.parse(domain)
+})
+suite.add('urijs: parse domain', function () {
+ urijs.parse(domain)
+})
+suite.add('WHATWG URL: parse domain', function () {
+ // eslint-disable-next-line
+ new URL(domain)
+})
+suite.add('fast-uri: parse IPv4', function () {
+ fasturi.parse(ipv4)
+})
+suite.add('urijs: parse IPv4', function () {
+ urijs.parse(ipv4)
+})
+suite.add('fast-uri: parse IPv6', function () {
+ fasturi.parse(ipv6)
+})
+suite.add('urijs: parse IPv6', function () {
+ urijs.parse(ipv6)
+})
+suite.add('fast-uri: parse URN', function () {
+ fasturi.parse(urn)
+})
+suite.add('urijs: parse URN', function () {
+ urijs.parse(urn)
+})
+suite.add('WHATWG URL: parse URN', function () {
+ // eslint-disable-next-line
+ new URL(urn)
+})
+suite.add('fast-uri: parse URN uuid', function () {
+ fasturi.parse(urnuuid)
+})
+suite.add('urijs: parse URN uuid', function () {
+ urijs.parse(urnuuid)
+})
+suite.add('fast-uri: serialize uri', function () {
+ fasturi.serialize({
+ scheme: 'uri',
+ userinfo: 'foo:bar',
+ host: 'example.com',
+ port: 1,
+ path: 'path',
+ query: 'query',
+ fragment: 'fragment'
+ })
+})
+suite.add('urijs: serialize uri', function () {
+ urijs.serialize({
+ scheme: 'uri',
+ userinfo: 'foo:bar',
+ host: 'example.com',
+ port: 1,
+ path: 'path',
+ query: 'query',
+ fragment: 'fragment'
+ })
+})
+suite.add('fast-uri: serialize IPv6', function () {
+ fasturi.serialize({ host: '2606:2800:220:1:248:1893:25c8:1946' })
+})
+suite.add('urijs: serialize IPv6', function () {
+ urijs.serialize({ host: '2606:2800:220:1:248:1893:25c8:1946' })
+})
+suite.add('fast-uri: serialize ws', function () {
+ fasturi.serialize({ scheme: 'ws', host: 'example.com', resourceName: '/foo?bar', secure: true })
+})
+suite.add('urijs: serialize ws', function () {
+ urijs.serialize({ scheme: 'ws', host: 'example.com', resourceName: '/foo?bar', secure: true })
+})
+suite.add('fast-uri: resolve', function () {
+ fasturi.resolve(base, '../../../g')
+})
+suite.add('urijs: resolve', function () {
+ urijs.resolve(base, '../../../g')
+})
+suite.on('cycle', cycle)
+
+suite.run()
+
+function cycle (e) {
+ console.log(e.target.toString())
+}
diff --git a/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/index.js b/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/index.js
new file mode 100644
index 00000000..a2cd183c
--- /dev/null
+++ b/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/index.js
@@ -0,0 +1,304 @@
+'use strict'
+
+const { normalizeIPv6, normalizeIPv4, removeDotSegments, recomposeAuthority, normalizeComponentEncoding } = require('./lib/utils')
+const SCHEMES = require('./lib/schemes')
+
+function normalize (uri, options) {
+ if (typeof uri === 'string') {
+ uri = serialize(parse(uri, options), options)
+ } else if (typeof uri === 'object') {
+ uri = parse(serialize(uri, options), options)
+ }
+ return uri
+}
+
+function resolve (baseURI, relativeURI, options) {
+ const schemelessOptions = Object.assign({ scheme: 'null' }, options)
+ const resolved = resolveComponents(parse(baseURI, schemelessOptions), parse(relativeURI, schemelessOptions), schemelessOptions, true)
+ return serialize(resolved, { ...schemelessOptions, skipEscape: true })
+}
+
+function resolveComponents (base, relative, options, skipNormalization) {
+ const target = {}
+ if (!skipNormalization) {
+ base = parse(serialize(base, options), options) // normalize base components
+ relative = parse(serialize(relative, options), options) // normalize relative components
+ }
+ options = options || {}
+
+ if (!options.tolerant && relative.scheme) {
+ target.scheme = relative.scheme
+ // target.authority = relative.authority;
+ target.userinfo = relative.userinfo
+ target.host = relative.host
+ target.port = relative.port
+ target.path = removeDotSegments(relative.path || '')
+ target.query = relative.query
+ } else {
+ if (relative.userinfo !== undefined || relative.host !== undefined || relative.port !== undefined) {
+ // target.authority = relative.authority;
+ target.userinfo = relative.userinfo
+ target.host = relative.host
+ target.port = relative.port
+ target.path = removeDotSegments(relative.path || '')
+ target.query = relative.query
+ } else {
+ if (!relative.path) {
+ target.path = base.path
+ if (relative.query !== undefined) {
+ target.query = relative.query
+ } else {
+ target.query = base.query
+ }
+ } else {
+ if (relative.path.charAt(0) === '/') {
+ target.path = removeDotSegments(relative.path)
+ } else {
+ if ((base.userinfo !== undefined || base.host !== undefined || base.port !== undefined) && !base.path) {
+ target.path = '/' + relative.path
+ } else if (!base.path) {
+ target.path = relative.path
+ } else {
+ target.path = base.path.slice(0, base.path.lastIndexOf('/') + 1) + relative.path
+ }
+ target.path = removeDotSegments(target.path)
+ }
+ target.query = relative.query
+ }
+ // target.authority = base.authority;
+ target.userinfo = base.userinfo
+ target.host = base.host
+ target.port = base.port
+ }
+ target.scheme = base.scheme
+ }
+
+ target.fragment = relative.fragment
+
+ return target
+}
+
+function equal (uriA, uriB, options) {
+ if (typeof uriA === 'string') {
+ uriA = unescape(uriA)
+ uriA = serialize(normalizeComponentEncoding(parse(uriA, options), true), { ...options, skipEscape: true })
+ } else if (typeof uriA === 'object') {
+ uriA = serialize(normalizeComponentEncoding(uriA, true), { ...options, skipEscape: true })
+ }
+
+ if (typeof uriB === 'string') {
+ uriB = unescape(uriB)
+ uriB = serialize(normalizeComponentEncoding(parse(uriB, options), true), { ...options, skipEscape: true })
+ } else if (typeof uriB === 'object') {
+ uriB = serialize(normalizeComponentEncoding(uriB, true), { ...options, skipEscape: true })
+ }
+
+ return uriA.toLowerCase() === uriB.toLowerCase()
+}
+
+function serialize (cmpts, opts) {
+ const components = {
+ host: cmpts.host,
+ scheme: cmpts.scheme,
+ userinfo: cmpts.userinfo,
+ port: cmpts.port,
+ path: cmpts.path,
+ query: cmpts.query,
+ nid: cmpts.nid,
+ nss: cmpts.nss,
+ uuid: cmpts.uuid,
+ fragment: cmpts.fragment,
+ reference: cmpts.reference,
+ resourceName: cmpts.resourceName,
+ secure: cmpts.secure,
+ error: ''
+ }
+ const options = Object.assign({}, opts)
+ const uriTokens = []
+
+ // find scheme handler
+ const schemeHandler = SCHEMES[(options.scheme || components.scheme || '').toLowerCase()]
+
+ // perform scheme specific serialization
+ if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(components, options)
+
+ if (components.path !== undefined) {
+ if (!options.skipEscape) {
+ components.path = escape(components.path)
+
+ if (components.scheme !== undefined) {
+ components.path = components.path.split('%3A').join(':')
+ }
+ } else {
+ components.path = unescape(components.path)
+ }
+ }
+
+ if (options.reference !== 'suffix' && components.scheme) {
+ uriTokens.push(components.scheme)
+ uriTokens.push(':')
+ }
+
+ const authority = recomposeAuthority(components, options)
+ if (authority !== undefined) {
+ if (options.reference !== 'suffix') {
+ uriTokens.push('//')
+ }
+
+ uriTokens.push(authority)
+
+ if (components.path && components.path.charAt(0) !== '/') {
+ uriTokens.push('/')
+ }
+ }
+ if (components.path !== undefined) {
+ let s = components.path
+
+ if (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) {
+ s = removeDotSegments(s)
+ }
+
+ if (authority === undefined) {
+ s = s.replace(/^\/\//u, '/%2F') // don't allow the path to start with "//"
+ }
+
+ uriTokens.push(s)
+ }
+
+ if (components.query !== undefined) {
+ uriTokens.push('?')
+ uriTokens.push(components.query)
+ }
+
+ if (components.fragment !== undefined) {
+ uriTokens.push('#')
+ uriTokens.push(components.fragment)
+ }
+ return uriTokens.join('')
+}
+
+const hexLookUp = Array.from({ length: 127 }, (v, k) => /[^!"$&'()*+,\-.;=_`a-z{}~]/u.test(String.fromCharCode(k)))
+
+function nonSimpleDomain (value) {
+ let code = 0
+ for (let i = 0, len = value.length; i < len; ++i) {
+ code = value.charCodeAt(i)
+ if (code > 126 || hexLookUp[code]) {
+ return true
+ }
+ }
+ return false
+}
+
+const URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u
+
+function parse (uri, opts) {
+ const options = Object.assign({}, opts)
+ const parsed = {
+ scheme: undefined,
+ userinfo: undefined,
+ host: '',
+ port: undefined,
+ path: '',
+ query: undefined,
+ fragment: undefined
+ }
+ const gotEncoding = uri.indexOf('%') !== -1
+ if (options.reference === 'suffix') uri = (options.scheme ? options.scheme + ':' : '') + '//' + uri
+
+ const matches = uri.match(URI_PARSE)
+
+ if (matches) {
+ // store each component
+ parsed.scheme = matches[1]
+ parsed.userinfo = matches[3]
+ parsed.host = matches[4]
+ parsed.port = parseInt(matches[5], 10)
+ parsed.path = matches[6] || ''
+ parsed.query = matches[7]
+ parsed.fragment = matches[8]
+
+ // fix port number
+ if (isNaN(parsed.port)) {
+ parsed.port = matches[5]
+ }
+ if (parsed.host) {
+ const ipv4result = normalizeIPv4(parsed.host)
+ if (ipv4result.isIPV4 === false) {
+ parsed.host = normalizeIPv6(ipv4result.host, { isIPV4: false }).host.toLowerCase()
+ } else {
+ parsed.host = ipv4result.host
+ }
+ }
+ if (parsed.scheme === undefined && parsed.userinfo === undefined && parsed.host === undefined && parsed.port === undefined && !parsed.path && parsed.query === undefined) {
+ parsed.reference = 'same-document'
+ } else if (parsed.scheme === undefined) {
+ parsed.reference = 'relative'
+ } else if (parsed.fragment === undefined) {
+ parsed.reference = 'absolute'
+ } else {
+ parsed.reference = 'uri'
+ }
+
+ // check for reference errors
+ if (options.reference && options.reference !== 'suffix' && options.reference !== parsed.reference) {
+ parsed.error = parsed.error || 'URI is not a ' + options.reference + ' reference.'
+ }
+
+ // find scheme handler
+ const schemeHandler = SCHEMES[(options.scheme || parsed.scheme || '').toLowerCase()]
+
+ // check if scheme can't handle IRIs
+ if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) {
+ // if host component is a domain name
+ if (parsed.host && (options.domainHost || (schemeHandler && schemeHandler.domainHost)) && nonSimpleDomain(parsed.host)) {
+ // convert Unicode IDN -> ASCII IDN
+ try {
+ parsed.host = URL.domainToASCII(parsed.host.toLowerCase())
+ } catch (e) {
+ parsed.error = parsed.error || "Host's domain name can not be converted to ASCII: " + e
+ }
+ }
+ // convert IRI -> URI
+ }
+
+ if (!schemeHandler || (schemeHandler && !schemeHandler.skipNormalize)) {
+ if (gotEncoding && parsed.scheme !== undefined) {
+ parsed.scheme = unescape(parsed.scheme)
+ }
+ if (gotEncoding && parsed.userinfo !== undefined) {
+ parsed.userinfo = unescape(parsed.userinfo)
+ }
+ if (gotEncoding && parsed.host !== undefined) {
+ parsed.host = unescape(parsed.host)
+ }
+ if (parsed.path !== undefined && parsed.path.length) {
+ parsed.path = escape(unescape(parsed.path))
+ }
+ if (parsed.fragment !== undefined && parsed.fragment.length) {
+ parsed.fragment = encodeURI(decodeURI(parsed.fragment))
+ }
+ }
+
+ // perform scheme specific parsing
+ if (schemeHandler && schemeHandler.parse) {
+ schemeHandler.parse(parsed, options)
+ }
+ } else {
+ parsed.error = parsed.error || 'URI can not be parsed.'
+ }
+ return parsed
+}
+
+const fastUri = {
+ normalize,
+ resolve,
+ resolveComponents,
+ equal,
+ serialize,
+ parse
+}
+
+module.exports = fastUri
+module.exports.default = fastUri
+module.exports.fastUri = fastUri
diff --git a/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/lib/schemes.js b/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/lib/schemes.js
new file mode 100644
index 00000000..45d06fe3
--- /dev/null
+++ b/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/lib/schemes.js
@@ -0,0 +1,188 @@
+'use strict'
+
+const UUID_REG = /^[\da-f]{8}\b-[\da-f]{4}\b-[\da-f]{4}\b-[\da-f]{4}\b-[\da-f]{12}$/iu
+const URN_REG = /([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-.:;=@]|%[\da-f]{2})+)/iu
+
+function isSecure (wsComponents) {
+ return typeof wsComponents.secure === 'boolean' ? wsComponents.secure : String(wsComponents.scheme).toLowerCase() === 'wss'
+}
+
+function httpParse (components) {
+ if (!components.host) {
+ components.error = components.error || 'HTTP URIs must have a host.'
+ }
+
+ return components
+}
+
+function httpSerialize (components) {
+ const secure = String(components.scheme).toLowerCase() === 'https'
+
+ // normalize the default port
+ if (components.port === (secure ? 443 : 80) || components.port === '') {
+ components.port = undefined
+ }
+
+ // normalize the empty path
+ if (!components.path) {
+ components.path = '/'
+ }
+
+ // NOTE: We do not parse query strings for HTTP URIs
+ // as WWW Form Url Encoded query strings are part of the HTML4+ spec,
+ // and not the HTTP spec.
+
+ return components
+}
+
+function wsParse (wsComponents) {
+// indicate if the secure flag is set
+ wsComponents.secure = isSecure(wsComponents)
+
+ // construct resouce name
+ wsComponents.resourceName = (wsComponents.path || '/') + (wsComponents.query ? '?' + wsComponents.query : '')
+ wsComponents.path = undefined
+ wsComponents.query = undefined
+
+ return wsComponents
+}
+
+function wsSerialize (wsComponents) {
+// normalize the default port
+ if (wsComponents.port === (isSecure(wsComponents) ? 443 : 80) || wsComponents.port === '') {
+ wsComponents.port = undefined
+ }
+
+ // ensure scheme matches secure flag
+ if (typeof wsComponents.secure === 'boolean') {
+ wsComponents.scheme = (wsComponents.secure ? 'wss' : 'ws')
+ wsComponents.secure = undefined
+ }
+
+ // reconstruct path from resource name
+ if (wsComponents.resourceName) {
+ const [path, query] = wsComponents.resourceName.split('?')
+ wsComponents.path = (path && path !== '/' ? path : undefined)
+ wsComponents.query = query
+ wsComponents.resourceName = undefined
+ }
+
+ // forbid fragment component
+ wsComponents.fragment = undefined
+
+ return wsComponents
+}
+
+function urnParse (urnComponents, options) {
+ if (!urnComponents.path) {
+ urnComponents.error = 'URN can not be parsed'
+ return urnComponents
+ }
+ const matches = urnComponents.path.match(URN_REG)
+ if (matches) {
+ const scheme = options.scheme || urnComponents.scheme || 'urn'
+ urnComponents.nid = matches[1].toLowerCase()
+ urnComponents.nss = matches[2]
+ const urnScheme = `${scheme}:${options.nid || urnComponents.nid}`
+ const schemeHandler = SCHEMES[urnScheme]
+ urnComponents.path = undefined
+
+ if (schemeHandler) {
+ urnComponents = schemeHandler.parse(urnComponents, options)
+ }
+ } else {
+ urnComponents.error = urnComponents.error || 'URN can not be parsed.'
+ }
+
+ return urnComponents
+}
+
+function urnSerialize (urnComponents, options) {
+ const scheme = options.scheme || urnComponents.scheme || 'urn'
+ const nid = urnComponents.nid.toLowerCase()
+ const urnScheme = `${scheme}:${options.nid || nid}`
+ const schemeHandler = SCHEMES[urnScheme]
+
+ if (schemeHandler) {
+ urnComponents = schemeHandler.serialize(urnComponents, options)
+ }
+
+ const uriComponents = urnComponents
+ const nss = urnComponents.nss
+ uriComponents.path = `${nid || options.nid}:${nss}`
+
+ options.skipEscape = true
+ return uriComponents
+}
+
+function urnuuidParse (urnComponents, options) {
+ const uuidComponents = urnComponents
+ uuidComponents.uuid = uuidComponents.nss
+ uuidComponents.nss = undefined
+
+ if (!options.tolerant && (!uuidComponents.uuid || !UUID_REG.test(uuidComponents.uuid))) {
+ uuidComponents.error = uuidComponents.error || 'UUID is not valid.'
+ }
+
+ return uuidComponents
+}
+
+function urnuuidSerialize (uuidComponents) {
+ const urnComponents = uuidComponents
+ // normalize UUID
+ urnComponents.nss = (uuidComponents.uuid || '').toLowerCase()
+ return urnComponents
+}
+
+const http = {
+ scheme: 'http',
+ domainHost: true,
+ parse: httpParse,
+ serialize: httpSerialize
+}
+
+const https = {
+ scheme: 'https',
+ domainHost: http.domainHost,
+ parse: httpParse,
+ serialize: httpSerialize
+}
+
+const ws = {
+ scheme: 'ws',
+ domainHost: true,
+ parse: wsParse,
+ serialize: wsSerialize
+}
+
+const wss = {
+ scheme: 'wss',
+ domainHost: ws.domainHost,
+ parse: ws.parse,
+ serialize: ws.serialize
+}
+
+const urn = {
+ scheme: 'urn',
+ parse: urnParse,
+ serialize: urnSerialize,
+ skipNormalize: true
+}
+
+const urnuuid = {
+ scheme: 'urn:uuid',
+ parse: urnuuidParse,
+ serialize: urnuuidSerialize,
+ skipNormalize: true
+}
+
+const SCHEMES = {
+ http,
+ https,
+ ws,
+ wss,
+ urn,
+ 'urn:uuid': urnuuid
+}
+
+module.exports = SCHEMES
diff --git a/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/lib/scopedChars.js b/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/lib/scopedChars.js
new file mode 100644
index 00000000..d4a61103
--- /dev/null
+++ b/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/lib/scopedChars.js
@@ -0,0 +1,30 @@
+'use strict'
+
+const HEX = {
+ 0: 0,
+ 1: 1,
+ 2: 2,
+ 3: 3,
+ 4: 4,
+ 5: 5,
+ 6: 6,
+ 7: 7,
+ 8: 8,
+ 9: 9,
+ a: 10,
+ A: 10,
+ b: 11,
+ B: 11,
+ c: 12,
+ C: 12,
+ d: 13,
+ D: 13,
+ e: 14,
+ E: 14,
+ f: 15,
+ F: 15
+}
+
+module.exports = {
+ HEX
+}
diff --git a/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/lib/utils.js b/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/lib/utils.js
new file mode 100644
index 00000000..78134c62
--- /dev/null
+++ b/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/lib/utils.js
@@ -0,0 +1,236 @@
+'use strict'
+
+const { HEX } = require('./scopedChars')
+
+function normalizeIPv4 (host) {
+ if (findToken(host, '.') < 3) { return { host, isIPV4: false } }
+ const matches = host.match(/^(\b[01]?\d{1,2}|\b2[0-4]\d|\b25[0-5])(\.([01]?\d{1,2}|2[0-4]\d|25[0-5])){3}$/u) || []
+ const [address] = matches
+ if (address) {
+ return { host: stripLeadingZeros(address, '.'), isIPV4: true }
+ } else {
+ return { host, isIPV4: false }
+ }
+}
+
+function stringToHexStripped (input) {
+ let acc = ''
+ let strip = true
+ for (const c of input) {
+ if (c !== '0' && strip === true) strip = false
+ if (HEX[c] === undefined) return undefined
+ if (!strip) acc += c
+ }
+ return acc
+}
+
+function getIPV6 (input) {
+ let tokenCount = 0
+ const output = { error: false, address: '', zone: '' }
+ const address = []
+ const buffer = []
+ let isZone = false
+ let endipv6Encountered = false
+ let endIpv6 = false
+
+ function consume () {
+ if (buffer.length) {
+ if (isZone === false) {
+ const hex = stringToHexStripped(buffer.join(''))
+ if (hex !== undefined) {
+ address.push(hex)
+ } else {
+ output.error = true
+ return false
+ }
+ }
+ buffer.length = 0
+ }
+ return true
+ }
+
+ for (let i = 0; i < input.length; i++) {
+ const cursor = input[i]
+ if (cursor === '[' || cursor === ']') { continue }
+ if (cursor === ':') {
+ if (endipv6Encountered === true) {
+ endIpv6 = true
+ }
+ if (!consume()) { break }
+ tokenCount++
+ address.push(':')
+ if (tokenCount > 7) {
+ // not valid
+ output.error = true
+ break
+ }
+ if (i - 1 >= 0 && input[i - 1] === ':') {
+ endipv6Encountered = true
+ }
+ continue
+ } else if (cursor === '%') {
+ if (!consume()) { break }
+ // switch to zone detection
+ isZone = true
+ } else {
+ buffer.push(cursor)
+ continue
+ }
+ }
+ if (buffer.length) {
+ if (isZone) {
+ output.zone = buffer.join('')
+ } else if (endIpv6) {
+ address.push(buffer.join(''))
+ } else {
+ address.push(stringToHexStripped(buffer.join('')))
+ }
+ }
+ output.address = address.join('')
+ return output
+}
+
+function normalizeIPv6 (host, opts = {}) {
+ if (findToken(host, ':') < 2) { return { host, isIPV6: false } }
+ const ipv6 = getIPV6(host)
+
+ if (!ipv6.error) {
+ let newHost = ipv6.address
+ let escapedHost = ipv6.address
+ if (ipv6.zone) {
+ newHost += '%' + ipv6.zone
+ escapedHost += '%25' + ipv6.zone
+ }
+ return { host: newHost, escapedHost, isIPV6: true }
+ } else {
+ return { host, isIPV6: false }
+ }
+}
+
+function stripLeadingZeros (str, token) {
+ let out = ''
+ let skip = true
+ const l = str.length
+ for (let i = 0; i < l; i++) {
+ const c = str[i]
+ if (c === '0' && skip) {
+ if ((i + 1 <= l && str[i + 1] === token) || i + 1 === l) {
+ out += c
+ skip = false
+ }
+ } else {
+ if (c === token) {
+ skip = true
+ } else {
+ skip = false
+ }
+ out += c
+ }
+ }
+ return out
+}
+
+function findToken (str, token) {
+ let ind = 0
+ for (let i = 0; i < str.length; i++) {
+ if (str[i] === token) ind++
+ }
+ return ind
+}
+
+const RDS1 = /^\.\.?\//u
+const RDS2 = /^\/\.(?:\/|$)/u
+const RDS3 = /^\/\.\.(?:\/|$)/u
+const RDS5 = /^\/?(?:.|\n)*?(?=\/|$)/u
+
+function removeDotSegments (input) {
+ const output = []
+
+ while (input.length) {
+ if (input.match(RDS1)) {
+ input = input.replace(RDS1, '')
+ } else if (input.match(RDS2)) {
+ input = input.replace(RDS2, '/')
+ } else if (input.match(RDS3)) {
+ input = input.replace(RDS3, '/')
+ output.pop()
+ } else if (input === '.' || input === '..') {
+ input = ''
+ } else {
+ const im = input.match(RDS5)
+ if (im) {
+ const s = im[0]
+ input = input.slice(s.length)
+ output.push(s)
+ } else {
+ throw new Error('Unexpected dot segment condition')
+ }
+ }
+ }
+ return output.join('')
+}
+
+function normalizeComponentEncoding (components, esc) {
+ const func = esc !== true ? escape : unescape
+ if (components.scheme !== undefined) {
+ components.scheme = func(components.scheme)
+ }
+ if (components.userinfo !== undefined) {
+ components.userinfo = func(components.userinfo)
+ }
+ if (components.host !== undefined) {
+ components.host = func(components.host)
+ }
+ if (components.path !== undefined) {
+ components.path = func(components.path)
+ }
+ if (components.query !== undefined) {
+ components.query = func(components.query)
+ }
+ if (components.fragment !== undefined) {
+ components.fragment = func(components.fragment)
+ }
+ return components
+}
+
+function recomposeAuthority (components, options) {
+ const uriTokens = []
+
+ if (components.userinfo !== undefined) {
+ uriTokens.push(components.userinfo)
+ uriTokens.push('@')
+ }
+
+ if (components.host !== undefined) {
+ let host = unescape(components.host)
+ const ipV4res = normalizeIPv4(host)
+
+ if (ipV4res.isIPV4) {
+ host = ipV4res.host
+ } else {
+ const ipV6res = normalizeIPv6(ipV4res.host, { isIPV4: false })
+ if (ipV6res.isIPV6 === true) {
+ host = `[${ipV6res.escapedHost}]`
+ } else {
+ host = components.host
+ }
+ }
+ uriTokens.push(host)
+ }
+
+ if (typeof components.port === 'number' || typeof components.port === 'string') {
+ uriTokens.push(':')
+ uriTokens.push(String(components.port))
+ }
+
+ return uriTokens.length ? uriTokens.join('') : undefined
+};
+
+module.exports = {
+ recomposeAuthority,
+ normalizeComponentEncoding,
+ removeDotSegments,
+ normalizeIPv4,
+ normalizeIPv6,
+ stringToHexStripped
+}
diff --git a/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/package.json b/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/package.json
new file mode 100644
index 00000000..44e13dfa
--- /dev/null
+++ b/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/package.json
@@ -0,0 +1,37 @@
+{
+ "name": "fast-uri",
+ "description": "Dependency free RFC 3986 URI toolbox",
+ "version": "2.4.0",
+ "main": "index.js",
+ "type": "commonjs",
+ "types": "types/index.d.ts",
+ "license": "MIT",
+ "author": "Vincent Le Goff (https://github.com/zekth)",
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/fastify/fast-uri.git"
+ },
+ "bugs": {
+ "url": "https://github.com/fastify/fast-uri/issues"
+ },
+ "homepage": "https://github.com/fastify/fast-uri",
+ "scripts": {
+ "bench": "node benchmark.js",
+ "lint:fix": "standard --fix",
+ "test:lint": "standard | snazzy",
+ "test:typescript": "tsd",
+ "test:unit": "tap -J test/*.test.js",
+ "test:unit:dev": "tap -J test/*.test.js --coverage-report=html",
+ "test": "npm run test:lint && npm run test:unit && npm run test:typescript",
+ "test:ci": "npm run test:lint && npm run test:unit -- --cov --coverage-report=lcovonly && npm run test:typescript"
+ },
+ "devDependencies": {
+ "benchmark": "^2.1.4",
+ "coveralls": "^3.1.1",
+ "snazzy": "^9.0.0",
+ "standard": "^17.0.0",
+ "tap": "^16.0.0",
+ "tsd": "^0.31.0",
+ "uri-js": "^4.4.1"
+ }
+}
diff --git a/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/test/.gitkeep b/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/test/.gitkeep
new file mode 100644
index 00000000..e69de29b
diff --git a/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/test/compatibility.test.js b/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/test/compatibility.test.js
new file mode 100644
index 00000000..5c5edc49
--- /dev/null
+++ b/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/test/compatibility.test.js
@@ -0,0 +1,130 @@
+'use strict'
+
+const tap = require('tap')
+const test = tap.test
+const fastifyURI = require('../')
+const urijs = require('uri-js')
+
+test('compatibility Parse', (t) => {
+ const toParse = [
+ '//www.g.com/error\n/bleh/bleh',
+ 'https://fastify.org',
+ '/definitions/Record%3Cstring%2CPerson%3E',
+ '//10.10.10.10',
+ '//10.10.000.10',
+ '//[2001:db8::7%en0]',
+ '//[2001:dbZ::1]:80',
+ '//[2001:db8::1]:80',
+ '//[2001:db8::001]:80',
+ 'uri://user:pass@example.com:123/one/two.three?q1=a1&q2=a2#body',
+ 'http://user:pass@example.com:123/one/space in.url?q1=a1&q2=a2#body',
+ '//[::ffff:129.144.52.38]',
+ 'uri://10.10.10.10.example.com/en/process',
+ '//[2606:2800:220:1:248:1893:25c8:1946]/test',
+ 'ws://example.com/chat',
+ 'ws://example.com/foo?bar=baz',
+ 'wss://example.com/?bar=baz',
+ 'wss://example.com/chat',
+ 'wss://example.com/foo?bar=baz',
+ 'wss://example.com/?bar=baz',
+ 'urn:uuid:f81d4fae-7dec-11d0-a765-00a0c91e6bf6',
+ 'urn:uuid:notauuid-7dec-11d0-a765-00a0c91e6bf6',
+ 'urn:example:%D0%B0123,z456',
+ '//[2606:2800:220:1:248:1893:25c8:1946:43209]',
+ 'http://foo.bar',
+ 'http://',
+ '#/$defs/stringMap',
+ '#/$defs/string%20Map',
+ '#/$defs/string Map',
+ '//?json=%7B%22foo%22%3A%22bar%22%7D'
+ // 'mailto:chris@example.com'-203845,
+ // 'mailto:infobot@example.com?subject=current-issue',
+ // 'mailto:infobot@example.com?body=send%20current-issue',
+ // 'mailto:infobot@example.com?body=send%20current-issue%0D%0Asend%20index',
+ // 'mailto:list@example.org?In-Reply-To=%3C3469A91.D10AF4C@example.com%3E',
+ // 'mailto:majordomo@example.com?body=subscribe%20bamboo-l',
+ // 'mailto:joe@example.com?cc=bob@example.com&body=hello',
+ // 'mailto:gorby%25kremvax@example.com',
+ // 'mailto:unlikely%3Faddress@example.com?blat=foop',
+ // 'mailto:Mike%26family@example.org',
+ // 'mailto:%22not%40me%22@example.org',
+ // 'mailto:%22oh%5C%5Cno%22@example.org',
+ // 'mailto:%22%5C%5C%5C%22it\'s%5C%20ugly%5C%5C%5C%22%22@example.org',
+ // 'mailto:user@example.org?subject=caf%C3%A9',
+ // 'mailto:user@example.org?subject=%3D%3Futf-8%3FQ%3Fcaf%3DC3%3DA9%3F%3D',
+ // 'mailto:user@example.org?subject=%3D%3Fiso-8859-1%3FQ%3Fcaf%3DE9%3F%3D',
+ // 'mailto:user@example.org?subject=caf%C3%A9&body=caf%C3%A9',
+ // 'mailto:user@%E7%B4%8D%E8%B1%86.example.org?subject=Test&body=NATTO'
+ ]
+ toParse.forEach((x) => {
+ t.same(fastifyURI.parse(x), urijs.parse(x), 'Compatibility parse: ' + x)
+ })
+ t.end()
+})
+
+test('compatibility serialize', (t) => {
+ const toSerialize = [
+ { host: '10.10.10.10.example.com' },
+ { host: '2001:db8::7' },
+ { host: '::ffff:129.144.52.38' },
+ { host: '2606:2800:220:1:248:1893:25c8:1946' },
+ { host: '10.10.10.10.example.com' },
+ { host: '10.10.10.10' },
+ { path: '?query' },
+ { path: 'foo:bar' },
+ { path: '//path' },
+ {
+ scheme: 'uri',
+ host: 'example.com',
+ port: '9000'
+ },
+ {
+ scheme: 'uri',
+ userinfo: 'foo:bar',
+ host: 'example.com',
+ port: 1,
+ path: 'path',
+ query: 'query',
+ fragment: 'fragment'
+ },
+ {
+ scheme: '',
+ userinfo: '',
+ host: '',
+ port: 0,
+ path: '',
+ query: '',
+ fragment: ''
+ },
+ {
+ scheme: undefined,
+ userinfo: undefined,
+ host: undefined,
+ port: undefined,
+ path: undefined,
+ query: undefined,
+ fragment: undefined
+ },
+ { host: 'fe80::a%en1' },
+ { host: 'fe80::a%25en1' },
+ {
+ scheme: 'ws',
+ host: 'example.com',
+ resourceName: '/foo?bar',
+ secure: true
+ },
+ {
+ scheme: 'scheme',
+ path: 'with:colon'
+ }
+ ]
+ toSerialize.forEach((x) => {
+ const r = JSON.stringify(x)
+ t.same(
+ fastifyURI.serialize(x),
+ urijs.serialize(x),
+ 'Compatibility serialize: ' + JSON.stringify(r)
+ )
+ })
+ t.end()
+})
diff --git a/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/test/equal.test.js b/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/test/equal.test.js
new file mode 100644
index 00000000..69783de8
--- /dev/null
+++ b/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/test/equal.test.js
@@ -0,0 +1,104 @@
+'use strict'
+
+const tap = require('tap')
+const test = tap.test
+const URI = require('../')
+
+const fn = URI.equal
+const runTest = (t, suite) => {
+ suite.forEach(s => {
+ const operator = s.result ? '==' : '!='
+ t.equal(fn(s.pair[0], s.pair[1]), s.result, `${s.pair[0]} ${operator} ${s.pair[1]}`)
+ t.equal(fn(s.pair[1], s.pair[0]), s.result, `${s.pair[1]} ${operator} ${s.pair[0]}`)
+ })
+}
+
+test('URI Equals', (t) => {
+ const suite = [
+ { pair: ['example://a/b/c/%7Bfoo%7D', 'eXAMPLE://a/./b/../b/%63/%7bfoo%7d'], result: true }, // test from RFC 3986
+ { pair: ['http://example.org/~user', 'http://example.org/%7euser'], result: true } // test from RFC 3987
+ ]
+ runTest(t, suite)
+ t.end()
+})
+
+// test('IRI Equals', (t) => {
+// // example from RFC 3987
+// t.equal(URI.equal('example://a/b/c/%7Bfoo%7D/ros\xE9', 'eXAMPLE://a/./b/../b/%63/%7bfoo%7d/ros%C3%A9', IRI_OPTION), true)
+// t.end()
+// })
+
+test('HTTP Equals', (t) => {
+ const suite = [
+ // test from RFC 2616
+ { pair: ['http://abc.com:80/~smith/home.html', 'http://abc.com/~smith/home.html'], result: true },
+ { pair: [{ scheme: 'http', host: 'abc.com', port: 80, path: '/~smith/home.html' }, 'http://abc.com/~smith/home.html'], result: true },
+ { pair: ['http://ABC.com/%7Esmith/home.html', 'http://abc.com/~smith/home.html'], result: true },
+ { pair: ['http://ABC.com:/%7esmith/home.html', 'http://abc.com/~smith/home.html'], result: true },
+ { pair: ['HTTP://ABC.COM', 'http://abc.com/'], result: true },
+ // test from RFC 3986
+ { pair: ['http://example.com:/', 'http://example.com:80/'], result: true }
+ ]
+ runTest(t, suite)
+ t.end()
+})
+
+test('HTTPS Equals', (t) => {
+ const suite = [
+ { pair: ['https://example.com', 'https://example.com:443/'], result: true },
+ { pair: ['https://example.com:/', 'https://example.com:443/'], result: true }
+ ]
+ runTest(t, suite)
+ t.end()
+})
+
+test('URN Equals', (t) => {
+ const suite = [
+ // test from RFC 2141
+ { pair: ['urn:foo:a123,456', 'urn:foo:a123,456'], result: true },
+ { pair: ['urn:foo:a123,456', 'URN:foo:a123,456'], result: true },
+ { pair: ['urn:foo:a123,456', 'urn:FOO:a123,456'], result: true }
+ ]
+
+ // Disabling for now as the whole equal logic might need
+ // to be refactored
+ // t.equal(URI.equal('urn:foo:a123,456', 'urn:foo:A123,456'), false)
+ // t.equal(URI.equal('urn:foo:a123%2C456', 'URN:FOO:a123%2c456'), true)
+
+ runTest(t, suite)
+ t.end()
+})
+
+test('UUID Equals', (t) => {
+ const suite = [
+ { pair: ['URN:UUID:F81D4FAE-7DEC-11D0-A765-00A0C91E6BF6', 'urn:uuid:f81d4fae-7dec-11d0-a765-00a0c91e6bf6'], result: true }
+ ]
+
+ runTest(t, suite)
+ t.end()
+})
+
+// test('Mailto Equals', (t) => {
+// // tests from RFC 6068
+// t.equal(URI.equal('mailto:addr1@an.example,addr2@an.example', 'mailto:?to=addr1@an.example,addr2@an.example'), true)
+// t.equal(URI.equal('mailto:?to=addr1@an.example,addr2@an.example', 'mailto:addr1@an.example?to=addr2@an.example'), true)
+// t.end()
+// })
+
+test('WS Equal', (t) => {
+ const suite = [
+ { pair: ['WS://ABC.COM:80/chat#one', 'ws://abc.com/chat'], result: true }
+ ]
+
+ runTest(t, suite)
+ t.end()
+})
+
+test('WSS Equal', (t) => {
+ const suite = [
+ { pair: ['WSS://ABC.COM:443/chat#one', 'wss://abc.com/chat'], result: true }
+ ]
+
+ runTest(t, suite)
+ t.end()
+})
diff --git a/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/test/parse.test.js b/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/test/parse.test.js
new file mode 100644
index 00000000..2fe21339
--- /dev/null
+++ b/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/test/parse.test.js
@@ -0,0 +1,310 @@
+'use strict'
+
+const tap = require('tap')
+const test = tap.test
+const URI = require('../')
+
+test('URI parse', (t) => {
+ let components
+
+ // scheme
+ components = URI.parse('uri:')
+ t.equal(components.error, undefined, 'scheme errors')
+ t.equal(components.scheme, 'uri', 'scheme')
+ // t.equal(components.authority, undefined, "authority");
+ t.equal(components.userinfo, undefined, 'userinfo')
+ t.equal(components.host, undefined, 'host')
+ t.equal(components.port, undefined, 'port')
+ t.equal(components.path, '', 'path')
+ t.equal(components.query, undefined, 'query')
+ t.equal(components.fragment, undefined, 'fragment')
+
+ // userinfo
+ components = URI.parse('//@')
+ t.equal(components.error, undefined, 'userinfo errors')
+ t.equal(components.scheme, undefined, 'scheme')
+ // t.equal(components.authority, "@", "authority");
+ t.equal(components.userinfo, '', 'userinfo')
+ t.equal(components.host, '', 'host')
+ t.equal(components.port, undefined, 'port')
+ t.equal(components.path, '', 'path')
+ t.equal(components.query, undefined, 'query')
+ t.equal(components.fragment, undefined, 'fragment')
+
+ // host
+ components = URI.parse('//')
+ t.equal(components.error, undefined, 'host errors')
+ t.equal(components.scheme, undefined, 'scheme')
+ // t.equal(components.authority, "", "authority");
+ t.equal(components.userinfo, undefined, 'userinfo')
+ t.equal(components.host, '', 'host')
+ t.equal(components.port, undefined, 'port')
+ t.equal(components.path, '', 'path')
+ t.equal(components.query, undefined, 'query')
+ t.equal(components.fragment, undefined, 'fragment')
+
+ // port
+ components = URI.parse('//:')
+ t.equal(components.error, undefined, 'port errors')
+ t.equal(components.scheme, undefined, 'scheme')
+ // t.equal(components.authority, ":", "authority");
+ t.equal(components.userinfo, undefined, 'userinfo')
+ t.equal(components.host, '', 'host')
+ t.equal(components.port, '', 'port')
+ t.equal(components.path, '', 'path')
+ t.equal(components.query, undefined, 'query')
+ t.equal(components.fragment, undefined, 'fragment')
+
+ // path
+ components = URI.parse('')
+ t.equal(components.error, undefined, 'path errors')
+ t.equal(components.scheme, undefined, 'scheme')
+ // t.equal(components.authority, undefined, "authority");
+ t.equal(components.userinfo, undefined, 'userinfo')
+ t.equal(components.host, undefined, 'host')
+ t.equal(components.port, undefined, 'port')
+ t.equal(components.path, '', 'path')
+ t.equal(components.query, undefined, 'query')
+ t.equal(components.fragment, undefined, 'fragment')
+
+ // query
+ components = URI.parse('?')
+ t.equal(components.error, undefined, 'query errors')
+ t.equal(components.scheme, undefined, 'scheme')
+ // t.equal(components.authority, undefined, "authority");
+ t.equal(components.userinfo, undefined, 'userinfo')
+ t.equal(components.host, undefined, 'host')
+ t.equal(components.port, undefined, 'port')
+ t.equal(components.path, '', 'path')
+ t.equal(components.query, '', 'query')
+ t.equal(components.fragment, undefined, 'fragment')
+
+ // fragment
+ components = URI.parse('#')
+ t.equal(components.error, undefined, 'fragment errors')
+ t.equal(components.scheme, undefined, 'scheme')
+ // t.equal(components.authority, undefined, "authority");
+ t.equal(components.userinfo, undefined, 'userinfo')
+ t.equal(components.host, undefined, 'host')
+ t.equal(components.port, undefined, 'port')
+ t.equal(components.path, '', 'path')
+ t.equal(components.query, undefined, 'query')
+ t.equal(components.fragment, '', 'fragment')
+
+ // fragment with character tabulation
+ components = URI.parse('#\t')
+ t.equal(components.error, undefined, 'path errors')
+ t.equal(components.scheme, undefined, 'scheme')
+ // t.equal(components.authority, undefined, "authority");
+ t.equal(components.userinfo, undefined, 'userinfo')
+ t.equal(components.host, undefined, 'host')
+ t.equal(components.port, undefined, 'port')
+ t.equal(components.path, '', 'path')
+ t.equal(components.query, undefined, 'query')
+ t.equal(components.fragment, '%09', 'fragment')
+
+ // fragment with line feed
+ components = URI.parse('#\n')
+ t.equal(components.error, undefined, 'path errors')
+ t.equal(components.scheme, undefined, 'scheme')
+ // t.equal(components.authority, undefined, "authority");
+ t.equal(components.userinfo, undefined, 'userinfo')
+ t.equal(components.host, undefined, 'host')
+ t.equal(components.port, undefined, 'port')
+ t.equal(components.path, '', 'path')
+ t.equal(components.query, undefined, 'query')
+ t.equal(components.fragment, '%0A', 'fragment')
+
+ // fragment with line tabulation
+ components = URI.parse('#\v')
+ t.equal(components.error, undefined, 'path errors')
+ t.equal(components.scheme, undefined, 'scheme')
+ // t.equal(components.authority, undefined, "authority");
+ t.equal(components.userinfo, undefined, 'userinfo')
+ t.equal(components.host, undefined, 'host')
+ t.equal(components.port, undefined, 'port')
+ t.equal(components.path, '', 'path')
+ t.equal(components.query, undefined, 'query')
+ t.equal(components.fragment, '%0B', 'fragment')
+
+ // fragment with form feed
+ components = URI.parse('#\f')
+ t.equal(components.error, undefined, 'path errors')
+ t.equal(components.scheme, undefined, 'scheme')
+ // t.equal(components.authority, undefined, "authority");
+ t.equal(components.userinfo, undefined, 'userinfo')
+ t.equal(components.host, undefined, 'host')
+ t.equal(components.port, undefined, 'port')
+ t.equal(components.path, '', 'path')
+ t.equal(components.query, undefined, 'query')
+ t.equal(components.fragment, '%0C', 'fragment')
+
+ // fragment with carriage return
+ components = URI.parse('#\r')
+ t.equal(components.error, undefined, 'path errors')
+ t.equal(components.scheme, undefined, 'scheme')
+ // t.equal(components.authority, undefined, "authority");
+ t.equal(components.userinfo, undefined, 'userinfo')
+ t.equal(components.host, undefined, 'host')
+ t.equal(components.port, undefined, 'port')
+ t.equal(components.path, '', 'path')
+ t.equal(components.query, undefined, 'query')
+ t.equal(components.fragment, '%0D', 'fragment')
+
+ // all
+ components = URI.parse('uri://user:pass@example.com:123/one/two.three?q1=a1&q2=a2#body')
+ t.equal(components.error, undefined, 'all errors')
+ t.equal(components.scheme, 'uri', 'scheme')
+ // t.equal(components.authority, "user:pass@example.com:123", "authority");
+ t.equal(components.userinfo, 'user:pass', 'userinfo')
+ t.equal(components.host, 'example.com', 'host')
+ t.equal(components.port, 123, 'port')
+ t.equal(components.path, '/one/two.three', 'path')
+ t.equal(components.query, 'q1=a1&q2=a2', 'query')
+ t.equal(components.fragment, 'body', 'fragment')
+
+ // IPv4address
+ components = URI.parse('//10.10.10.10')
+ t.equal(components.error, undefined, 'IPv4address errors')
+ t.equal(components.scheme, undefined, 'scheme')
+ t.equal(components.userinfo, undefined, 'userinfo')
+ t.equal(components.host, '10.10.10.10', 'host')
+ t.equal(components.port, undefined, 'port')
+ t.equal(components.path, '', 'path')
+ t.equal(components.query, undefined, 'query')
+ t.equal(components.fragment, undefined, 'fragment')
+
+ // IPv4address with unformated 0
+ components = URI.parse('//10.10.000.10')
+ t.equal(components.error, undefined, 'IPv4address errors')
+ t.equal(components.scheme, undefined, 'scheme')
+ t.equal(components.userinfo, undefined, 'userinfo')
+ t.equal(components.host, '10.10.0.10', 'host')
+ t.equal(components.port, undefined, 'port')
+ t.equal(components.path, '', 'path')
+ t.equal(components.query, undefined, 'query')
+ t.equal(components.fragment, undefined, 'fragment')
+
+ // IPv6address
+ components = URI.parse('//[2001:db8::7]')
+ t.equal(components.error, undefined, 'IPv4address errors')
+ t.equal(components.scheme, undefined, 'scheme')
+ t.equal(components.userinfo, undefined, 'userinfo')
+ t.equal(components.host, '2001:db8::7', 'host')
+ t.equal(components.port, undefined, 'port')
+ t.equal(components.path, '', 'path')
+ t.equal(components.query, undefined, 'query')
+ t.equal(components.fragment, undefined, 'fragment')
+
+ // invalid IPv6
+ components = URI.parse('//[2001:dbZ::7]')
+ t.equal(components.host, '[2001:dbz::7]')
+
+ // mixed IPv4address & IPv6address
+ components = URI.parse('//[::ffff:129.144.52.38]')
+ t.equal(components.error, undefined, 'IPv4address errors')
+ t.equal(components.scheme, undefined, 'scheme')
+ t.equal(components.userinfo, undefined, 'userinfo')
+ t.equal(components.host, '::ffff:129.144.52.38', 'host')
+ t.equal(components.port, undefined, 'port')
+ t.equal(components.path, '', 'path')
+ t.equal(components.query, undefined, 'query')
+ t.equal(components.fragment, undefined, 'fragment')
+
+ // mixed IPv4address & reg-name, example from terion-name (https://github.com/garycourt/uri-js/issues/4)
+ components = URI.parse('uri://10.10.10.10.example.com/en/process')
+ t.equal(components.error, undefined, 'mixed errors')
+ t.equal(components.scheme, 'uri', 'scheme')
+ t.equal(components.userinfo, undefined, 'userinfo')
+ t.equal(components.host, '10.10.10.10.example.com', 'host')
+ t.equal(components.port, undefined, 'port')
+ t.equal(components.path, '/en/process', 'path')
+ t.equal(components.query, undefined, 'query')
+ t.equal(components.fragment, undefined, 'fragment')
+
+ // IPv6address, example from bkw (https://github.com/garycourt/uri-js/pull/16)
+ components = URI.parse('//[2606:2800:220:1:248:1893:25c8:1946]/test')
+ t.equal(components.error, undefined, 'IPv6address errors')
+ t.equal(components.scheme, undefined, 'scheme')
+ t.equal(components.userinfo, undefined, 'userinfo')
+ t.equal(components.host, '2606:2800:220:1:248:1893:25c8:1946', 'host')
+ t.equal(components.port, undefined, 'port')
+ t.equal(components.path, '/test', 'path')
+ t.equal(components.query, undefined, 'query')
+ t.equal(components.fragment, undefined, 'fragment')
+
+ // IPv6address, example from RFC 5952
+ components = URI.parse('//[2001:db8::1]:80')
+ t.equal(components.error, undefined, 'IPv6address errors')
+ t.equal(components.scheme, undefined, 'scheme')
+ t.equal(components.userinfo, undefined, 'userinfo')
+ t.equal(components.host, '2001:db8::1', 'host')
+ t.equal(components.port, 80, 'port')
+ t.equal(components.path, '', 'path')
+ t.equal(components.query, undefined, 'query')
+ t.equal(components.fragment, undefined, 'fragment')
+
+ // IPv6address with zone identifier, RFC 6874
+ components = URI.parse('//[fe80::a%25en1]')
+ t.equal(components.error, undefined, 'IPv4address errors')
+ t.equal(components.scheme, undefined, 'scheme')
+ t.equal(components.userinfo, undefined, 'userinfo')
+ t.equal(components.host, 'fe80::a%en1', 'host')
+ t.equal(components.port, undefined, 'port')
+ t.equal(components.path, '', 'path')
+ t.equal(components.query, undefined, 'query')
+ t.equal(components.fragment, undefined, 'fragment')
+
+ // IPv6address with an unescaped interface specifier, example from pekkanikander (https://github.com/garycourt/uri-js/pull/22)
+ components = URI.parse('//[2001:db8::7%en0]')
+ t.equal(components.error, undefined, 'IPv6address interface errors')
+ t.equal(components.scheme, undefined, 'scheme')
+ t.equal(components.userinfo, undefined, 'userinfo')
+ t.equal(components.host, '2001:db8::7%en0', 'host')
+ t.equal(components.port, undefined, 'port')
+ t.equal(components.path, '', 'path')
+ t.equal(components.query, undefined, 'query')
+ t.equal(components.fragment, undefined, 'fragment')
+
+ // UUID V1
+ components = URI.parse('urn:uuid:b571b0bc-4713-11ec-81d3-0242ac130003')
+ t.equal(components.error, undefined, 'errors')
+ t.equal(components.scheme, 'urn', 'scheme')
+ // t.equal(components.authority, undefined, "authority");
+ t.equal(components.userinfo, undefined, 'userinfo')
+ t.equal(components.host, undefined, 'host')
+ t.equal(components.port, undefined, 'port')
+ t.equal(components.path, undefined, 'path')
+ t.equal(components.query, undefined, 'query')
+ t.equal(components.fragment, undefined, 'fragment')
+ t.equal(components.nid, 'uuid', 'nid')
+ t.equal(components.nss, undefined, 'nss')
+ t.equal(components.uuid, 'b571b0bc-4713-11ec-81d3-0242ac130003', 'uuid')
+
+ // UUID v4
+ components = URI.parse('urn:uuid:97a32222-89b7-420e-8507-4360723e2c2a')
+ t.equal(components.uuid, '97a32222-89b7-420e-8507-4360723e2c2a', 'uuid')
+
+ components = URI.parse('urn:uuid:notauuid-7dec-11d0-a765-00a0c91e6bf6')
+ t.notSame(components.error, undefined, 'errors')
+
+ components = URI.parse('urn:foo:a123,456')
+ t.equal(components.error, undefined, 'errors')
+ t.equal(components.scheme, 'urn', 'scheme')
+ // t.equal(components.authority, undefined, "authority");
+ t.equal(components.userinfo, undefined, 'userinfo')
+ t.equal(components.host, undefined, 'host')
+ t.equal(components.port, undefined, 'port')
+ t.equal(components.path, undefined, 'path')
+ t.equal(components.query, undefined, 'query')
+ t.equal(components.fragment, undefined, 'fragment')
+ t.equal(components.nid, 'foo', 'nid')
+ t.equal(components.nss, 'a123,456', 'nss')
+
+ components = URI.parse('//[2606:2800:220:1:248:1893:25c8:1946:43209]')
+ t.equal(components.host, '[2606:2800:220:1:248:1893:25c8:1946:43209]')
+
+ components = URI.parse('urn:foo:|\\24fpl')
+ t.equal(components.error, 'URN can not be parsed.')
+ t.end()
+})
diff --git a/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/test/resolve.test.js b/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/test/resolve.test.js
new file mode 100644
index 00000000..ab38188f
--- /dev/null
+++ b/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/test/resolve.test.js
@@ -0,0 +1,76 @@
+'use strict'
+
+const tap = require('tap')
+const test = tap.test
+const URI = require('../')
+
+test('URI Resolving', (t) => {
+ // normal examples from RFC 3986
+ const base = 'uri://a/b/c/d;p?q'
+ t.equal(URI.resolve(base, 'g:h'), 'g:h', 'g:h')
+ t.equal(URI.resolve(base, 'g:h'), 'g:h', 'g:h')
+ t.equal(URI.resolve(base, 'g'), 'uri://a/b/c/g', 'g')
+ t.equal(URI.resolve(base, './g'), 'uri://a/b/c/g', './g')
+ t.equal(URI.resolve(base, 'g/'), 'uri://a/b/c/g/', 'g/')
+ t.equal(URI.resolve(base, '/g'), 'uri://a/g', '/g')
+ t.equal(URI.resolve(base, '//g'), 'uri://g', '//g')
+ t.equal(URI.resolve(base, '?y'), 'uri://a/b/c/d;p?y', '?y')
+ t.equal(URI.resolve(base, 'g?y'), 'uri://a/b/c/g?y', 'g?y')
+ t.equal(URI.resolve(base, '#s'), 'uri://a/b/c/d;p?q#s', '#s')
+ t.equal(URI.resolve(base, 'g#s'), 'uri://a/b/c/g#s', 'g#s')
+ t.equal(URI.resolve(base, 'g?y#s'), 'uri://a/b/c/g?y#s', 'g?y#s')
+ t.equal(URI.resolve(base, ';x'), 'uri://a/b/c/;x', ';x')
+ t.equal(URI.resolve(base, 'g;x'), 'uri://a/b/c/g;x', 'g;x')
+ t.equal(URI.resolve(base, 'g;x?y#s'), 'uri://a/b/c/g;x?y#s', 'g;x?y#s')
+ t.equal(URI.resolve(base, ''), 'uri://a/b/c/d;p?q', '')
+ t.equal(URI.resolve(base, '.'), 'uri://a/b/c/', '.')
+ t.equal(URI.resolve(base, './'), 'uri://a/b/c/', './')
+ t.equal(URI.resolve(base, '..'), 'uri://a/b/', '..')
+ t.equal(URI.resolve(base, '../'), 'uri://a/b/', '../')
+ t.equal(URI.resolve(base, '../g'), 'uri://a/b/g', '../g')
+ t.equal(URI.resolve(base, '../..'), 'uri://a/', '../..')
+ t.equal(URI.resolve(base, '../../'), 'uri://a/', '../../')
+ t.equal(URI.resolve(base, '../../g'), 'uri://a/g', '../../g')
+
+ // abnormal examples from RFC 3986
+ t.equal(URI.resolve(base, '../../../g'), 'uri://a/g', '../../../g')
+ t.equal(URI.resolve(base, '../../../../g'), 'uri://a/g', '../../../../g')
+
+ t.equal(URI.resolve(base, '/./g'), 'uri://a/g', '/./g')
+ t.equal(URI.resolve(base, '/../g'), 'uri://a/g', '/../g')
+ t.equal(URI.resolve(base, 'g.'), 'uri://a/b/c/g.', 'g.')
+ t.equal(URI.resolve(base, '.g'), 'uri://a/b/c/.g', '.g')
+ t.equal(URI.resolve(base, 'g..'), 'uri://a/b/c/g..', 'g..')
+ t.equal(URI.resolve(base, '..g'), 'uri://a/b/c/..g', '..g')
+
+ t.equal(URI.resolve(base, './../g'), 'uri://a/b/g', './../g')
+ t.equal(URI.resolve(base, './g/.'), 'uri://a/b/c/g/', './g/.')
+ t.equal(URI.resolve(base, 'g/./h'), 'uri://a/b/c/g/h', 'g/./h')
+ t.equal(URI.resolve(base, 'g/../h'), 'uri://a/b/c/h', 'g/../h')
+ t.equal(URI.resolve(base, 'g;x=1/./y'), 'uri://a/b/c/g;x=1/y', 'g;x=1/./y')
+ t.equal(URI.resolve(base, 'g;x=1/../y'), 'uri://a/b/c/y', 'g;x=1/../y')
+
+ t.equal(URI.resolve(base, 'g?y/./x'), 'uri://a/b/c/g?y/./x', 'g?y/./x')
+ t.equal(URI.resolve(base, 'g?y/../x'), 'uri://a/b/c/g?y/../x', 'g?y/../x')
+ t.equal(URI.resolve(base, 'g#s/./x'), 'uri://a/b/c/g#s/./x', 'g#s/./x')
+ t.equal(URI.resolve(base, 'g#s/../x'), 'uri://a/b/c/g#s/../x', 'g#s/../x')
+
+ t.equal(URI.resolve(base, 'uri:g'), 'uri:g', 'uri:g')
+ t.equal(URI.resolve(base, 'uri:g', { tolerant: true }), 'uri://a/b/c/g', 'uri:g')
+
+ // examples by PAEz
+ // example was provided to avoid infinite loop within regex
+ // this is not the case anymore
+ // t.equal(URI.resolve('//www.g.com/', '/adf\ngf'), '//www.g.com/adf%0Agf', '/adf\\ngf')
+ // t.equal(URI.resolve('//www.g.com/error\n/bleh/bleh', '..'), '//www.g.com/error%0A/', '//www.g.com/error\\n/bleh/bleh')
+ t.end()
+})
+
+test('URN Resolving', (t) => {
+ // example from epoberezkin
+ t.equal(URI.resolve('', 'urn:some:ip:prop'), 'urn:some:ip:prop', 'urn:some:ip:prop')
+ t.equal(URI.resolve('#', 'urn:some:ip:prop'), 'urn:some:ip:prop', 'urn:some:ip:prop')
+ t.equal(URI.resolve('urn:some:ip:prop', 'urn:some:ip:prop'), 'urn:some:ip:prop', 'urn:some:ip:prop')
+ t.equal(URI.resolve('urn:some:other:prop', 'urn:some:ip:prop'), 'urn:some:ip:prop', 'urn:some:ip:prop')
+ t.end()
+})
diff --git a/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/test/serialize.test.js b/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/test/serialize.test.js
new file mode 100644
index 00000000..db84820b
--- /dev/null
+++ b/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/test/serialize.test.js
@@ -0,0 +1,144 @@
+'use strict'
+
+const tap = require('tap')
+const test = tap.test
+const URI = require('../')
+
+test('URI Serialize', (t) => {
+ let components = {
+ scheme: undefined,
+ userinfo: undefined,
+ host: undefined,
+ port: undefined,
+ path: undefined,
+ query: undefined,
+ fragment: undefined
+ }
+ t.equal(URI.serialize(components), '', 'Undefined Components')
+
+ components = {
+ scheme: '',
+ userinfo: '',
+ host: '',
+ port: 0,
+ path: '',
+ query: '',
+ fragment: ''
+ }
+ t.equal(URI.serialize(components), '//@:0?#', 'Empty Components')
+
+ components = {
+ scheme: 'uri',
+ userinfo: 'foo:bar',
+ host: 'example.com',
+ port: 1,
+ path: 'path',
+ query: 'query',
+ fragment: 'fragment'
+ }
+ t.equal(URI.serialize(components), 'uri://foo:bar@example.com:1/path?query#fragment', 'All Components')
+
+ components = {
+ scheme: 'uri',
+ host: 'example.com',
+ port: '9000'
+ }
+ t.equal(URI.serialize(components), 'uri://example.com:9000', 'String port')
+
+ t.equal(URI.serialize({ path: '//path' }), '/%2Fpath', 'Double slash path')
+ t.equal(URI.serialize({ path: 'foo:bar' }), 'foo%3Abar', 'Colon path')
+ t.equal(URI.serialize({ path: '?query' }), '%3Fquery', 'Query path')
+
+ t.equal(URI.serialize({ host: '10.10.10.10' }), '//10.10.10.10', 'IPv4address')
+
+ // mixed IPv4address & reg-name, example from terion-name (https://github.com/garycourt/uri-js/issues/4)
+ t.equal(URI.serialize({ host: '10.10.10.10.example.com' }), '//10.10.10.10.example.com', 'Mixed IPv4address & reg-name')
+
+ // IPv6address
+ t.equal(URI.serialize({ host: '2001:db8::7' }), '//[2001:db8::7]', 'IPv6 Host')
+ t.equal(URI.serialize({ host: '::ffff:129.144.52.38' }), '//[::ffff:129.144.52.38]', 'IPv6 Mixed Host')
+ t.equal(URI.serialize({ host: '2606:2800:220:1:248:1893:25c8:1946' }), '//[2606:2800:220:1:248:1893:25c8:1946]', 'IPv6 Full Host')
+
+ // IPv6address with zone identifier, RFC 6874
+ t.equal(URI.serialize({ host: 'fe80::a%en1' }), '//[fe80::a%25en1]', 'IPv6 Zone Unescaped Host')
+ t.equal(URI.serialize({ host: 'fe80::a%25en1' }), '//[fe80::a%25en1]', 'IPv6 Zone Escaped Host')
+
+ t.end()
+})
+
+test('WS serialize', (t) => {
+ t.equal(URI.serialize({ scheme: 'ws' }), 'ws:')
+ t.equal(URI.serialize({ scheme: 'ws', host: 'example.com' }), 'ws://example.com')
+ t.equal(URI.serialize({ scheme: 'ws', resourceName: '/' }), 'ws:')
+ t.equal(URI.serialize({ scheme: 'ws', resourceName: '/foo' }), 'ws:/foo')
+ t.equal(URI.serialize({ scheme: 'ws', resourceName: '/foo?bar' }), 'ws:/foo?bar')
+ t.equal(URI.serialize({ scheme: 'ws', secure: false }), 'ws:')
+ t.equal(URI.serialize({ scheme: 'ws', secure: true }), 'wss:')
+ t.equal(URI.serialize({ scheme: 'ws', host: 'example.com', resourceName: '/foo' }), 'ws://example.com/foo')
+ t.equal(URI.serialize({ scheme: 'ws', host: 'example.com', resourceName: '/foo?bar' }), 'ws://example.com/foo?bar')
+ t.equal(URI.serialize({ scheme: 'ws', host: 'example.com', secure: false }), 'ws://example.com')
+ t.equal(URI.serialize({ scheme: 'ws', host: 'example.com', secure: true }), 'wss://example.com')
+ t.equal(URI.serialize({ scheme: 'ws', host: 'example.com', resourceName: '/foo?bar', secure: false }), 'ws://example.com/foo?bar')
+ t.equal(URI.serialize({ scheme: 'ws', host: 'example.com', resourceName: '/foo?bar', secure: true }), 'wss://example.com/foo?bar')
+ t.end()
+})
+
+test('WSS serialize', (t) => {
+ t.equal(URI.serialize({ scheme: 'wss' }), 'wss:')
+ t.equal(URI.serialize({ scheme: 'wss', host: 'example.com' }), 'wss://example.com')
+ t.equal(URI.serialize({ scheme: 'wss', resourceName: '/' }), 'wss:')
+ t.equal(URI.serialize({ scheme: 'wss', resourceName: '/foo' }), 'wss:/foo')
+ t.equal(URI.serialize({ scheme: 'wss', resourceName: '/foo?bar' }), 'wss:/foo?bar')
+ t.equal(URI.serialize({ scheme: 'wss', secure: false }), 'ws:')
+ t.equal(URI.serialize({ scheme: 'wss', secure: true }), 'wss:')
+ t.equal(URI.serialize({ scheme: 'wss', host: 'example.com', resourceName: '/foo' }), 'wss://example.com/foo')
+ t.equal(URI.serialize({ scheme: 'wss', host: 'example.com', resourceName: '/foo?bar' }), 'wss://example.com/foo?bar')
+ t.equal(URI.serialize({ scheme: 'wss', host: 'example.com', secure: false }), 'ws://example.com')
+ t.equal(URI.serialize({ scheme: 'wss', host: 'example.com', secure: true }), 'wss://example.com')
+ t.equal(URI.serialize({ scheme: 'wss', host: 'example.com', resourceName: '/foo?bar', secure: false }), 'ws://example.com/foo?bar')
+ t.equal(URI.serialize({ scheme: 'wss', host: 'example.com', resourceName: '/foo?bar', secure: true }), 'wss://example.com/foo?bar')
+
+ t.end()
+})
+
+test('URN serialize', (t) => {
+// example from RFC 2141
+ const components = {
+ scheme: 'urn',
+ nid: 'foo',
+ nss: 'a123,456'
+ }
+ t.equal(URI.serialize(components), 'urn:foo:a123,456')
+ // example from RFC 4122
+ let uuidcomponents = {
+ scheme: 'urn',
+ nid: 'uuid',
+ uuid: 'f81d4fae-7dec-11d0-a765-00a0c91e6bf6'
+ }
+ t.equal(URI.serialize(uuidcomponents), 'urn:uuid:f81d4fae-7dec-11d0-a765-00a0c91e6bf6')
+
+ uuidcomponents = {
+ scheme: 'urn',
+ nid: 'uuid',
+ uuid: 'notauuid-7dec-11d0-a765-00a0c91e6bf6'
+ }
+ t.equal(URI.serialize(uuidcomponents), 'urn:uuid:notauuid-7dec-11d0-a765-00a0c91e6bf6')
+ t.end()
+})
+test('URN NID Override', (t) => {
+ let components = URI.parse('urn:foo:f81d4fae-7dec-11d0-a765-00a0c91e6bf6', { nid: 'uuid' })
+ t.equal(components.error, undefined, 'errors')
+ t.equal(components.scheme, 'urn', 'scheme')
+ t.equal(components.path, undefined, 'path')
+ t.equal(components.nid, 'foo', 'nid')
+ t.equal(components.nss, undefined, 'nss')
+ t.equal(components.uuid, 'f81d4fae-7dec-11d0-a765-00a0c91e6bf6', 'uuid')
+
+ components = {
+ scheme: 'urn',
+ nid: 'foo',
+ uuid: 'f81d4fae-7dec-11d0-a765-00a0c91e6bf6'
+ }
+ t.equal(URI.serialize(components, { nid: 'uuid' }), 'urn:foo:f81d4fae-7dec-11d0-a765-00a0c91e6bf6')
+ t.end()
+})
diff --git a/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/types/index.d.ts b/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/types/index.d.ts
new file mode 100644
index 00000000..b00d8b11
--- /dev/null
+++ b/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/types/index.d.ts
@@ -0,0 +1,53 @@
+type FastUri = typeof fastUri
+
+declare namespace fastUri {
+ export interface URIComponent {
+ scheme?: string;
+ userinfo?: string;
+ host?: string;
+ port?: number | string;
+ path?: string;
+ query?: string;
+ fragment?: string;
+ reference?: string;
+ error?: string;
+ }
+ export interface Options {
+ scheme?: string;
+ reference?: string;
+ unicodeSupport?: boolean;
+ domainHost?: boolean;
+ absolutePath?: boolean;
+ tolerant?: boolean;
+ }
+
+ /**
+ * @deprecated Use Options instead
+ */
+ export type options = Options
+ /**
+ * @deprecated Use URIComponent instead
+ */
+ export type URIComponents = URIComponent
+
+ 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
diff --git a/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/types/index.test-d.ts b/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/types/index.test-d.ts
new file mode 100644
index 00000000..1e2e2475
--- /dev/null
+++ b/sdk/node_modules/@fastify/ajv-compiler/node_modules/fast-uri/types/index.test-d.ts
@@ -0,0 +1,17 @@
+import uri, { URIComponents, URIComponent, Options, options } from "..";
+import { expectDeprecated, expectType } from "tsd";
+
+const parsed = uri.parse("foo");
+expectType(parsed);
+const parsed2 = uri.parse("foo", {
+ domainHost: true,
+ scheme: 'https',
+ unicodeSupport: false
+})
+expectType(parsed2);
+
+expectType({} as URIComponents)
+expectDeprecated({} as URIComponents)
+
+expectType({} as options)
+expectDeprecated({} as options)
diff --git a/sdk/node_modules/@fastify/ajv-compiler/package.json b/sdk/node_modules/@fastify/ajv-compiler/package.json
new file mode 100644
index 00000000..c57612d6
--- /dev/null
+++ b/sdk/node_modules/@fastify/ajv-compiler/package.json
@@ -0,0 +1,54 @@
+{
+ "name": "@fastify/ajv-compiler",
+ "version": "3.6.0",
+ "description": "Build and manage the AJV instances for the fastify framework",
+ "main": "index.js",
+ "type": "commonjs",
+ "types": "types/index.d.ts",
+ "directories": {
+ "test": "test"
+ },
+ "scripts": {
+ "lint": "standard",
+ "lint:fix": "standard --fix",
+ "unit": "tap",
+ "test": "npm run unit && npm run test:typescript",
+ "test:typescript": "tsd",
+ "ajv:compile": "ajv compile -s test/source.json -o test/validate_schema.js"
+ },
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/fastify/ajv-compiler.git"
+ },
+ "keywords": [
+ "ajv",
+ "validator",
+ "schema",
+ "compiler",
+ "fastify"
+ ],
+ "author": "Manuel Spigolon (https://github.com/Eomm)",
+ "license": "MIT",
+ "bugs": {
+ "url": "https://github.com/fastify/ajv-compiler/issues"
+ },
+ "homepage": "https://github.com/fastify/ajv-compiler#readme",
+ "devDependencies": {
+ "ajv-cli": "^5.0.0",
+ "ajv-errors": "^3.0.0",
+ "ajv-i18n": "^4.0.1",
+ "ajv-merge-patch": "^5.0.1",
+ "cronometro": "^3.0.1",
+ "fastify": "^4.0.0",
+ "require-from-string": "^2.0.2",
+ "sanitize-filename": "^1.6.3",
+ "standard": "^17.0.0",
+ "tap": "^16.2.0",
+ "tsd": "^0.31.0"
+ },
+ "dependencies": {
+ "ajv": "^8.11.0",
+ "ajv-formats": "^2.1.1",
+ "fast-uri": "^2.0.0"
+ }
+}
diff --git a/sdk/node_modules/@fastify/ajv-compiler/standalone.js b/sdk/node_modules/@fastify/ajv-compiler/standalone.js
new file mode 100644
index 00000000..42428a0d
--- /dev/null
+++ b/sdk/node_modules/@fastify/ajv-compiler/standalone.js
@@ -0,0 +1,44 @@
+'use strict'
+
+const ValidatorSelector = require('./index')
+const standaloneCode = require('ajv/dist/standalone').default
+
+function StandaloneValidator (options = { readMode: true }) {
+ if (options.readMode === true && !options.restoreFunction) {
+ throw new Error('You must provide a restoreFunction options when readMode ON')
+ }
+
+ if (options.readMode !== true && !options.storeFunction) {
+ throw new Error('You must provide a storeFunction options when readMode OFF')
+ }
+
+ if (options.readMode === true) {
+ // READ MODE: it behalf only in the restore function provided by the user
+ return function wrapper () {
+ return function (opts) {
+ return options.restoreFunction(opts)
+ }
+ }
+ }
+
+ // WRITE MODE: it behalf on the default ValidatorSelector, wrapping the API to run the Ajv Standalone code generation
+ const factory = ValidatorSelector()
+ return function wrapper (externalSchemas, ajvOptions = {}) {
+ if (!ajvOptions.customOptions || !ajvOptions.customOptions.code) {
+ // to generate the validation source code, these options are mandatory
+ ajvOptions.customOptions = Object.assign({}, ajvOptions.customOptions, { code: { source: true } })
+ }
+
+ const compiler = factory(externalSchemas, ajvOptions)
+ return function (opts) { // { schema/*, method, url, httpPart */ }
+ const validationFunc = compiler(opts)
+
+ const schemaValidationCode = standaloneCode(compiler[ValidatorSelector.AjvReference].ajv, validationFunc)
+ options.storeFunction(opts, schemaValidationCode)
+
+ return validationFunc
+ }
+ }
+}
+
+module.exports = StandaloneValidator
diff --git a/sdk/node_modules/@fastify/ajv-compiler/test/.gitkeep b/sdk/node_modules/@fastify/ajv-compiler/test/.gitkeep
new file mode 100644
index 00000000..e69de29b
diff --git a/sdk/node_modules/@fastify/ajv-compiler/test/duplicated-id-compile.test.js b/sdk/node_modules/@fastify/ajv-compiler/test/duplicated-id-compile.test.js
new file mode 100644
index 00000000..849016c6
--- /dev/null
+++ b/sdk/node_modules/@fastify/ajv-compiler/test/duplicated-id-compile.test.js
@@ -0,0 +1,59 @@
+'use strict'
+
+const t = require('tap')
+const AjvCompiler = require('../index')
+
+const postSchema = Object.freeze({
+ $schema: 'http://json-schema.org/draft-07/schema#',
+ type: 'object',
+ $id: 'http://mydomain.com/user',
+ title: 'User schema',
+ description: 'Contains all user fields',
+ properties: {
+ username: { type: 'string', minLength: 4 },
+ firstName: { type: 'string', minLength: 1 },
+ lastName: { type: 'string', minLength: 1 },
+ email: { type: 'string' },
+ password: { type: 'string', minLength: 6 },
+ bio: { type: 'string' }
+ },
+ required: ['username', 'firstName', 'lastName', 'email', 'bio', 'password']
+})
+
+const patchSchema = Object.freeze({
+ $schema: 'http://json-schema.org/draft-07/schema#',
+ type: 'object',
+ $id: 'http://mydomain.com/user',
+ title: 'User schema',
+ description: 'Contains all user fields',
+ properties: {
+ firstName: { type: 'string', minLength: 1 },
+ lastName: { type: 'string', minLength: 1 },
+ bio: { type: 'string' }
+ }
+})
+
+const fastifyAjvOptionsDefault = Object.freeze({
+ customOptions: {}
+})
+
+t.test('must not store schema on compile', t => {
+ t.plan(4)
+ const factory = AjvCompiler()
+ const compiler = factory({}, fastifyAjvOptionsDefault)
+ const postFn = compiler({ schema: postSchema })
+ const patchFn = compiler({ schema: patchSchema })
+
+ const resultForPost = postFn({})
+ t.equal(resultForPost, false)
+ t.has(postFn.errors, [
+ {
+ keyword: 'required',
+ message: "must have required property 'username'"
+ }
+ ])
+
+ const resultForPatch = patchFn({})
+ t.ok(resultForPatch)
+ t.notOk(patchFn.errors)
+})
diff --git a/sdk/node_modules/@fastify/ajv-compiler/test/index.test.js b/sdk/node_modules/@fastify/ajv-compiler/test/index.test.js
new file mode 100644
index 00000000..fe1427ce
--- /dev/null
+++ b/sdk/node_modules/@fastify/ajv-compiler/test/index.test.js
@@ -0,0 +1,307 @@
+'use strict'
+
+const t = require('tap')
+const fastify = require('fastify')
+const AjvCompiler = require('../index')
+
+const sym = Symbol.for('fastify.ajv-compiler.reference')
+
+const sampleSchema = Object.freeze({
+ $id: 'example1',
+ type: 'object',
+ properties: {
+ name: { type: 'string' }
+ }
+})
+
+const externalSchemas1 = Object.freeze({})
+const externalSchemas2 = Object.freeze({
+ foo: {
+ $id: 'foo',
+ type: 'object',
+ properties: {
+ name: { type: 'string' }
+ }
+ }
+})
+
+const fastifyAjvOptionsDefault = Object.freeze({
+ customOptions: {}
+})
+
+const fastifyJtdDefault = Object.freeze({
+ customOptions: { },
+ mode: 'JTD'
+})
+
+const fastifyAjvOptionsCustom = Object.freeze({
+ customOptions: {
+ allErrors: true,
+ removeAdditional: false
+ },
+ plugins: [
+ require('ajv-formats'),
+ [require('ajv-errors'), { singleError: false }]
+ ]
+})
+
+t.test('basic usage', t => {
+ t.plan(1)
+ const factory = AjvCompiler()
+ const compiler = factory(externalSchemas1, fastifyAjvOptionsDefault)
+ const validatorFunc = compiler({ schema: sampleSchema })
+ const result = validatorFunc({ name: 'hello' })
+ t.equal(result, true)
+})
+
+t.test('array coercion', t => {
+ t.plan(2)
+ const factory = AjvCompiler()
+ const compiler = factory(externalSchemas1, fastifyAjvOptionsDefault)
+
+ const arraySchema = {
+ $id: 'example1',
+ type: 'object',
+ properties: {
+ name: { type: 'array', items: { type: 'string' } }
+ }
+ }
+
+ const validatorFunc = compiler({ schema: arraySchema })
+
+ const inputObj = { name: 'hello' }
+ t.equal(validatorFunc(inputObj), true)
+ t.same(inputObj, { name: ['hello'] }, 'the name property should be coerced to an array')
+})
+
+t.test('nullable default', t => {
+ t.plan(2)
+ const factory = AjvCompiler()
+ const compiler = factory({}, fastifyAjvOptionsDefault)
+ const validatorFunc = compiler({
+ schema: {
+ type: 'object',
+ properties: {
+ nullable: { type: 'string', nullable: true },
+ notNullable: { type: 'string' }
+ }
+ }
+ })
+ const input = { nullable: null, notNullable: null }
+ const result = validatorFunc(input)
+ t.equal(result, true)
+ t.same(input, { nullable: null, notNullable: '' }, 'the notNullable field has been coerced')
+})
+
+t.test('plugin loading', t => {
+ t.plan(3)
+ const factory = AjvCompiler()
+ const compiler = factory(externalSchemas1, fastifyAjvOptionsCustom)
+ const validatorFunc = compiler({
+ schema: {
+ type: 'object',
+ properties: {
+ q: {
+ type: 'string',
+ format: 'date',
+ formatMinimum: '2016-02-06',
+ formatExclusiveMaximum: '2016-12-27'
+ }
+ },
+ required: ['q'],
+ errorMessage: 'hello world'
+ }
+ })
+ const result = validatorFunc({ q: '2016-10-02' })
+ t.equal(result, true)
+
+ const resultFail = validatorFunc({})
+ t.equal(resultFail, false)
+ t.equal(validatorFunc.errors[0].message, 'hello world')
+})
+
+t.test('optimization - cache ajv instance', t => {
+ t.plan(5)
+ const factory = AjvCompiler()
+ const compiler1 = factory(externalSchemas1, fastifyAjvOptionsDefault)
+ const compiler2 = factory(externalSchemas1, fastifyAjvOptionsDefault)
+ t.equal(compiler1, compiler2, 'same instance')
+ t.same(compiler1, compiler2, 'same instance')
+
+ const compiler3 = factory(externalSchemas2, fastifyAjvOptionsDefault)
+ t.not(compiler3, compiler1, 'new ajv instance when externa schema change')
+
+ const compiler4 = factory(externalSchemas1, fastifyAjvOptionsCustom)
+ t.not(compiler4, compiler1, 'new ajv instance when externa schema change')
+ t.not(compiler4, compiler3, 'new ajv instance when externa schema change')
+})
+
+t.test('the onCreate callback can enhance the ajv instance', t => {
+ t.plan(2)
+ const factory = AjvCompiler()
+
+ const fastifyAjvCustomOptionsFormats = Object.freeze({
+ onCreate (ajv) {
+ for (const [formatName, format] of Object.entries(this.customOptions.formats)) {
+ ajv.addFormat(formatName, format)
+ }
+ },
+ customOptions: {
+ formats: {
+ date: /foo/
+ }
+ }
+ })
+
+ const compiler1 = factory(externalSchemas1, fastifyAjvCustomOptionsFormats)
+ const validatorFunc = compiler1({
+ schema: {
+ type: 'string',
+ format: 'date'
+ }
+ })
+ const result = validatorFunc('foo')
+ t.equal(result, true)
+
+ const resultFail = validatorFunc('2016-10-02')
+ t.equal(resultFail, false)
+})
+
+// https://github.com/fastify/fastify/pull/2969
+t.test('compile same $id when in external schema', t => {
+ t.plan(3)
+ const factory = AjvCompiler()
+
+ const base = {
+ $id: 'urn:schema:base',
+ definitions: {
+ hello: { type: 'string' }
+ },
+ type: 'object',
+ properties: {
+ hello: { $ref: '#/definitions/hello' }
+ }
+ }
+
+ const refSchema = {
+ $id: 'urn:schema:ref',
+ type: 'object',
+ properties: {
+ hello: { $ref: 'urn:schema:base#/definitions/hello' }
+ }
+ }
+
+ const compiler = factory({
+ [base.$id]: base,
+ [refSchema.$id]: refSchema
+
+ }, fastifyAjvOptionsDefault)
+
+ t.notOk(compiler[sym], 'the ajv reference do not exists if code is not activated')
+
+ const validatorFunc1 = compiler({
+ schema: {
+ $id: 'urn:schema:ref'
+ }
+ })
+
+ const validatorFunc2 = compiler({
+ schema: {
+ $id: 'urn:schema:ref'
+ }
+ })
+
+ t.pass('the compile does not fail if the schema compiled is already in the external schemas')
+ t.equal(validatorFunc1, validatorFunc2, 'the returned function is the same')
+})
+
+t.test('JTD MODE', t => {
+ t.plan(2)
+
+ t.test('compile jtd schema', t => {
+ t.plan(4)
+ const factory = AjvCompiler()
+
+ const jtdSchema = {
+ discriminator: 'version',
+ mapping: {
+ 1: {
+ properties: {
+ foo: { type: 'uint8' }
+ }
+ },
+ 2: {
+ properties: {
+ foo: { type: 'string' }
+ }
+ }
+ }
+ }
+
+ const compiler = factory({}, fastifyJtdDefault)
+ const validatorFunc = compiler({ schema: jtdSchema })
+ t.pass('generated validation function for JTD SCHEMA')
+
+ const result = validatorFunc({
+ version: '2',
+ foo: []
+ })
+ t.notOk(result, 'failed validation')
+ t.type(validatorFunc.errors, 'Array')
+
+ const success = validatorFunc({
+ version: '1',
+ foo: 42
+ })
+ t.ok(success)
+ })
+
+ t.test('fastify integration', async t => {
+ const factory = AjvCompiler()
+
+ const app = fastify({
+ jsonShorthand: false,
+ ajv: {
+ customOptions: { },
+ mode: 'JTD'
+ },
+ schemaController: {
+ compilersFactory: {
+ buildValidator: factory
+ }
+ }
+ })
+
+ app.post('/', {
+ schema: {
+ body: {
+ discriminator: 'version',
+ mapping: {
+ 1: {
+ properties: {
+ foo: { type: 'uint8' }
+ }
+ },
+ 2: {
+ properties: {
+ foo: { type: 'string' }
+ }
+ }
+ }
+ }
+ }
+ }, () => {})
+
+ const res = await app.inject({
+ url: '/',
+ method: 'POST',
+ payload: {
+ version: '1',
+ foo: 'this is not a number'
+ }
+ })
+
+ t.equal(res.statusCode, 400)
+ t.equal(res.json().message, 'body/foo must be uint8')
+ })
+})
diff --git a/sdk/node_modules/@fastify/ajv-compiler/test/plugins.test.js b/sdk/node_modules/@fastify/ajv-compiler/test/plugins.test.js
new file mode 100644
index 00000000..dacb0e89
--- /dev/null
+++ b/sdk/node_modules/@fastify/ajv-compiler/test/plugins.test.js
@@ -0,0 +1,264 @@
+'use strict'
+
+const t = require('tap')
+const fastify = require('fastify')
+const AjvCompiler = require('../index')
+
+const ajvFormats = require('ajv-formats')
+const ajvErrors = require('ajv-errors')
+const localize = require('ajv-i18n')
+
+t.test('Format Baseline test', async (t) => {
+ const app = buildApplication({
+ customOptions: {
+ validateFormats: false
+ }
+ })
+
+ const res = await app.inject({
+ url: '/hello',
+ headers: {
+ 'x-foo': 'hello',
+ 'x-date': 'not a date',
+ 'x-email': 'not an email'
+ },
+ query: {
+ foo: 'hello',
+ date: 'not a date',
+ email: 'not an email'
+ }
+ })
+ t.equal(res.statusCode, 200, 'format validation does not apply as configured')
+ t.equal(res.payload, 'hello')
+})
+
+t.test('Custom Format plugin loading test', (t) => {
+ t.plan(6)
+ const app = buildApplication({
+ customOptions: {
+ validateFormats: true
+ },
+ plugins: [[ajvFormats, { mode: 'fast' }]]
+ })
+
+ app.inject('/hello', (err, res) => {
+ t.error(err)
+ t.equal(res.statusCode, 400, 'format validation applies')
+ })
+
+ app.inject('/2ad0612c-7578-4b18-9a6f-579863f40e0b', (err, res) => {
+ t.error(err)
+ t.equal(res.statusCode, 400, 'format validation applies')
+ })
+
+ app.inject({
+ url: '/2ad0612c-7578-4b18-9a6f-579863f40e0b',
+ headers: {
+ 'x-foo': 'hello',
+ 'x-date': new Date().toISOString(),
+ 'x-email': 'foo@bar.baz'
+ },
+ query: {
+ foo: 'hello',
+ date: new Date().toISOString(),
+ email: 'foo@bar.baz'
+ }
+ }, (err, res) => {
+ t.error(err)
+ t.equal(res.statusCode, 200)
+ })
+})
+
+t.test('Format plugin set by default test', (t) => {
+ t.plan(6)
+ const app = buildApplication({})
+
+ app.inject('/hello', (err, res) => {
+ t.error(err)
+ t.equal(res.statusCode, 400, 'format validation applies')
+ })
+
+ app.inject('/2ad0612c-7578-4b18-9a6f-579863f40e0b', (err, res) => {
+ t.error(err)
+ t.equal(res.statusCode, 400, 'format validation applies')
+ })
+
+ app.inject({
+ url: '/2ad0612c-7578-4b18-9a6f-579863f40e0b',
+ headers: {
+ 'x-foo': 'hello',
+ 'x-date': new Date().toISOString(),
+ 'x-email': 'foo@bar.baz'
+ },
+ query: {
+ foo: 'hello',
+ date: new Date().toISOString(),
+ email: 'foo@bar.baz'
+ }
+ }, (err, res) => {
+ t.error(err)
+ t.equal(res.statusCode, 200)
+ })
+})
+
+t.test('Custom error messages', (t) => {
+ t.plan(9)
+
+ const app = buildApplication({
+ customOptions: {
+ removeAdditional: false,
+ allErrors: true
+ },
+ plugins: [ajvFormats, ajvErrors]
+ })
+
+ const errorMessage = {
+ required: 'custom miss',
+ type: 'custom type', // will not replace internal "type" error for the property "foo"
+ _: 'custom type', // this prop will do it
+ additionalProperties: 'custom too many params'
+ }
+
+ app.post('/', {
+ handler: () => { t.fail('dont call me') },
+ schema: {
+ body: {
+ type: 'object',
+ required: ['foo'],
+ properties: {
+ foo: { type: 'integer' }
+ },
+ additionalProperties: false,
+ errorMessage
+ }
+ }
+ })
+
+ app.inject({
+ url: '/',
+ method: 'post',
+ payload: {}
+ }, (err, res) => {
+ t.error(err)
+ t.equal(res.statusCode, 400)
+ t.match(res.json().message, errorMessage.required)
+ })
+
+ app.inject({
+ url: '/',
+ method: 'post',
+ payload: { foo: 'not a number' }
+ }, (err, res) => {
+ t.error(err)
+ t.equal(res.statusCode, 400)
+ t.match(res.json().message, errorMessage.type)
+ })
+
+ app.inject({
+ url: '/',
+ method: 'post',
+ payload: { foo: 3, bar: 'ops' }
+ }, (err, res) => {
+ t.error(err)
+ t.equal(res.statusCode, 400)
+ t.match(res.json().message, errorMessage.additionalProperties)
+ })
+})
+
+t.test('Custom i18n error messages', (t) => {
+ t.plan(3)
+
+ const app = buildApplication({
+ customOptions: {
+ allErrors: true,
+ messages: false
+ },
+ plugins: [ajvFormats]
+ })
+
+ app.post('/', {
+ handler: () => { t.fail('dont call me') },
+ schema: {
+ body: {
+ type: 'object',
+ required: ['foo'],
+ properties: {
+ foo: { type: 'integer' }
+ }
+ }
+ }
+ })
+
+ app.setErrorHandler((error, request, reply) => {
+ t.pass('Error handler executed')
+ if (error.validation) {
+ localize.ru(error.validation)
+ reply.status(400).send(error.validation)
+ return
+ }
+ t.fail('not other errors')
+ })
+
+ app.inject({
+ method: 'POST',
+ url: '/',
+ payload: {
+ foo: 'string'
+ }
+ }, (err, res) => {
+ t.error(err)
+ t.equal(res.json()[0].message, 'должно быть integer')
+ })
+})
+
+function buildApplication (ajvOptions) {
+ const factory = AjvCompiler()
+
+ const app = fastify({
+ ajv: ajvOptions,
+ schemaController: {
+ compilersFactory: {
+ buildValidator: factory
+ }
+ }
+ })
+
+ app.get('/:id', {
+ schema: {
+ headers: {
+ type: 'object',
+ required: [
+ 'x-foo',
+ 'x-date',
+ 'x-email'
+ ],
+ properties: {
+ 'x-foo': { type: 'string' },
+ 'x-date': { type: 'string', format: 'date-time' },
+ 'x-email': { type: 'string', format: 'email' }
+ }
+ },
+ query: {
+ type: 'object',
+ required: [
+ 'foo',
+ 'date',
+ 'email'
+ ],
+ properties: {
+ foo: { type: 'string' },
+ date: { type: 'string', format: 'date-time' },
+ email: { type: 'string', format: 'email' }
+ }
+ },
+ params: {
+ type: 'object',
+ properties: {
+ id: { type: 'string', format: 'uuid' }
+ }
+ }
+ }
+ }, async () => 'hello')
+
+ return app
+}
diff --git a/sdk/node_modules/@fastify/ajv-compiler/test/serialization.test.js b/sdk/node_modules/@fastify/ajv-compiler/test/serialization.test.js
new file mode 100644
index 00000000..20821e0d
--- /dev/null
+++ b/sdk/node_modules/@fastify/ajv-compiler/test/serialization.test.js
@@ -0,0 +1,279 @@
+'use strict'
+
+const t = require('tap')
+const fastify = require('fastify')
+const AjvCompiler = require('../index')
+
+const jtdSchema = {
+ discriminator: 'version',
+ mapping: {
+ 1: {
+ properties: {
+ foo: { type: 'uint8' }
+ }
+ },
+ 2: {
+ properties: {
+ foo: { type: 'string' }
+ }
+ }
+ }
+}
+
+const externalSchemas1 = Object.freeze({})
+const externalSchemas2 = Object.freeze({
+ foo: {
+ definitions: {
+ coordinates: {
+ properties: {
+ lat: { type: 'float32' },
+ lng: { type: 'float32' }
+ }
+ }
+ }
+ }
+})
+
+const fastifyAjvOptionsDefault = Object.freeze({
+ customOptions: {}
+})
+
+t.test('basic serializer usage', t => {
+ t.plan(4)
+ const factory = AjvCompiler({ jtdSerializer: true })
+ const compiler = factory(externalSchemas1, fastifyAjvOptionsDefault)
+ const serializeFunc = compiler({ schema: jtdSchema })
+ t.equal(serializeFunc({ version: '1', foo: 42 }), '{"version":"1","foo":42}')
+ t.equal(serializeFunc({ version: '2', foo: 'hello' }), '{"version":"2","foo":"hello"}')
+ t.equal(serializeFunc({ version: '3', foo: 'hello' }), '{"version":"3"}')
+ t.equal(serializeFunc({ version: '2', foo: ['not', 1, { string: 'string' }] }), '{"version":"2","foo":"not,1,[object Object]"}')
+})
+
+t.test('external schemas are ignored', t => {
+ t.plan(1)
+ const factory = AjvCompiler({ jtdSerializer: true })
+ const compiler = factory(externalSchemas2, fastifyAjvOptionsDefault)
+ const serializeFunc = compiler({
+ schema: {
+ definitions: {
+ coordinates: {
+ properties: {
+ lat: { type: 'float32' },
+ lng: { type: 'float32' }
+ }
+ }
+ },
+ properties: {
+ userLoc: { ref: 'coordinates' },
+ serverLoc: { ref: 'coordinates' }
+ }
+ }
+ })
+ t.equal(serializeFunc(
+ { userLoc: { lat: 50, lng: -90 }, serverLoc: { lat: -15, lng: 50 } }),
+ '{"userLoc":{"lat":50,"lng":-90},"serverLoc":{"lat":-15,"lng":50}}'
+ )
+})
+
+t.test('fastify integration within JTD serializer', async t => {
+ const factoryValidator = AjvCompiler()
+ const factorySerializer = AjvCompiler({ jtdSerializer: true })
+
+ const app = fastify({
+ jsonShorthand: false,
+ ajv: {
+ customOptions: { },
+ mode: 'JTD'
+ },
+ schemaController: {
+ compilersFactory: {
+ buildValidator: factoryValidator,
+ buildSerializer: factorySerializer
+ }
+ }
+ })
+
+ app.post('/', {
+ schema: {
+ body: jtdSchema,
+ response: {
+ 200: {
+ properties: {
+ id: { type: 'string' },
+ createdAt: { type: 'timestamp' },
+ karma: { type: 'int32' },
+ isAdmin: { type: 'boolean' }
+ }
+ },
+ 400: jtdSchema
+ }
+ }
+ }, async () => {
+ return {
+ id: '123',
+ createdAt: new Date('1999-01-31T23:00:00.000Z'),
+ karma: 42,
+ isAdmin: true,
+ remove: 'me'
+ }
+ })
+
+ {
+ const res = await app.inject({
+ url: '/',
+ method: 'POST',
+ payload: {
+ version: '1',
+ foo: 'not a number'
+ }
+ })
+
+ t.equal(res.statusCode, 400)
+ t.same(res.json(), { version: 'undefined' })
+ }
+
+ {
+ const res = await app.inject({
+ url: '/',
+ method: 'POST',
+ payload: {
+ version: '1',
+ foo: 32
+ }
+ })
+
+ t.equal(res.statusCode, 200)
+ t.same(res.json(), {
+ id: '123',
+ createdAt: '1999-01-31T23:00:00.000Z',
+ karma: 42,
+ isAdmin: true
+ })
+ }
+})
+
+t.test('fastify integration and cached serializer', async t => {
+ const factoryValidator = AjvCompiler()
+ const factorySerializer = AjvCompiler({ jtdSerializer: true })
+
+ const app = fastify({
+ jsonShorthand: false,
+ ajv: {
+ customOptions: { },
+ mode: 'JTD'
+ },
+ schemaController: {
+ compilersFactory: {
+ buildValidator: factoryValidator,
+ buildSerializer: factorySerializer
+ }
+ }
+ })
+
+ app.register(async function plugin (app, opts) {
+ app.post('/', {
+ schema: {
+ body: jtdSchema,
+ response: {
+ 200: {
+ properties: {
+ id: { type: 'string' },
+ createdAt: { type: 'timestamp' },
+ karma: { type: 'int32' },
+ isAdmin: { type: 'boolean' }
+ }
+ },
+ 400: jtdSchema
+ }
+ }
+ }, async () => {
+ return {
+ id: '123',
+ createdAt: new Date('1999-01-31T23:00:00.000Z'),
+ karma: 42,
+ isAdmin: true,
+ remove: 'me'
+ }
+ })
+ })
+
+ app.register(async function plugin (app, opts) {
+ app.post('/two', {
+ schema: {
+ body: jtdSchema,
+ response: {
+ 400: jtdSchema
+ }
+ }
+ }, () => {})
+ })
+
+ {
+ const res = await app.inject({
+ url: '/',
+ method: 'POST',
+ payload: {
+ version: '1',
+ foo: 'not a number'
+ }
+ })
+
+ t.equal(res.statusCode, 400)
+ t.same(res.json(), { version: 'undefined' })
+ }
+
+ {
+ const res = await app.inject({
+ url: '/',
+ method: 'POST',
+ payload: {
+ version: '1',
+ foo: 32
+ }
+ })
+
+ t.equal(res.statusCode, 200)
+ t.same(res.json(), {
+ id: '123',
+ createdAt: '1999-01-31T23:00:00.000Z',
+ karma: 42,
+ isAdmin: true
+ })
+ }
+})
+
+t.test('fastify integration within JTD serializer and custom options', async t => {
+ const factorySerializer = AjvCompiler({ jtdSerializer: true })
+
+ const app = fastify({
+ jsonShorthand: false,
+ serializerOpts: {
+ allErrors: true,
+ logger: 'wrong-value'
+ },
+ schemaController: {
+ compilersFactory: {
+ buildSerializer: factorySerializer
+ }
+ }
+ })
+
+ app.post('/', {
+ schema: {
+ response: {
+ 200: {
+ properties: {
+ test: { type: 'boolean' }
+ }
+ }
+ }
+ }
+ }, async () => { })
+
+ try {
+ await app.ready()
+ t.fail('should throw')
+ } catch (error) {
+ t.equal(error.message, 'logger must implement log, warn and error methods', 'the wrong setting is forwarded to ajv/jtd')
+ }
+})
diff --git a/sdk/node_modules/@fastify/ajv-compiler/test/standalone.test.js b/sdk/node_modules/@fastify/ajv-compiler/test/standalone.test.js
new file mode 100644
index 00000000..f32fcbac
--- /dev/null
+++ b/sdk/node_modules/@fastify/ajv-compiler/test/standalone.test.js
@@ -0,0 +1,203 @@
+'use strict'
+
+const fs = require('node:fs')
+const path = require('node:path')
+const t = require('tap')
+const fastify = require('fastify')
+const sanitize = require('sanitize-filename')
+
+const { StandaloneValidator: AjvStandaloneValidator } = require('../')
+
+function generateFileName (routeOpts) {
+ return `/ajv-generated-${sanitize(routeOpts.schema.$id)}-${routeOpts.method}-${routeOpts.httpPart}-${sanitize(routeOpts.url)}.js`
+}
+
+const generatedFileNames = []
+
+t.test('standalone', t => {
+ t.plan(4)
+
+ t.teardown(async () => {
+ for (const fileName of generatedFileNames) {
+ await fs.promises.unlink(path.join(__dirname, fileName))
+ }
+ })
+
+ t.test('errors', t => {
+ t.plan(2)
+ t.throws(() => {
+ AjvStandaloneValidator()
+ }, 'missing restoreFunction')
+ t.throws(() => {
+ AjvStandaloneValidator({ readMode: false })
+ }, 'missing storeFunction')
+ })
+
+ t.test('generate standalone code', t => {
+ t.plan(5)
+
+ const base = {
+ $id: 'urn:schema:base',
+ definitions: {
+ hello: { type: 'string' }
+ },
+ type: 'object',
+ properties: {
+ hello: { $ref: '#/definitions/hello' }
+ }
+ }
+
+ const refSchema = {
+ $id: 'urn:schema:ref',
+ type: 'object',
+ properties: {
+ hello: { $ref: 'urn:schema:base#/definitions/hello' }
+ }
+ }
+
+ const endpointSchema = {
+ schema: {
+ $id: 'urn:schema:endpoint',
+ $ref: 'urn:schema:ref'
+ }
+ }
+
+ const schemaMap = {
+ [base.$id]: base,
+ [refSchema.$id]: refSchema
+ }
+
+ const factory = AjvStandaloneValidator({
+ readMode: false,
+ storeFunction (routeOpts, schemaValidationCode) {
+ t.same(routeOpts, endpointSchema)
+ t.type(schemaValidationCode, 'string')
+ fs.writeFileSync(path.join(__dirname, '/ajv-generated.js'), schemaValidationCode)
+ generatedFileNames.push('/ajv-generated.js')
+ t.pass('stored the validation function')
+ }
+ })
+
+ const compiler = factory(schemaMap)
+ compiler(endpointSchema)
+ t.pass('compiled the endpoint schema')
+
+ t.test('usage standalone code', t => {
+ t.plan(3)
+ const standaloneValidate = require('./ajv-generated')
+
+ const valid = standaloneValidate({ hello: 'world' })
+ t.ok(valid)
+
+ const invalid = standaloneValidate({ hello: [] })
+ t.notOk(invalid)
+
+ t.ok(standaloneValidate)
+ })
+ })
+
+ t.test('fastify integration - writeMode', async t => {
+ t.plan(6)
+
+ const factory = AjvStandaloneValidator({
+ readMode: false,
+ storeFunction (routeOpts, schemaValidationCode) {
+ const fileName = generateFileName(routeOpts)
+ t.ok(routeOpts)
+ fs.writeFileSync(path.join(__dirname, fileName), schemaValidationCode)
+ t.pass('stored the validation function')
+ generatedFileNames.push(fileName)
+ },
+ restoreFunction () {
+ t.fail('write mode ON')
+ }
+ })
+
+ const app = buildApp(factory)
+ await app.ready()
+ })
+
+ t.test('fastify integration - readMode', async t => {
+ t.plan(6)
+
+ const factory = AjvStandaloneValidator({
+ readMode: true,
+ storeFunction () {
+ t.fail('read mode ON')
+ },
+ restoreFunction (routeOpts) {
+ t.pass('restore the validation function')
+ const fileName = generateFileName(routeOpts)
+ return require(path.join(__dirname, fileName))
+ }
+ })
+
+ const app = buildApp(factory)
+ await app.ready()
+
+ let res = await app.inject({
+ url: '/foo',
+ method: 'POST',
+ payload: { hello: [] }
+ })
+ t.equal(res.statusCode, 400)
+
+ res = await app.inject({
+ url: '/bar?lang=invalid',
+ method: 'GET'
+ })
+ t.equal(res.statusCode, 400)
+
+ res = await app.inject({
+ url: '/bar?lang=it',
+ method: 'GET'
+ })
+ t.equal(res.statusCode, 200)
+ })
+
+ function buildApp (factory) {
+ const app = fastify({
+ jsonShorthand: false,
+ schemaController: {
+ compilersFactory: {
+ buildValidator: factory
+ }
+ }
+ })
+
+ app.addSchema({
+ $id: 'urn:schema:foo',
+ type: 'object',
+ properties: {
+ name: { type: 'string' },
+ id: { type: 'integer' }
+ }
+ })
+
+ app.post('/foo', {
+ schema: {
+ body: {
+ $id: 'urn:schema:body',
+ type: 'object',
+ properties: {
+ hello: { $ref: 'urn:schema:foo#/properties/name' }
+ }
+ }
+ }
+ }, () => { return 'ok' })
+
+ app.get('/bar', {
+ schema: {
+ query: {
+ $id: 'urn:schema:query',
+ type: 'object',
+ properties: {
+ lang: { type: 'string', enum: ['it', 'en'] }
+ }
+ }
+ }
+ }, () => { return 'ok' })
+
+ return app
+ }
+})
diff --git a/sdk/node_modules/@fastify/ajv-compiler/types/index.d.ts b/sdk/node_modules/@fastify/ajv-compiler/types/index.d.ts
new file mode 100644
index 00000000..5feb2455
--- /dev/null
+++ b/sdk/node_modules/@fastify/ajv-compiler/types/index.d.ts
@@ -0,0 +1,72 @@
+import { AnySchema, default as _ajv, Options as AjvOptions, ValidateFunction } from "ajv";
+import { default as AjvJTD, JTDOptions } from "ajv/dist/jtd";
+import type { Options, ErrorObject } from "ajv";
+import { AnyValidateFunction } from "ajv/dist/core";
+
+type Ajv = _ajv;
+type AjvSerializerGenerator = typeof AjvCompiler
+
+type AjvJTDCompile = AjvJTD['compileSerializer']
+type AjvCompile = (schema: AnySchema, _meta?: boolean) => AnyValidateFunction
+
+declare namespace AjvCompiler {
+ export type { Options, ErrorObject }
+ export { Ajv };
+
+ export type BuildSerializerFromPool = typeof buildSerializerFromPool
+
+ export type BuildCompilerFromPool = typeof buildCompilerFromPool
+
+ export const AjvReference: Symbol
+
+ export enum HttpParts {
+ Body = "body",
+ Headers = "headers",
+ Params = "params",
+ Query = "querystring",
+ }
+
+ export type RouteDefinition = {
+ method: string,
+ url: string,
+ httpPart: HttpParts,
+ schema?: unknown,
+ }
+
+ export type StandaloneRestoreFunction = (opts: RouteDefinition) => ValidateFunction
+
+ export type StandaloneStoreFunction = (opts: RouteDefinition, schemaValidationCode: string) => void
+
+ export type StandaloneOptionsReadModeOn = {
+ readMode: true;
+ restoreFunction?: StandaloneRestoreFunction
+ }
+
+ export type StandaloneOptionsReadModeOff = {
+ readMode?: false | undefined;
+ storeFunction?: StandaloneStoreFunction;
+ }
+
+ export type StandaloneOptions = StandaloneOptionsReadModeOn | StandaloneOptionsReadModeOff
+
+ export type ValidatorFactory = BuildCompilerFromPool | BuildSerializerFromPool
+
+ export type ValidatorCompiler = ReturnType
+
+ export { StandaloneValidator }
+
+ export const AjvCompiler: AjvSerializerGenerator
+ export { AjvCompiler as default }
+}
+
+declare function buildCompilerFromPool(externalSchemas: { [key: string]: AnySchema | AnySchema[] }, options?: { mode: 'JTD'; customOptions?: JTDOptions; onCreate?: (ajvInstance: Ajv) => void }): AjvCompile
+declare function buildCompilerFromPool(externalSchemas: { [key: string]: AnySchema | AnySchema[] }, options?: { mode?: never; customOptions?: AjvOptions; onCreate?: (ajvInstance: Ajv) => void }): AjvCompile
+
+declare function buildSerializerFromPool(externalSchemas: any, serializerOpts?: { mode?: never; } & JTDOptions): AjvJTDCompile
+
+declare function AjvCompiler(opts: { jtdSerializer: true }): AjvCompiler.BuildSerializerFromPool
+declare function AjvCompiler(opts?: { jtdSerializer?: false }): AjvCompiler.BuildCompilerFromPool
+
+declare function StandaloneValidator(options: AjvCompiler.StandaloneOptions): AjvCompiler.BuildCompilerFromPool;
+
+export = AjvCompiler
diff --git a/sdk/node_modules/@fastify/ajv-compiler/types/index.test-d.ts b/sdk/node_modules/@fastify/ajv-compiler/types/index.test-d.ts
new file mode 100644
index 00000000..22ff4678
--- /dev/null
+++ b/sdk/node_modules/@fastify/ajv-compiler/types/index.test-d.ts
@@ -0,0 +1,227 @@
+import { AnySchemaObject, ValidateFunction } from "ajv";
+import { AnyValidateFunction } from "ajv/dist/core";
+import { expectAssignable, expectType } from "tsd";
+import AjvCompiler, { AjvReference, ValidatorFactory, StandaloneValidator, RouteDefinition, ErrorObject, BuildCompilerFromPool, BuildSerializerFromPool, ValidatorCompiler } from "..";
+
+{
+ const compiler = AjvCompiler({});
+ expectType(compiler);
+}
+{
+ const compiler = AjvCompiler();
+ expectType(compiler);
+}
+{
+ const compiler = AjvCompiler({ jtdSerializer: false});
+ expectType(compiler);
+}
+
+{
+ const factory = AjvCompiler({ jtdSerializer: false });
+ expectType(factory);
+ factory({}, {
+ onCreate(ajv) {
+ expectType(ajv)
+ }
+ });
+}
+
+{
+ const compiler = AjvCompiler({ jtdSerializer: true});
+ expectType(compiler);
+}
+const reader = StandaloneValidator({
+ readMode: true,
+ restoreFunction: (route: RouteDefinition) => {
+ expectAssignable(route)
+ return {} as ValidateFunction
+ },
+});
+expectAssignable(reader);
+
+const writer = StandaloneValidator({
+ readMode: false,
+ storeFunction: (route: RouteDefinition, code: string) => {
+ expectAssignable(route)
+ expectAssignable(code)
+ },
+});
+expectAssignable(writer);
+
+expectType(({} as ErrorObject).data)
+expectType(({} as ErrorObject).instancePath)
+expectType(({} as ErrorObject).keyword)
+expectType(({} as ErrorObject).message)
+expectType>(({} as ErrorObject).params)
+expectType(({} as ErrorObject).parentSchema)
+expectType(({} as ErrorObject).propertyName)
+expectType(({} as ErrorObject).schema)
+expectType(({} as ErrorObject).schemaPath)
+
+expectType(AjvReference)
+
+{
+ const jtdSchema = {
+ discriminator: 'version',
+ mapping: {
+ 1: {
+ properties: {
+ foo: { type: 'uint8' }
+ }
+ },
+ 2: {
+ properties: {
+ foo: { type: 'string' }
+ }
+ }
+ }
+ }
+
+ const externalSchemas1 = {
+ foo: {
+ definitions: {
+ coordinates: {
+ properties: {
+ lat: { type: 'float32' },
+ lng: { type: 'float32' }
+ }
+ }
+ }
+ }
+ }
+
+ const factory = AjvCompiler({ jtdSerializer: true })
+ expectType(factory)
+ const compiler = factory(externalSchemas1, {})
+ expectAssignable(compiler)
+ const serializeFunc = compiler({ schema: jtdSchema })
+ expectType<(data: unknown) => string>(serializeFunc)
+ expectType(serializeFunc({ version: '1', foo: 42 }))
+}
+// JTD
+{
+
+ const factory = AjvCompiler()
+ expectType(factory)
+
+ const jtdSchema = {
+ discriminator: 'version',
+ mapping: {
+ 1: {
+ properties: {
+ foo: { type: 'uint8' }
+ }
+ },
+ 2: {
+ properties: {
+ foo: { type: 'string' }
+ }
+ }
+ }
+ }
+
+ const compiler = factory({}, {
+ customOptions: {},
+ mode: 'JTD'
+ })
+ expectAssignable(compiler)
+ const validatorFunc = compiler({ schema: jtdSchema })
+ expectAssignable(validatorFunc)
+
+ expectType>(validatorFunc({
+ version: '2',
+ foo: []
+ }))
+}
+
+// generate standalone code
+{
+ const base = {
+ $id: 'urn:schema:base',
+ definitions: {
+ hello: { type: 'string' }
+ },
+ type: 'object',
+ properties: {
+ hello: { $ref: '#/definitions/hello' }
+ }
+ }
+
+ const refSchema = {
+ $id: 'urn:schema:ref',
+ type: 'object',
+ properties: {
+ hello: { $ref: 'urn:schema:base#/definitions/hello' }
+ }
+ }
+
+ const endpointSchema = {
+ schema: {
+ $id: 'urn:schema:endpoint',
+ $ref: 'urn:schema:ref'
+ }
+ }
+
+ const schemaMap = {
+ [base.$id]: base,
+ [refSchema.$id]: refSchema
+ }
+
+ const factory = StandaloneValidator({
+ readMode: false,
+ storeFunction(routeOpts, schemaValidationCode) {
+ expectType(routeOpts)
+ expectType(schemaValidationCode)
+ }
+ })
+ expectAssignable(factory)
+
+ const compiler = factory(schemaMap)
+ expectAssignable(compiler)
+ expectAssignable(compiler(endpointSchema))
+}
+
+{
+ const base = {
+ $id: 'urn:schema:base',
+ definitions: {
+ hello: { type: 'string' }
+ },
+ type: 'object',
+ properties: {
+ hello: { $ref: '#/definitions/hello' }
+ }
+ }
+
+ const refSchema = {
+ $id: 'urn:schema:ref',
+ type: 'object',
+ properties: {
+ hello: { $ref: 'urn:schema:base#/definitions/hello' }
+ }
+ }
+
+ const endpointSchema = {
+ schema: {
+ $id: 'urn:schema:endpoint',
+ $ref: 'urn:schema:ref'
+ }
+ }
+
+ const schemaMap = {
+ [base.$id]: base,
+ [refSchema.$id]: refSchema
+ }
+ const factory = StandaloneValidator({
+ readMode: true,
+ restoreFunction(routeOpts) {
+ expectType(routeOpts)
+ return {} as ValidateFunction
+ }
+ })
+ expectAssignable(factory)
+
+ const compiler = factory(schemaMap)
+ expectAssignable(compiler)
+ expectType>(compiler(endpointSchema))
+}
diff --git a/sdk/node_modules/@fastify/error/.gitattributes b/sdk/node_modules/@fastify/error/.gitattributes
new file mode 100644
index 00000000..a0e7df93
--- /dev/null
+++ b/sdk/node_modules/@fastify/error/.gitattributes
@@ -0,0 +1,2 @@
+# Set default behavior to automatically convert line endings
+* text=auto eol=lf
diff --git a/sdk/node_modules/@fastify/error/.github/dependabot.yml b/sdk/node_modules/@fastify/error/.github/dependabot.yml
new file mode 100644
index 00000000..dfa7fa6c
--- /dev/null
+++ b/sdk/node_modules/@fastify/error/.github/dependabot.yml
@@ -0,0 +1,13 @@
+version: 2
+updates:
+ - package-ecosystem: "github-actions"
+ directory: "/"
+ schedule:
+ interval: "monthly"
+ open-pull-requests-limit: 10
+
+ - package-ecosystem: "npm"
+ directory: "/"
+ schedule:
+ interval: "weekly"
+ open-pull-requests-limit: 10
diff --git a/sdk/node_modules/@fastify/error/.github/workflows/ci.yml b/sdk/node_modules/@fastify/error/.github/workflows/ci.yml
new file mode 100644
index 00000000..7b002766
--- /dev/null
+++ b/sdk/node_modules/@fastify/error/.github/workflows/ci.yml
@@ -0,0 +1,23 @@
+name: CI
+
+on:
+ push:
+ branches:
+ - main
+ - master
+ - next
+ - 'v*'
+ paths-ignore:
+ - 'docs/**'
+ - '*.md'
+ pull_request:
+ paths-ignore:
+ - 'docs/**'
+ - '*.md'
+
+jobs:
+ test:
+ uses: fastify/workflows/.github/workflows/plugins-ci.yml@v3
+ with:
+ license-check: true
+ lint: true
diff --git a/sdk/node_modules/@fastify/error/.taprc b/sdk/node_modules/@fastify/error/.taprc
new file mode 100644
index 00000000..7695d35c
--- /dev/null
+++ b/sdk/node_modules/@fastify/error/.taprc
@@ -0,0 +1,2 @@
+files:
+ - test/**/*.test.js
\ No newline at end of file
diff --git a/sdk/node_modules/@fastify/error/LICENSE b/sdk/node_modules/@fastify/error/LICENSE
new file mode 100644
index 00000000..08250b88
--- /dev/null
+++ b/sdk/node_modules/@fastify/error/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Fastify
+
+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.
diff --git a/sdk/node_modules/@fastify/error/README.md b/sdk/node_modules/@fastify/error/README.md
new file mode 100644
index 00000000..ee705d0f
--- /dev/null
+++ b/sdk/node_modules/@fastify/error/README.md
@@ -0,0 +1,62 @@
+# @fastify/error
+
+
+[](https://www.npmjs.com/package/@fastify/error)
+[](https://standardjs.com/)
+
+A small utility, used by Fastify itself, for generating consistent error objects across your codebase and plugins.
+
+### Install
+```
+npm i @fastify/error
+```
+
+### Usage
+
+The module exports a function that you can use for consistent error objects, it takes 4 parameters:
+
+```
+createError(code, message [, statusCode [, Base]])
+```
+
+- `code` (`string`, required) - The error code, you can access it later with `error.code`. For consistency, we recommend prefixing plugin error codes with `FST_`
+- `message` (`string`, required) - The error message. You can also use interpolated strings for formatting the message.
+- `statusCode` (`number`, optional) - The status code that Fastify will use if the error is sent via HTTP.
+- `Base` (`ErrorConstructor`, optional) - The base error object that will be used. (eg `TypeError`, `RangeError`)
+
+```js
+const createError = require('@fastify/error')
+const CustomError = createError('ERROR_CODE', 'Hello')
+console.log(new CustomError()) // error.message => 'Hello'
+```
+
+How to use an interpolated string:
+```js
+const createError = require('@fastify/error')
+const CustomError = createError('ERROR_CODE', 'Hello %s')
+console.log(new CustomError('world')) // error.message => 'Hello world'
+```
+
+How to add cause:
+```js
+const createError = require('@fastify/error')
+const CustomError = createError('ERROR_CODE', 'Hello %s')
+console.log(new CustomError('world', {cause: new Error('cause')}))
+// error.message => 'Hello world'
+// error.cause => Error('cause')
+```
+
+### TypeScript
+
+It is possible to limit your error constructor with a generic type using TypeScript:
+
+```ts
+const CustomError = createError<[string]>('ERROR_CODE', 'Hello %s')
+new CustomError('world')
+//@ts-expect-error
+new CustomError(1)
+```
+
+## License
+
+Licensed under [MIT](./LICENSE).
diff --git a/sdk/node_modules/@fastify/error/benchmarks/create.js b/sdk/node_modules/@fastify/error/benchmarks/create.js
new file mode 100644
index 00000000..bb9abbfe
--- /dev/null
+++ b/sdk/node_modules/@fastify/error/benchmarks/create.js
@@ -0,0 +1,9 @@
+'use strict'
+
+const benchmark = require('benchmark')
+const createError = require('..')
+
+new benchmark.Suite()
+ .add('create FastifyError', function () { createError('CODE', 'Not available') }, { minSamples: 100 })
+ .on('cycle', function onCycle (event) { console.log(String(event.target)) })
+ .run({ async: false })
diff --git a/sdk/node_modules/@fastify/error/benchmarks/instantiate.js b/sdk/node_modules/@fastify/error/benchmarks/instantiate.js
new file mode 100644
index 00000000..890aaf0a
--- /dev/null
+++ b/sdk/node_modules/@fastify/error/benchmarks/instantiate.js
@@ -0,0 +1,18 @@
+'use strict'
+
+const benchmark = require('benchmark')
+const createError = require('..')
+
+const FastifyError = createError('CODE', 'Not available')
+const FastifyError1 = createError('CODE', 'Not %s available')
+const FastifyError2 = createError('CODE', 'Not %s available %s')
+
+const cause = new Error('cause')
+new benchmark.Suite()
+ .add('instantiate Error', function () { new Error() }, { minSamples: 100 }) // eslint-disable-line no-new
+ .add('instantiate FastifyError', function () { new FastifyError() }, { minSamples: 100 }) // eslint-disable-line no-new
+ .add('instantiate FastifyError arg 1', function () { new FastifyError1('q') }, { minSamples: 100 }) // eslint-disable-line no-new
+ .add('instantiate FastifyError arg 2', function () { new FastifyError2('qq', 'ss') }, { minSamples: 100 }) // eslint-disable-line no-new
+ .add('instantiate FastifyError cause', function () { new FastifyError2({ cause }) }, { minSamples: 100 }) // eslint-disable-line no-new
+ .on('cycle', function onCycle (event) { console.log(String(event.target)) })
+ .run({ async: false })
diff --git a/sdk/node_modules/@fastify/error/benchmarks/no-stack.js b/sdk/node_modules/@fastify/error/benchmarks/no-stack.js
new file mode 100644
index 00000000..b626b5c7
--- /dev/null
+++ b/sdk/node_modules/@fastify/error/benchmarks/no-stack.js
@@ -0,0 +1,13 @@
+'use strict'
+
+const benchmark = require('benchmark')
+const createError = require('..')
+
+const FastifyError = createError('CODE', 'Not available')
+Error.stackTraceLimit = 0
+
+new benchmark.Suite()
+ .add('no-stack instantiate Error', function () { new Error() }, { minSamples: 100 }) // eslint-disable-line no-new
+ .add('no-stack instantiate FastifyError', function () { new FastifyError() }, { minSamples: 100 }) // eslint-disable-line no-new
+ .on('cycle', function onCycle (event) { console.log(String(event.target)) })
+ .run({ async: false })
diff --git a/sdk/node_modules/@fastify/error/benchmarks/toString.js b/sdk/node_modules/@fastify/error/benchmarks/toString.js
new file mode 100644
index 00000000..11915492
--- /dev/null
+++ b/sdk/node_modules/@fastify/error/benchmarks/toString.js
@@ -0,0 +1,11 @@
+'use strict'
+
+const benchmark = require('benchmark')
+const createError = require('..')
+
+const FastifyError = createError('CODE', 'Not available')
+
+new benchmark.Suite()
+ .add('FastifyError toString', function () { new FastifyError().toString() }, { minSamples: 100 })
+ .on('cycle', function onCycle (event) { console.log(String(event.target)) })
+ .run({ async: false })
diff --git a/sdk/node_modules/@fastify/error/index.js b/sdk/node_modules/@fastify/error/index.js
new file mode 100644
index 00000000..257cd7c7
--- /dev/null
+++ b/sdk/node_modules/@fastify/error/index.js
@@ -0,0 +1,53 @@
+'use strict'
+
+const { format } = require('node:util')
+
+function toString () {
+ return `${this.name} [${this.code}]: ${this.message}`
+}
+
+function createError (code, message, statusCode = 500, Base = Error) {
+ if (!code) throw new Error('Fastify error code must not be empty')
+ if (!message) throw new Error('Fastify error message must not be empty')
+
+ code = code.toUpperCase()
+ !statusCode && (statusCode = undefined)
+
+ function FastifyError (...args) {
+ if (!new.target) {
+ return new FastifyError(...args)
+ }
+
+ this.code = code
+ this.name = 'FastifyError'
+ this.statusCode = statusCode
+
+ const lastElement = args.length - 1
+ if (lastElement !== -1 && args[lastElement] && typeof args[lastElement] === 'object' && 'cause' in args[lastElement]) {
+ this.cause = args.pop().cause
+ }
+
+ this.message = format(message, ...args)
+
+ Error.stackTraceLimit !== 0 && Error.captureStackTrace(this, FastifyError)
+ }
+
+ FastifyError.prototype = Object.create(Base.prototype, {
+ constructor: {
+ value: FastifyError,
+ enumerable: false,
+ writable: true,
+ configurable: true
+ }
+ })
+
+ FastifyError.prototype[Symbol.toStringTag] = 'Error'
+
+ FastifyError.prototype.toString = toString
+
+ return FastifyError
+}
+
+module.exports = createError
+module.exports.default = createError
+module.exports.createError = createError
diff --git a/sdk/node_modules/@fastify/error/package.json b/sdk/node_modules/@fastify/error/package.json
new file mode 100644
index 00000000..805b9ac9
--- /dev/null
+++ b/sdk/node_modules/@fastify/error/package.json
@@ -0,0 +1,45 @@
+{
+ "name": "@fastify/error",
+ "version": "3.4.1",
+ "description": "A small utility, used by Fastify itself, for generating consistent error objects across your codebase and plugins.",
+ "main": "index.js",
+ "type": "commonjs",
+ "types": "types/index.d.ts",
+ "scripts": {
+ "lint": "standard",
+ "lint:fix": "standard --fix",
+ "test": "npm run test:unit && npm run test:typescript",
+ "test:unit": "tap",
+ "test:typescript": "tsd"
+ },
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/fastify/fastify-error.git"
+ },
+ "keywords": [
+ "fastify",
+ "error",
+ "utility",
+ "plugin"
+ ],
+ "author": "Tomas Della Vedova",
+ "license": "MIT",
+ "bugs": {
+ "url": "https://github.com/fastify/fastify-error/issues"
+ },
+ "homepage": "https://github.com/fastify/fastify-error#readme",
+ "devDependencies": {
+ "benchmark": "^2.1.4",
+ "standard": "^17.0.0",
+ "tap": "^16.0.0",
+ "tsd": "^0.29.0"
+ },
+ "tsd": {
+ "compilerOptions": {
+ "esModuleInterop": true
+ }
+ },
+ "publishConfig": {
+ "access": "public"
+ }
+}
diff --git a/sdk/node_modules/@fastify/error/test/index.test.js b/sdk/node_modules/@fastify/error/test/index.test.js
new file mode 100644
index 00000000..2fabd6fa
--- /dev/null
+++ b/sdk/node_modules/@fastify/error/test/index.test.js
@@ -0,0 +1,184 @@
+'use strict'
+
+const { test } = require('tap')
+const createError = require('..')
+
+test('Create error with zero parameter', t => {
+ t.plan(6)
+
+ const NewError = createError('CODE', 'Not available')
+ const err = new NewError()
+ t.ok(err instanceof Error)
+ t.equal(err.name, 'FastifyError')
+ t.equal(err.message, 'Not available')
+ t.equal(err.code, 'CODE')
+ t.equal(err.statusCode, 500)
+ t.ok(err.stack)
+})
+
+test('Create error with 1 parameter', t => {
+ t.plan(6)
+
+ const NewError = createError('CODE', 'hey %s')
+ const err = new NewError('alice')
+ t.ok(err instanceof Error)
+ t.equal(err.name, 'FastifyError')
+ t.equal(err.message, 'hey alice')
+ t.equal(err.code, 'CODE')
+ t.equal(err.statusCode, 500)
+ t.ok(err.stack)
+})
+
+test('Create error with 1 parameter set to undefined', t => {
+ t.plan(1)
+
+ const NewError = createError('CODE', 'hey %s')
+ const err = new NewError(undefined)
+ t.equal(err.message, 'hey undefined')
+})
+
+test('Create error with 2 parameters', (t) => {
+ t.plan(6)
+
+ const NewError = createError('CODE', 'hey %s, I like your %s')
+ const err = new NewError('alice', 'attitude')
+ t.ok(err instanceof Error)
+ t.equal(err.name, 'FastifyError')
+ t.equal(err.message, 'hey alice, I like your attitude')
+ t.equal(err.code, 'CODE')
+ t.equal(err.statusCode, 500)
+ t.ok(err.stack)
+})
+
+test('Create error with 2 parameters set to undefined', t => {
+ t.plan(1)
+
+ const NewError = createError('CODE', 'hey %s, I like your %s')
+ const err = new NewError(undefined, undefined)
+ t.equal(err.message, 'hey undefined, I like your undefined')
+})
+
+test('Create error with 3 parameters', t => {
+ t.plan(6)
+
+ const NewError = createError('CODE', 'hey %s, I like your %s %s')
+ const err = new NewError('alice', 'attitude', 'see you')
+ t.ok(err instanceof Error)
+ t.equal(err.name, 'FastifyError')
+ t.equal(err.message, 'hey alice, I like your attitude see you')
+ t.equal(err.code, 'CODE')
+ t.equal(err.statusCode, 500)
+ t.ok(err.stack)
+})
+
+test('Create error with 3 parameters set to undefined', t => {
+ t.plan(4)
+
+ const NewError = createError('CODE', 'hey %s, I like your %s %s')
+ const err = new NewError(undefined, undefined, undefined)
+ t.equal(err.message, 'hey undefined, I like your undefined undefined')
+ t.equal(err.code, 'CODE')
+ t.equal(err.statusCode, 500)
+ t.ok(err.stack)
+})
+
+test('Create error with 4 parameters set to undefined', t => {
+ t.plan(4)
+
+ const NewError = createError('CODE', 'hey %s, I like your %s %s and %s')
+ const err = new NewError(undefined, undefined, undefined, undefined)
+ t.equal(err.message, 'hey undefined, I like your undefined undefined and undefined')
+ t.equal(err.code, 'CODE')
+ t.equal(err.statusCode, 500)
+ t.ok(err.stack)
+})
+
+test('Create error with no statusCode property', t => {
+ t.plan(6)
+
+ const NewError = createError('CODE', 'hey %s', 0)
+ const err = new NewError('dude')
+ t.ok(err instanceof Error)
+ t.equal(err.name, 'FastifyError')
+ t.equal(err.message, 'hey dude')
+ t.equal(err.code, 'CODE')
+ t.equal(err.statusCode, undefined)
+ t.ok(err.stack)
+})
+
+test('Should throw when error code has no fastify code', t => {
+ t.plan(1)
+
+ t.throws(() => createError(), new Error('Fastify error code must not be empty'))
+})
+
+test('Should throw when error code has no message', t => {
+ t.plan(1)
+
+ t.throws(() => createError('code'), new Error('Fastify error message must not be empty'))
+})
+
+test('Create error with different base', t => {
+ t.plan(7)
+
+ const NewError = createError('CODE', 'hey %s', 500, TypeError)
+ const err = new NewError('dude')
+ t.ok(err instanceof Error)
+ t.ok(err instanceof TypeError)
+ t.equal(err.name, 'FastifyError')
+ t.equal(err.message, 'hey dude')
+ t.equal(err.code, 'CODE')
+ t.equal(err.statusCode, 500)
+ t.ok(err.stack)
+})
+
+test('FastifyError.toString returns code', t => {
+ t.plan(1)
+
+ const NewError = createError('CODE', 'foo')
+ const err = new NewError()
+ t.equal(err.toString(), 'FastifyError [CODE]: foo')
+})
+
+test('Create the error without the new keyword', t => {
+ t.plan(6)
+
+ const NewError = createError('CODE', 'Not available')
+ const err = NewError()
+ t.ok(err instanceof Error)
+ t.equal(err.name, 'FastifyError')
+ t.equal(err.message, 'Not available')
+ t.equal(err.code, 'CODE')
+ t.equal(err.statusCode, 500)
+ t.ok(err.stack)
+})
+
+test('Create an error with cause', t => {
+ t.plan(2)
+ const cause = new Error('HEY')
+ const NewError = createError('CODE', 'Not available')
+ const err = NewError({ cause })
+
+ t.ok(err instanceof Error)
+ t.equal(err.cause, cause)
+})
+
+test('Create an error with cause and message', t => {
+ t.plan(2)
+ const cause = new Error('HEY')
+ const NewError = createError('CODE', 'Not available: %s')
+ const err = NewError('foo', { cause })
+
+ t.ok(err instanceof Error)
+ t.equal(err.cause, cause)
+})
+
+test('Create an error with last argument null', t => {
+ t.plan(2)
+ const cause = new Error('HEY')
+ const NewError = createError('CODE', 'Not available')
+ const err = NewError({ cause }, null)
+
+ t.ok(err instanceof Error)
+ t.notOk(err.cause)
+})
diff --git a/sdk/node_modules/@fastify/error/types/index.d.ts b/sdk/node_modules/@fastify/error/types/index.d.ts
new file mode 100644
index 00000000..332b1b6b
--- /dev/null
+++ b/sdk/node_modules/@fastify/error/types/index.d.ts
@@ -0,0 +1,44 @@
+declare function createError (
+ code: C,
+ message: string,
+ statusCode: SC,
+ Base?: ErrorConstructor
+): createError.FastifyErrorConstructor<{ code: C, statusCode: SC }, Arg>
+
+declare function createError (
+ code: C,
+ message: string,
+ statusCode?: number,
+ Base?: ErrorConstructor
+): createError.FastifyErrorConstructor<{ code: C }, Arg>
+
+declare function createError (
+ code: string,
+ message: string,
+ statusCode?: number,
+ Base?: ErrorConstructor
+): createError.FastifyErrorConstructor<{ code: string }, Arg>
+
+type CreateError = typeof createError
+
+declare namespace createError {
+ export interface FastifyError extends Error {
+ code: string
+ name: string
+ statusCode?: number
+ }
+
+ export interface FastifyErrorConstructor<
+ E extends { code: string, statusCode?: number } = { code: string, statusCode?: number },
+ T extends unknown[] = [any?, any?, any?]
+ > {
+ new(...arg: T): FastifyError & E
+ (...arg: T): FastifyError & E
+ readonly prototype: FastifyError & E
+ }
+
+ export const createError: CreateError
+ export { createError as default }
+}
+
+export = createError
diff --git a/sdk/node_modules/@fastify/error/types/index.test-d.ts b/sdk/node_modules/@fastify/error/types/index.test-d.ts
new file mode 100644
index 00000000..cf5ea564
--- /dev/null
+++ b/sdk/node_modules/@fastify/error/types/index.test-d.ts
@@ -0,0 +1,72 @@
+import createError, { FastifyError, FastifyErrorConstructor } from '..'
+import { expectType, expectError } from 'tsd'
+
+const CustomError = createError('ERROR_CODE', 'message')
+expectType>(CustomError)
+const err = new CustomError()
+expectType(err)
+expectType<'ERROR_CODE'>(err.code)
+expectType(err.message)
+expectType(err.statusCode)
+
+const CustomTypedError = createError('OTHER_CODE', 'message', 400)
+expectType>(CustomTypedError)
+const typed = new CustomTypedError()
+expectType(typed)
+expectType<'OTHER_CODE'>(typed.code)
+expectType(typed.message)
+expectType<400>(typed.statusCode)
+
+/* eslint-disable no-new */
+const CustomTypedArgError = createError<[string]>('OTHER_CODE', 'expect %s message', 400)
+CustomTypedArgError('a')
+expectError(CustomTypedArgError('a', 'b'))
+expectError(new CustomTypedArgError('a', 'b'))
+expectError(CustomTypedArgError(1))
+expectError(new CustomTypedArgError(1))
+
+const CustomTypedArgError2 = createError('OTHER_CODE', 'expect %s message', 400)
+CustomTypedArgError2('a')
+expectError(CustomTypedArgError2('a', 'b'))
+expectError(new CustomTypedArgError2('a', 'b'))
+expectError(CustomTypedArgError2(1))
+expectError(new CustomTypedArgError2(1))
+
+const CustomTypedArgError3 = createError('OTHER_CODE', 'expect %s message but got %s', 400)
+expectError(CustomTypedArgError3('a'))
+CustomTypedArgError3('a', 'b')
+new CustomTypedArgError3('a', 'b')
+expectError(CustomTypedArgError3(1))
+expectError(new CustomTypedArgError3(1))
+expectError(new CustomTypedArgError3(1, 2))
+expectError(new CustomTypedArgError3('1', 2))
+expectError(new CustomTypedArgError3(1, '2'))
+
+const CustomTypedArgError4 = createError('OTHER_CODE', 'expect %s message but got %s', 400)
+expectError(CustomTypedArgError4('a'))
+CustomTypedArgError4('a', 'b')
+new CustomTypedArgError4('a', 'b')
+expectError(CustomTypedArgError4(1))
+expectError(new CustomTypedArgError4(1))
+expectError(new CustomTypedArgError4(1, 2))
+expectError(new CustomTypedArgError4('1', 2))
+expectError(new CustomTypedArgError4(1, '2'))
+
+const CustomTypedArgError5 = createError<[string, string, string, string]>('OTHER_CODE', 'expect %s message but got %s. Please contact %s by emailing to %s', 400)
+expectError(CustomTypedArgError5('a'))
+expectError(new CustomTypedArgError5('a', 'b'))
+expectError(new CustomTypedArgError5('a', 'b', 'c'))
+CustomTypedArgError5('a', 'b', 'c', 'd')
+expectError(new CustomTypedArgError5('a', 'b', 'c', 'd', 'e'))
+
+const CustomTypedArgError6 = createError('OTHER_CODE', 'expect %s message but got %s. Please contact %s by emailing to %s', 400)
+expectError(CustomTypedArgError6('a'))
+expectError(new CustomTypedArgError6('a', 'b'))
+expectError(new CustomTypedArgError6('a', 'b', 'c'))
+CustomTypedArgError6('a', 'b', 'c', 'd')
+expectError(new CustomTypedArgError6('a', 'b', 'c', 'd', 'e'))
+
+
+const CustomErrorWithErrorConstructor = createError('ERROR_CODE', 'message', 500, TypeError)
+expectType>(CustomErrorWithErrorConstructor)
+CustomErrorWithErrorConstructor({cause: new Error('Error')})
\ No newline at end of file
diff --git a/sdk/node_modules/@fastify/fast-json-stringify-compiler/.eslintrc b/sdk/node_modules/@fastify/fast-json-stringify-compiler/.eslintrc
new file mode 100644
index 00000000..185ff2ec
--- /dev/null
+++ b/sdk/node_modules/@fastify/fast-json-stringify-compiler/.eslintrc
@@ -0,0 +1 @@
+{"extends": "standard"}
diff --git a/sdk/node_modules/@fastify/fast-json-stringify-compiler/.github/dependabot.yml b/sdk/node_modules/@fastify/fast-json-stringify-compiler/.github/dependabot.yml
new file mode 100644
index 00000000..dfa7fa6c
--- /dev/null
+++ b/sdk/node_modules/@fastify/fast-json-stringify-compiler/.github/dependabot.yml
@@ -0,0 +1,13 @@
+version: 2
+updates:
+ - package-ecosystem: "github-actions"
+ directory: "/"
+ schedule:
+ interval: "monthly"
+ open-pull-requests-limit: 10
+
+ - package-ecosystem: "npm"
+ directory: "/"
+ schedule:
+ interval: "weekly"
+ open-pull-requests-limit: 10
diff --git a/sdk/node_modules/@fastify/fast-json-stringify-compiler/.github/workflows/ci.yml b/sdk/node_modules/@fastify/fast-json-stringify-compiler/.github/workflows/ci.yml
new file mode 100644
index 00000000..079a8f01
--- /dev/null
+++ b/sdk/node_modules/@fastify/fast-json-stringify-compiler/.github/workflows/ci.yml
@@ -0,0 +1,18 @@
+name: CI
+
+on:
+ push:
+ paths-ignore:
+ - 'docs/**'
+ - '*.md'
+ pull_request:
+ paths-ignore:
+ - 'docs/**'
+ - '*.md'
+
+jobs:
+ test:
+ uses: fastify/workflows/.github/workflows/plugins-ci.yml@v3
+ with:
+ license-check: true
+ lint: true
diff --git a/sdk/node_modules/@fastify/fast-json-stringify-compiler/LICENSE b/sdk/node_modules/@fastify/fast-json-stringify-compiler/LICENSE
new file mode 100644
index 00000000..5559f4f5
--- /dev/null
+++ b/sdk/node_modules/@fastify/fast-json-stringify-compiler/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Fastify
+
+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.
diff --git a/sdk/node_modules/@fastify/fast-json-stringify-compiler/README.md b/sdk/node_modules/@fastify/fast-json-stringify-compiler/README.md
new file mode 100644
index 00000000..911f7e02
--- /dev/null
+++ b/sdk/node_modules/@fastify/fast-json-stringify-compiler/README.md
@@ -0,0 +1,127 @@
+# @fastify/fast-json-stringify-compiler
+Build and manage the [`fast-json-stringify`](https://www.npmjs.com/package/fast-json-stringify) instances for the fastify framework.
+This package is responsible for compiling the application's `response` JSON schemas into optimized functions to speed up the response time.
+
+[](http://standardjs.com/)
+[](https://github.com/fastify/fast-json-stringify-compiler/actions/workflows/ci.yml)
+
+
+## Versions
+
+| `@fastify/fast-json-stringify-compiler` | `fast-json-stringify` | Supported `fastify` |
+|----------------------------------------:|----------------------:|--------------------:|
+| v1.x | v3.x | ^3.x |
+| v2.x | v3.x | ^4.x |
+| v3.x | v4.x | ^4.x |
+| v4.x | v5.x | ^4.x |
+
+### fast-json-stringify Configuration
+
+The `fast-json-stringify` configuration is the default one. You can check it the default settings in the [`fast-json-stringify` option](https://github.com/fastify/fast-json-stringify/#options) documentation.
+
+You can also override the default configuration by passing the [`serializerOpts`](https://www.fastify.io/docs/latest/Reference/Server/#serializeropts) configuration to the Fastify instance.
+
+## Usage
+
+This module is already used as default by Fastify.
+If you need to provide to your server instance a different version, refer to [the official doc](https://www.fastify.io/docs/latest/Reference/Server/#schemacontroller).
+
+### fast-json-stringify Standalone
+
+`fast-json-stringify@v4.1.0` introduces the [standalone feature](https://github.com/fastify/fast-json-stringify#standalone) that let you to pre-compile your schemas and use them in your application for a faster startup.
+
+To use this feature, you must be aware of the following:
+
+1. You must generate and save the application's compiled schemas.
+2. Read the compiled schemas from the file and provide them back to your Fastify application.
+
+
+#### Generate and save the compiled schemas
+
+Fastify helps you to generate the serialization schemas functions and it is your choice to save them where you want.
+To accomplish this, you must use a new compiler: `@fastify/fast-json-stringify-compiler/standalone`.
+
+You must provide 2 parameters to this compiler:
+
+- `readMode: false`: a boolean to indicate that you want generate the schemas functions string.
+- `storeFunction`" a sync function that must store the source code of the schemas functions. You may provide an async function too, but you must manage errors.
+
+When `readMode: false`, **the compiler is meant to be used in development ONLY**.
+
+
+```js
+const { StandaloneSerializer } = require('@fastify/fast-json-stringify-compiler')
+
+const factory = StandaloneSerializer({
+ readMode: false,
+ storeFunction (routeOpts, schemaSerializationCode) {
+ // routeOpts is like: { schema, method, url, httpStatus }
+ // schemaSerializationCode is a string source code that is the compiled schema function
+ const fileName = generateFileName(routeOpts)
+ fs.writeFileSync(path.join(__dirname, fileName), schemaSerializationCode)
+ }
+})
+
+const app = fastify({
+ jsonShorthand: false,
+ schemaController: {
+ compilersFactory: {
+ buildSerializer: factory
+ }
+ }
+})
+
+// ... add all your routes with schemas ...
+
+app.ready().then(() => {
+ // at this stage all your schemas are compiled and stored in the file system
+ // now it is important to turn off the readMode
+})
+```
+
+#### Read the compiled schemas functions
+
+At this stage, you should have a file for every route's schema.
+To use them, you must use the `@fastify/fast-json-stringify-compiler/standalone` with the parameters:
+
+- `readMode: true`: a boolean to indicate that you want read and use the schemas functions string.
+- `restoreFunction`" a sync function that must return a function to serialize the route's payload.
+
+Important keep away before you continue reading the documentation:
+
+- when you use the `readMode: true`, the application schemas are not compiled (they are ignored). So, if you change your schemas, you must recompile them!
+- as you can see, you must relate the route's schema to the file name using the `routeOpts` object. You may use the `routeOpts.schema.$id` field to do so, it is up to you to define a unique schema identifier.
+
+```js
+const { StandaloneSerializer } = require('@fastify/fast-json-stringify-compiler')
+
+const factory = StandaloneSerializer({
+ readMode: true,
+ restoreFunction (routeOpts) {
+ // routeOpts is like: { schema, method, url, httpStatus }
+ const fileName = generateFileName(routeOpts)
+ return require(path.join(__dirname, fileName))
+ }
+})
+
+const app = fastify({
+ jsonShorthand: false,
+ schemaController: {
+ compilersFactory: {
+ buildSerializer: factory
+ }
+ }
+})
+
+// ... add all your routes with schemas as before...
+
+app.listen({ port: 3000 })
+```
+
+### How it works
+
+This module provide a factory function to produce [Serializer Compilers](https://www.fastify.io/docs/latest/Reference/Server/#serializercompiler) functions.
+
+## License
+
+Licensed under [MIT](./LICENSE).
diff --git a/sdk/node_modules/@fastify/fast-json-stringify-compiler/index.js b/sdk/node_modules/@fastify/fast-json-stringify-compiler/index.js
new file mode 100644
index 00000000..a021ea14
--- /dev/null
+++ b/sdk/node_modules/@fastify/fast-json-stringify-compiler/index.js
@@ -0,0 +1,23 @@
+'use strict'
+
+const fastJsonStringify = require('fast-json-stringify')
+
+function SerializerSelector () {
+ return function buildSerializerFactory (externalSchemas, serializerOpts) {
+ const fjsOpts = Object.assign({}, serializerOpts, { schema: externalSchemas })
+ return responseSchemaCompiler.bind(null, fjsOpts)
+ }
+}
+
+function responseSchemaCompiler (fjsOpts, { schema /* method, url, httpStatus */ }) {
+ if (fjsOpts.schema && schema.$id && fjsOpts.schema[schema.$id]) {
+ fjsOpts.schema = { ...fjsOpts.schema }
+ delete fjsOpts.schema[schema.$id]
+ }
+ return fastJsonStringify(schema, fjsOpts)
+}
+
+module.exports = SerializerSelector
+module.exports.default = SerializerSelector
+module.exports.SerializerSelector = SerializerSelector
+module.exports.StandaloneSerializer = require('./standalone')
diff --git a/sdk/node_modules/@fastify/fast-json-stringify-compiler/package.json b/sdk/node_modules/@fastify/fast-json-stringify-compiler/package.json
new file mode 100644
index 00000000..c9511bdd
--- /dev/null
+++ b/sdk/node_modules/@fastify/fast-json-stringify-compiler/package.json
@@ -0,0 +1,40 @@
+{
+ "name": "@fastify/fast-json-stringify-compiler",
+ "description": "Build and manage the fast-json-stringify instances for the fastify framework",
+ "version": "4.3.0",
+ "main": "index.js",
+ "types": "types/index.d.ts",
+ "scripts": {
+ "lint": "standard",
+ "lint:fix": "standard --fix",
+ "unit": "tap test/**/*.test.js",
+ "test": "npm run unit && npm run test:typescript",
+ "test:typescript": "tsd"
+ },
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/fastify/fast-json-stringify-compiler.git"
+ },
+ "keywords": [],
+ "author": "Manuel Spigolon (https://github.com/Eomm)",
+ "license": "MIT",
+ "bugs": {
+ "url": "https://github.com/fastify/fast-json-stringify-compiler/issues"
+ },
+ "homepage": "https://github.com/fastify/fast-json-stringify-compiler#readme",
+ "devDependencies": {
+ "@fastify/pre-commit": "^2.0.2",
+ "fastify": "^4.0.0",
+ "sanitize-filename": "^1.6.3",
+ "standard": "^17.0.0",
+ "tap": "^16.0.0",
+ "tsd": "^0.28.0"
+ },
+ "pre-commit": [
+ "lint",
+ "test"
+ ],
+ "dependencies": {
+ "fast-json-stringify": "^5.7.0"
+ }
+}
diff --git a/sdk/node_modules/@fastify/fast-json-stringify-compiler/standalone.js b/sdk/node_modules/@fastify/fast-json-stringify-compiler/standalone.js
new file mode 100644
index 00000000..39b4937d
--- /dev/null
+++ b/sdk/node_modules/@fastify/fast-json-stringify-compiler/standalone.js
@@ -0,0 +1,42 @@
+'use strict'
+
+const SerializerSelector = require('./index')
+
+function StandaloneSerializer (options = { readMode: true }) {
+ if (options.readMode === true && typeof options.restoreFunction !== 'function') {
+ throw new Error('You must provide a function for the restoreFunction-option when readMode ON')
+ }
+
+ if (options.readMode !== true && typeof options.storeFunction !== 'function') {
+ throw new Error('You must provide a function for the storeFunction-option when readMode OFF')
+ }
+
+ if (options.readMode === true) {
+ // READ MODE: it behalf only in the restore function provided by the user
+ return function wrapper () {
+ return function (opts) {
+ return options.restoreFunction(opts)
+ }
+ }
+ }
+
+ // WRITE MODE: it behalf on the default SerializerSelector, wrapping the API to run the Ajv Standalone code generation
+ const factory = SerializerSelector()
+ return function wrapper (externalSchemas, serializerOpts = {}) {
+ // to generate the serialization source code, this option is mandatory
+ serializerOpts.mode = 'standalone'
+
+ const compiler = factory(externalSchemas, serializerOpts)
+ return function (opts) { // { schema/*, method, url, httpPart */ }
+ const serializeFuncCode = compiler(opts)
+
+ options.storeFunction(opts, serializeFuncCode)
+
+ // eslint-disable-next-line no-new-func
+ return new Function(serializeFuncCode)
+ }
+ }
+}
+
+module.exports = StandaloneSerializer
+module.exports.default = StandaloneSerializer
diff --git a/sdk/node_modules/@fastify/fast-json-stringify-compiler/test/duplicate-schema.test.js b/sdk/node_modules/@fastify/fast-json-stringify-compiler/test/duplicate-schema.test.js
new file mode 100644
index 00000000..d6904edf
--- /dev/null
+++ b/sdk/node_modules/@fastify/fast-json-stringify-compiler/test/duplicate-schema.test.js
@@ -0,0 +1,26 @@
+'use strict'
+
+const t = require('tap')
+const FjsCompiler = require('../index')
+
+t.test('Use input schema duplicate in the externalSchemas', async t => {
+ t.plan(1)
+ const externalSchemas = {
+ schema1: {
+ $id: 'schema1',
+ type: 'number'
+ },
+ schema2: {
+ $id: 'schema2',
+ type: 'string'
+ }
+ }
+
+ const factory = FjsCompiler()
+ const compiler = factory(externalSchemas)
+
+ compiler({ schema: externalSchemas.schema1 })
+ compiler({ schema: externalSchemas.schema2 })
+
+ t.pass()
+})
diff --git a/sdk/node_modules/@fastify/fast-json-stringify-compiler/test/plugin.test.js b/sdk/node_modules/@fastify/fast-json-stringify-compiler/test/plugin.test.js
new file mode 100644
index 00000000..df2582b1
--- /dev/null
+++ b/sdk/node_modules/@fastify/fast-json-stringify-compiler/test/plugin.test.js
@@ -0,0 +1,78 @@
+'use strict'
+
+const t = require('tap')
+const fastify = require('fastify')
+const FjsCompiler = require('../index')
+
+const echo = async (req, reply) => { return req.body }
+
+const sampleSchema = Object.freeze({
+ $id: 'example1',
+ type: 'object',
+ properties: {
+ name: { type: 'string' }
+ }
+})
+
+const externalSchemas1 = Object.freeze({})
+const externalSchemas2 = Object.freeze({
+ foo: {
+ $id: 'foo',
+ type: 'object',
+ properties: {
+ name: { type: 'string' }
+ }
+ }
+})
+
+const fastifyFjsOptionsDefault = Object.freeze({})
+
+t.test('basic usage', t => {
+ t.plan(1)
+ const factory = FjsCompiler()
+ const compiler = factory(externalSchemas1, fastifyFjsOptionsDefault)
+ const serializeFunc = compiler({ schema: sampleSchema })
+ const result = serializeFunc({ name: 'hello' })
+ t.equal(result, '{"name":"hello"}')
+})
+
+t.test('fastify integration', async t => {
+ const factory = FjsCompiler()
+
+ const app = fastify({
+ serializerOpts: {
+ rounding: 'ceil'
+ },
+ schemaController: {
+ compilersFactory: {
+ buildSerializer: factory
+ }
+ }
+ })
+
+ app.addSchema(externalSchemas2.foo)
+
+ app.post('/', {
+ handler: echo,
+ schema: {
+ response: {
+ 200: {
+ $ref: 'foo#'
+ }
+ }
+ }
+ })
+
+ const res = await app.inject({
+ url: '/',
+ method: 'POST',
+ payload: {
+ version: '1',
+ foo: 'this is not a number',
+ name: 'serialize me'
+ }
+ })
+
+ t.equal(res.statusCode, 200)
+ t.same(res.json(), { name: 'serialize me' })
+})
diff --git a/sdk/node_modules/@fastify/fast-json-stringify-compiler/test/standalone.test.js b/sdk/node_modules/@fastify/fast-json-stringify-compiler/test/standalone.test.js
new file mode 100644
index 00000000..51f773c5
--- /dev/null
+++ b/sdk/node_modules/@fastify/fast-json-stringify-compiler/test/standalone.test.js
@@ -0,0 +1,230 @@
+'use strict'
+
+const fs = require('fs')
+const path = require('path')
+const t = require('tap')
+const fastify = require('fastify')
+const sanitize = require('sanitize-filename')
+
+const { StandaloneSerializer: FjsStandaloneCompiler } = require('../')
+
+const generatedFileNames = []
+
+function generateFileName (routeOpts) {
+ const fileName = `/fjs-generated-${sanitize(routeOpts.schema.$id)}-${routeOpts.method}-${routeOpts.httpPart}-${sanitize(routeOpts.url)}.js`
+ generatedFileNames.push(fileName)
+ return fileName
+}
+
+t.test('standalone', t => {
+ t.plan(5)
+
+ t.teardown(async () => {
+ for (const fileName of generatedFileNames) {
+ try {
+ await fs.promises.unlink(path.join(__dirname, fileName))
+ } catch (e) {}
+ }
+ })
+
+ t.test('errors', t => {
+ t.plan(2)
+ t.throws(() => {
+ FjsStandaloneCompiler()
+ }, 'missing restoreFunction')
+ t.throws(() => {
+ FjsStandaloneCompiler({ readMode: false })
+ }, 'missing storeFunction')
+ })
+
+ t.test('generate standalone code', t => {
+ t.plan(5)
+
+ const base = {
+ $id: 'urn:schema:base',
+ definitions: {
+ hello: { type: 'string' }
+ },
+ type: 'object',
+ properties: {
+ hello: { $ref: '#/definitions/hello' }
+ }
+ }
+
+ const refSchema = {
+ $id: 'urn:schema:ref',
+ type: 'object',
+ properties: {
+ hello: { $ref: 'urn:schema:base#/definitions/hello' }
+ }
+ }
+
+ const endpointSchema = {
+ schema: {
+ $id: 'urn:schema:endpoint',
+ $ref: 'urn:schema:ref'
+ }
+ }
+
+ const schemaMap = {
+ [base.$id]: base,
+ [refSchema.$id]: refSchema
+ }
+
+ const factory = FjsStandaloneCompiler({
+ readMode: false,
+ storeFunction (routeOpts, schemaSerializerCode) {
+ t.same(routeOpts, endpointSchema)
+ t.type(schemaSerializerCode, 'string')
+ fs.writeFileSync(path.join(__dirname, '/fjs-generated.js'), schemaSerializerCode)
+ generatedFileNames.push('/fjs-generated.js')
+ t.pass('stored the serializer function')
+ }
+ })
+
+ const compiler = factory(schemaMap)
+ compiler(endpointSchema)
+ t.pass('compiled the endpoint schema')
+
+ t.test('usage standalone code', t => {
+ t.plan(3)
+ const standaloneSerializer = require('./fjs-generated')
+ t.ok(standaloneSerializer)
+
+ const valid = standaloneSerializer({ hello: 'world' })
+ t.same(valid, JSON.stringify({ hello: 'world' }))
+
+ const invalid = standaloneSerializer({ hello: [] })
+ t.same(invalid, '{"hello":""}')
+ })
+ })
+
+ t.test('fastify integration - writeMode', async t => {
+ t.plan(4)
+
+ const factory = FjsStandaloneCompiler({
+ readMode: false,
+ storeFunction (routeOpts, schemaSerializationCode) {
+ const fileName = generateFileName(routeOpts)
+ t.ok(routeOpts)
+ fs.writeFileSync(path.join(__dirname, fileName), schemaSerializationCode)
+ t.pass(`stored the serializer function ${fileName}`)
+ },
+ restoreFunction () {
+ t.fail('write mode ON')
+ }
+ })
+
+ const app = buildApp(factory)
+ await app.ready()
+ })
+
+ t.test('fastify integration - writeMode forces standalone', async t => {
+ t.plan(4)
+
+ const factory = FjsStandaloneCompiler({
+ readMode: false,
+ storeFunction (routeOpts, schemaSerializationCode) {
+ const fileName = generateFileName(routeOpts)
+ t.ok(routeOpts)
+ fs.writeFileSync(path.join(__dirname, fileName), schemaSerializationCode)
+ t.pass(`stored the serializer function ${fileName}`)
+ },
+ restoreFunction () {
+ t.fail('write mode ON')
+ }
+ })
+
+ const app = buildApp(factory, {
+ mode: 'not-standalone',
+ rounding: 'ceil'
+ })
+
+ await app.ready()
+ })
+
+ t.test('fastify integration - readMode', async t => {
+ t.plan(6)
+
+ const factory = FjsStandaloneCompiler({
+ readMode: true,
+ storeFunction () {
+ t.fail('read mode ON')
+ },
+ restoreFunction (routeOpts) {
+ const fileName = generateFileName(routeOpts)
+ t.pass(`restore the serializer function ${fileName}}`)
+ return require(path.join(__dirname, fileName))
+ }
+ })
+
+ const app = buildApp(factory)
+ await app.ready()
+
+ let res = await app.inject({
+ url: '/foo',
+ method: 'POST'
+ })
+ t.equal(res.statusCode, 200)
+ t.equal(res.payload, JSON.stringify({ hello: 'world' }))
+
+ res = await app.inject({
+ url: '/bar?lang=it',
+ method: 'GET'
+ })
+ t.equal(res.statusCode, 200)
+ t.equal(res.payload, JSON.stringify({ lang: 'en' }))
+ })
+
+ function buildApp (factory, serializerOpts) {
+ const app = fastify({
+ exposeHeadRoutes: false,
+ jsonShorthand: false,
+ schemaController: {
+ compilersFactory: {
+ buildSerializer: factory
+ }
+ },
+ serializerOpts
+ })
+
+ app.addSchema({
+ $id: 'urn:schema:foo',
+ type: 'object',
+ properties: {
+ name: { type: 'string' },
+ id: { type: 'integer' }
+ }
+ })
+
+ app.post('/foo', {
+ schema: {
+ response: {
+ 200: {
+ $id: 'urn:schema:response',
+ type: 'object',
+ properties: {
+ hello: { $ref: 'urn:schema:foo#/properties/name' }
+ }
+ }
+ }
+ }
+ }, () => { return { hello: 'world' } })
+
+ app.get('/bar', {
+ schema: {
+ response: {
+ 200: {
+ $id: 'urn:schema:response:bar',
+ type: 'object',
+ properties: {
+ lang: { type: 'string', enum: ['it', 'en'] }
+ }
+ }
+ }
+ }
+ }, () => { return { lang: 'en' } })
+
+ return app
+ }
+})
diff --git a/sdk/node_modules/@fastify/fast-json-stringify-compiler/types/index.d.ts b/sdk/node_modules/@fastify/fast-json-stringify-compiler/types/index.d.ts
new file mode 100644
index 00000000..26bbf1f3
--- /dev/null
+++ b/sdk/node_modules/@fastify/fast-json-stringify-compiler/types/index.d.ts
@@ -0,0 +1,45 @@
+import { Options } from 'fast-json-stringify'
+
+type FastJsonStringifyFactory = () => SerializerSelector.SerializerFactory
+
+declare namespace SerializerSelector {
+ export type SerializerFactory = (
+ externalSchemas?: unknown,
+ options?: Options
+ ) => SerializerCompiler;
+
+ export type SerializerCompiler = (
+ externalSchemas?: unknown,
+ options?: Options
+ ) => Serializer;
+
+ export type Serializer = (doc: any) => string
+
+ export type RouteDefinition = {
+ method: string;
+ url: string;
+ httpStatus: string;
+ schema?: unknown;
+ }
+
+ export type StandaloneOptions = StandaloneOptionsReadModeOn | StandaloneOptionsReadModeOff
+
+ export type StandaloneOptionsReadModeOn = {
+ readMode: true;
+ restoreFunction?(opts: RouteDefinition): Serializer;
+ }
+
+ export type StandaloneOptionsReadModeOff = {
+ readMode?: false | undefined;
+ storeFunction?(opts: RouteDefinition, schemaSerializationCode: string): void;
+ }
+
+ export type { Options }
+ export const SerializerSelector: FastJsonStringifyFactory;
+ export function StandaloneSerializer(options: StandaloneOptions): SerializerFactory;
+
+ export { SerializerSelector as default }
+}
+
+declare function SerializerSelector(...params: Parameters): ReturnType
+export = SerializerSelector
diff --git a/sdk/node_modules/@fastify/fast-json-stringify-compiler/types/index.test-d.ts b/sdk/node_modules/@fastify/fast-json-stringify-compiler/types/index.test-d.ts
new file mode 100644
index 00000000..d1dbd85c
--- /dev/null
+++ b/sdk/node_modules/@fastify/fast-json-stringify-compiler/types/index.test-d.ts
@@ -0,0 +1,141 @@
+import { expectAssignable, expectError, expectType } from "tsd";
+import SerializerSelector, {
+ RouteDefinition,
+ Serializer,
+ SerializerCompiler,
+ SerializerFactory,
+ SerializerSelector as SerializerSelectorNamed,
+ StandaloneSerializer,
+} from "..";
+
+/**
+ * SerializerSelector
+ */
+
+{
+ const compiler = SerializerSelector();
+ expectType(compiler);
+}
+
+{
+ const compiler = SerializerSelectorNamed();
+ expectType(compiler);
+}
+
+{
+ {
+ const sampleSchema = {
+ $id: 'example1',
+ type: 'object',
+ properties: {
+ name: { type: 'string' }
+ }
+ }
+
+ const externalSchemas1 = {}
+
+ const factory = SerializerSelector()
+ expectType(factory);
+ const compiler = factory(externalSchemas1, {})
+ expectType(compiler);
+ const serializeFunc = compiler({ schema: sampleSchema })
+ expectType(serializeFunc);
+
+ expectType(serializeFunc({ name: 'hello' }))
+ }
+}
+
+/**
+ * StandaloneSerializer
+ */
+
+const reader = StandaloneSerializer({
+ readMode: true,
+ restoreFunction: (route: RouteDefinition) => {
+ expectAssignable(route)
+ return {} as Serializer
+ },
+});
+expectType(reader);
+
+const writer = StandaloneSerializer({
+ readMode: false,
+ storeFunction: (route: RouteDefinition, code: string) => {
+ expectAssignable(route)
+ expectAssignable(code)
+ },
+});
+expectType(writer);
+
+{
+ const base = {
+ $id: 'urn:schema:base',
+ definitions: {
+ hello: { type: 'string' }
+ },
+ type: 'object',
+ properties: {
+ hello: { $ref: '#/definitions/hello' }
+ }
+ }
+
+ const refSchema = {
+ $id: 'urn:schema:ref',
+ type: 'object',
+ properties: {
+ hello: { $ref: 'urn:schema:base#/definitions/hello' }
+ }
+ }
+
+ const endpointSchema = {
+ schema: {
+ $id: 'urn:schema:endpoint',
+ $ref: 'urn:schema:ref'
+ }
+ }
+
+ const schemaMap = {
+ [base.$id]: base,
+ [refSchema.$id]: refSchema
+ }
+
+ expectError(StandaloneSerializer({
+ readMode: true,
+ storeFunction () { }
+ }))
+ expectError(StandaloneSerializer({
+ readMode: false,
+ restoreFunction () {}
+ }))
+ expectError(StandaloneSerializer({
+ restoreFunction () {}
+ }))
+
+ expectType(StandaloneSerializer({
+ storeFunction (routeOpts, schemaSerializerCode) {
+ expectType(routeOpts)
+ expectType(schemaSerializerCode)
+ }
+ }))
+
+ expectType(StandaloneSerializer({
+ readMode: true,
+ restoreFunction (routeOpts) {
+ expectType(routeOpts)
+ return {} as Serializer
+ }
+ }))
+
+ const factory = StandaloneSerializer({
+ readMode: false,
+ storeFunction (routeOpts, schemaSerializerCode) {
+ expectType(routeOpts)
+ expectType(schemaSerializerCode)
+ }
+ })
+ expectType(factory)
+
+ const compiler = factory(schemaMap)
+ expectType(compiler)
+ expectType(compiler(endpointSchema))
+}
diff --git a/sdk/node_modules/@fastify/merge-json-schemas/.gitattributes b/sdk/node_modules/@fastify/merge-json-schemas/.gitattributes
new file mode 100644
index 00000000..83beb313
--- /dev/null
+++ b/sdk/node_modules/@fastify/merge-json-schemas/.gitattributes
@@ -0,0 +1,2 @@
+# Set default behavior to automatically convert line endings
+* text=auto eol=lf
\ No newline at end of file
diff --git a/sdk/node_modules/@fastify/merge-json-schemas/.github/test.yml b/sdk/node_modules/@fastify/merge-json-schemas/.github/test.yml
new file mode 100644
index 00000000..fce3203a
--- /dev/null
+++ b/sdk/node_modules/@fastify/merge-json-schemas/.github/test.yml
@@ -0,0 +1,32 @@
+name: Run Tests
+
+on: [push, pull_request]
+
+permissions:
+ contents: read
+
+jobs:
+ test:
+ name: Test
+ runs-on: ${{ matrix.os }}
+
+ strategy:
+ matrix:
+ node-version: [18.x, 20.x]
+ os: [ubuntu-latest, windows-latest, macOS-latest]
+
+ steps:
+ - uses: actions/checkout@v3
+
+ - name: Use Node.js ${{ matrix.node-version }}
+ uses: actions/setup-node@v3
+ with:
+ node-version: ${{ matrix.node-version }}
+
+ - name: Install
+ run: |
+ npm install
+
+ - name: Test
+ run: |
+ npm run test
diff --git a/sdk/node_modules/@fastify/merge-json-schemas/LICENSE b/sdk/node_modules/@fastify/merge-json-schemas/LICENSE
new file mode 100644
index 00000000..226c5a9d
--- /dev/null
+++ b/sdk/node_modules/@fastify/merge-json-schemas/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Fastify
+
+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.
diff --git a/sdk/node_modules/@fastify/merge-json-schemas/README.md b/sdk/node_modules/@fastify/merge-json-schemas/README.md
new file mode 100644
index 00000000..fe05f90e
--- /dev/null
+++ b/sdk/node_modules/@fastify/merge-json-schemas/README.md
@@ -0,0 +1,115 @@
+# @fastify/merge-json-schema
+
+__merge-json-schema__ is a javascript library that build a logical product (AND) for multiple [JSON schemas](https://json-schema.org/draft/2020-12/json-schema-core#name-introduction).
+
+- [Installation](#installation)
+- [Usage](#usage)
+- [API](#api)
+ - [mergeSchemas(schemas, options)](#mergeschemasschemas-options)
+ - [resolvers](#resolvers)
+ - [defaultResolver](#defaultresolver)
+- [License](#license)
+
+
+
+## Installation
+
+```bash
+npm install @fastify/merge-json-schema
+```
+
+
+
+## Usage
+
+```javascript
+const assert = require('node:assert')
+const { mergeSchemas } = require('merge-json-schema')
+
+const schema1 = {
+ $id: 'schema1',
+ type: 'object',
+ properties: {
+ foo: { type: 'string', enum: ['foo1', 'foo2'] },
+ bar: { type: 'string', minLength: 3 }
+ }
+}
+
+const schema2 = {
+ $id: 'schema1',
+ type: 'object',
+ properties: {
+ foo: { type: 'string', enum: ['foo1', 'foo3'] },
+ bar: { type: 'string', minLength: 5 }
+ },
+ required: ['foo']
+}
+
+const mergedSchema = mergeSchemas([schema1, schema2])
+assert.deepStrictEqual(mergedSchema, {
+ $id: 'schema1',
+ type: 'object',
+ properties: {
+ foo: { type: 'string', enum: ['foo1'] },
+ bar: { type: 'string', minLength: 5 }
+ },
+ required: ['foo']
+})
+```
+
+
+
+## API
+
+
+
+#### mergeSchemas(schemas, options)
+
+Builds a logical conjunction (AND) of multiple [JSON schemas](https://json-schema.org/draft/2020-12/json-schema-core#name-introduction).
+
+- `schemas` __\__ - list of JSON schemas to merge.
+- `options` __\__ - optional options.
+ - `resolvers` __\__ - custom resolvers for JSON schema keywords. Each key is the name of a JSON schema keyword. Each value is a resolver function. See [keywordResolver](#keywordresolver-keyword-values-mergedschema-parentschemas-options).
+ - `defaultResolver` __\__ - custom default resolver for JSON schema keywords. See [keywordResolver](#keywordresolver-keyword-values-mergedschema-parentschemas-options).
+ - `onConflict` __\__ - action to take when a conflict is found. Used by the default `defaultResolver`. Default is `throw`. Possible values are:
+ - `throw` - throws an error if found a multiple different schemas for the same keyword.
+ - `ignore` - do nothing if found a multiple different schemas for the same keyword.
+ - `first` - use the value of the first schema if found a multiple different schemas for the same keyword.
+
+#### resolvers
+
+A list of default resolvers that __merge-json-schema__ uses to merge JSON schemas. You can override the default resolvers by passing a list of custom resolvers in the `options` argument of `mergeSchemas`. See [keywordResolver](#keywordresolver-keyword-values-mergedschema-parentschemas-options).
+
+#### defaultResolver
+
+A default resolver that __merge-json-schema__ uses to merge JSON schemas. Default resolver is used when no custom resolver is defined for a JSON schema keyword. By default, the default resolver works as follows:
+
+- If only one schema contains the keyword, the value of the keyword is used as the merged value.
+- If multiple schemas contain the exact same value for the keyword, the value of the keyword is used as the merged value.
+- If multiple schemas contain different values for the keyword, it throws an error.
+
+#### keywordResolver (keyword, values, mergedSchema, parentSchemas, options)
+
+__merge-json-schema__ uses a set of resolvers to merge JSON schemas. Each resolver is associated with a JSON schema keyword. The resolver is called when the keyword is found in the schemas to merge. The resolver is called with the following arguments:
+
+- `keyword` __\__ - the name of the keyword to merge.
+- `values` __\__ - the values of the keyword to merge. The length of the array is equal to the number of schemas to merge. If a schema does not contain the keyword, the value is `undefined`.
+- `mergedSchema` __\__ - an instance of the merged schema.
+- `parentSchemas` __\__ - the list of parent schemas.
+- `options` __\__ - the options passed to `mergeSchemas`.
+
+The resolver must set the merged value of the `keyword` in the `mergedSchema` object.
+
+__Example:__ resolver for the `minNumber` keyword.
+
+```javascript
+function minNumberResolver (keyword, values, mergedSchema) {
+ mergedSchema[keyword] = Math.min(...values)
+}
+```
+
+
+
+## License
+
+MIT
diff --git a/sdk/node_modules/@fastify/merge-json-schemas/index.js b/sdk/node_modules/@fastify/merge-json-schemas/index.js
new file mode 100644
index 00000000..7c04b15c
--- /dev/null
+++ b/sdk/node_modules/@fastify/merge-json-schemas/index.js
@@ -0,0 +1,357 @@
+'use strict'
+
+const deepEqual = require('fast-deep-equal')
+const resolvers = require('./lib/resolvers')
+const errors = require('./lib/errors')
+
+const keywordsResolvers = {
+ $id: resolvers.skip,
+ type: resolvers.hybridArraysIntersection,
+ enum: resolvers.arraysIntersection,
+ minLength: resolvers.maxNumber,
+ maxLength: resolvers.minNumber,
+ minimum: resolvers.maxNumber,
+ maximum: resolvers.minNumber,
+ multipleOf: resolvers.commonMultiple,
+ exclusiveMinimum: resolvers.maxNumber,
+ exclusiveMaximum: resolvers.minNumber,
+ minItems: resolvers.maxNumber,
+ maxItems: resolvers.minNumber,
+ maxProperties: resolvers.minNumber,
+ minProperties: resolvers.maxNumber,
+ const: resolvers.allEqual,
+ default: resolvers.allEqual,
+ format: resolvers.allEqual,
+ required: resolvers.arraysUnion,
+ properties: mergeProperties,
+ patternProperties: mergeObjects,
+ additionalProperties: mergeSchemasResolver,
+ items: mergeItems,
+ additionalItems: mergeAdditionalItems,
+ definitions: mergeObjects,
+ $defs: mergeObjects,
+ nullable: resolvers.booleanAnd,
+ oneOf: mergeOneOf,
+ anyOf: mergeOneOf,
+ allOf: resolvers.arraysUnion,
+ not: mergeSchemasResolver,
+ if: mergeIfThenElseSchemas,
+ then: resolvers.skip,
+ else: resolvers.skip,
+ dependencies: mergeDependencies,
+ dependentRequired: mergeDependencies,
+ dependentSchemas: mergeObjects,
+ propertyNames: mergeSchemasResolver,
+ uniqueItems: resolvers.booleanOr,
+ contains: mergeSchemasResolver
+}
+
+function mergeSchemasResolver (keyword, values, mergedSchema, schemas, options) {
+ mergedSchema[keyword] = _mergeSchemas(values, options)
+}
+
+function cartesianProduct (arrays) {
+ let result = [[]]
+
+ for (const array of arrays) {
+ const temp = []
+ for (const x of result) {
+ for (const y of array) {
+ temp.push([...x, y])
+ }
+ }
+ result = temp
+ }
+
+ return result
+}
+
+function mergeOneOf (keyword, values, mergedSchema, schemas, options) {
+ if (values.length === 1) {
+ mergedSchema[keyword] = values[0]
+ return
+ }
+
+ const product = cartesianProduct(values)
+ const mergedOneOf = []
+ for (const combination of product) {
+ try {
+ const mergedSchema = _mergeSchemas(combination, options)
+ if (mergedSchema !== undefined) {
+ mergedOneOf.push(mergedSchema)
+ }
+ } catch (error) {
+ // If this combination is not valid, we can ignore it.
+ if (error instanceof errors.MergeError) continue
+ throw error
+ }
+ }
+ mergedSchema[keyword] = mergedOneOf
+}
+
+function getSchemaForItem (schema, index) {
+ const { items, additionalItems } = schema
+
+ if (Array.isArray(items)) {
+ if (index < items.length) {
+ return items[index]
+ }
+ return additionalItems
+ }
+
+ if (items !== undefined) {
+ return items
+ }
+
+ return additionalItems
+}
+
+function mergeItems (keyword, values, mergedSchema, schemas, options) {
+ let maxArrayItemsLength = 0
+ for (const itemsSchema of values) {
+ if (Array.isArray(itemsSchema)) {
+ maxArrayItemsLength = Math.max(maxArrayItemsLength, itemsSchema.length)
+ }
+ }
+
+ if (maxArrayItemsLength === 0) {
+ mergedSchema[keyword] = _mergeSchemas(values, options)
+ return
+ }
+
+ const mergedItemsSchemas = []
+ for (let i = 0; i < maxArrayItemsLength; i++) {
+ const indexItemSchemas = []
+ for (const schema of schemas) {
+ const itemSchema = getSchemaForItem(schema, i)
+ if (itemSchema !== undefined) {
+ indexItemSchemas.push(itemSchema)
+ }
+ }
+ mergedItemsSchemas[i] = _mergeSchemas(indexItemSchemas, options)
+ }
+ mergedSchema[keyword] = mergedItemsSchemas
+}
+
+function mergeAdditionalItems (keyword, values, mergedSchema, schemas, options) {
+ let hasArrayItems = false
+ for (const schema of schemas) {
+ if (Array.isArray(schema.items)) {
+ hasArrayItems = true
+ break
+ }
+ }
+
+ if (!hasArrayItems) {
+ mergedSchema[keyword] = _mergeSchemas(values, options)
+ return
+ }
+
+ const mergedAdditionalItemsSchemas = []
+ for (const schema of schemas) {
+ let additionalItemsSchema = schema.additionalItems
+ if (
+ additionalItemsSchema === undefined &&
+ !Array.isArray(schema.items)
+ ) {
+ additionalItemsSchema = schema.items
+ }
+ if (additionalItemsSchema !== undefined) {
+ mergedAdditionalItemsSchemas.push(additionalItemsSchema)
+ }
+ }
+
+ mergedSchema[keyword] = _mergeSchemas(mergedAdditionalItemsSchemas, options)
+}
+
+function getSchemaForProperty (schema, propertyName) {
+ const { properties, patternProperties, additionalProperties } = schema
+
+ if (properties?.[propertyName] !== undefined) {
+ return properties[propertyName]
+ }
+
+ for (const pattern of Object.keys(patternProperties ?? {})) {
+ const regexp = new RegExp(pattern)
+ if (regexp.test(propertyName)) {
+ return patternProperties[pattern]
+ }
+ }
+
+ return additionalProperties
+}
+
+function mergeProperties (keyword, values, mergedSchema, schemas, options) {
+ const foundProperties = {}
+ for (const currentSchema of schemas) {
+ const properties = currentSchema.properties ?? {}
+ for (const propertyName of Object.keys(properties)) {
+ if (foundProperties[propertyName] !== undefined) continue
+
+ const propertySchema = properties[propertyName]
+ foundProperties[propertyName] = [propertySchema]
+
+ for (const anotherSchema of schemas) {
+ if (currentSchema === anotherSchema) continue
+
+ const propertySchema = getSchemaForProperty(anotherSchema, propertyName)
+ if (propertySchema !== undefined) {
+ foundProperties[propertyName].push(propertySchema)
+ }
+ }
+ }
+ }
+
+ const mergedProperties = {}
+ for (const property of Object.keys(foundProperties)) {
+ const propertySchemas = foundProperties[property]
+ mergedProperties[property] = _mergeSchemas(propertySchemas, options)
+ }
+ mergedSchema[keyword] = mergedProperties
+}
+
+function mergeObjects (keyword, values, mergedSchema, schemas, options) {
+ const objectsProperties = {}
+
+ for (const properties of values) {
+ for (const propertyName of Object.keys(properties)) {
+ if (objectsProperties[propertyName] === undefined) {
+ objectsProperties[propertyName] = []
+ }
+ objectsProperties[propertyName].push(properties[propertyName])
+ }
+ }
+
+ const mergedProperties = {}
+ for (const propertyName of Object.keys(objectsProperties)) {
+ const propertySchemas = objectsProperties[propertyName]
+ const mergedPropertySchema = _mergeSchemas(propertySchemas, options)
+ mergedProperties[propertyName] = mergedPropertySchema
+ }
+
+ mergedSchema[keyword] = mergedProperties
+}
+
+function mergeIfThenElseSchemas (keyword, values, mergedSchema, schemas, options) {
+ for (let i = 0; i < schemas.length; i++) {
+ const subSchema = {
+ if: schemas[i].if,
+ then: schemas[i].then,
+ else: schemas[i].else
+ }
+
+ if (subSchema.if === undefined) continue
+
+ if (mergedSchema.if === undefined) {
+ mergedSchema.if = subSchema.if
+ if (subSchema.then !== undefined) {
+ mergedSchema.then = subSchema.then
+ }
+ if (subSchema.else !== undefined) {
+ mergedSchema.else = subSchema.else
+ }
+ continue
+ }
+
+ if (mergedSchema.then !== undefined) {
+ mergedSchema.then = _mergeSchemas([mergedSchema.then, subSchema], options)
+ }
+ if (mergedSchema.else !== undefined) {
+ mergedSchema.else = _mergeSchemas([mergedSchema.else, subSchema], options)
+ }
+ }
+}
+
+function mergeDependencies (keyword, values, mergedSchema) {
+ const mergedDependencies = {}
+ for (const dependencies of values) {
+ for (const propertyName of Object.keys(dependencies)) {
+ if (mergedDependencies[propertyName] === undefined) {
+ mergedDependencies[propertyName] = []
+ }
+ const mergedPropertyDependencies = mergedDependencies[propertyName]
+ for (const propertyDependency of dependencies[propertyName]) {
+ if (!mergedPropertyDependencies.includes(propertyDependency)) {
+ mergedPropertyDependencies.push(propertyDependency)
+ }
+ }
+ }
+ }
+ mergedSchema[keyword] = mergedDependencies
+}
+
+function _mergeSchemas (schemas, options) {
+ if (schemas.length === 0) return {}
+ if (schemas.length === 1) return schemas[0]
+
+ const mergedSchema = {}
+ const keywords = {}
+
+ let allSchemasAreTrue = true
+
+ for (const schema of schemas) {
+ if (schema === false) return false
+ if (schema === true) continue
+ allSchemasAreTrue = false
+
+ for (const keyword of Object.keys(schema)) {
+ if (keywords[keyword] === undefined) {
+ keywords[keyword] = []
+ }
+ keywords[keyword].push(schema[keyword])
+ }
+ }
+
+ if (allSchemasAreTrue) return true
+
+ for (const keyword of Object.keys(keywords)) {
+ const keywordValues = keywords[keyword]
+ const resolver = options.resolvers[keyword] ?? options.defaultResolver
+ resolver(keyword, keywordValues, mergedSchema, schemas, options)
+ }
+
+ return mergedSchema
+}
+
+function defaultResolver (keyword, values, mergedSchema, schemas, options) {
+ const onConflict = options.onConflict ?? 'throw'
+
+ if (values.length === 1 || onConflict === 'first') {
+ mergedSchema[keyword] = values[0]
+ return
+ }
+
+ let allValuesEqual = true
+ for (let i = 1; i < values.length; i++) {
+ if (!deepEqual(values[i], values[0])) {
+ allValuesEqual = false
+ break
+ }
+ }
+
+ if (allValuesEqual) {
+ mergedSchema[keyword] = values[0]
+ return
+ }
+
+ if (onConflict === 'throw') {
+ throw new errors.ResolverNotFoundError(keyword, values)
+ }
+ if (onConflict === 'skip') {
+ return
+ }
+ throw new errors.InvalidOnConflictOptionError(onConflict)
+}
+
+function mergeSchemas (schemas, options = {}) {
+ if (options.defaultResolver === undefined) {
+ options.defaultResolver = defaultResolver
+ }
+
+ options.resolvers = { ...keywordsResolvers, ...options.resolvers }
+
+ const mergedSchema = _mergeSchemas(schemas, options)
+ return mergedSchema
+}
+
+module.exports = { mergeSchemas, keywordsResolvers, defaultResolver, ...errors }
diff --git a/sdk/node_modules/@fastify/merge-json-schemas/lib/errors.js b/sdk/node_modules/@fastify/merge-json-schemas/lib/errors.js
new file mode 100644
index 00000000..0a14792e
--- /dev/null
+++ b/sdk/node_modules/@fastify/merge-json-schemas/lib/errors.js
@@ -0,0 +1,36 @@
+'use strict'
+
+class MergeError extends Error {
+ constructor (keyword, schemas) {
+ super()
+ this.name = 'JsonSchemaMergeError'
+ this.code = 'JSON_SCHEMA_MERGE_ERROR'
+ this.message = `Failed to merge "${keyword}" keyword schemas.`
+ this.schemas = schemas
+ }
+}
+
+class ResolverNotFoundError extends Error {
+ constructor (keyword, schemas) {
+ super()
+ this.name = 'JsonSchemaMergeError'
+ this.code = 'JSON_SCHEMA_MERGE_ERROR'
+ this.message = `Resolver for "${keyword}" keyword not found.`
+ this.schemas = schemas
+ }
+}
+
+class InvalidOnConflictOptionError extends Error {
+ constructor (onConflict) {
+ super()
+ this.name = 'JsonSchemaMergeError'
+ this.code = 'JSON_SCHEMA_MERGE_ERROR'
+ this.message = `Invalid "onConflict" option: "${onConflict}".`
+ }
+}
+
+module.exports = {
+ MergeError,
+ ResolverNotFoundError,
+ InvalidOnConflictOptionError
+}
diff --git a/sdk/node_modules/@fastify/merge-json-schemas/lib/resolvers.js b/sdk/node_modules/@fastify/merge-json-schemas/lib/resolvers.js
new file mode 100644
index 00000000..59dc8432
--- /dev/null
+++ b/sdk/node_modules/@fastify/merge-json-schemas/lib/resolvers.js
@@ -0,0 +1,127 @@
+'use strict'
+
+const deepEqual = require('fast-deep-equal')
+const { MergeError } = require('./errors')
+
+function _arraysIntersection (arrays) {
+ let intersection = arrays[0]
+ for (let i = 1; i < arrays.length; i++) {
+ intersection = intersection.filter(
+ value => arrays[i].includes(value)
+ )
+ }
+ return intersection
+}
+
+function arraysIntersection (keyword, values, mergedSchema) {
+ const intersection = _arraysIntersection(values)
+ if (intersection.length === 0) {
+ throw new MergeError(keyword, values)
+ }
+ mergedSchema[keyword] = intersection
+}
+
+function hybridArraysIntersection (keyword, values, mergedSchema) {
+ for (let i = 0; i < values.length; i++) {
+ if (!Array.isArray(values[i])) {
+ values[i] = [values[i]]
+ }
+ }
+
+ const intersection = _arraysIntersection(values)
+ if (intersection.length === 0) {
+ throw new MergeError(keyword, values)
+ }
+
+ if (intersection.length === 1) {
+ mergedSchema[keyword] = intersection[0]
+ } else {
+ mergedSchema[keyword] = intersection
+ }
+}
+
+function arraysUnion (keyword, values, mergedSchema) {
+ const union = []
+
+ for (const array of values) {
+ for (const value of array) {
+ if (!union.includes(value)) {
+ union.push(value)
+ }
+ }
+ }
+
+ mergedSchema[keyword] = union
+}
+
+function minNumber (keyword, values, mergedSchema) {
+ mergedSchema[keyword] = Math.min(...values)
+}
+
+function maxNumber (keyword, values, mergedSchema) {
+ mergedSchema[keyword] = Math.max(...values)
+}
+
+function commonMultiple (keyword, values, mergedSchema) {
+ const gcd = (a, b) => (!b ? a : gcd(b, a % b))
+ const lcm = (a, b) => (a * b) / gcd(a, b)
+
+ let scale = 1
+ for (const value of values) {
+ while (value * scale % 1 !== 0) {
+ scale *= 10
+ }
+ }
+
+ let multiple = values[0] * scale
+ for (const value of values) {
+ multiple = lcm(multiple, value * scale)
+ }
+
+ mergedSchema[keyword] = multiple / scale
+}
+
+function allEqual (keyword, values, mergedSchema) {
+ const firstValue = values[0]
+ for (let i = 1; i < values.length; i++) {
+ if (!deepEqual(values[i], firstValue)) {
+ throw new MergeError(keyword, values)
+ }
+ }
+ mergedSchema[keyword] = firstValue
+}
+
+function skip () {}
+
+function booleanAnd (keyword, values, mergedSchema) {
+ for (const value of values) {
+ if (value === false) {
+ mergedSchema[keyword] = false
+ return
+ }
+ }
+ mergedSchema[keyword] = true
+}
+
+function booleanOr (keyword, values, mergedSchema) {
+ for (const value of values) {
+ if (value === true) {
+ mergedSchema[keyword] = true
+ return
+ }
+ }
+ mergedSchema[keyword] = false
+}
+
+module.exports = {
+ arraysIntersection,
+ hybridArraysIntersection,
+ arraysUnion,
+ minNumber,
+ maxNumber,
+ commonMultiple,
+ allEqual,
+ booleanAnd,
+ booleanOr,
+ skip
+}
diff --git a/sdk/node_modules/@fastify/merge-json-schemas/package.json b/sdk/node_modules/@fastify/merge-json-schemas/package.json
new file mode 100644
index 00000000..7f78ca97
--- /dev/null
+++ b/sdk/node_modules/@fastify/merge-json-schemas/package.json
@@ -0,0 +1,39 @@
+{
+ "name": "@fastify/merge-json-schemas",
+ "version": "0.1.1",
+ "description": "Builds a logical conjunction (AND) of multiple JSON schemas",
+ "main": "index.js",
+ "type": "commonjs",
+ "types": "types/index.d.ts",
+ "scripts": {
+ "lint": "standard",
+ "lint:fix": "standard --fix",
+ "test:unit": "c8 --100 node --test",
+ "test:types": "tsd",
+ "test": "npm run lint && npm run test:unit && npm run test:types"
+ },
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/fastify/merge-json-schemas.git"
+ },
+ "keywords": [
+ "json",
+ "schema",
+ "merge",
+ "allOf"
+ ],
+ "author": "Ivan Tymoshenko ",
+ "license": "MIT",
+ "bugs": {
+ "url": "https://github.com/fastify/merge-json-schemas/issues"
+ },
+ "homepage": "https://github.com/fastify/merge-json-schemas#readme",
+ "devDependencies": {
+ "c8": "^8.0.1",
+ "standard": "^17.1.0",
+ "tsd": "^0.30.3"
+ },
+ "dependencies": {
+ "fast-deep-equal": "^3.1.3"
+ }
+}
diff --git a/sdk/node_modules/@fastify/merge-json-schemas/test/additional-items.test.js b/sdk/node_modules/@fastify/merge-json-schemas/test/additional-items.test.js
new file mode 100644
index 00000000..707450f6
--- /dev/null
+++ b/sdk/node_modules/@fastify/merge-json-schemas/test/additional-items.test.js
@@ -0,0 +1,164 @@
+'use strict'
+
+const assert = require('node:assert/strict')
+const { test } = require('node:test')
+const { mergeSchemas } = require('../index')
+const { defaultResolver } = require('./utils')
+
+test('should merge empty schema and additionalItems = false keyword', () => {
+ const schema1 = { type: 'array' }
+ const schema2 = {
+ type: 'array',
+ additionalItems: false
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ type: 'array',
+ additionalItems: false
+ })
+})
+
+test('should merge two schemas with boolean additionalItems', () => {
+ const schema1 = {
+ type: 'array',
+ additionalItems: true
+ }
+ const schema2 = {
+ type: 'array',
+ additionalItems: false
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ type: 'array',
+ additionalItems: false
+ })
+})
+
+test('should merge additionalItems schema with false value', () => {
+ const schema1 = {
+ type: 'array',
+ additionalItems: {
+ type: 'string'
+ }
+ }
+ const schema2 = {
+ type: 'array',
+ additionalItems: false
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ type: 'array',
+ additionalItems: false
+ })
+})
+
+test('should merge additionalItems schema with true value', () => {
+ const schema1 = {
+ type: 'array',
+ additionalItems: {
+ type: 'string'
+ }
+ }
+ const schema2 = {
+ type: 'array',
+ additionalItems: true
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ type: 'array',
+ additionalItems: {
+ type: 'string'
+ }
+ })
+})
+
+test('should merge two additionalItems schemas', () => {
+ const schema1 = {
+ type: 'array',
+ additionalItems: {
+ type: 'string'
+ }
+ }
+ const schema2 = {
+ type: 'array',
+ additionalItems: {
+ type: 'string', minLength: 1
+ }
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ type: 'array',
+ additionalItems: {
+ type: 'string', minLength: 1
+ }
+ })
+})
+
+test('should merge additionalItems with items array', () => {
+ const schema1 = {
+ type: 'array',
+ items: [
+ { type: 'string', const: 'foo1' },
+ { type: 'string', const: 'foo2' },
+ { type: 'string', const: 'foo3' }
+ ]
+ }
+ const schema2 = {
+ type: 'array',
+ additionalItems: {
+ type: 'string', minLength: 42
+ }
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ type: 'array',
+ items: [
+ { type: 'string', const: 'foo1', minLength: 42 },
+ { type: 'string', const: 'foo2', minLength: 42 },
+ { type: 'string', const: 'foo3', minLength: 42 }
+ ],
+ additionalItems: {
+ type: 'string', minLength: 42
+ }
+ })
+})
+
+test('should merge items array and additionalItems with items array', () => {
+ const schema1 = {
+ type: 'array',
+ items: [
+ { type: 'string', const: 'foo1' },
+ { type: 'string', const: 'foo2' },
+ { type: 'string', const: 'foo3' }
+ ]
+ }
+ const schema2 = {
+ type: 'array',
+ items: [
+ { type: 'string', minLength: 1 },
+ { type: 'string', minLength: 2 }
+ ],
+ additionalItems: {
+ type: 'string', minLength: 3
+ }
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ type: 'array',
+ items: [
+ { type: 'string', const: 'foo1', minLength: 1 },
+ { type: 'string', const: 'foo2', minLength: 2 },
+ { type: 'string', const: 'foo3', minLength: 3 }
+ ],
+ additionalItems: {
+ type: 'string', minLength: 3
+ }
+ })
+})
diff --git a/sdk/node_modules/@fastify/merge-json-schemas/test/additional-properties.test.js b/sdk/node_modules/@fastify/merge-json-schemas/test/additional-properties.test.js
new file mode 100644
index 00000000..e4304ac0
--- /dev/null
+++ b/sdk/node_modules/@fastify/merge-json-schemas/test/additional-properties.test.js
@@ -0,0 +1,129 @@
+'use strict'
+
+const assert = require('node:assert/strict')
+const { test } = require('node:test')
+const { mergeSchemas } = require('../index')
+const { defaultResolver } = require('./utils')
+
+test('should merge empty schema and additionalProperties=false keyword', () => {
+ const schema1 = { type: 'object' }
+ const schema2 = {
+ type: 'object',
+ additionalProperties: false
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ type: 'object',
+ additionalProperties: false
+ })
+})
+
+test('should merge two schemas with boolean additionalProperties', () => {
+ const schema1 = {
+ type: 'object',
+ additionalProperties: true
+ }
+ const schema2 = {
+ type: 'object',
+ additionalProperties: false
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ type: 'object',
+ additionalProperties: false
+ })
+})
+
+test('should merge additionalProperties schema with false value', () => {
+ const schema1 = {
+ type: 'object',
+ additionalProperties: {
+ type: 'string'
+ }
+ }
+ const schema2 = {
+ type: 'object',
+ additionalProperties: false
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ type: 'object',
+ additionalProperties: false
+ })
+})
+
+test('should merge additionalProperties schema with true value', () => {
+ const schema1 = {
+ type: 'object',
+ additionalProperties: {
+ type: 'string'
+ }
+ }
+ const schema2 = {
+ type: 'object',
+ additionalProperties: true
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ type: 'object',
+ additionalProperties: {
+ type: 'string'
+ }
+ })
+})
+
+test('should merge two additionalProperties schemas', () => {
+ const schema1 = {
+ type: 'object',
+ additionalProperties: {
+ type: 'string'
+ }
+ }
+ const schema2 = {
+ type: 'object',
+ additionalProperties: {
+ type: 'string', minLength: 1
+ }
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ type: 'object',
+ additionalProperties: {
+ type: 'string', minLength: 1
+ }
+ })
+})
+
+test('should merge two additionalProperties and properties schemas', () => {
+ const schema1 = {
+ type: 'object',
+ additionalProperties: {
+ type: 'string'
+ }
+ }
+ const schema2 = {
+ type: 'object',
+ properties: {
+ foo: { type: ['string', 'number'] }
+ },
+ additionalProperties: {
+ type: 'string', minLength: 1
+ }
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ type: 'object',
+ properties: {
+ foo: { type: 'string' }
+ },
+ additionalProperties: {
+ type: 'string', minLength: 1
+ }
+ })
+})
diff --git a/sdk/node_modules/@fastify/merge-json-schemas/test/all-of.test.js b/sdk/node_modules/@fastify/merge-json-schemas/test/all-of.test.js
new file mode 100644
index 00000000..2b2acef7
--- /dev/null
+++ b/sdk/node_modules/@fastify/merge-json-schemas/test/all-of.test.js
@@ -0,0 +1,43 @@
+'use strict'
+
+const assert = require('node:assert/strict')
+const { test } = require('node:test')
+const { mergeSchemas } = require('../index')
+const { defaultResolver } = require('./utils')
+
+test('should merge empty schema and allOf keyword', () => {
+ const schema1 = {}
+ const schema2 = {
+ allOf: [
+ { type: 'string', const: 'foo' }
+ ]
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ allOf: [
+ { type: 'string', const: 'foo' }
+ ]
+ })
+})
+
+test('should merge schemas with allOfs schemas', () => {
+ const schema1 = {
+ allOf: [
+ { type: 'number', minimum: 0 }
+ ]
+ }
+ const schema2 = {
+ allOf: [
+ { type: 'string', const: 'foo' }
+ ]
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ allOf: [
+ { type: 'number', minimum: 0 },
+ { type: 'string', const: 'foo' }
+ ]
+ })
+})
diff --git a/sdk/node_modules/@fastify/merge-json-schemas/test/any-of.test.js b/sdk/node_modules/@fastify/merge-json-schemas/test/any-of.test.js
new file mode 100644
index 00000000..98b3a21e
--- /dev/null
+++ b/sdk/node_modules/@fastify/merge-json-schemas/test/any-of.test.js
@@ -0,0 +1,81 @@
+'use strict'
+
+const assert = require('node:assert/strict')
+const { test } = require('node:test')
+const { mergeSchemas } = require('../index')
+const { defaultResolver } = require('./utils')
+
+test('should merge empty schema and anyOf keyword', () => {
+ const schema1 = {}
+ const schema2 = {
+ anyOf: [
+ { type: 'string', const: 'foo' }
+ ]
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ anyOf: [
+ { type: 'string', const: 'foo' }
+ ]
+ })
+})
+
+test('should merge two schemas with anyOfs schemas', () => {
+ const schema1 = {
+ anyOf: [
+ { type: 'string', enum: ['foo1', 'foo2', 'foo3'] },
+ { type: 'string', enum: ['foo3', 'foo4', 'foo5'] }
+ ]
+ }
+ const schema2 = {
+ anyOf: [
+ { type: 'string', enum: ['foo2', 'foo3', 'foo4'] },
+ { type: 'string', enum: ['foo3', 'foo6', 'foo7'] }
+ ]
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ anyOf: [
+ { type: 'string', enum: ['foo2', 'foo3'] },
+ { type: 'string', enum: ['foo3'] },
+ { type: 'string', enum: ['foo3', 'foo4'] },
+ { type: 'string', enum: ['foo3'] }
+ ]
+ })
+})
+
+test('should merge three schemas with anyOfs schemas', () => {
+ const schema1 = {
+ anyOf: [
+ { type: 'string', enum: ['foo1', 'foo2', 'foo3', 'foo4'] },
+ { type: 'string', enum: ['foo3', 'foo4', 'foo5', 'foo7'] }
+ ]
+ }
+ const schema2 = {
+ anyOf: [
+ { type: 'string', enum: ['foo2', 'foo3', 'foo4', 'foo5'] },
+ { type: 'string', enum: ['foo3', 'foo6', 'foo7', 'foo8'] }
+ ]
+ }
+
+ const schema3 = {
+ anyOf: [
+ { type: 'string', enum: ['foo1', 'foo3', 'foo5', 'foo7'] },
+ { type: 'string', enum: ['foo2', 'foo4', 'foo6', 'foo8'] }
+ ]
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2, schema3], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ anyOf: [
+ { type: 'string', enum: ['foo3'] },
+ { type: 'string', enum: ['foo2', 'foo4'] },
+ { type: 'string', enum: ['foo3'] },
+ { type: 'string', enum: ['foo3', 'foo5'] },
+ { type: 'string', enum: ['foo4'] },
+ { type: 'string', enum: ['foo3', 'foo7'] }
+ ]
+ })
+})
diff --git a/sdk/node_modules/@fastify/merge-json-schemas/test/const.test.js b/sdk/node_modules/@fastify/merge-json-schemas/test/const.test.js
new file mode 100644
index 00000000..1b8cfe0d
--- /dev/null
+++ b/sdk/node_modules/@fastify/merge-json-schemas/test/const.test.js
@@ -0,0 +1,58 @@
+'use strict'
+
+const assert = require('node:assert/strict')
+const { test } = require('node:test')
+const { mergeSchemas } = require('../index')
+const { defaultResolver } = require('./utils')
+
+test('should merge empty schema and string const keyword', () => {
+ const schema1 = { type: 'string' }
+ const schema2 = { type: 'string', const: 'foo' }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'string', const: 'foo' })
+})
+
+test('should merge equal string const keywords', () => {
+ const schema1 = { type: 'string', const: 'foo' }
+ const schema2 = { type: 'string', const: 'foo' }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'string', const: 'foo' })
+})
+
+test('should merge equal object const keywords', () => {
+ const schema1 = { type: 'string', const: { foo: 'bar' } }
+ const schema2 = { type: 'string', const: { foo: 'bar' } }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'string', const: { foo: 'bar' } })
+})
+
+test('should throw an error if const string values are different', () => {
+ const schema1 = { type: 'string', const: 'foo' }
+ const schema2 = { type: 'string', const: 'bar' }
+
+ assert.throws(() => {
+ mergeSchemas([schema1, schema2], { defaultResolver })
+ }, {
+ name: 'JsonSchemaMergeError',
+ code: 'JSON_SCHEMA_MERGE_ERROR',
+ message: 'Failed to merge "const" keyword schemas.',
+ schemas: ['foo', 'bar']
+ })
+})
+
+test('should throw an error if const object values are different', () => {
+ const schema1 = { type: 'object', const: { foo: 'bar' } }
+ const schema2 = { type: 'object', const: { foo: 'baz' } }
+
+ assert.throws(() => {
+ mergeSchemas([schema1, schema2], { defaultResolver })
+ }, {
+ name: 'JsonSchemaMergeError',
+ code: 'JSON_SCHEMA_MERGE_ERROR',
+ message: 'Failed to merge "const" keyword schemas.',
+ schemas: [{ foo: 'bar' }, { foo: 'baz' }]
+ })
+})
diff --git a/sdk/node_modules/@fastify/merge-json-schemas/test/contains.test.js b/sdk/node_modules/@fastify/merge-json-schemas/test/contains.test.js
new file mode 100644
index 00000000..66efb05b
--- /dev/null
+++ b/sdk/node_modules/@fastify/merge-json-schemas/test/contains.test.js
@@ -0,0 +1,55 @@
+'use strict'
+
+const assert = require('node:assert/strict')
+const { test } = require('node:test')
+const { mergeSchemas } = require('../index')
+const { defaultResolver } = require('./utils')
+
+test('should merge empty schema and contains keyword', () => {
+ const schema1 = {}
+ const schema2 = {
+ type: 'array',
+ contains: {
+ type: 'integer',
+ minimum: 5
+ }
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ type: 'array',
+ contains: {
+ type: 'integer',
+ minimum: 5
+ }
+ })
+})
+
+test('should merge two contains keyword schemas', () => {
+ const schema1 = {
+ type: 'array',
+ contains: {
+ type: 'integer',
+ minimum: 5,
+ maximum: 14
+ }
+ }
+ const schema2 = {
+ type: 'array',
+ contains: {
+ type: 'integer',
+ minimum: 9,
+ maximum: 10
+ }
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ type: 'array',
+ contains: {
+ type: 'integer',
+ minimum: 9,
+ maximum: 10
+ }
+ })
+})
diff --git a/sdk/node_modules/@fastify/merge-json-schemas/test/custom-resolvers.test.js b/sdk/node_modules/@fastify/merge-json-schemas/test/custom-resolvers.test.js
new file mode 100644
index 00000000..20791881
--- /dev/null
+++ b/sdk/node_modules/@fastify/merge-json-schemas/test/custom-resolvers.test.js
@@ -0,0 +1,50 @@
+'use strict'
+
+const assert = require('node:assert/strict')
+const { test } = require('node:test')
+const { mergeSchemas } = require('../index')
+const { defaultResolver } = require('./utils')
+
+test('should use a custom resolver instead of default one', () => {
+ const schema1 = { type: 'string' }
+ const schema2 = { type: 'number' }
+
+ const mergedSchema = mergeSchemas(
+ [schema1, schema2],
+ {
+ resolvers: {
+ type: (keyword, values, mergedSchema, schemas) => {
+ assert.strictEqual(keyword, 'type')
+ assert.deepStrictEqual(values, ['string', 'number'])
+ assert.deepStrictEqual(schemas, [schema1, schema2])
+
+ mergedSchema[keyword] = 'custom-type'
+ }
+ },
+ defaultResolver
+ }
+ )
+ assert.deepStrictEqual(mergedSchema, { type: 'custom-type' })
+})
+
+test('should use a custom resolver for unknown keyword', () => {
+ const schema1 = { customKeyword: 'string' }
+ const schema2 = { customKeyword: 'number' }
+
+ const mergedSchema = mergeSchemas(
+ [schema1, schema2],
+ {
+ resolvers: {
+ customKeyword: (keyword, values, mergedSchema, schemas) => {
+ assert.strictEqual(keyword, 'customKeyword')
+ assert.deepStrictEqual(values, ['string', 'number'])
+ assert.deepStrictEqual(schemas, [schema1, schema2])
+
+ mergedSchema[keyword] = 'custom-type'
+ }
+ },
+ defaultResolver
+ }
+ )
+ assert.deepStrictEqual(mergedSchema, { customKeyword: 'custom-type' })
+})
diff --git a/sdk/node_modules/@fastify/merge-json-schemas/test/default-resolver.test.js b/sdk/node_modules/@fastify/merge-json-schemas/test/default-resolver.test.js
new file mode 100644
index 00000000..186a13aa
--- /dev/null
+++ b/sdk/node_modules/@fastify/merge-json-schemas/test/default-resolver.test.js
@@ -0,0 +1,111 @@
+'use strict'
+
+const assert = require('node:assert/strict')
+const { test } = require('node:test')
+const { mergeSchemas } = require('../index')
+
+test('should merge an unknown keyword with an empty schema', () => {
+ const schema1 = {}
+ const schema2 = { customKeyword: 42 }
+
+ const mergedSchema = mergeSchemas([schema1, schema2])
+ assert.deepStrictEqual(mergedSchema, { customKeyword: 42 })
+})
+
+test('should merge two equal unknown keywords', () => {
+ const schema1 = { customKeyword: 42 }
+ const schema2 = { customKeyword: 42 }
+
+ const mergedSchema = mergeSchemas([schema1, schema2])
+ assert.deepStrictEqual(mergedSchema, { customKeyword: 42 })
+})
+
+test('should merge two equal unknown object keywords', () => {
+ const schema1 = { type: 'string', customKeyword: { foo: 'bar' } }
+ const schema2 = { type: 'string', customKeyword: { foo: 'bar' } }
+
+ const mergedSchema = mergeSchemas([schema1, schema2])
+ assert.deepStrictEqual(mergedSchema, {
+ type: 'string',
+ customKeyword: { foo: 'bar' }
+ })
+})
+
+test('should use custom defaultResolver if passed', () => {
+ const schema1 = { type: 'string', customKeyword: 42 }
+ const schema2 = { type: 'string', customKeyword: 43 }
+
+ const mergedSchema = mergeSchemas(
+ [schema1, schema2],
+ {
+ defaultResolver: (keyword, values, mergedSchema, schemas) => {
+ assert.strictEqual(keyword, 'customKeyword')
+ assert.deepStrictEqual(values, [42, 43])
+ assert.deepStrictEqual(schemas, [schema1, schema2])
+
+ mergedSchema.customKeyword = 'custom-value-42'
+ }
+ }
+ )
+ assert.deepStrictEqual(mergedSchema, {
+ type: 'string',
+ customKeyword: 'custom-value-42'
+ })
+})
+
+test('should trow an error when merging two different unknown keywords', () => {
+ const schema1 = { customKeyword: 42 }
+ const schema2 = { customKeyword: 43 }
+
+ assert.throws(() => {
+ mergeSchemas([schema1, schema2])
+ }, {
+ name: 'JsonSchemaMergeError',
+ code: 'JSON_SCHEMA_MERGE_ERROR',
+ message: 'Resolver for "customKeyword" keyword not found.',
+ schemas: [42, 43]
+ })
+})
+
+test('should trow an error when merging two different unknown keywords with onConflict = throw', () => {
+ const schema1 = { customKeyword: 42 }
+ const schema2 = { customKeyword: 43 }
+
+ assert.throws(() => {
+ mergeSchemas([schema1, schema2], { onConflict: 'throw' })
+ }, {
+ name: 'JsonSchemaMergeError',
+ code: 'JSON_SCHEMA_MERGE_ERROR',
+ message: 'Resolver for "customKeyword" keyword not found.',
+ schemas: [42, 43]
+ })
+})
+
+test('should skip the keyword schemas if onConflict = skip', () => {
+ const schema1 = { customKeyword: 42 }
+ const schema2 = { customKeyword: 43 }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { onConflict: 'skip' })
+ assert.deepStrictEqual(mergedSchema, {})
+})
+
+test('should pick first schema if onConflict = first', () => {
+ const schema1 = { customKeyword: 42 }
+ const schema2 = { customKeyword: 43 }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { onConflict: 'first' })
+ assert.deepStrictEqual(mergedSchema, { customKeyword: 42 })
+})
+
+test('should throw an error if pass wrong onConflict value', () => {
+ const schema1 = { customKeyword: 42 }
+ const schema2 = { customKeyword: 43 }
+
+ assert.throws(() => {
+ mergeSchemas([schema1, schema2], { onConflict: 'foo' })
+ }, {
+ name: 'JsonSchemaMergeError',
+ code: 'JSON_SCHEMA_MERGE_ERROR',
+ message: 'Invalid "onConflict" option: "foo".'
+ })
+})
diff --git a/sdk/node_modules/@fastify/merge-json-schemas/test/default.test.js b/sdk/node_modules/@fastify/merge-json-schemas/test/default.test.js
new file mode 100644
index 00000000..a87cbcc5
--- /dev/null
+++ b/sdk/node_modules/@fastify/merge-json-schemas/test/default.test.js
@@ -0,0 +1,50 @@
+'use strict'
+
+const assert = require('node:assert/strict')
+const { test } = require('node:test')
+const { mergeSchemas } = require('../index')
+const { defaultResolver } = require('./utils')
+
+test('should merge empty schema and string default keyword', () => {
+ const schema1 = { type: 'string' }
+ const schema2 = { type: 'string', default: 'foo' }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'string', default: 'foo' })
+})
+
+test('should merge equal string default keywords', () => {
+ const schema1 = { type: 'string', default: 'foo' }
+ const schema2 = { type: 'string', default: 'foo' }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'string', default: 'foo' })
+})
+
+test('should throw an error if default string values are different', () => {
+ const schema1 = { type: 'string', default: 'foo' }
+ const schema2 = { type: 'string', default: 'bar' }
+
+ assert.throws(() => {
+ mergeSchemas([schema1, schema2], { defaultResolver })
+ }, {
+ name: 'JsonSchemaMergeError',
+ code: 'JSON_SCHEMA_MERGE_ERROR',
+ message: 'Failed to merge "default" keyword schemas.',
+ schemas: ['foo', 'bar']
+ })
+})
+
+test('should throw an error if default object values are different', () => {
+ const schema1 = { type: 'object', default: { foo: 'bar' } }
+ const schema2 = { type: 'object', default: { foo: 'baz' } }
+
+ assert.throws(() => {
+ mergeSchemas([schema1, schema2], { defaultResolver })
+ }, {
+ name: 'JsonSchemaMergeError',
+ code: 'JSON_SCHEMA_MERGE_ERROR',
+ message: 'Failed to merge "default" keyword schemas.',
+ schemas: [{ foo: 'bar' }, { foo: 'baz' }]
+ })
+})
diff --git a/sdk/node_modules/@fastify/merge-json-schemas/test/definitions.test.js b/sdk/node_modules/@fastify/merge-json-schemas/test/definitions.test.js
new file mode 100644
index 00000000..2f90280b
--- /dev/null
+++ b/sdk/node_modules/@fastify/merge-json-schemas/test/definitions.test.js
@@ -0,0 +1,46 @@
+'use strict'
+
+const assert = require('node:assert/strict')
+const { test } = require('node:test')
+const { mergeSchemas } = require('../index')
+const { defaultResolver } = require('./utils')
+
+test('should merge empty schema and definitions keyword', () => {
+ const schema1 = {}
+ const schema2 = {
+ definitions: {
+ foo: { type: 'string', const: 'foo' }
+ }
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ definitions: {
+ foo: { type: 'string', const: 'foo' }
+ }
+ })
+})
+
+test('should merge two definition schemas', () => {
+ const schema1 = {
+ definitions: {
+ foo: { type: 'string', enum: ['foo', 'bar'] },
+ bar: { type: 'string', enum: ['foo', 'bar'] }
+ }
+ }
+ const schema2 = {
+ definitions: {
+ foo: { type: 'string', enum: ['foo'] },
+ baz: { type: 'string' }
+ }
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ definitions: {
+ foo: { type: 'string', enum: ['foo'] },
+ bar: { type: 'string', enum: ['foo', 'bar'] },
+ baz: { type: 'string' }
+ }
+ })
+})
diff --git a/sdk/node_modules/@fastify/merge-json-schemas/test/defs.test.js b/sdk/node_modules/@fastify/merge-json-schemas/test/defs.test.js
new file mode 100644
index 00000000..e5433abb
--- /dev/null
+++ b/sdk/node_modules/@fastify/merge-json-schemas/test/defs.test.js
@@ -0,0 +1,46 @@
+'use strict'
+
+const assert = require('node:assert/strict')
+const { test } = require('node:test')
+const { mergeSchemas } = require('../index')
+const { defaultResolver } = require('./utils')
+
+test('should merge empty schema and $defs keyword', () => {
+ const schema1 = {}
+ const schema2 = {
+ $defs: {
+ foo: { type: 'string', const: 'foo' }
+ }
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ $defs: {
+ foo: { type: 'string', const: 'foo' }
+ }
+ })
+})
+
+test('should merge two definition schemas', () => {
+ const schema1 = {
+ $defs: {
+ foo: { type: 'string', enum: ['foo', 'bar'] },
+ bar: { type: 'string', enum: ['foo', 'bar'] }
+ }
+ }
+ const schema2 = {
+ $defs: {
+ foo: { type: 'string', enum: ['foo'] },
+ baz: { type: 'string' }
+ }
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ $defs: {
+ foo: { type: 'string', enum: ['foo'] },
+ bar: { type: 'string', enum: ['foo', 'bar'] },
+ baz: { type: 'string' }
+ }
+ })
+})
diff --git a/sdk/node_modules/@fastify/merge-json-schemas/test/dependencies.test.js b/sdk/node_modules/@fastify/merge-json-schemas/test/dependencies.test.js
new file mode 100644
index 00000000..3afb0cf9
--- /dev/null
+++ b/sdk/node_modules/@fastify/merge-json-schemas/test/dependencies.test.js
@@ -0,0 +1,75 @@
+'use strict'
+
+const assert = require('node:assert/strict')
+const { test } = require('node:test')
+const { mergeSchemas } = require('../index')
+const { defaultResolver } = require('./utils')
+
+test('should merge empty schema and dependencies keyword', () => {
+ const schema1 = {}
+ const schema2 = {
+ type: 'object',
+ properties: {
+ foo: { type: 'string' },
+ bar: { type: 'string' }
+ },
+ dependencies: {
+ foo: ['bar']
+ }
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ type: 'object',
+ properties: {
+ foo: { type: 'string' },
+ bar: { type: 'string' }
+ },
+ dependencies: {
+ foo: ['bar']
+ }
+ })
+})
+
+test('should merge two dependencies keyword schemas', () => {
+ const schema1 = {
+ type: 'object',
+ properties: {
+ foo: { type: 'string' },
+ bar: { type: 'string' },
+ que: { type: 'string' }
+ },
+ dependencies: {
+ foo: ['bar', 'que'],
+ bar: ['que']
+ }
+ }
+ const schema2 = {
+ type: 'object',
+ properties: {
+ foo: { type: 'string' },
+ bar: { type: 'string' },
+ baz: { type: 'string' }
+ },
+ dependencies: {
+ foo: ['baz'],
+ baz: ['foo']
+ }
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ type: 'object',
+ properties: {
+ foo: { type: 'string' },
+ bar: { type: 'string' },
+ que: { type: 'string' },
+ baz: { type: 'string' }
+ },
+ dependencies: {
+ foo: ['bar', 'que', 'baz'],
+ bar: ['que'],
+ baz: ['foo']
+ }
+ })
+})
diff --git a/sdk/node_modules/@fastify/merge-json-schemas/test/dependent-required.test.js b/sdk/node_modules/@fastify/merge-json-schemas/test/dependent-required.test.js
new file mode 100644
index 00000000..7729b959
--- /dev/null
+++ b/sdk/node_modules/@fastify/merge-json-schemas/test/dependent-required.test.js
@@ -0,0 +1,75 @@
+'use strict'
+
+const assert = require('node:assert/strict')
+const { test } = require('node:test')
+const { mergeSchemas } = require('../index')
+const { defaultResolver } = require('./utils')
+
+test('should merge empty schema and dependentRequired keyword', () => {
+ const schema1 = {}
+ const schema2 = {
+ type: 'object',
+ properties: {
+ foo: { type: 'string' },
+ bar: { type: 'string' }
+ },
+ dependentRequired: {
+ foo: ['bar']
+ }
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ type: 'object',
+ properties: {
+ foo: { type: 'string' },
+ bar: { type: 'string' }
+ },
+ dependentRequired: {
+ foo: ['bar']
+ }
+ })
+})
+
+test('should merge two dependentRequired keyword schemas', () => {
+ const schema1 = {
+ type: 'object',
+ properties: {
+ foo: { type: 'string' },
+ bar: { type: 'string' },
+ que: { type: 'string' }
+ },
+ dependentRequired: {
+ foo: ['bar', 'que'],
+ bar: ['que']
+ }
+ }
+ const schema2 = {
+ type: 'object',
+ properties: {
+ foo: { type: 'string' },
+ bar: { type: 'string' },
+ baz: { type: 'string' }
+ },
+ dependentRequired: {
+ foo: ['baz'],
+ baz: ['foo']
+ }
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ type: 'object',
+ properties: {
+ foo: { type: 'string' },
+ bar: { type: 'string' },
+ que: { type: 'string' },
+ baz: { type: 'string' }
+ },
+ dependentRequired: {
+ foo: ['bar', 'que', 'baz'],
+ bar: ['que'],
+ baz: ['foo']
+ }
+ })
+})
diff --git a/sdk/node_modules/@fastify/merge-json-schemas/test/dependent-schemas.test.js b/sdk/node_modules/@fastify/merge-json-schemas/test/dependent-schemas.test.js
new file mode 100644
index 00000000..76e04353
--- /dev/null
+++ b/sdk/node_modules/@fastify/merge-json-schemas/test/dependent-schemas.test.js
@@ -0,0 +1,76 @@
+'use strict'
+
+const assert = require('node:assert/strict')
+const { test } = require('node:test')
+const { mergeSchemas } = require('../index')
+const { defaultResolver } = require('./utils')
+
+test('should merge empty schema and dependentRequired keyword', () => {
+ const schema1 = {}
+ const schema2 = {
+ type: 'object',
+ properties: {
+ foo: { type: 'string' },
+ bar: { type: 'string' }
+ },
+ dependentSchemas: {
+ foo: { required: ['bar'] }
+ }
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ type: 'object',
+ properties: {
+ foo: { type: 'string' },
+ bar: { type: 'string' }
+ },
+ dependentSchemas: {
+ foo: { required: ['bar'] }
+ }
+ })
+})
+
+test('should merge two dependentRequired keyword schemas', () => {
+ const schema1 = {
+ type: 'object',
+ properties: {
+ foo: { type: 'string' },
+ bar: { type: 'string' },
+ que: { type: 'string' }
+ },
+ dependentSchemas: {
+ foo: { required: ['bar', 'que'] },
+ bar: { required: ['que'] }
+ }
+ }
+
+ const schema2 = {
+ type: 'object',
+ properties: {
+ foo: { type: 'string' },
+ bar: { type: 'string' },
+ baz: { type: 'string' }
+ },
+ dependentSchemas: {
+ foo: { required: ['baz'] },
+ baz: { required: ['foo'] }
+ }
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ type: 'object',
+ properties: {
+ foo: { type: 'string' },
+ bar: { type: 'string' },
+ que: { type: 'string' },
+ baz: { type: 'string' }
+ },
+ dependentSchemas: {
+ foo: { required: ['bar', 'que', 'baz'] },
+ bar: { required: ['que'] },
+ baz: { required: ['foo'] }
+ }
+ })
+})
diff --git a/sdk/node_modules/@fastify/merge-json-schemas/test/enum.test.js b/sdk/node_modules/@fastify/merge-json-schemas/test/enum.test.js
new file mode 100644
index 00000000..8a0dd133
--- /dev/null
+++ b/sdk/node_modules/@fastify/merge-json-schemas/test/enum.test.js
@@ -0,0 +1,44 @@
+'use strict'
+
+const assert = require('node:assert/strict')
+const { test } = require('node:test')
+const { mergeSchemas } = require('../index')
+const { defaultResolver } = require('./utils')
+
+test('should merge empty schema and string enum values', () => {
+ const schema1 = { type: 'string' }
+ const schema2 = { type: 'string', enum: ['foo', 'bar'] }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'string', enum: ['foo', 'bar'] })
+})
+
+test('should merge equal string enum values', () => {
+ const schema1 = { type: 'string', enum: ['foo', 'bar'] }
+ const schema2 = { type: 'string', enum: ['foo', 'bar'] }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'string', enum: ['foo', 'bar'] })
+})
+
+test('should merge different string enum values', () => {
+ const schema1 = { type: 'string', enum: ['foo', 'bar'] }
+ const schema2 = { type: 'string', enum: ['foo', 'baz'] }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'string', enum: ['foo'] })
+})
+
+test('should throw an error if can not merge enum values', () => {
+ const schema1 = { type: 'string', enum: ['foo', 'bar'] }
+ const schema2 = { type: 'string', enum: ['baz', 'qux'] }
+
+ assert.throws(() => {
+ mergeSchemas([schema1, schema2], { defaultResolver })
+ }, {
+ name: 'JsonSchemaMergeError',
+ code: 'JSON_SCHEMA_MERGE_ERROR',
+ message: 'Failed to merge "enum" keyword schemas.',
+ schemas: [['foo', 'bar'], ['baz', 'qux']]
+ })
+})
diff --git a/sdk/node_modules/@fastify/merge-json-schemas/test/exclusive-maximum.test.js b/sdk/node_modules/@fastify/merge-json-schemas/test/exclusive-maximum.test.js
new file mode 100644
index 00000000..9481bb5f
--- /dev/null
+++ b/sdk/node_modules/@fastify/merge-json-schemas/test/exclusive-maximum.test.js
@@ -0,0 +1,30 @@
+'use strict'
+
+const assert = require('node:assert/strict')
+const { test } = require('node:test')
+const { mergeSchemas } = require('../index')
+const { defaultResolver } = require('./utils')
+
+test('should merge empty schema and exclusiveMaximum keyword', () => {
+ const schema1 = { type: 'number' }
+ const schema2 = { type: 'number', exclusiveMaximum: 42 }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'number', exclusiveMaximum: 42 })
+})
+
+test('should merge equal exclusiveMaximum values', () => {
+ const schema1 = { type: 'number', exclusiveMaximum: 42 }
+ const schema2 = { type: 'number', exclusiveMaximum: 42 }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'number', exclusiveMaximum: 42 })
+})
+
+test('should merge different exclusiveMaximum values', () => {
+ const schema1 = { type: 'integer', exclusiveMaximum: 42 }
+ const schema2 = { type: 'integer', exclusiveMaximum: 43 }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'integer', exclusiveMaximum: 42 })
+})
diff --git a/sdk/node_modules/@fastify/merge-json-schemas/test/exclusive-minimum.test.js b/sdk/node_modules/@fastify/merge-json-schemas/test/exclusive-minimum.test.js
new file mode 100644
index 00000000..d2de2581
--- /dev/null
+++ b/sdk/node_modules/@fastify/merge-json-schemas/test/exclusive-minimum.test.js
@@ -0,0 +1,30 @@
+'use strict'
+
+const assert = require('node:assert/strict')
+const { test } = require('node:test')
+const { mergeSchemas } = require('../index')
+const { defaultResolver } = require('./utils')
+
+test('should merge empty schema and exclusiveMinimum keyword', () => {
+ const schema1 = { type: 'number' }
+ const schema2 = { type: 'number', exclusiveMinimum: 42 }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'number', exclusiveMinimum: 42 })
+})
+
+test('should merge equal exclusiveMinimum values', () => {
+ const schema1 = { type: 'number', exclusiveMinimum: 42 }
+ const schema2 = { type: 'number', exclusiveMinimum: 42 }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'number', exclusiveMinimum: 42 })
+})
+
+test('should merge different exclusiveMinimum values', () => {
+ const schema1 = { type: 'integer', exclusiveMinimum: 42 }
+ const schema2 = { type: 'integer', exclusiveMinimum: 43 }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'integer', exclusiveMinimum: 43 })
+})
diff --git a/sdk/node_modules/@fastify/merge-json-schemas/test/format.test.js b/sdk/node_modules/@fastify/merge-json-schemas/test/format.test.js
new file mode 100644
index 00000000..e79e1c88
--- /dev/null
+++ b/sdk/node_modules/@fastify/merge-json-schemas/test/format.test.js
@@ -0,0 +1,36 @@
+'use strict'
+
+const assert = require('node:assert/strict')
+const { test } = require('node:test')
+const { mergeSchemas } = require('../index')
+const { defaultResolver } = require('./utils')
+
+test('should merge empty schema and string format keyword', () => {
+ const schema1 = { type: 'string' }
+ const schema2 = { type: 'string', format: 'date-time' }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'string', format: 'date-time' })
+})
+
+test('should merge equal string format keywords', () => {
+ const schema1 = { type: 'string', format: 'date-time' }
+ const schema2 = { type: 'string', format: 'date-time' }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'string', format: 'date-time' })
+})
+
+test('should throw an error if format keyword values are different', () => {
+ const schema1 = { type: 'string', format: 'date-time' }
+ const schema2 = { type: 'string', format: 'date' }
+
+ assert.throws(() => {
+ mergeSchemas([schema1, schema2], { defaultResolver })
+ }, {
+ name: 'JsonSchemaMergeError',
+ code: 'JSON_SCHEMA_MERGE_ERROR',
+ message: 'Failed to merge "format" keyword schemas.',
+ schemas: ['date-time', 'date']
+ })
+})
diff --git a/sdk/node_modules/@fastify/merge-json-schemas/test/id.test.js b/sdk/node_modules/@fastify/merge-json-schemas/test/id.test.js
new file mode 100644
index 00000000..9221738d
--- /dev/null
+++ b/sdk/node_modules/@fastify/merge-json-schemas/test/id.test.js
@@ -0,0 +1,22 @@
+'use strict'
+
+const assert = require('node:assert/strict')
+const { test } = require('node:test')
+const { mergeSchemas } = require('../index')
+const { defaultResolver } = require('./utils')
+
+test('should skip $id keyword if they are equal', () => {
+ const schema1 = { $id: 'foo', type: 'string' }
+ const schema2 = { $id: 'foo', type: 'string' }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'string' })
+})
+
+test('should skip $id keyword if they are different', () => {
+ const schema1 = { $id: 'foo', type: 'string' }
+ const schema2 = { $id: 'bar', type: 'string' }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'string' })
+})
diff --git a/sdk/node_modules/@fastify/merge-json-schemas/test/if-then-else.test.js b/sdk/node_modules/@fastify/merge-json-schemas/test/if-then-else.test.js
new file mode 100644
index 00000000..2135611a
--- /dev/null
+++ b/sdk/node_modules/@fastify/merge-json-schemas/test/if-then-else.test.js
@@ -0,0 +1,550 @@
+'use strict'
+
+const assert = require('node:assert/strict')
+const { test } = require('node:test')
+const { mergeSchemas } = require('../index')
+const { defaultResolver } = require('./utils')
+
+test('should merge empty schema and if/then/else keywords', () => {
+ const schema1 = {}
+ const schema2 = {
+ if: {
+ type: 'string',
+ const: 'foo'
+ },
+ then: {
+ type: 'string',
+ const: 'bar'
+ },
+ else: {
+ type: 'string',
+ const: 'baz'
+ }
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ if: {
+ type: 'string',
+ const: 'foo'
+ },
+ then: {
+ type: 'string',
+ const: 'bar'
+ },
+ else: {
+ type: 'string',
+ const: 'baz'
+ }
+ })
+})
+
+test('should merge if/then/else schema with an empty schema', () => {
+ const schema1 = {
+ if: {
+ type: 'string',
+ const: 'foo'
+ },
+ then: {
+ type: 'string',
+ const: 'bar'
+ },
+ else: {
+ type: 'string',
+ const: 'baz'
+ }
+ }
+ const schema2 = {}
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ if: {
+ type: 'string',
+ const: 'foo'
+ },
+ then: {
+ type: 'string',
+ const: 'bar'
+ },
+ else: {
+ type: 'string',
+ const: 'baz'
+ }
+ })
+})
+
+test('should merge two if/then/else schemas', () => {
+ const schema1 = {
+ type: 'object',
+ if: {
+ properties: {
+ foo1: { type: 'string', const: 'foo1' }
+ }
+ },
+ then: {
+ properties: {
+ bar1: { type: 'string', const: 'bar1' }
+ }
+ },
+ else: {
+ properties: {
+ baz1: { type: 'string', const: 'baz1' }
+ }
+ }
+ }
+ const schema2 = {
+ type: 'object',
+ if: {
+ properties: {
+ foo2: { type: 'string', const: 'foo2' }
+ }
+ },
+ then: {
+ properties: {
+ bar2: { type: 'string', const: 'bar2' }
+ }
+ },
+ else: {
+ properties: {
+ baz2: { type: 'string', const: 'baz2' }
+ }
+ }
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ type: 'object',
+ if: {
+ properties: {
+ foo1: { type: 'string', const: 'foo1' }
+ }
+ },
+ then: {
+ properties: {
+ bar1: { type: 'string', const: 'bar1' }
+ },
+ if: {
+ properties: {
+ foo2: { type: 'string', const: 'foo2' }
+ }
+ },
+ then: {
+ properties: {
+ bar2: { type: 'string', const: 'bar2' }
+ }
+ },
+ else: {
+ properties: {
+ baz2: { type: 'string', const: 'baz2' }
+ }
+ }
+ },
+ else: {
+ properties: {
+ baz1: { type: 'string', const: 'baz1' }
+ },
+ if: {
+ properties: {
+ foo2: { type: 'string', const: 'foo2' }
+ }
+ },
+ then: {
+ properties: {
+ bar2: { type: 'string', const: 'bar2' }
+ }
+ },
+ else: {
+ properties: {
+ baz2: { type: 'string', const: 'baz2' }
+ }
+ }
+ }
+ })
+})
+
+test('should merge three if/then/else schemas', () => {
+ const schema1 = {
+ type: 'object',
+ if: {
+ properties: {
+ foo1: { type: 'string', const: 'foo1' }
+ }
+ },
+ then: {
+ properties: {
+ bar1: { type: 'string', const: 'bar1' }
+ }
+ },
+ else: {
+ properties: {
+ baz1: { type: 'string', const: 'baz1' }
+ }
+ }
+ }
+ const schema2 = {
+ type: 'object',
+ if: {
+ properties: {
+ foo2: { type: 'string', const: 'foo2' }
+ }
+ },
+ then: {
+ properties: {
+ bar2: { type: 'string', const: 'bar2' }
+ }
+ },
+ else: {
+ properties: {
+ baz2: { type: 'string', const: 'baz2' }
+ }
+ }
+ }
+ const schema3 = {
+ type: 'object',
+ if: {
+ properties: {
+ foo3: { type: 'string', const: 'foo3' }
+ }
+ },
+ then: {
+ properties: {
+ bar3: { type: 'string', const: 'bar3' }
+ }
+ },
+ else: {
+ properties: {
+ baz3: { type: 'string', const: 'baz3' }
+ }
+ }
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2, schema3], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ type: 'object',
+ if: {
+ properties: {
+ foo1: { type: 'string', const: 'foo1' }
+ }
+ },
+ then: {
+ properties: {
+ bar1: { type: 'string', const: 'bar1' }
+ },
+ if: {
+ properties: {
+ foo2: { type: 'string', const: 'foo2' }
+ }
+ },
+ then: {
+ properties: {
+ bar2: { type: 'string', const: 'bar2' }
+ },
+ if: {
+ properties: {
+ foo3: { type: 'string', const: 'foo3' }
+ }
+ },
+ then: {
+ properties: {
+ bar3: { type: 'string', const: 'bar3' }
+ }
+ },
+ else: {
+ properties: {
+ baz3: { type: 'string', const: 'baz3' }
+ }
+ }
+ },
+ else: {
+ properties: {
+ baz2: { type: 'string', const: 'baz2' }
+ },
+ if: {
+ properties: {
+ foo3: { type: 'string', const: 'foo3' }
+ }
+ },
+ then: {
+ properties: {
+ bar3: { type: 'string', const: 'bar3' }
+ }
+ },
+ else: {
+ properties: {
+ baz3: { type: 'string', const: 'baz3' }
+ }
+ }
+ }
+ },
+ else: {
+ properties: {
+ baz1: { type: 'string', const: 'baz1' }
+ },
+ if: {
+ properties: {
+ foo2: { type: 'string', const: 'foo2' }
+ }
+ },
+ then: {
+ properties: {
+ bar2: { type: 'string', const: 'bar2' }
+ },
+ if: {
+ properties: {
+ foo3: { type: 'string', const: 'foo3' }
+ }
+ },
+ then: {
+ properties: {
+ bar3: { type: 'string', const: 'bar3' }
+ }
+ },
+ else: {
+ properties: {
+ baz3: { type: 'string', const: 'baz3' }
+ }
+ }
+ },
+ else: {
+ properties: {
+ baz2: { type: 'string', const: 'baz2' }
+ },
+ if: {
+ properties: {
+ foo3: { type: 'string', const: 'foo3' }
+ }
+ },
+ then: {
+ properties: {
+ bar3: { type: 'string', const: 'bar3' }
+ }
+ },
+ else: {
+ properties: {
+ baz3: { type: 'string', const: 'baz3' }
+ }
+ }
+ }
+ }
+ })
+})
+
+test('should two if/then keyword schemas', () => {
+ const schema1 = {
+ type: 'object',
+ if: {
+ properties: {
+ foo1: { type: 'string', const: 'foo1' }
+ }
+ },
+ then: {
+ properties: {
+ bar1: { type: 'string', const: 'bar1' }
+ }
+ }
+ }
+
+ const schema2 = {
+ type: 'object',
+ if: {
+ properties: {
+ foo2: { type: 'string', const: 'foo2' }
+ }
+ },
+ then: {
+ properties: {
+ bar2: { type: 'string', const: 'bar2' }
+ }
+ }
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ type: 'object',
+ if: {
+ properties: {
+ foo1: { type: 'string', const: 'foo1' }
+ }
+ },
+ then: {
+ properties: {
+ bar1: { type: 'string', const: 'bar1' }
+ },
+ if: {
+ properties: {
+ foo2: { type: 'string', const: 'foo2' }
+ }
+ },
+ then: {
+ properties: {
+ bar2: { type: 'string', const: 'bar2' }
+ }
+ }
+ }
+ })
+})
+
+test('should two if/else keyword schemas', () => {
+ const schema1 = {
+ type: 'object',
+ if: {
+ properties: {
+ foo1: { type: 'string', const: 'foo1' }
+ }
+ },
+ else: {
+ properties: {
+ bar1: { type: 'string', const: 'bar1' }
+ }
+ }
+ }
+
+ const schema2 = {
+ type: 'object',
+ if: {
+ properties: {
+ foo2: { type: 'string', const: 'foo2' }
+ }
+ },
+ else: {
+ properties: {
+ bar2: { type: 'string', const: 'bar2' }
+ }
+ }
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ type: 'object',
+ if: {
+ properties: {
+ foo1: { type: 'string', const: 'foo1' }
+ }
+ },
+ else: {
+ properties: {
+ bar1: { type: 'string', const: 'bar1' }
+ },
+ if: {
+ properties: {
+ foo2: { type: 'string', const: 'foo2' }
+ }
+ },
+ else: {
+ properties: {
+ bar2: { type: 'string', const: 'bar2' }
+ }
+ }
+ }
+ })
+})
+
+test('should two if/then and if/else keyword schemas', () => {
+ const schema1 = {
+ type: 'object',
+ if: {
+ properties: {
+ foo1: { type: 'string', const: 'foo1' }
+ }
+ },
+ then: {
+ properties: {
+ bar1: { type: 'string', const: 'bar1' }
+ }
+ }
+ }
+
+ const schema2 = {
+ type: 'object',
+ if: {
+ properties: {
+ foo2: { type: 'string', const: 'foo2' }
+ }
+ },
+ else: {
+ properties: {
+ bar2: { type: 'string', const: 'bar2' }
+ }
+ }
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ type: 'object',
+ if: {
+ properties: {
+ foo1: { type: 'string', const: 'foo1' }
+ }
+ },
+ then: {
+ properties: {
+ bar1: { type: 'string', const: 'bar1' }
+ },
+ if: {
+ properties: {
+ foo2: { type: 'string', const: 'foo2' }
+ }
+ },
+ else: {
+ properties: {
+ bar2: { type: 'string', const: 'bar2' }
+ }
+ }
+ }
+ })
+})
+
+test('should two if/else and if/then keyword schemas', () => {
+ const schema1 = {
+ type: 'object',
+ if: {
+ properties: {
+ foo1: { type: 'string', const: 'foo1' }
+ }
+ },
+ else: {
+ properties: {
+ bar1: { type: 'string', const: 'bar1' }
+ }
+ }
+ }
+
+ const schema2 = {
+ type: 'object',
+ if: {
+ properties: {
+ foo2: { type: 'string', const: 'foo2' }
+ }
+ },
+ then: {
+ properties: {
+ bar2: { type: 'string', const: 'bar2' }
+ }
+ }
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ type: 'object',
+ if: {
+ properties: {
+ foo1: { type: 'string', const: 'foo1' }
+ }
+ },
+ else: {
+ properties: {
+ bar1: { type: 'string', const: 'bar1' }
+ },
+ if: {
+ properties: {
+ foo2: { type: 'string', const: 'foo2' }
+ }
+ },
+ then: {
+ properties: {
+ bar2: { type: 'string', const: 'bar2' }
+ }
+ }
+ }
+ })
+})
diff --git a/sdk/node_modules/@fastify/merge-json-schemas/test/items.test.js b/sdk/node_modules/@fastify/merge-json-schemas/test/items.test.js
new file mode 100644
index 00000000..b7805303
--- /dev/null
+++ b/sdk/node_modules/@fastify/merge-json-schemas/test/items.test.js
@@ -0,0 +1,152 @@
+'use strict'
+
+const assert = require('node:assert/strict')
+const { test } = require('node:test')
+const { mergeSchemas } = require('../index')
+const { defaultResolver } = require('./utils')
+
+test('should merge empty schema and items keyword', () => {
+ const schema1 = { type: 'array' }
+ const schema2 = {
+ type: 'array',
+ items: {
+ type: 'object',
+ properties: {
+ foo: { type: 'string' }
+ }
+ }
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ type: 'array',
+ items: {
+ type: 'object',
+ properties: {
+ foo: { type: 'string' }
+ }
+ }
+ })
+})
+
+test('should merge two equal item schemas', () => {
+ const schema1 = {
+ type: 'array',
+ items: {
+ type: 'object',
+ properties: {
+ foo: { type: 'string' }
+ }
+ }
+ }
+
+ const schema2 = {
+ type: 'array',
+ items: {
+ type: 'object',
+ properties: {
+ foo: { type: 'string' }
+ }
+ }
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ type: 'array',
+ items: {
+ type: 'object',
+ properties: {
+ foo: { type: 'string' }
+ }
+ }
+ })
+})
+
+test('should merge two different sets of item schemas', () => {
+ const schema1 = {
+ type: 'array',
+ items: {
+ type: 'object',
+ properties: {
+ foo: { type: 'string' },
+ bar: { type: 'number' }
+ }
+ }
+ }
+
+ const schema2 = {
+ type: 'array',
+ items: {
+ type: 'object',
+ properties: {
+ foo: { type: 'string' },
+ baz: { type: 'boolean' }
+ }
+ }
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ type: 'array',
+ items: {
+ type: 'object',
+ properties: {
+ foo: { type: 'string' },
+ bar: { type: 'number' },
+ baz: { type: 'boolean' }
+ }
+ }
+ })
+})
+
+test('should merge two different sets of item schemas with additionalItems', () => {
+ const schema1 = {
+ type: 'array',
+ items: [
+ {
+ type: 'object',
+ properties: {
+ foo: { type: 'string', const: 'foo' }
+ }
+ }
+ ],
+ additionalItems: {
+ type: 'object',
+ properties: {
+ baz: { type: 'string', const: 'baz' }
+ }
+ }
+ }
+
+ const schema2 = {
+ type: 'array',
+ items: {
+ type: 'object',
+ properties: {
+ foo: { type: 'string' },
+ baz: { type: 'string' }
+ }
+ }
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ type: 'array',
+ items: [
+ {
+ type: 'object',
+ properties: {
+ foo: { type: 'string', const: 'foo' },
+ baz: { type: 'string' }
+ }
+ }
+ ],
+ additionalItems: {
+ type: 'object',
+ properties: {
+ foo: { type: 'string' },
+ baz: { type: 'string', const: 'baz' }
+ }
+ }
+ })
+})
diff --git a/sdk/node_modules/@fastify/merge-json-schemas/test/max-items.test.js b/sdk/node_modules/@fastify/merge-json-schemas/test/max-items.test.js
new file mode 100644
index 00000000..939cf299
--- /dev/null
+++ b/sdk/node_modules/@fastify/merge-json-schemas/test/max-items.test.js
@@ -0,0 +1,30 @@
+'use strict'
+
+const assert = require('node:assert/strict')
+const { test } = require('node:test')
+const { mergeSchemas } = require('../index')
+const { defaultResolver } = require('./utils')
+
+test('should merge empty schema and maxItems keyword', () => {
+ const schema1 = { type: 'array' }
+ const schema2 = { type: 'array', maxItems: 42 }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'array', maxItems: 42 })
+})
+
+test('should merge equal maxItems values', () => {
+ const schema1 = { type: 'array', maxItems: 42 }
+ const schema2 = { type: 'array', maxItems: 42 }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'array', maxItems: 42 })
+})
+
+test('should merge different maxItems values', () => {
+ const schema1 = { type: 'array', maxItems: 42 }
+ const schema2 = { type: 'array', maxItems: 43 }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'array', maxItems: 42 })
+})
diff --git a/sdk/node_modules/@fastify/merge-json-schemas/test/max-length.test.js b/sdk/node_modules/@fastify/merge-json-schemas/test/max-length.test.js
new file mode 100644
index 00000000..c97002fb
--- /dev/null
+++ b/sdk/node_modules/@fastify/merge-json-schemas/test/max-length.test.js
@@ -0,0 +1,30 @@
+'use strict'
+
+const assert = require('node:assert/strict')
+const { test } = require('node:test')
+const { mergeSchemas } = require('../index')
+const { defaultResolver } = require('./utils')
+
+test('should merge empty schema and maxLength keyword', () => {
+ const schema1 = { type: 'string' }
+ const schema2 = { type: 'string', maxLength: 42 }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'string', maxLength: 42 })
+})
+
+test('should merge equal maxLength values', () => {
+ const schema1 = { type: 'string', maxLength: 42 }
+ const schema2 = { type: 'string', maxLength: 42 }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'string', maxLength: 42 })
+})
+
+test('should merge different maxLength values', () => {
+ const schema1 = { type: 'string', maxLength: 42 }
+ const schema2 = { type: 'string', maxLength: 43 }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'string', maxLength: 42 })
+})
diff --git a/sdk/node_modules/@fastify/merge-json-schemas/test/max-properties.test.js b/sdk/node_modules/@fastify/merge-json-schemas/test/max-properties.test.js
new file mode 100644
index 00000000..b5b39496
--- /dev/null
+++ b/sdk/node_modules/@fastify/merge-json-schemas/test/max-properties.test.js
@@ -0,0 +1,30 @@
+'use strict'
+
+const assert = require('node:assert/strict')
+const { test } = require('node:test')
+const { mergeSchemas } = require('../index')
+const { defaultResolver } = require('./utils')
+
+test('should merge empty schema and maxProperties keyword', () => {
+ const schema1 = { type: 'object' }
+ const schema2 = { type: 'object', maxProperties: 42 }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'object', maxProperties: 42 })
+})
+
+test('should merge equal maxProperties values', () => {
+ const schema1 = { type: 'object', maxProperties: 42 }
+ const schema2 = { type: 'object', maxProperties: 42 }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'object', maxProperties: 42 })
+})
+
+test('should merge different maxProperties values', () => {
+ const schema1 = { type: 'object', maxProperties: 42 }
+ const schema2 = { type: 'object', maxProperties: 43 }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'object', maxProperties: 42 })
+})
diff --git a/sdk/node_modules/@fastify/merge-json-schemas/test/maximum.test.js b/sdk/node_modules/@fastify/merge-json-schemas/test/maximum.test.js
new file mode 100644
index 00000000..4a0c982f
--- /dev/null
+++ b/sdk/node_modules/@fastify/merge-json-schemas/test/maximum.test.js
@@ -0,0 +1,30 @@
+'use strict'
+
+const assert = require('node:assert/strict')
+const { test } = require('node:test')
+const { mergeSchemas } = require('../index')
+const { defaultResolver } = require('./utils')
+
+test('should merge empty schema and maximum keyword', () => {
+ const schema1 = { type: 'number' }
+ const schema2 = { type: 'number', maximum: 42 }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'number', maximum: 42 })
+})
+
+test('should merge equal maximum values', () => {
+ const schema1 = { type: 'number', maximum: 42 }
+ const schema2 = { type: 'number', maximum: 42 }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'number', maximum: 42 })
+})
+
+test('should merge different maximum values', () => {
+ const schema1 = { type: 'integer', maximum: 42 }
+ const schema2 = { type: 'integer', maximum: 43 }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'integer', maximum: 42 })
+})
diff --git a/sdk/node_modules/@fastify/merge-json-schemas/test/merge-schema.test.js b/sdk/node_modules/@fastify/merge-json-schemas/test/merge-schema.test.js
new file mode 100644
index 00000000..a41c3a98
--- /dev/null
+++ b/sdk/node_modules/@fastify/merge-json-schemas/test/merge-schema.test.js
@@ -0,0 +1,29 @@
+'use strict'
+
+const assert = require('node:assert/strict')
+const { test } = require('node:test')
+const { mergeSchemas } = require('../index')
+const { defaultResolver } = require('./utils')
+
+test('should return an empty schema if passing an empty array', () => {
+ const mergedSchema = mergeSchemas([], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {})
+})
+
+test('should return true if passing all true values', () => {
+ const mergedSchema = mergeSchemas([true, true, true], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, true)
+})
+
+test('should return true if passing all false values', () => {
+ const mergedSchema = mergeSchemas([false, false, false], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, false)
+})
+
+test('should return true if passing at least one false schema', () => {
+ const schema1 = { type: 'string' }
+ const schema2 = { type: 'number' }
+
+ const mergedSchema = mergeSchemas([schema1, schema2, false], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, false)
+})
diff --git a/sdk/node_modules/@fastify/merge-json-schemas/test/min-items.test.js b/sdk/node_modules/@fastify/merge-json-schemas/test/min-items.test.js
new file mode 100644
index 00000000..b5d50735
--- /dev/null
+++ b/sdk/node_modules/@fastify/merge-json-schemas/test/min-items.test.js
@@ -0,0 +1,30 @@
+'use strict'
+
+const assert = require('node:assert/strict')
+const { test } = require('node:test')
+const { mergeSchemas } = require('../index')
+const { defaultResolver } = require('./utils')
+
+test('should merge empty schema and minItems keyword', () => {
+ const schema1 = { type: 'array' }
+ const schema2 = { type: 'array', minItems: 42 }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'array', minItems: 42 })
+})
+
+test('should merge equal minItems values', () => {
+ const schema1 = { type: 'array', minItems: 42 }
+ const schema2 = { type: 'array', minItems: 42 }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'array', minItems: 42 })
+})
+
+test('should merge different minItems values', () => {
+ const schema1 = { type: 'array', minItems: 42 }
+ const schema2 = { type: 'array', minItems: 43 }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'array', minItems: 43 })
+})
diff --git a/sdk/node_modules/@fastify/merge-json-schemas/test/min-length.test.js b/sdk/node_modules/@fastify/merge-json-schemas/test/min-length.test.js
new file mode 100644
index 00000000..64a2c445
--- /dev/null
+++ b/sdk/node_modules/@fastify/merge-json-schemas/test/min-length.test.js
@@ -0,0 +1,30 @@
+'use strict'
+
+const assert = require('node:assert/strict')
+const { test } = require('node:test')
+const { mergeSchemas } = require('../index')
+const { defaultResolver } = require('./utils')
+
+test('should merge empty schema and minLength keyword', () => {
+ const schema1 = { type: 'string' }
+ const schema2 = { type: 'string', minLength: 42 }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'string', minLength: 42 })
+})
+
+test('should merge equal minLength values', () => {
+ const schema1 = { type: 'string', minLength: 42 }
+ const schema2 = { type: 'string', minLength: 42 }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'string', minLength: 42 })
+})
+
+test('should merge different minLength values', () => {
+ const schema1 = { type: 'string', minLength: 42 }
+ const schema2 = { type: 'string', minLength: 43 }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'string', minLength: 43 })
+})
diff --git a/sdk/node_modules/@fastify/merge-json-schemas/test/min-properties.test.js b/sdk/node_modules/@fastify/merge-json-schemas/test/min-properties.test.js
new file mode 100644
index 00000000..bfe4599b
--- /dev/null
+++ b/sdk/node_modules/@fastify/merge-json-schemas/test/min-properties.test.js
@@ -0,0 +1,30 @@
+'use strict'
+
+const assert = require('node:assert/strict')
+const { test } = require('node:test')
+const { mergeSchemas } = require('../index')
+const { defaultResolver } = require('./utils')
+
+test('should merge empty schema and minProperties keyword', () => {
+ const schema1 = { type: 'object' }
+ const schema2 = { type: 'object', minProperties: 42 }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'object', minProperties: 42 })
+})
+
+test('should merge equal minItems values', () => {
+ const schema1 = { type: 'object', minProperties: 42 }
+ const schema2 = { type: 'object', minProperties: 42 }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'object', minProperties: 42 })
+})
+
+test('should merge different minItems values', () => {
+ const schema1 = { type: 'object', minProperties: 42 }
+ const schema2 = { type: 'object', minProperties: 43 }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'object', minProperties: 43 })
+})
diff --git a/sdk/node_modules/@fastify/merge-json-schemas/test/minimum.test.js b/sdk/node_modules/@fastify/merge-json-schemas/test/minimum.test.js
new file mode 100644
index 00000000..f0dd105a
--- /dev/null
+++ b/sdk/node_modules/@fastify/merge-json-schemas/test/minimum.test.js
@@ -0,0 +1,30 @@
+'use strict'
+
+const assert = require('node:assert/strict')
+const { test } = require('node:test')
+const { mergeSchemas } = require('../index')
+const { defaultResolver } = require('./utils')
+
+test('should merge empty schema and minimum keyword', () => {
+ const schema1 = { type: 'number' }
+ const schema2 = { type: 'number', minimum: 42 }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'number', minimum: 42 })
+})
+
+test('should merge equal minimum values', () => {
+ const schema1 = { type: 'number', minimum: 42 }
+ const schema2 = { type: 'number', minimum: 42 }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'number', minimum: 42 })
+})
+
+test('should merge different minimum values', () => {
+ const schema1 = { type: 'integer', minimum: 42 }
+ const schema2 = { type: 'integer', minimum: 43 }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'integer', minimum: 43 })
+})
diff --git a/sdk/node_modules/@fastify/merge-json-schemas/test/multiple-of.test.js b/sdk/node_modules/@fastify/merge-json-schemas/test/multiple-of.test.js
new file mode 100644
index 00000000..f07a32bc
--- /dev/null
+++ b/sdk/node_modules/@fastify/merge-json-schemas/test/multiple-of.test.js
@@ -0,0 +1,36 @@
+'use strict'
+
+const assert = require('node:assert/strict')
+const { test } = require('node:test')
+const { mergeSchemas } = require('../index')
+const { defaultResolver } = require('./utils')
+
+test('should merge empty schema and multipleOf keyword', () => {
+ const schema1 = { type: 'number' }
+ const schema2 = { type: 'number', multipleOf: 42 }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'number', multipleOf: 42 })
+})
+
+test('should merge two schemas with multipleOf keywords', () => {
+ const schema1 = { type: 'number', multipleOf: 2 }
+ const schema2 = { type: 'number', multipleOf: 3 }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'number', multipleOf: 6 })
+})
+
+test('should merge multiple schemas with float multipleOf keywords', () => {
+ const schema1 = { type: 'number', multipleOf: 0.2 }
+ const schema2 = { type: 'number', multipleOf: 2 }
+ const schema3 = { type: 'number', multipleOf: 2 }
+ const schema4 = { type: 'number', multipleOf: 0.5 }
+ const schema5 = { type: 'number', multipleOf: 1.5 }
+
+ const mergedSchema = mergeSchemas(
+ [schema1, schema2, schema3, schema4, schema5],
+ { defaultResolver }
+ )
+ assert.deepStrictEqual(mergedSchema, { type: 'number', multipleOf: 6 })
+})
diff --git a/sdk/node_modules/@fastify/merge-json-schemas/test/not.test.js b/sdk/node_modules/@fastify/merge-json-schemas/test/not.test.js
new file mode 100644
index 00000000..e73131d4
--- /dev/null
+++ b/sdk/node_modules/@fastify/merge-json-schemas/test/not.test.js
@@ -0,0 +1,29 @@
+'use strict'
+
+const assert = require('node:assert/strict')
+const { test } = require('node:test')
+const { mergeSchemas } = require('../index')
+const { defaultResolver } = require('./utils')
+
+test('should merge two "not" keyword schemas', () => {
+ const schema1 = {
+ type: 'array',
+ not: {
+ type: 'string'
+ }
+ }
+ const schema2 = {
+ type: 'array',
+ not: {
+ type: 'string', minLength: 1
+ }
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ type: 'array',
+ not: {
+ type: 'string', minLength: 1
+ }
+ })
+})
diff --git a/sdk/node_modules/@fastify/merge-json-schemas/test/nullable.test.js b/sdk/node_modules/@fastify/merge-json-schemas/test/nullable.test.js
new file mode 100644
index 00000000..ef5fcfd8
--- /dev/null
+++ b/sdk/node_modules/@fastify/merge-json-schemas/test/nullable.test.js
@@ -0,0 +1,30 @@
+'use strict'
+
+const assert = require('node:assert/strict')
+const { test } = require('node:test')
+const { mergeSchemas } = require('../index')
+const { defaultResolver } = require('./utils')
+
+test('should merge empty schema and nullable = true keyword', () => {
+ const schema1 = { type: 'string' }
+ const schema2 = { type: 'string', nullable: true }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'string', nullable: true })
+})
+
+test('should merge empty schema and nullable = false keyword', () => {
+ const schema1 = { type: 'string' }
+ const schema2 = { type: 'string', nullable: false }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'string', nullable: false })
+})
+
+test('should merge schemas with nullable true and false values', () => {
+ const schema1 = { type: 'string', nullable: false }
+ const schema2 = { type: 'string', nullable: true }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'string', nullable: false })
+})
diff --git a/sdk/node_modules/@fastify/merge-json-schemas/test/one-of.test.js b/sdk/node_modules/@fastify/merge-json-schemas/test/one-of.test.js
new file mode 100644
index 00000000..94eab45a
--- /dev/null
+++ b/sdk/node_modules/@fastify/merge-json-schemas/test/one-of.test.js
@@ -0,0 +1,144 @@
+'use strict'
+
+const assert = require('node:assert/strict')
+const { test } = require('node:test')
+const { mergeSchemas, MergeError } = require('../index')
+const { defaultResolver } = require('./utils')
+
+test('should merge empty schema and oneOf keyword', () => {
+ const schema1 = {}
+ const schema2 = {
+ oneOf: [
+ { type: 'string', const: 'foo' }
+ ]
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ oneOf: [
+ { type: 'string', const: 'foo' }
+ ]
+ })
+})
+
+test('should merge two schemas with oneOfs schemas', () => {
+ const schema1 = {
+ oneOf: [
+ { type: 'string', enum: ['foo1', 'foo2', 'foo3'] },
+ { type: 'string', enum: ['foo3', 'foo4', 'foo5'] }
+ ]
+ }
+ const schema2 = {
+ oneOf: [
+ { type: 'string', enum: ['foo2', 'foo3', 'foo4'] },
+ { type: 'string', enum: ['foo3', 'foo6', 'foo7'] }
+ ]
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ oneOf: [
+ { type: 'string', enum: ['foo2', 'foo3'] },
+ { type: 'string', enum: ['foo3'] },
+ { type: 'string', enum: ['foo3', 'foo4'] },
+ { type: 'string', enum: ['foo3'] }
+ ]
+ })
+})
+
+test('should merge three schemas with oneOfs schemas', () => {
+ const schema1 = {
+ oneOf: [
+ { type: 'string', enum: ['foo1', 'foo2', 'foo3', 'foo4'] },
+ { type: 'string', enum: ['foo3', 'foo4', 'foo5', 'foo7'] }
+ ]
+ }
+ const schema2 = {
+ oneOf: [
+ { type: 'string', enum: ['foo2', 'foo3', 'foo4', 'foo5'] },
+ { type: 'string', enum: ['foo3', 'foo6', 'foo7', 'foo8'] }
+ ]
+ }
+
+ const schema3 = {
+ oneOf: [
+ { type: 'string', enum: ['foo1', 'foo3', 'foo5', 'foo7'] },
+ { type: 'string', enum: ['foo2', 'foo4', 'foo6', 'foo8'] }
+ ]
+ }
+
+ const mergedSchema = mergeSchemas(
+ [schema1, schema2, schema3],
+ { defaultResolver }
+ )
+ assert.deepStrictEqual(mergedSchema, {
+ oneOf: [
+ { type: 'string', enum: ['foo3'] },
+ { type: 'string', enum: ['foo2', 'foo4'] },
+ { type: 'string', enum: ['foo3'] },
+ { type: 'string', enum: ['foo3', 'foo5'] },
+ { type: 'string', enum: ['foo4'] },
+ { type: 'string', enum: ['foo3', 'foo7'] }
+ ]
+ })
+})
+
+test('should throw a non MergeError error during oneOf merge', () => {
+ const schema1 = {
+ oneOf: [
+ { type: 'string', customKeyword: 42 },
+ { type: 'string', customKeyword: 43 }
+ ]
+ }
+ const schema2 = {
+ oneOf: [
+ { type: 'string', customKeyword: 44 },
+ { type: 'string', customKeyword: 45 }
+ ]
+ }
+
+ assert.throws(() => {
+ mergeSchemas(
+ [schema1, schema2],
+ {
+ resolvers: {
+ customKeyword: () => {
+ throw new Error('Custom error')
+ }
+ },
+ defaultResolver
+ }
+ )
+ }, {
+ name: 'Error',
+ message: 'Custom error'
+ })
+})
+
+test('should not throw a MergeError error during oneOf merge', () => {
+ const schema1 = {
+ oneOf: [
+ { type: 'string', customKeyword: 42 },
+ { type: 'string', customKeyword: 43 }
+ ]
+ }
+ const schema2 = {
+ oneOf: [
+ { type: 'string', customKeyword: 44 },
+ { type: 'string', customKeyword: 45 }
+ ]
+ }
+
+ const mergedSchema = mergeSchemas(
+ [schema1, schema2],
+ {
+ resolvers: {
+ customKeyword: (keyword, values) => {
+ throw new MergeError(keyword, values)
+ }
+ },
+ defaultResolver
+ }
+ )
+ assert.deepStrictEqual(mergedSchema, { oneOf: [] })
+})
diff --git a/sdk/node_modules/@fastify/merge-json-schemas/test/properties.test.js b/sdk/node_modules/@fastify/merge-json-schemas/test/properties.test.js
new file mode 100644
index 00000000..6e26492d
--- /dev/null
+++ b/sdk/node_modules/@fastify/merge-json-schemas/test/properties.test.js
@@ -0,0 +1,312 @@
+'use strict'
+
+const assert = require('node:assert/strict')
+const { test } = require('node:test')
+const { mergeSchemas } = require('../index')
+const { defaultResolver } = require('./utils')
+
+test('should merge empty schema and properties keyword', () => {
+ const schema1 = { type: 'object' }
+ const schema2 = {
+ type: 'object',
+ properties: {
+ foo: { type: 'string' }
+ }
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ type: 'object',
+ properties: {
+ foo: { type: 'string' }
+ }
+ })
+})
+
+test('should merge two equal property schemas', () => {
+ const schema1 = {
+ type: 'object',
+ properties: {
+ foo: { type: 'string' }
+ }
+ }
+
+ const schema2 = {
+ type: 'object',
+ properties: {
+ foo: { type: 'string' }
+ }
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ type: 'object',
+ properties: {
+ foo: { type: 'string' }
+ }
+ })
+})
+
+test('should merge two different sets of property schemas', () => {
+ const schema1 = {
+ type: 'object',
+ properties: {
+ foo: { type: 'string' },
+ bar: { type: 'number' }
+ }
+ }
+
+ const schema2 = {
+ type: 'object',
+ properties: {
+ foo: { type: 'string' },
+ baz: { type: 'boolean' }
+ }
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ type: 'object',
+ properties: {
+ foo: { type: 'string' },
+ bar: { type: 'number' },
+ baz: { type: 'boolean' }
+ }
+ })
+})
+
+test('should merge property with different schemas', () => {
+ const schema1 = {
+ type: 'object',
+ properties: {
+ foo: {
+ type: ['string', 'number'],
+ enum: ['42', 2, 3]
+ }
+ }
+ }
+
+ const schema2 = {
+ type: 'object',
+ properties: {
+ foo: {
+ type: ['number', 'null'],
+ enum: [1, 2, 3, null]
+ }
+ }
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ type: 'object',
+ properties: {
+ foo: { type: 'number', enum: [2, 3] }
+ }
+ })
+})
+
+test('should merge properties if one schema has additionalProperties = false', () => {
+ const schema1 = {
+ type: 'object',
+ properties: {
+ foo: { type: 'string' },
+ bar: { type: 'number' }
+ },
+ additionalProperties: false
+ }
+
+ const schema2 = {
+ type: 'object',
+ properties: {
+ foo: { type: 'string', enum: ['42'] },
+ baz: { type: 'string' }
+ }
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ type: 'object',
+ properties: {
+ foo: { type: 'string', enum: ['42'] },
+ bar: { type: 'number' },
+ baz: false
+ },
+ additionalProperties: false
+ })
+})
+
+test('should merge properties if both schemas have additionalProperties = false', () => {
+ const schema1 = {
+ type: 'object',
+ properties: {
+ foo: { type: 'string' },
+ bar: { type: 'number' }
+ },
+ additionalProperties: false
+ }
+
+ const schema2 = {
+ type: 'object',
+ properties: {
+ foo: { type: 'string', enum: ['42'] },
+ baz: { type: 'string' }
+ },
+ additionalProperties: false
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ type: 'object',
+ properties: {
+ foo: { type: 'string', enum: ['42'] },
+ bar: false,
+ baz: false
+ },
+ additionalProperties: false
+ })
+})
+
+test('should merge properties if one schema has additionalProperties schema', () => {
+ const schema1 = {
+ type: 'object',
+ properties: {
+ foo: { type: 'string' },
+ bar: { type: 'number' }
+ },
+ additionalProperties: { type: 'string', enum: ['43'] }
+ }
+
+ const schema2 = {
+ type: 'object',
+ properties: {
+ foo: { type: 'string', enum: ['42'] },
+ baz: { type: 'string' }
+ }
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ type: 'object',
+ properties: {
+ foo: { type: 'string', enum: ['42'] },
+ bar: { type: 'number' },
+ baz: { type: 'string', enum: ['43'] }
+ },
+ additionalProperties: { type: 'string', enum: ['43'] }
+ })
+})
+
+test('should merge properties if both schemas have additionalProperties schemas', () => {
+ const schema1 = {
+ type: 'object',
+ properties: {
+ foo: { type: 'string' },
+ bar: { type: 'number' }
+ },
+ additionalProperties: {
+ type: ['string', 'number', 'null'],
+ enum: ['45', '43', 41, null]
+ }
+ }
+
+ const schema2 = {
+ type: 'object',
+ properties: {
+ foo: { type: 'string', enum: ['42'] },
+ baz: { type: 'string' }
+ },
+ additionalProperties: {
+ type: ['string', 'boolean', 'number'],
+ enum: ['44', '43', true, 41]
+ }
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ type: 'object',
+ properties: {
+ foo: { type: 'string', enum: ['42'] },
+ bar: { type: 'number', enum: ['44', '43', true, 41] },
+ baz: { type: 'string', enum: ['45', '43', 41, null] }
+ },
+ additionalProperties: { type: ['string', 'number'], enum: ['43', 41] }
+ })
+})
+
+test('should merge properties if one schema has patternProperties schema', () => {
+ const schema1 = {
+ type: 'object',
+ properties: {
+ foo: { type: 'string' },
+ bar: { type: 'number' }
+ },
+ patternProperties: {
+ '^baz$': { type: 'string', enum: ['43'] }
+ }
+ }
+
+ const schema2 = {
+ type: 'object',
+ properties: {
+ foo: { type: 'string', enum: ['42'] },
+ baz: { type: 'string' },
+ qux: { type: 'string' }
+ }
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ type: 'object',
+ properties: {
+ foo: { type: 'string', enum: ['42'] },
+ bar: { type: 'number' },
+ baz: { type: 'string', enum: ['43'] },
+ qux: { type: 'string' }
+ },
+ patternProperties: {
+ '^baz$': { type: 'string', enum: ['43'] }
+ }
+ })
+})
+
+test('should merge properties if both schemas have patternProperties schemas', () => {
+ const schema1 = {
+ type: 'object',
+ properties: {
+ foo: { type: 'string' },
+ bar: { type: 'number' },
+ bak: { type: 'number' }
+ },
+ patternProperties: {
+ '^baz$': { type: 'string', enum: ['43'] }
+ }
+ }
+
+ const schema2 = {
+ type: 'object',
+ properties: {
+ foo: { type: 'string', enum: ['42'] },
+ baz: { type: 'string' },
+ qux: { type: 'string' }
+ },
+ patternProperties: {
+ '^bar$': { type: 'number', minimum: 2 }
+ }
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ type: 'object',
+ properties: {
+ foo: { type: 'string', enum: ['42'] },
+ bar: { type: 'number', minimum: 2 },
+ bak: { type: 'number' },
+ baz: { type: 'string', enum: ['43'] },
+ qux: { type: 'string' }
+ },
+ patternProperties: {
+ '^bar$': { type: 'number', minimum: 2 },
+ '^baz$': { type: 'string', enum: ['43'] }
+ }
+ })
+})
diff --git a/sdk/node_modules/@fastify/merge-json-schemas/test/property-names.test.js b/sdk/node_modules/@fastify/merge-json-schemas/test/property-names.test.js
new file mode 100644
index 00000000..9f27572a
--- /dev/null
+++ b/sdk/node_modules/@fastify/merge-json-schemas/test/property-names.test.js
@@ -0,0 +1,49 @@
+'use strict'
+
+const assert = require('node:assert/strict')
+const { test } = require('node:test')
+const { mergeSchemas } = require('../index')
+const { defaultResolver } = require('./utils')
+
+test('should merge empty schema and propertyNames keyword', () => {
+ const schema1 = {}
+ const schema2 = {
+ type: 'object',
+ propertyNames: {
+ pattern: '^[a-zA-Z]+$',
+ minLength: 42
+ }
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ type: 'object',
+ propertyNames: {
+ pattern: '^[a-zA-Z]+$',
+ minLength: 42
+ }
+ })
+})
+
+test('should merge two propertyNames keyword schemas', () => {
+ const schema1 = {
+ type: 'object',
+ propertyNames: {
+ minLength: 42
+ }
+ }
+ const schema2 = {
+ type: 'object',
+ propertyNames: {
+ minLength: 43
+ }
+ }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, {
+ type: 'object',
+ propertyNames: {
+ minLength: 43
+ }
+ })
+})
diff --git a/sdk/node_modules/@fastify/merge-json-schemas/test/required.test.js b/sdk/node_modules/@fastify/merge-json-schemas/test/required.test.js
new file mode 100644
index 00000000..3afa392f
--- /dev/null
+++ b/sdk/node_modules/@fastify/merge-json-schemas/test/required.test.js
@@ -0,0 +1,30 @@
+'use strict'
+
+const assert = require('node:assert/strict')
+const { test } = require('node:test')
+const { mergeSchemas } = require('../index')
+const { defaultResolver } = require('./utils')
+
+test('should merge empty schema and required keyword', () => {
+ const schema1 = { type: 'object' }
+ const schema2 = { type: 'object', required: ['foo'] }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'object', required: ['foo'] })
+})
+
+test('should merge two equal required keywords', () => {
+ const schema1 = { type: 'object', required: ['foo'] }
+ const schema2 = { type: 'object', required: ['foo'] }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'object', required: ['foo'] })
+})
+
+test('should merge two different required keywords', () => {
+ const schema1 = { type: 'object', required: ['foo', 'bar'] }
+ const schema2 = { type: 'object', required: ['foo', 'baz'] }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'object', required: ['foo', 'bar', 'baz'] })
+})
diff --git a/sdk/node_modules/@fastify/merge-json-schemas/test/type.test.js b/sdk/node_modules/@fastify/merge-json-schemas/test/type.test.js
new file mode 100644
index 00000000..69c0861a
--- /dev/null
+++ b/sdk/node_modules/@fastify/merge-json-schemas/test/type.test.js
@@ -0,0 +1,52 @@
+'use strict'
+
+const assert = require('node:assert/strict')
+const { test } = require('node:test')
+const { mergeSchemas } = require('../index')
+const { defaultResolver } = require('./utils')
+
+test('should merge equal type values', () => {
+ const schema1 = { type: 'string' }
+ const schema2 = { type: 'string' }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'string' })
+})
+
+test('should merge array type values', () => {
+ const schema1 = { type: ['string', 'number'] }
+ const schema2 = { type: ['null', 'string'] }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'string' })
+})
+
+test('should merge array type values', () => {
+ const schema1 = { type: ['string', 'number'] }
+ const schema2 = { type: 'string' }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'string' })
+})
+
+test('should merge array type values', () => {
+ const schema1 = { type: ['number', 'string', 'boolean'] }
+ const schema2 = { type: ['string', 'number', 'null'] }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: ['number', 'string'] })
+})
+
+test('should throw an error if can not merge type values', () => {
+ const schema1 = { type: 'string' }
+ const schema2 = { type: 'number' }
+
+ assert.throws(() => {
+ mergeSchemas([schema1, schema2], { defaultResolver })
+ }, {
+ name: 'JsonSchemaMergeError',
+ code: 'JSON_SCHEMA_MERGE_ERROR',
+ message: 'Failed to merge "type" keyword schemas.',
+ schemas: [['string'], ['number']]
+ })
+})
diff --git a/sdk/node_modules/@fastify/merge-json-schemas/test/unique-items.test.js b/sdk/node_modules/@fastify/merge-json-schemas/test/unique-items.test.js
new file mode 100644
index 00000000..61a55e80
--- /dev/null
+++ b/sdk/node_modules/@fastify/merge-json-schemas/test/unique-items.test.js
@@ -0,0 +1,38 @@
+'use strict'
+
+const assert = require('node:assert/strict')
+const { test } = require('node:test')
+const { mergeSchemas } = require('../index')
+const { defaultResolver } = require('./utils')
+
+test('should merge empty schema and uniqueItems keyword', () => {
+ const schema1 = { type: 'array' }
+ const schema2 = { type: 'array', uniqueItems: true }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'array', uniqueItems: true })
+})
+
+test('should merge two equal uniqueItems keyword schemas = true', () => {
+ const schema1 = { type: 'array', uniqueItems: true }
+ const schema2 = { type: 'array', uniqueItems: true }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'array', uniqueItems: true })
+})
+
+test('should merge two equal uniqueItems keyword schemas = false', () => {
+ const schema1 = { type: 'array', uniqueItems: false }
+ const schema2 = { type: 'array', uniqueItems: false }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'array', uniqueItems: false })
+})
+
+test('should merge two equal uniqueItems keyword schemas', () => {
+ const schema1 = { type: 'array', uniqueItems: false }
+ const schema2 = { type: 'array', uniqueItems: true }
+
+ const mergedSchema = mergeSchemas([schema1, schema2], { defaultResolver })
+ assert.deepStrictEqual(mergedSchema, { type: 'array', uniqueItems: true })
+})
diff --git a/sdk/node_modules/@fastify/merge-json-schemas/test/utils.js b/sdk/node_modules/@fastify/merge-json-schemas/test/utils.js
new file mode 100644
index 00000000..956ba245
--- /dev/null
+++ b/sdk/node_modules/@fastify/merge-json-schemas/test/utils.js
@@ -0,0 +1,9 @@
+'use strict'
+
+function defaultResolver () {
+ throw new Error('Default resolver should not be called.')
+}
+
+module.exports = {
+ defaultResolver
+}
diff --git a/sdk/node_modules/@fastify/merge-json-schemas/types/index.d.ts b/sdk/node_modules/@fastify/merge-json-schemas/types/index.d.ts
new file mode 100644
index 00000000..c2dd06c5
--- /dev/null
+++ b/sdk/node_modules/@fastify/merge-json-schemas/types/index.d.ts
@@ -0,0 +1,62 @@
+export type KeywordResolver = (
+ keyword: string,
+ keywordValues: any[],
+ mergedSchema: any,
+ parentSchemas: any[],
+ options: MergeOptions
+) => any
+
+export type KeywordResolvers = {
+ $id: KeywordResolver,
+ type: KeywordResolver,
+ enum: KeywordResolver,
+ minLength: KeywordResolver,
+ maxLength: KeywordResolver,
+ minimum: KeywordResolver,
+ maximum: KeywordResolver,
+ multipleOf: KeywordResolver,
+ exclusiveMinimum: KeywordResolver,
+ exclusiveMaximum: KeywordResolver,
+ minItems: KeywordResolver,
+ maxItems: KeywordResolver,
+ maxProperties: KeywordResolver,
+ minProperties: KeywordResolver,
+ const: KeywordResolver,
+ default: KeywordResolver,
+ format: KeywordResolver,
+ required: KeywordResolver,
+ properties: KeywordResolver,
+ patternProperties: KeywordResolver,
+ additionalProperties: KeywordResolver,
+ items: KeywordResolver,
+ additionalItems: KeywordResolver,
+ definitions: KeywordResolver,
+ $defs: KeywordResolver,
+ nullable: KeywordResolver,
+ oneOf: KeywordResolver,
+ anyOf: KeywordResolver,
+ allOf: KeywordResolver,
+ not: KeywordResolver,
+ if: KeywordResolver,
+ then: KeywordResolver,
+ else: KeywordResolver,
+ dependencies: KeywordResolver,
+ dependentRequired: KeywordResolver,
+ dependentSchemas: KeywordResolver,
+ propertyNames: KeywordResolver,
+ uniqueItems: KeywordResolver,
+ contains: KeywordResolver
+}
+
+export type MergeOptions = {
+ defaultResolver?: KeywordResolver,
+ resolvers?: Partial,
+ // enum of ["throw", "skip", "first"]
+ onConflict?: "throw" | "skip" | "first"
+}
+
+export function mergeSchemas(schemas: any[], options?: MergeOptions): any;
+
+export const keywordsResolvers: KeywordResolvers
+export const defaultResolver: KeywordResolver
+
diff --git a/sdk/node_modules/@fastify/merge-json-schemas/types/index.test-d.ts b/sdk/node_modules/@fastify/merge-json-schemas/types/index.test-d.ts
new file mode 100644
index 00000000..7d82a148
--- /dev/null
+++ b/sdk/node_modules/@fastify/merge-json-schemas/types/index.test-d.ts
@@ -0,0 +1,52 @@
+import { mergeSchemas, MergeOptions } from '..'
+import { expectType } from 'tsd'
+
+{
+ const schema1 = { type: 'string', enum: ['foo', 'bar'] }
+ const schema2 = { type: 'string', enum: ['foo', 'baz'] }
+
+ mergeSchemas([schema1, schema2])
+}
+
+{
+ const schema1 = { type: 'string', enum: ['foo', 'bar'] }
+ const schema2 = { type: 'string', enum: ['foo', 'baz'] }
+
+ const mergeOptions: MergeOptions = {
+ resolvers: {
+ enum: (
+ keyword: string,
+ keywordValues: any[],
+ mergedSchema: any,
+ parentSchemas: any[],
+ options: MergeOptions
+ ) => {
+ expectType(keyword)
+ expectType(keywordValues)
+ expectType(mergedSchema)
+ expectType(parentSchemas)
+ expectType(options)
+
+ return keywordValues
+ }
+ },
+ defaultResolver: (
+ keyword: string,
+ keywordValues: any[],
+ mergedSchema: any,
+ parentSchemas: any[],
+ options: MergeOptions
+ ) => {
+ expectType(keyword)
+ expectType(keywordValues)
+ expectType(mergedSchema)
+ expectType(parentSchemas)
+ expectType(options)
+
+ return keywordValues
+ },
+ onConflict: 'throw'
+ }
+
+ mergeSchemas([schema1, schema2], mergeOptions)
+}
diff --git a/sdk/node_modules/@img/sharp-darwin-arm64/LICENSE b/sdk/node_modules/@img/sharp-darwin-arm64/LICENSE
new file mode 100644
index 00000000..37ec93a1
--- /dev/null
+++ b/sdk/node_modules/@img/sharp-darwin-arm64/LICENSE
@@ -0,0 +1,191 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction, and
+distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by the copyright
+owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all other entities
+that control, are controlled by, or are under common control with that entity.
+For the purposes of this definition, "control" means (i) the power, direct or
+indirect, to cause the direction or management of such entity, whether by
+contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the
+outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity exercising
+permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications, including
+but not limited to software source code, documentation source, and configuration
+files.
+
+"Object" form shall mean any form resulting from mechanical transformation or
+translation of a Source form, including but not limited to compiled object code,
+generated documentation, and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or Object form, made
+available under the License, as indicated by a copyright notice that is included
+in or attached to the work (an example is provided in the Appendix below).
+
+"Derivative Works" shall mean any work, whether in Source or Object form, that
+is based on (or derived from) the Work and for which the editorial revisions,
+annotations, elaborations, or other modifications represent, as a whole, an
+original work of authorship. For the purposes of this License, Derivative Works
+shall not include works that remain separable from, or merely link (or bind by
+name) to the interfaces of, the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including the original version
+of the Work and any modifications or additions to that Work or Derivative Works
+thereof, that is intentionally submitted to Licensor for inclusion in the Work
+by the copyright owner or by an individual or Legal Entity authorized to submit
+on behalf of the copyright owner. For the purposes of this definition,
+"submitted" means any form of electronic, verbal, or written communication sent
+to the Licensor or its representatives, including but not limited to
+communication on electronic mailing lists, source code control systems, and
+issue tracking systems that are managed by, or on behalf of, the Licensor for
+the purpose of discussing and improving the Work, but excluding communication
+that is conspicuously marked or otherwise designated in writing by the copyright
+owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity on behalf
+of whom a Contribution has been received by Licensor and subsequently
+incorporated within the Work.
+
+2. Grant of Copyright License.
+
+Subject to the terms and conditions of this License, each Contributor hereby
+grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
+irrevocable copyright license to reproduce, prepare Derivative Works of,
+publicly display, publicly perform, sublicense, and distribute the Work and such
+Derivative Works in Source or Object form.
+
+3. Grant of Patent License.
+
+Subject to the terms and conditions of this License, each Contributor hereby
+grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
+irrevocable (except as stated in this section) patent license to make, have
+made, use, offer to sell, sell, import, and otherwise transfer the Work, where
+such license applies only to those patent claims licensable by such Contributor
+that are necessarily infringed by their Contribution(s) alone or by combination
+of their Contribution(s) with the Work to which such Contribution(s) was
+submitted. If You institute patent litigation against any entity (including a
+cross-claim or counterclaim in a lawsuit) alleging that the Work or a
+Contribution incorporated within the Work constitutes direct or contributory
+patent infringement, then any patent licenses granted to You under this License
+for that Work shall terminate as of the date such litigation is filed.
+
+4. Redistribution.
+
+You may reproduce and distribute copies of the Work or Derivative Works thereof
+in any medium, with or without modifications, and in Source or Object form,
+provided that You meet the following conditions:
+
+You must give any other recipients of the Work or Derivative Works a copy of
+this License; and
+You must cause any modified files to carry prominent notices stating that You
+changed the files; and
+You must retain, in the Source form of any Derivative Works that You distribute,
+all copyright, patent, trademark, and attribution notices from the Source form
+of the Work, excluding those notices that do not pertain to any part of the
+Derivative Works; and
+If the Work includes a "NOTICE" text file as part of its distribution, then any
+Derivative Works that You distribute must include a readable copy of the
+attribution notices contained within such NOTICE file, excluding those notices
+that do not pertain to any part of the Derivative Works, in at least one of the
+following places: within a NOTICE text file distributed as part of the
+Derivative Works; within the Source form or documentation, if provided along
+with the Derivative Works; or, within a display generated by the Derivative
+Works, if and wherever such third-party notices normally appear. The contents of
+the NOTICE file are for informational purposes only and do not modify the
+License. You may add Your own attribution notices within Derivative Works that
+You distribute, alongside or as an addendum to the NOTICE text from the Work,
+provided that such additional attribution notices cannot be construed as
+modifying the License.
+You may add Your own copyright statement to Your modifications and may provide
+additional or different license terms and conditions for use, reproduction, or
+distribution of Your modifications, or for any such Derivative Works as a whole,
+provided Your use, reproduction, and distribution of the Work otherwise complies
+with the conditions stated in this License.
+
+5. Submission of Contributions.
+
+Unless You explicitly state otherwise, any Contribution intentionally submitted
+for inclusion in the Work by You to the Licensor shall be under the terms and
+conditions of this License, without any additional terms or conditions.
+Notwithstanding the above, nothing herein shall supersede or modify the terms of
+any separate license agreement you may have executed with Licensor regarding
+such Contributions.
+
+6. Trademarks.
+
+This License does not grant permission to use the trade names, trademarks,
+service marks, or product names of the Licensor, except as required for
+reasonable and customary use in describing the origin of the Work and
+reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty.
+
+Unless required by applicable law or agreed to in writing, Licensor provides the
+Work (and each Contributor provides its Contributions) on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied,
+including, without limitation, any warranties or conditions of TITLE,
+NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are
+solely responsible for determining the appropriateness of using or
+redistributing the Work and assume any risks associated with Your exercise of
+permissions under this License.
+
+8. Limitation of Liability.
+
+In no event and under no legal theory, whether in tort (including negligence),
+contract, or otherwise, unless required by applicable law (such as deliberate
+and grossly negligent acts) or agreed to in writing, shall any Contributor be
+liable to You for damages, including any direct, indirect, special, incidental,
+or consequential damages of any character arising as a result of this License or
+out of the use or inability to use the Work (including but not limited to
+damages for loss of goodwill, work stoppage, computer failure or malfunction, or
+any and all other commercial damages or losses), even if such Contributor has
+been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability.
+
+While redistributing the Work or Derivative Works thereof, You may choose to
+offer, and charge a fee for, acceptance of support, warranty, indemnity, or
+other liability obligations and/or rights consistent with this License. However,
+in accepting such obligations, You may act only on Your own behalf and on Your
+sole responsibility, not on behalf of any other Contributor, and only if You
+agree to indemnify, defend, and hold each Contributor harmless for any liability
+incurred by, or claims asserted against, such Contributor by reason of your
+accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work
+
+To apply the Apache License to your work, attach the following boilerplate
+notice, with the fields enclosed by brackets "[]" replaced with your own
+identifying information. (Don't include the brackets!) The text should be
+enclosed in the appropriate comment syntax for the file format. We also
+recommend that a file or class name and description of purpose be included on
+the same "printed page" as the copyright notice for easier identification within
+third-party archives.
+
+ Copyright [yyyy] [name of copyright owner]
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
diff --git a/sdk/node_modules/@img/sharp-darwin-arm64/README.md b/sdk/node_modules/@img/sharp-darwin-arm64/README.md
new file mode 100644
index 00000000..8220bf77
--- /dev/null
+++ b/sdk/node_modules/@img/sharp-darwin-arm64/README.md
@@ -0,0 +1,18 @@
+# `@img/sharp-darwin-arm64`
+
+Prebuilt sharp for use with macOS 64-bit ARM.
+
+## Licensing
+
+Copyright 2013 Lovell Fuller and others.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+[https://www.apache.org/licenses/LICENSE-2.0](https://www.apache.org/licenses/LICENSE-2.0)
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/sdk/node_modules/@img/sharp-darwin-arm64/lib/sharp-darwin-arm64.node b/sdk/node_modules/@img/sharp-darwin-arm64/lib/sharp-darwin-arm64.node
new file mode 100755
index 00000000..4297c204
Binary files /dev/null and b/sdk/node_modules/@img/sharp-darwin-arm64/lib/sharp-darwin-arm64.node differ
diff --git a/sdk/node_modules/@img/sharp-darwin-arm64/package.json b/sdk/node_modules/@img/sharp-darwin-arm64/package.json
new file mode 100644
index 00000000..3092b051
--- /dev/null
+++ b/sdk/node_modules/@img/sharp-darwin-arm64/package.json
@@ -0,0 +1,40 @@
+{
+ "name": "@img/sharp-darwin-arm64",
+ "version": "0.33.5",
+ "description": "Prebuilt sharp for use with macOS 64-bit ARM",
+ "author": "Lovell Fuller ",
+ "homepage": "https://sharp.pixelplumbing.com",
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/lovell/sharp.git",
+ "directory": "npm/darwin-arm64"
+ },
+ "license": "Apache-2.0",
+ "funding": {
+ "url": "https://opencollective.com/libvips"
+ },
+ "preferUnplugged": true,
+ "optionalDependencies": {
+ "@img/sharp-libvips-darwin-arm64": "1.0.4"
+ },
+ "files": [
+ "lib"
+ ],
+ "publishConfig": {
+ "access": "public"
+ },
+ "type": "commonjs",
+ "exports": {
+ "./sharp.node": "./lib/sharp-darwin-arm64.node",
+ "./package": "./package.json"
+ },
+ "engines": {
+ "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+ },
+ "os": [
+ "darwin"
+ ],
+ "cpu": [
+ "arm64"
+ ]
+}
diff --git a/sdk/node_modules/@img/sharp-libvips-darwin-arm64/README.md b/sdk/node_modules/@img/sharp-libvips-darwin-arm64/README.md
new file mode 100644
index 00000000..7516f72d
--- /dev/null
+++ b/sdk/node_modules/@img/sharp-libvips-darwin-arm64/README.md
@@ -0,0 +1,46 @@
+# `@img/sharp-libvips-darwin-arm64`
+
+Prebuilt libvips and dependencies for use with sharp on macOS 64-bit ARM.
+
+## Licensing
+
+This software contains third-party libraries
+used under the terms of the following licences:
+
+| Library | Used under the terms of |
+|---------------|-----------------------------------------------------------------------------------------------------------|
+| aom | BSD 2-Clause + [Alliance for Open Media Patent License 1.0](https://aomedia.org/license/patent-license/) |
+| cairo | Mozilla Public License 2.0 |
+| cgif | MIT Licence |
+| expat | MIT Licence |
+| fontconfig | [fontconfig Licence](https://gitlab.freedesktop.org/fontconfig/fontconfig/blob/main/COPYING) (BSD-like) |
+| freetype | [freetype Licence](https://git.savannah.gnu.org/cgit/freetype/freetype2.git/tree/docs/FTL.TXT) (BSD-like) |
+| fribidi | LGPLv3 |
+| glib | LGPLv3 |
+| harfbuzz | MIT Licence |
+| highway | Apache-2.0 License, BSD 3-Clause |
+| lcms | MIT Licence |
+| libarchive | BSD 2-Clause |
+| libexif | LGPLv3 |
+| libffi | MIT Licence |
+| libheif | LGPLv3 |
+| libimagequant | [BSD 2-Clause](https://github.com/lovell/libimagequant/blob/main/COPYRIGHT) |
+| libnsgif | MIT Licence |
+| libpng | [libpng License](https://github.com/pnggroup/libpng/blob/master/LICENSE) |
+| librsvg | LGPLv3 |
+| libspng | [BSD 2-Clause, libpng License](https://github.com/randy408/libspng/blob/master/LICENSE) |
+| libtiff | [libtiff License](https://gitlab.com/libtiff/libtiff/blob/master/LICENSE.md) (BSD-like) |
+| libvips | LGPLv3 |
+| libwebp | New BSD License |
+| libxml2 | MIT Licence |
+| mozjpeg | [zlib License, IJG License, BSD-3-Clause](https://github.com/mozilla/mozjpeg/blob/master/LICENSE.md) |
+| pango | LGPLv3 |
+| pixman | MIT Licence |
+| proxy-libintl | LGPLv3 |
+| zlib-ng | [zlib Licence](https://github.com/zlib-ng/zlib-ng/blob/develop/LICENSE.md) |
+
+Use of libraries under the terms of the LGPLv3 is via the
+"any later version" clause of the LGPLv2 or LGPLv2.1.
+
+Please report any errors or omissions via
+https://github.com/lovell/sharp-libvips/issues/new
diff --git a/sdk/node_modules/@img/sharp-libvips-darwin-arm64/lib/glib-2.0/include/glibconfig.h b/sdk/node_modules/@img/sharp-libvips-darwin-arm64/lib/glib-2.0/include/glibconfig.h
new file mode 100644
index 00000000..46a5b303
--- /dev/null
+++ b/sdk/node_modules/@img/sharp-libvips-darwin-arm64/lib/glib-2.0/include/glibconfig.h
@@ -0,0 +1,220 @@
+/* glibconfig.h
+ *
+ * This is a generated file. Please modify 'glibconfig.h.in'
+ */
+
+#ifndef __GLIBCONFIG_H__
+#define __GLIBCONFIG_H__
+
+#include
+
+#include
+#include
+#define GLIB_HAVE_ALLOCA_H
+
+#define GLIB_STATIC_COMPILATION 1
+#define GOBJECT_STATIC_COMPILATION 1
+#define GIO_STATIC_COMPILATION 1
+#define GMODULE_STATIC_COMPILATION 1
+#define GI_STATIC_COMPILATION 1
+#define G_INTL_STATIC_COMPILATION 1
+#define FFI_STATIC_BUILD 1
+
+/* Specifies that GLib's g_print*() functions wrap the
+ * system printf functions. This is useful to know, for example,
+ * when using glibc's register_printf_function().
+ */
+#define GLIB_USING_SYSTEM_PRINTF
+
+G_BEGIN_DECLS
+
+#define G_MINFLOAT FLT_MIN
+#define G_MAXFLOAT FLT_MAX
+#define G_MINDOUBLE DBL_MIN
+#define G_MAXDOUBLE DBL_MAX
+#define G_MINSHORT SHRT_MIN
+#define G_MAXSHORT SHRT_MAX
+#define G_MAXUSHORT USHRT_MAX
+#define G_MININT INT_MIN
+#define G_MAXINT INT_MAX
+#define G_MAXUINT UINT_MAX
+#define G_MINLONG LONG_MIN
+#define G_MAXLONG LONG_MAX
+#define G_MAXULONG ULONG_MAX
+
+typedef signed char gint8;
+typedef unsigned char guint8;
+
+typedef signed short gint16;
+typedef unsigned short guint16;
+
+#define G_GINT16_MODIFIER "h"
+#define G_GINT16_FORMAT "hi"
+#define G_GUINT16_FORMAT "hu"
+
+
+typedef signed int gint32;
+typedef unsigned int guint32;
+
+#define G_GINT32_MODIFIER ""
+#define G_GINT32_FORMAT "i"
+#define G_GUINT32_FORMAT "u"
+
+
+#define G_HAVE_GINT64 1 /* deprecated, always true */
+
+G_GNUC_EXTENSION typedef signed long long gint64;
+G_GNUC_EXTENSION typedef unsigned long long guint64;
+
+#define G_GINT64_CONSTANT(val) (G_GNUC_EXTENSION (val##LL))
+#define G_GUINT64_CONSTANT(val) (G_GNUC_EXTENSION (val##ULL))
+
+#define G_GINT64_MODIFIER "ll"
+#define G_GINT64_FORMAT "lli"
+#define G_GUINT64_FORMAT "llu"
+
+
+#define GLIB_SIZEOF_VOID_P 8
+#define GLIB_SIZEOF_LONG 8
+#define GLIB_SIZEOF_SIZE_T 8
+#define GLIB_SIZEOF_SSIZE_T 8
+
+typedef signed long gssize;
+typedef unsigned long gsize;
+#define G_GSIZE_MODIFIER "l"
+#define G_GSSIZE_MODIFIER "l"
+#define G_GSIZE_FORMAT "lu"
+#define G_GSSIZE_FORMAT "li"
+
+#define G_MAXSIZE G_MAXULONG
+#define G_MINSSIZE G_MINLONG
+#define G_MAXSSIZE G_MAXLONG
+
+typedef gint64 goffset;
+#define G_MINOFFSET G_MININT64
+#define G_MAXOFFSET G_MAXINT64
+
+#define G_GOFFSET_MODIFIER G_GINT64_MODIFIER
+#define G_GOFFSET_FORMAT G_GINT64_FORMAT
+#define G_GOFFSET_CONSTANT(val) G_GINT64_CONSTANT(val)
+
+#define G_POLLFD_FORMAT "%d"
+
+#define GPOINTER_TO_INT(p) ((gint) (glong) (p))
+#define GPOINTER_TO_UINT(p) ((guint) (gulong) (p))
+
+#define GINT_TO_POINTER(i) ((gpointer) (glong) (i))
+#define GUINT_TO_POINTER(u) ((gpointer) (gulong) (u))
+
+typedef signed long gintptr;
+typedef unsigned long guintptr;
+
+#define G_GINTPTR_MODIFIER "l"
+#define G_GINTPTR_FORMAT "li"
+#define G_GUINTPTR_FORMAT "lu"
+
+#define GLIB_MAJOR_VERSION 2
+#define GLIB_MINOR_VERSION 81
+#define GLIB_MICRO_VERSION 1
+
+#define G_OS_UNIX
+
+#define G_VA_COPY va_copy
+
+
+#define G_HAVE_ISO_VARARGS 1
+
+/* gcc-2.95.x supports both gnu style and ISO varargs, but if -ansi
+ * is passed ISO vararg support is turned off, and there is no work
+ * around to turn it on, so we unconditionally turn it off.
+ */
+#if __GNUC__ == 2 && __GNUC_MINOR__ == 95
+# undef G_HAVE_ISO_VARARGS
+#endif
+
+#define G_HAVE_GROWING_STACK 0
+
+#ifndef _MSC_VER
+# define G_HAVE_GNUC_VARARGS 1
+#endif
+
+#if defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590)
+#define G_GNUC_INTERNAL __attribute__((visibility("hidden")))
+#elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x550)
+#define G_GNUC_INTERNAL __hidden
+#elif defined (__GNUC__) && defined (G_HAVE_GNUC_VISIBILITY)
+#define G_GNUC_INTERNAL __attribute__((visibility("hidden")))
+#else
+#define G_GNUC_INTERNAL
+#endif
+
+#define G_THREADS_ENABLED
+#define G_THREADS_IMPL_POSIX
+
+#define G_ATOMIC_LOCK_FREE
+
+#define GINT16_TO_LE(val) ((gint16) (val))
+#define GUINT16_TO_LE(val) ((guint16) (val))
+#define GINT16_TO_BE(val) ((gint16) GUINT16_SWAP_LE_BE (val))
+#define GUINT16_TO_BE(val) (GUINT16_SWAP_LE_BE (val))
+
+#define GINT32_TO_LE(val) ((gint32) (val))
+#define GUINT32_TO_LE(val) ((guint32) (val))
+#define GINT32_TO_BE(val) ((gint32) GUINT32_SWAP_LE_BE (val))
+#define GUINT32_TO_BE(val) (GUINT32_SWAP_LE_BE (val))
+
+#define GINT64_TO_LE(val) ((gint64) (val))
+#define GUINT64_TO_LE(val) ((guint64) (val))
+#define GINT64_TO_BE(val) ((gint64) GUINT64_SWAP_LE_BE (val))
+#define GUINT64_TO_BE(val) (GUINT64_SWAP_LE_BE (val))
+
+#define GLONG_TO_LE(val) ((glong) GINT64_TO_LE (val))
+#define GULONG_TO_LE(val) ((gulong) GUINT64_TO_LE (val))
+#define GLONG_TO_BE(val) ((glong) GINT64_TO_BE (val))
+#define GULONG_TO_BE(val) ((gulong) GUINT64_TO_BE (val))
+#define GINT_TO_LE(val) ((gint) GINT32_TO_LE (val))
+#define GUINT_TO_LE(val) ((guint) GUINT32_TO_LE (val))
+#define GINT_TO_BE(val) ((gint) GINT32_TO_BE (val))
+#define GUINT_TO_BE(val) ((guint) GUINT32_TO_BE (val))
+#define GSIZE_TO_LE(val) ((gsize) GUINT64_TO_LE (val))
+#define GSSIZE_TO_LE(val) ((gssize) GINT64_TO_LE (val))
+#define GSIZE_TO_BE(val) ((gsize) GUINT64_TO_BE (val))
+#define GSSIZE_TO_BE(val) ((gssize) GINT64_TO_BE (val))
+#define G_BYTE_ORDER G_LITTLE_ENDIAN
+
+#define GLIB_SYSDEF_POLLIN =1
+#define GLIB_SYSDEF_POLLOUT =4
+#define GLIB_SYSDEF_POLLPRI =2
+#define GLIB_SYSDEF_POLLHUP =16
+#define GLIB_SYSDEF_POLLERR =8
+#define GLIB_SYSDEF_POLLNVAL =32
+
+/* No way to disable deprecation warnings for macros, so only emit deprecation
+ * warnings on platforms where usage of this macro is broken */
+#if defined(__APPLE__) || defined(_MSC_VER) || defined(__CYGWIN__)
+#define G_MODULE_SUFFIX "so" GLIB_DEPRECATED_MACRO_IN_2_76
+#else
+#define G_MODULE_SUFFIX "so"
+#endif
+
+typedef int GPid;
+#define G_PID_FORMAT "i"
+
+#define GLIB_SYSDEF_AF_UNIX 1
+#define GLIB_SYSDEF_AF_INET 2
+#define GLIB_SYSDEF_AF_INET6 30
+
+#define GLIB_SYSDEF_MSG_OOB 1
+#define GLIB_SYSDEF_MSG_PEEK 2
+#define GLIB_SYSDEF_MSG_DONTROUTE 4
+
+#define G_DIR_SEPARATOR '/'
+#define G_DIR_SEPARATOR_S "/"
+#define G_SEARCHPATH_SEPARATOR ':'
+#define G_SEARCHPATH_SEPARATOR_S ":"
+
+#undef G_HAVE_FREE_SIZED
+
+G_END_DECLS
+
+#endif /* __GLIBCONFIG_H__ */
diff --git a/sdk/node_modules/@img/sharp-libvips-darwin-arm64/lib/index.js b/sdk/node_modules/@img/sharp-libvips-darwin-arm64/lib/index.js
new file mode 100644
index 00000000..5092b4dd
--- /dev/null
+++ b/sdk/node_modules/@img/sharp-libvips-darwin-arm64/lib/index.js
@@ -0,0 +1 @@
+module.exports = __dirname;
diff --git a/sdk/node_modules/@img/sharp-libvips-darwin-arm64/lib/libvips-cpp.42.dylib b/sdk/node_modules/@img/sharp-libvips-darwin-arm64/lib/libvips-cpp.42.dylib
new file mode 100644
index 00000000..941c7d6b
Binary files /dev/null and b/sdk/node_modules/@img/sharp-libvips-darwin-arm64/lib/libvips-cpp.42.dylib differ
diff --git a/sdk/node_modules/@img/sharp-libvips-darwin-arm64/package.json b/sdk/node_modules/@img/sharp-libvips-darwin-arm64/package.json
new file mode 100644
index 00000000..b76bdb6b
--- /dev/null
+++ b/sdk/node_modules/@img/sharp-libvips-darwin-arm64/package.json
@@ -0,0 +1,36 @@
+{
+ "name": "@img/sharp-libvips-darwin-arm64",
+ "version": "1.0.4",
+ "description": "Prebuilt libvips and dependencies for use with sharp on macOS 64-bit ARM",
+ "author": "Lovell Fuller ",
+ "homepage": "https://sharp.pixelplumbing.com",
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/lovell/sharp-libvips.git",
+ "directory": "npm/darwin-arm64"
+ },
+ "license": "LGPL-3.0-or-later",
+ "funding": {
+ "url": "https://opencollective.com/libvips"
+ },
+ "preferUnplugged": true,
+ "publishConfig": {
+ "access": "public"
+ },
+ "files": [
+ "lib",
+ "versions.json"
+ ],
+ "type": "commonjs",
+ "exports": {
+ "./lib": "./lib/index.js",
+ "./package": "./package.json",
+ "./versions": "./versions.json"
+ },
+ "os": [
+ "darwin"
+ ],
+ "cpu": [
+ "arm64"
+ ]
+}
diff --git a/sdk/node_modules/@img/sharp-libvips-darwin-arm64/versions.json b/sdk/node_modules/@img/sharp-libvips-darwin-arm64/versions.json
new file mode 100644
index 00000000..0b50c290
--- /dev/null
+++ b/sdk/node_modules/@img/sharp-libvips-darwin-arm64/versions.json
@@ -0,0 +1,30 @@
+{
+ "aom": "3.9.1",
+ "archive": "3.7.4",
+ "cairo": "1.18.0",
+ "cgif": "0.4.1",
+ "exif": "0.6.24",
+ "expat": "2.6.2",
+ "ffi": "3.4.6",
+ "fontconfig": "2.15.0",
+ "freetype": "2.13.2",
+ "fribidi": "1.0.15",
+ "glib": "2.81.1",
+ "harfbuzz": "9.0.0",
+ "heif": "1.18.2",
+ "highway": "1.2.0",
+ "imagequant": "2.4.1",
+ "lcms": "2.16",
+ "mozjpeg": "4.1.5",
+ "pango": "1.54.0",
+ "pixman": "0.43.4",
+ "png": "1.6.43",
+ "proxy-libintl": "0.4",
+ "rsvg": "2.58.93",
+ "spng": "0.7.4",
+ "tiff": "4.6.0",
+ "vips": "8.15.3",
+ "webp": "1.4.0",
+ "xml": "2.13.3",
+ "zlib-ng": "2.2.1"
+}
\ No newline at end of file
diff --git a/sdk/node_modules/@isaacs/cliui/LICENSE.txt b/sdk/node_modules/@isaacs/cliui/LICENSE.txt
new file mode 100644
index 00000000..c7e27478
--- /dev/null
+++ b/sdk/node_modules/@isaacs/cliui/LICENSE.txt
@@ -0,0 +1,14 @@
+Copyright (c) 2015, Contributors
+
+Permission to use, copy, modify, and/or distribute this software
+for any purpose with or without fee is hereby granted, provided
+that the above copyright notice and this permission notice
+appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
+OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE
+LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES
+OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
diff --git a/sdk/node_modules/@isaacs/cliui/README.md b/sdk/node_modules/@isaacs/cliui/README.md
new file mode 100644
index 00000000..48806426
--- /dev/null
+++ b/sdk/node_modules/@isaacs/cliui/README.md
@@ -0,0 +1,143 @@
+# @isaacs/cliui
+
+Temporary fork of [cliui](http://npm.im/cliui).
+
+
+[](https://www.npmjs.com/package/cliui)
+[](https://conventionalcommits.org)
+
+
+easily create complex multi-column command-line-interfaces.
+
+## Example
+
+```js
+const ui = require('cliui')()
+
+ui.div('Usage: $0 [command] [options]')
+
+ui.div({
+ text: 'Options:',
+ padding: [2, 0, 1, 0]
+})
+
+ui.div(
+ {
+ text: "-f, --file",
+ width: 20,
+ padding: [0, 4, 0, 4]
+ },
+ {
+ text: "the file to load." +
+ chalk.green("(if this description is long it wraps).")
+ ,
+ width: 20
+ },
+ {
+ text: chalk.red("[required]"),
+ align: 'right'
+ }
+)
+
+console.log(ui.toString())
+```
+
+## Deno/ESM Support
+
+As of `v7` `cliui` supports [Deno](https://github.com/denoland/deno) and
+[ESM](https://nodejs.org/api/esm.html#esm_ecmascript_modules):
+
+```typescript
+import cliui from "https://deno.land/x/cliui/deno.ts";
+
+const ui = cliui({})
+
+ui.div('Usage: $0 [command] [options]')
+
+ui.div({
+ text: 'Options:',
+ padding: [2, 0, 1, 0]
+})
+
+ui.div({
+ text: "-f, --file",
+ width: 20,
+ padding: [0, 4, 0, 4]
+})
+
+console.log(ui.toString())
+```
+
+
+
+## Layout DSL
+
+cliui exposes a simple layout DSL:
+
+If you create a single `ui.div`, passing a string rather than an
+object:
+
+* `\n`: characters will be interpreted as new rows.
+* `\t`: characters will be interpreted as new columns.
+* `\s`: characters will be interpreted as padding.
+
+**as an example...**
+
+```js
+var ui = require('./')({
+ width: 60
+})
+
+ui.div(
+ 'Usage: node ./bin/foo.js\n' +
+ ' \t provide a regex\n' +
+ ' \t provide a glob\t [required]'
+)
+
+console.log(ui.toString())
+```
+
+**will output:**
+
+```shell
+Usage: node ./bin/foo.js
+ provide a regex
+ provide a glob [required]
+```
+
+## Methods
+
+```js
+cliui = require('cliui')
+```
+
+### cliui({width: integer})
+
+Specify the maximum width of the UI being generated.
+If no width is provided, cliui will try to get the current window's width and use it, and if that doesn't work, width will be set to `80`.
+
+### cliui({wrap: boolean})
+
+Enable or disable the wrapping of text in a column.
+
+### cliui.div(column, column, column)
+
+Create a row with any number of columns, a column
+can either be a string, or an object with the following
+options:
+
+* **text:** some text to place in the column.
+* **width:** the width of a column.
+* **align:** alignment, `right` or `center`.
+* **padding:** `[top, right, bottom, left]`.
+* **border:** should a border be placed around the div?
+
+### cliui.span(column, column, column)
+
+Similar to `div`, except the next row will be appended without
+a new line being created.
+
+### cliui.resetOutput()
+
+Resets the UI elements of the current cliui instance, maintaining the values
+set for `width` and `wrap`.
diff --git a/sdk/node_modules/@isaacs/cliui/build/index.cjs b/sdk/node_modules/@isaacs/cliui/build/index.cjs
new file mode 100644
index 00000000..aca2b850
--- /dev/null
+++ b/sdk/node_modules/@isaacs/cliui/build/index.cjs
@@ -0,0 +1,317 @@
+'use strict';
+
+const align = {
+ right: alignRight,
+ center: alignCenter
+};
+const top = 0;
+const right = 1;
+const bottom = 2;
+const left = 3;
+class UI {
+ constructor(opts) {
+ var _a;
+ this.width = opts.width;
+ /* c8 ignore start */
+ this.wrap = (_a = opts.wrap) !== null && _a !== void 0 ? _a : true;
+ /* c8 ignore stop */
+ this.rows = [];
+ }
+ span(...args) {
+ const cols = this.div(...args);
+ cols.span = true;
+ }
+ resetOutput() {
+ this.rows = [];
+ }
+ div(...args) {
+ if (args.length === 0) {
+ this.div('');
+ }
+ if (this.wrap && this.shouldApplyLayoutDSL(...args) && typeof args[0] === 'string') {
+ return this.applyLayoutDSL(args[0]);
+ }
+ const cols = args.map(arg => {
+ if (typeof arg === 'string') {
+ return this.colFromString(arg);
+ }
+ return arg;
+ });
+ this.rows.push(cols);
+ return cols;
+ }
+ shouldApplyLayoutDSL(...args) {
+ return args.length === 1 && typeof args[0] === 'string' &&
+ /[\t\n]/.test(args[0]);
+ }
+ applyLayoutDSL(str) {
+ const rows = str.split('\n').map(row => row.split('\t'));
+ let leftColumnWidth = 0;
+ // simple heuristic for layout, make sure the
+ // second column lines up along the left-hand.
+ // don't allow the first column to take up more
+ // than 50% of the screen.
+ rows.forEach(columns => {
+ if (columns.length > 1 && mixin.stringWidth(columns[0]) > leftColumnWidth) {
+ leftColumnWidth = Math.min(Math.floor(this.width * 0.5), mixin.stringWidth(columns[0]));
+ }
+ });
+ // generate a table:
+ // replacing ' ' with padding calculations.
+ // using the algorithmically generated width.
+ rows.forEach(columns => {
+ this.div(...columns.map((r, i) => {
+ return {
+ text: r.trim(),
+ padding: this.measurePadding(r),
+ width: (i === 0 && columns.length > 1) ? leftColumnWidth : undefined
+ };
+ }));
+ });
+ return this.rows[this.rows.length - 1];
+ }
+ colFromString(text) {
+ return {
+ text,
+ padding: this.measurePadding(text)
+ };
+ }
+ measurePadding(str) {
+ // measure padding without ansi escape codes
+ const noAnsi = mixin.stripAnsi(str);
+ return [0, noAnsi.match(/\s*$/)[0].length, 0, noAnsi.match(/^\s*/)[0].length];
+ }
+ toString() {
+ const lines = [];
+ this.rows.forEach(row => {
+ this.rowToString(row, lines);
+ });
+ // don't display any lines with the
+ // hidden flag set.
+ return lines
+ .filter(line => !line.hidden)
+ .map(line => line.text)
+ .join('\n');
+ }
+ rowToString(row, lines) {
+ this.rasterize(row).forEach((rrow, r) => {
+ let str = '';
+ rrow.forEach((col, c) => {
+ const { width } = row[c]; // the width with padding.
+ const wrapWidth = this.negatePadding(row[c]); // the width without padding.
+ let ts = col; // temporary string used during alignment/padding.
+ if (wrapWidth > mixin.stringWidth(col)) {
+ ts += ' '.repeat(wrapWidth - mixin.stringWidth(col));
+ }
+ // align the string within its column.
+ if (row[c].align && row[c].align !== 'left' && this.wrap) {
+ const fn = align[row[c].align];
+ ts = fn(ts, wrapWidth);
+ if (mixin.stringWidth(ts) < wrapWidth) {
+ /* c8 ignore start */
+ const w = width || 0;
+ /* c8 ignore stop */
+ ts += ' '.repeat(w - mixin.stringWidth(ts) - 1);
+ }
+ }
+ // apply border and padding to string.
+ const padding = row[c].padding || [0, 0, 0, 0];
+ if (padding[left]) {
+ str += ' '.repeat(padding[left]);
+ }
+ str += addBorder(row[c], ts, '| ');
+ str += ts;
+ str += addBorder(row[c], ts, ' |');
+ if (padding[right]) {
+ str += ' '.repeat(padding[right]);
+ }
+ // if prior row is span, try to render the
+ // current row on the prior line.
+ if (r === 0 && lines.length > 0) {
+ str = this.renderInline(str, lines[lines.length - 1]);
+ }
+ });
+ // remove trailing whitespace.
+ lines.push({
+ text: str.replace(/ +$/, ''),
+ span: row.span
+ });
+ });
+ return lines;
+ }
+ // if the full 'source' can render in
+ // the target line, do so.
+ renderInline(source, previousLine) {
+ const match = source.match(/^ */);
+ /* c8 ignore start */
+ const leadingWhitespace = match ? match[0].length : 0;
+ /* c8 ignore stop */
+ const target = previousLine.text;
+ const targetTextWidth = mixin.stringWidth(target.trimEnd());
+ if (!previousLine.span) {
+ return source;
+ }
+ // if we're not applying wrapping logic,
+ // just always append to the span.
+ if (!this.wrap) {
+ previousLine.hidden = true;
+ return target + source;
+ }
+ if (leadingWhitespace < targetTextWidth) {
+ return source;
+ }
+ previousLine.hidden = true;
+ return target.trimEnd() + ' '.repeat(leadingWhitespace - targetTextWidth) + source.trimStart();
+ }
+ rasterize(row) {
+ const rrows = [];
+ const widths = this.columnWidths(row);
+ let wrapped;
+ // word wrap all columns, and create
+ // a data-structure that is easy to rasterize.
+ row.forEach((col, c) => {
+ // leave room for left and right padding.
+ col.width = widths[c];
+ if (this.wrap) {
+ wrapped = mixin.wrap(col.text, this.negatePadding(col), { hard: true }).split('\n');
+ }
+ else {
+ wrapped = col.text.split('\n');
+ }
+ if (col.border) {
+ wrapped.unshift('.' + '-'.repeat(this.negatePadding(col) + 2) + '.');
+ wrapped.push("'" + '-'.repeat(this.negatePadding(col) + 2) + "'");
+ }
+ // add top and bottom padding.
+ if (col.padding) {
+ wrapped.unshift(...new Array(col.padding[top] || 0).fill(''));
+ wrapped.push(...new Array(col.padding[bottom] || 0).fill(''));
+ }
+ wrapped.forEach((str, r) => {
+ if (!rrows[r]) {
+ rrows.push([]);
+ }
+ const rrow = rrows[r];
+ for (let i = 0; i < c; i++) {
+ if (rrow[i] === undefined) {
+ rrow.push('');
+ }
+ }
+ rrow.push(str);
+ });
+ });
+ return rrows;
+ }
+ negatePadding(col) {
+ /* c8 ignore start */
+ let wrapWidth = col.width || 0;
+ /* c8 ignore stop */
+ if (col.padding) {
+ wrapWidth -= (col.padding[left] || 0) + (col.padding[right] || 0);
+ }
+ if (col.border) {
+ wrapWidth -= 4;
+ }
+ return wrapWidth;
+ }
+ columnWidths(row) {
+ if (!this.wrap) {
+ return row.map(col => {
+ return col.width || mixin.stringWidth(col.text);
+ });
+ }
+ let unset = row.length;
+ let remainingWidth = this.width;
+ // column widths can be set in config.
+ const widths = row.map(col => {
+ if (col.width) {
+ unset--;
+ remainingWidth -= col.width;
+ return col.width;
+ }
+ return undefined;
+ });
+ // any unset widths should be calculated.
+ /* c8 ignore start */
+ const unsetWidth = unset ? Math.floor(remainingWidth / unset) : 0;
+ /* c8 ignore stop */
+ return widths.map((w, i) => {
+ if (w === undefined) {
+ return Math.max(unsetWidth, _minWidth(row[i]));
+ }
+ return w;
+ });
+ }
+}
+function addBorder(col, ts, style) {
+ if (col.border) {
+ if (/[.']-+[.']/.test(ts)) {
+ return '';
+ }
+ if (ts.trim().length !== 0) {
+ return style;
+ }
+ return ' ';
+ }
+ return '';
+}
+// calculates the minimum width of
+// a column, based on padding preferences.
+function _minWidth(col) {
+ const padding = col.padding || [];
+ const minWidth = 1 + (padding[left] || 0) + (padding[right] || 0);
+ if (col.border) {
+ return minWidth + 4;
+ }
+ return minWidth;
+}
+function getWindowWidth() {
+ /* c8 ignore start */
+ if (typeof process === 'object' && process.stdout && process.stdout.columns) {
+ return process.stdout.columns;
+ }
+ return 80;
+}
+/* c8 ignore stop */
+function alignRight(str, width) {
+ str = str.trim();
+ const strWidth = mixin.stringWidth(str);
+ if (strWidth < width) {
+ return ' '.repeat(width - strWidth) + str;
+ }
+ return str;
+}
+function alignCenter(str, width) {
+ str = str.trim();
+ const strWidth = mixin.stringWidth(str);
+ /* c8 ignore start */
+ if (strWidth >= width) {
+ return str;
+ }
+ /* c8 ignore stop */
+ return ' '.repeat((width - strWidth) >> 1) + str;
+}
+let mixin;
+function cliui(opts, _mixin) {
+ mixin = _mixin;
+ return new UI({
+ /* c8 ignore start */
+ width: (opts === null || opts === void 0 ? void 0 : opts.width) || getWindowWidth(),
+ wrap: opts === null || opts === void 0 ? void 0 : opts.wrap
+ /* c8 ignore stop */
+ });
+}
+
+// Bootstrap cliui with CommonJS dependencies:
+const stringWidth = require('string-width-cjs');
+const stripAnsi = require('strip-ansi-cjs');
+const wrap = require('wrap-ansi-cjs');
+function ui(opts) {
+ return cliui(opts, {
+ stringWidth,
+ stripAnsi,
+ wrap
+ });
+}
+
+module.exports = ui;
diff --git a/sdk/node_modules/@isaacs/cliui/build/index.d.cts b/sdk/node_modules/@isaacs/cliui/build/index.d.cts
new file mode 100644
index 00000000..4567f945
--- /dev/null
+++ b/sdk/node_modules/@isaacs/cliui/build/index.d.cts
@@ -0,0 +1,43 @@
+interface UIOptions {
+ width: number;
+ wrap?: boolean;
+ rows?: string[];
+}
+interface Column {
+ text: string;
+ width?: number;
+ align?: "right" | "left" | "center";
+ padding: number[];
+ border?: boolean;
+}
+interface ColumnArray extends Array {
+ span: boolean;
+}
+interface Line {
+ hidden?: boolean;
+ text: string;
+ span?: boolean;
+}
+declare class UI {
+ width: number;
+ wrap: boolean;
+ rows: ColumnArray[];
+ constructor(opts: UIOptions);
+ span(...args: ColumnArray): void;
+ resetOutput(): void;
+ div(...args: (Column | string)[]): ColumnArray;
+ private shouldApplyLayoutDSL;
+ private applyLayoutDSL;
+ private colFromString;
+ private measurePadding;
+ toString(): string;
+ rowToString(row: ColumnArray, lines: Line[]): Line[];
+ // if the full 'source' can render in
+ // the target line, do so.
+ private renderInline;
+ private rasterize;
+ private negatePadding;
+ private columnWidths;
+}
+declare function ui(opts: UIOptions): UI;
+export { ui as default };
diff --git a/sdk/node_modules/@isaacs/cliui/build/lib/index.js b/sdk/node_modules/@isaacs/cliui/build/lib/index.js
new file mode 100644
index 00000000..587b5ecd
--- /dev/null
+++ b/sdk/node_modules/@isaacs/cliui/build/lib/index.js
@@ -0,0 +1,302 @@
+'use strict';
+const align = {
+ right: alignRight,
+ center: alignCenter
+};
+const top = 0;
+const right = 1;
+const bottom = 2;
+const left = 3;
+export class UI {
+ constructor(opts) {
+ var _a;
+ this.width = opts.width;
+ /* c8 ignore start */
+ this.wrap = (_a = opts.wrap) !== null && _a !== void 0 ? _a : true;
+ /* c8 ignore stop */
+ this.rows = [];
+ }
+ span(...args) {
+ const cols = this.div(...args);
+ cols.span = true;
+ }
+ resetOutput() {
+ this.rows = [];
+ }
+ div(...args) {
+ if (args.length === 0) {
+ this.div('');
+ }
+ if (this.wrap && this.shouldApplyLayoutDSL(...args) && typeof args[0] === 'string') {
+ return this.applyLayoutDSL(args[0]);
+ }
+ const cols = args.map(arg => {
+ if (typeof arg === 'string') {
+ return this.colFromString(arg);
+ }
+ return arg;
+ });
+ this.rows.push(cols);
+ return cols;
+ }
+ shouldApplyLayoutDSL(...args) {
+ return args.length === 1 && typeof args[0] === 'string' &&
+ /[\t\n]/.test(args[0]);
+ }
+ applyLayoutDSL(str) {
+ const rows = str.split('\n').map(row => row.split('\t'));
+ let leftColumnWidth = 0;
+ // simple heuristic for layout, make sure the
+ // second column lines up along the left-hand.
+ // don't allow the first column to take up more
+ // than 50% of the screen.
+ rows.forEach(columns => {
+ if (columns.length > 1 && mixin.stringWidth(columns[0]) > leftColumnWidth) {
+ leftColumnWidth = Math.min(Math.floor(this.width * 0.5), mixin.stringWidth(columns[0]));
+ }
+ });
+ // generate a table:
+ // replacing ' ' with padding calculations.
+ // using the algorithmically generated width.
+ rows.forEach(columns => {
+ this.div(...columns.map((r, i) => {
+ return {
+ text: r.trim(),
+ padding: this.measurePadding(r),
+ width: (i === 0 && columns.length > 1) ? leftColumnWidth : undefined
+ };
+ }));
+ });
+ return this.rows[this.rows.length - 1];
+ }
+ colFromString(text) {
+ return {
+ text,
+ padding: this.measurePadding(text)
+ };
+ }
+ measurePadding(str) {
+ // measure padding without ansi escape codes
+ const noAnsi = mixin.stripAnsi(str);
+ return [0, noAnsi.match(/\s*$/)[0].length, 0, noAnsi.match(/^\s*/)[0].length];
+ }
+ toString() {
+ const lines = [];
+ this.rows.forEach(row => {
+ this.rowToString(row, lines);
+ });
+ // don't display any lines with the
+ // hidden flag set.
+ return lines
+ .filter(line => !line.hidden)
+ .map(line => line.text)
+ .join('\n');
+ }
+ rowToString(row, lines) {
+ this.rasterize(row).forEach((rrow, r) => {
+ let str = '';
+ rrow.forEach((col, c) => {
+ const { width } = row[c]; // the width with padding.
+ const wrapWidth = this.negatePadding(row[c]); // the width without padding.
+ let ts = col; // temporary string used during alignment/padding.
+ if (wrapWidth > mixin.stringWidth(col)) {
+ ts += ' '.repeat(wrapWidth - mixin.stringWidth(col));
+ }
+ // align the string within its column.
+ if (row[c].align && row[c].align !== 'left' && this.wrap) {
+ const fn = align[row[c].align];
+ ts = fn(ts, wrapWidth);
+ if (mixin.stringWidth(ts) < wrapWidth) {
+ /* c8 ignore start */
+ const w = width || 0;
+ /* c8 ignore stop */
+ ts += ' '.repeat(w - mixin.stringWidth(ts) - 1);
+ }
+ }
+ // apply border and padding to string.
+ const padding = row[c].padding || [0, 0, 0, 0];
+ if (padding[left]) {
+ str += ' '.repeat(padding[left]);
+ }
+ str += addBorder(row[c], ts, '| ');
+ str += ts;
+ str += addBorder(row[c], ts, ' |');
+ if (padding[right]) {
+ str += ' '.repeat(padding[right]);
+ }
+ // if prior row is span, try to render the
+ // current row on the prior line.
+ if (r === 0 && lines.length > 0) {
+ str = this.renderInline(str, lines[lines.length - 1]);
+ }
+ });
+ // remove trailing whitespace.
+ lines.push({
+ text: str.replace(/ +$/, ''),
+ span: row.span
+ });
+ });
+ return lines;
+ }
+ // if the full 'source' can render in
+ // the target line, do so.
+ renderInline(source, previousLine) {
+ const match = source.match(/^ */);
+ /* c8 ignore start */
+ const leadingWhitespace = match ? match[0].length : 0;
+ /* c8 ignore stop */
+ const target = previousLine.text;
+ const targetTextWidth = mixin.stringWidth(target.trimEnd());
+ if (!previousLine.span) {
+ return source;
+ }
+ // if we're not applying wrapping logic,
+ // just always append to the span.
+ if (!this.wrap) {
+ previousLine.hidden = true;
+ return target + source;
+ }
+ if (leadingWhitespace < targetTextWidth) {
+ return source;
+ }
+ previousLine.hidden = true;
+ return target.trimEnd() + ' '.repeat(leadingWhitespace - targetTextWidth) + source.trimStart();
+ }
+ rasterize(row) {
+ const rrows = [];
+ const widths = this.columnWidths(row);
+ let wrapped;
+ // word wrap all columns, and create
+ // a data-structure that is easy to rasterize.
+ row.forEach((col, c) => {
+ // leave room for left and right padding.
+ col.width = widths[c];
+ if (this.wrap) {
+ wrapped = mixin.wrap(col.text, this.negatePadding(col), { hard: true }).split('\n');
+ }
+ else {
+ wrapped = col.text.split('\n');
+ }
+ if (col.border) {
+ wrapped.unshift('.' + '-'.repeat(this.negatePadding(col) + 2) + '.');
+ wrapped.push("'" + '-'.repeat(this.negatePadding(col) + 2) + "'");
+ }
+ // add top and bottom padding.
+ if (col.padding) {
+ wrapped.unshift(...new Array(col.padding[top] || 0).fill(''));
+ wrapped.push(...new Array(col.padding[bottom] || 0).fill(''));
+ }
+ wrapped.forEach((str, r) => {
+ if (!rrows[r]) {
+ rrows.push([]);
+ }
+ const rrow = rrows[r];
+ for (let i = 0; i < c; i++) {
+ if (rrow[i] === undefined) {
+ rrow.push('');
+ }
+ }
+ rrow.push(str);
+ });
+ });
+ return rrows;
+ }
+ negatePadding(col) {
+ /* c8 ignore start */
+ let wrapWidth = col.width || 0;
+ /* c8 ignore stop */
+ if (col.padding) {
+ wrapWidth -= (col.padding[left] || 0) + (col.padding[right] || 0);
+ }
+ if (col.border) {
+ wrapWidth -= 4;
+ }
+ return wrapWidth;
+ }
+ columnWidths(row) {
+ if (!this.wrap) {
+ return row.map(col => {
+ return col.width || mixin.stringWidth(col.text);
+ });
+ }
+ let unset = row.length;
+ let remainingWidth = this.width;
+ // column widths can be set in config.
+ const widths = row.map(col => {
+ if (col.width) {
+ unset--;
+ remainingWidth -= col.width;
+ return col.width;
+ }
+ return undefined;
+ });
+ // any unset widths should be calculated.
+ /* c8 ignore start */
+ const unsetWidth = unset ? Math.floor(remainingWidth / unset) : 0;
+ /* c8 ignore stop */
+ return widths.map((w, i) => {
+ if (w === undefined) {
+ return Math.max(unsetWidth, _minWidth(row[i]));
+ }
+ return w;
+ });
+ }
+}
+function addBorder(col, ts, style) {
+ if (col.border) {
+ if (/[.']-+[.']/.test(ts)) {
+ return '';
+ }
+ if (ts.trim().length !== 0) {
+ return style;
+ }
+ return ' ';
+ }
+ return '';
+}
+// calculates the minimum width of
+// a column, based on padding preferences.
+function _minWidth(col) {
+ const padding = col.padding || [];
+ const minWidth = 1 + (padding[left] || 0) + (padding[right] || 0);
+ if (col.border) {
+ return minWidth + 4;
+ }
+ return minWidth;
+}
+function getWindowWidth() {
+ /* c8 ignore start */
+ if (typeof process === 'object' && process.stdout && process.stdout.columns) {
+ return process.stdout.columns;
+ }
+ return 80;
+}
+/* c8 ignore stop */
+function alignRight(str, width) {
+ str = str.trim();
+ const strWidth = mixin.stringWidth(str);
+ if (strWidth < width) {
+ return ' '.repeat(width - strWidth) + str;
+ }
+ return str;
+}
+function alignCenter(str, width) {
+ str = str.trim();
+ const strWidth = mixin.stringWidth(str);
+ /* c8 ignore start */
+ if (strWidth >= width) {
+ return str;
+ }
+ /* c8 ignore stop */
+ return ' '.repeat((width - strWidth) >> 1) + str;
+}
+let mixin;
+export function cliui(opts, _mixin) {
+ mixin = _mixin;
+ return new UI({
+ /* c8 ignore start */
+ width: (opts === null || opts === void 0 ? void 0 : opts.width) || getWindowWidth(),
+ wrap: opts === null || opts === void 0 ? void 0 : opts.wrap
+ /* c8 ignore stop */
+ });
+}
diff --git a/sdk/node_modules/@isaacs/cliui/index.mjs b/sdk/node_modules/@isaacs/cliui/index.mjs
new file mode 100644
index 00000000..5177519a
--- /dev/null
+++ b/sdk/node_modules/@isaacs/cliui/index.mjs
@@ -0,0 +1,14 @@
+// Bootstrap cliui with ESM dependencies:
+import { cliui } from './build/lib/index.js'
+
+import stringWidth from 'string-width'
+import stripAnsi from 'strip-ansi'
+import wrap from 'wrap-ansi'
+
+export default function ui (opts) {
+ return cliui(opts, {
+ stringWidth,
+ stripAnsi,
+ wrap
+ })
+}
diff --git a/sdk/node_modules/@isaacs/cliui/package.json b/sdk/node_modules/@isaacs/cliui/package.json
new file mode 100644
index 00000000..7a952532
--- /dev/null
+++ b/sdk/node_modules/@isaacs/cliui/package.json
@@ -0,0 +1,86 @@
+{
+ "name": "@isaacs/cliui",
+ "version": "8.0.2",
+ "description": "easily create complex multi-column command-line-interfaces",
+ "main": "build/index.cjs",
+ "exports": {
+ ".": [
+ {
+ "import": "./index.mjs",
+ "require": "./build/index.cjs"
+ },
+ "./build/index.cjs"
+ ]
+ },
+ "type": "module",
+ "module": "./index.mjs",
+ "scripts": {
+ "check": "standardx '**/*.ts' && standardx '**/*.js' && standardx '**/*.cjs'",
+ "fix": "standardx --fix '**/*.ts' && standardx --fix '**/*.js' && standardx --fix '**/*.cjs'",
+ "pretest": "rimraf build && tsc -p tsconfig.test.json && cross-env NODE_ENV=test npm run build:cjs",
+ "test": "c8 mocha ./test/*.cjs",
+ "test:esm": "c8 mocha ./test/**/*.mjs",
+ "postest": "check",
+ "coverage": "c8 report --check-coverage",
+ "precompile": "rimraf build",
+ "compile": "tsc",
+ "postcompile": "npm run build:cjs",
+ "build:cjs": "rollup -c",
+ "prepare": "npm run compile"
+ },
+ "repository": "yargs/cliui",
+ "standard": {
+ "ignore": [
+ "**/example/**"
+ ],
+ "globals": [
+ "it"
+ ]
+ },
+ "keywords": [
+ "cli",
+ "command-line",
+ "layout",
+ "design",
+ "console",
+ "wrap",
+ "table"
+ ],
+ "author": "Ben Coe ",
+ "license": "ISC",
+ "dependencies": {
+ "string-width": "^5.1.2",
+ "string-width-cjs": "npm:string-width@^4.2.0",
+ "strip-ansi": "^7.0.1",
+ "strip-ansi-cjs": "npm:strip-ansi@^6.0.1",
+ "wrap-ansi": "^8.1.0",
+ "wrap-ansi-cjs": "npm:wrap-ansi@^7.0.0"
+ },
+ "devDependencies": {
+ "@types/node": "^14.0.27",
+ "@typescript-eslint/eslint-plugin": "^4.0.0",
+ "@typescript-eslint/parser": "^4.0.0",
+ "c8": "^7.3.0",
+ "chai": "^4.2.0",
+ "chalk": "^4.1.0",
+ "cross-env": "^7.0.2",
+ "eslint": "^7.6.0",
+ "eslint-plugin-import": "^2.22.0",
+ "eslint-plugin-node": "^11.1.0",
+ "gts": "^3.0.0",
+ "mocha": "^10.0.0",
+ "rimraf": "^3.0.2",
+ "rollup": "^2.23.1",
+ "rollup-plugin-ts": "^3.0.2",
+ "standardx": "^7.0.0",
+ "typescript": "^4.0.0"
+ },
+ "files": [
+ "build",
+ "index.mjs",
+ "!*.d.ts"
+ ],
+ "engines": {
+ "node": ">=12"
+ }
+}
diff --git a/sdk/node_modules/@jridgewell/gen-mapping/LICENSE b/sdk/node_modules/@jridgewell/gen-mapping/LICENSE
new file mode 100644
index 00000000..1f6ce94c
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/gen-mapping/LICENSE
@@ -0,0 +1,19 @@
+Copyright 2024 Justin Ridgewell
+
+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.
diff --git a/sdk/node_modules/@jridgewell/gen-mapping/README.md b/sdk/node_modules/@jridgewell/gen-mapping/README.md
new file mode 100644
index 00000000..93692b10
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/gen-mapping/README.md
@@ -0,0 +1,227 @@
+# @jridgewell/gen-mapping
+
+> Generate source maps
+
+`gen-mapping` allows you to generate a source map during transpilation or minification.
+With a source map, you're able to trace the original location in the source file, either in Chrome's
+DevTools or using a library like [`@jridgewell/trace-mapping`][trace-mapping].
+
+You may already be familiar with the [`source-map`][source-map] package's `SourceMapGenerator`. This
+provides the same `addMapping` and `setSourceContent` API.
+
+## Installation
+
+```sh
+npm install @jridgewell/gen-mapping
+```
+
+## Usage
+
+```typescript
+import { GenMapping, addMapping, setSourceContent, toEncodedMap, toDecodedMap } from '@jridgewell/gen-mapping';
+
+const map = new GenMapping({
+ file: 'output.js',
+ sourceRoot: 'https://example.com/',
+});
+
+setSourceContent(map, 'input.js', `function foo() {}`);
+
+addMapping(map, {
+ // Lines start at line 1, columns at column 0.
+ generated: { line: 1, column: 0 },
+ source: 'input.js',
+ original: { line: 1, column: 0 },
+});
+
+addMapping(map, {
+ generated: { line: 1, column: 9 },
+ source: 'input.js',
+ original: { line: 1, column: 9 },
+ name: 'foo',
+});
+
+assert.deepEqual(toDecodedMap(map), {
+ version: 3,
+ file: 'output.js',
+ names: ['foo'],
+ sourceRoot: 'https://example.com/',
+ sources: ['input.js'],
+ sourcesContent: ['function foo() {}'],
+ mappings: [
+ [ [0, 0, 0, 0], [9, 0, 0, 9, 0] ]
+ ],
+});
+
+assert.deepEqual(toEncodedMap(map), {
+ version: 3,
+ file: 'output.js',
+ names: ['foo'],
+ sourceRoot: 'https://example.com/',
+ sources: ['input.js'],
+ sourcesContent: ['function foo() {}'],
+ mappings: 'AAAA,SAASA',
+});
+```
+
+### Smaller Sourcemaps
+
+Not everything needs to be added to a sourcemap, and needless markings can cause signficantly
+larger file sizes. `gen-mapping` exposes `maybeAddSegment`/`maybeAddMapping` APIs that will
+intelligently determine if this marking adds useful information. If not, the marking will be
+skipped.
+
+```typescript
+import { maybeAddMapping } from '@jridgewell/gen-mapping';
+
+const map = new GenMapping();
+
+// Adding a sourceless marking at the beginning of a line isn't useful.
+maybeAddMapping(map, {
+ generated: { line: 1, column: 0 },
+});
+
+// Adding a new source marking is useful.
+maybeAddMapping(map, {
+ generated: { line: 1, column: 0 },
+ source: 'input.js',
+ original: { line: 1, column: 0 },
+});
+
+// But adding another marking pointing to the exact same original location isn't, even if the
+// generated column changed.
+maybeAddMapping(map, {
+ generated: { line: 1, column: 9 },
+ source: 'input.js',
+ original: { line: 1, column: 0 },
+});
+
+assert.deepEqual(toEncodedMap(map), {
+ version: 3,
+ names: [],
+ sources: ['input.js'],
+ sourcesContent: [null],
+ mappings: 'AAAA',
+});
+```
+
+## Benchmarks
+
+```
+node v18.0.0
+
+amp.js.map
+Memory Usage:
+gen-mapping: addSegment 5852872 bytes
+gen-mapping: addMapping 7716042 bytes
+source-map-js 6143250 bytes
+source-map-0.6.1 6124102 bytes
+source-map-0.8.0 6121173 bytes
+Smallest memory usage is gen-mapping: addSegment
+
+Adding speed:
+gen-mapping: addSegment x 441 ops/sec ±2.07% (90 runs sampled)
+gen-mapping: addMapping x 350 ops/sec ±2.40% (86 runs sampled)
+source-map-js: addMapping x 169 ops/sec ±2.42% (80 runs sampled)
+source-map-0.6.1: addMapping x 167 ops/sec ±2.56% (80 runs sampled)
+source-map-0.8.0: addMapping x 168 ops/sec ±2.52% (80 runs sampled)
+Fastest is gen-mapping: addSegment
+
+Generate speed:
+gen-mapping: decoded output x 150,824,370 ops/sec ±0.07% (102 runs sampled)
+gen-mapping: encoded output x 663 ops/sec ±0.22% (98 runs sampled)
+source-map-js: encoded output x 197 ops/sec ±0.45% (84 runs sampled)
+source-map-0.6.1: encoded output x 198 ops/sec ±0.33% (85 runs sampled)
+source-map-0.8.0: encoded output x 197 ops/sec ±0.06% (93 runs sampled)
+Fastest is gen-mapping: decoded output
+
+
+***
+
+
+babel.min.js.map
+Memory Usage:
+gen-mapping: addSegment 37578063 bytes
+gen-mapping: addMapping 37212897 bytes
+source-map-js 47638527 bytes
+source-map-0.6.1 47690503 bytes
+source-map-0.8.0 47470188 bytes
+Smallest memory usage is gen-mapping: addMapping
+
+Adding speed:
+gen-mapping: addSegment x 31.05 ops/sec ±8.31% (43 runs sampled)
+gen-mapping: addMapping x 29.83 ops/sec ±7.36% (51 runs sampled)
+source-map-js: addMapping x 20.73 ops/sec ±6.22% (38 runs sampled)
+source-map-0.6.1: addMapping x 20.03 ops/sec ±10.51% (38 runs sampled)
+source-map-0.8.0: addMapping x 19.30 ops/sec ±8.27% (37 runs sampled)
+Fastest is gen-mapping: addSegment
+
+Generate speed:
+gen-mapping: decoded output x 381,379,234 ops/sec ±0.29% (96 runs sampled)
+gen-mapping: encoded output x 95.15 ops/sec ±2.98% (72 runs sampled)
+source-map-js: encoded output x 15.20 ops/sec ±7.41% (33 runs sampled)
+source-map-0.6.1: encoded output x 16.36 ops/sec ±10.46% (31 runs sampled)
+source-map-0.8.0: encoded output x 16.06 ops/sec ±6.45% (31 runs sampled)
+Fastest is gen-mapping: decoded output
+
+
+***
+
+
+preact.js.map
+Memory Usage:
+gen-mapping: addSegment 416247 bytes
+gen-mapping: addMapping 419824 bytes
+source-map-js 1024619 bytes
+source-map-0.6.1 1146004 bytes
+source-map-0.8.0 1113250 bytes
+Smallest memory usage is gen-mapping: addSegment
+
+Adding speed:
+gen-mapping: addSegment x 13,755 ops/sec ±0.15% (98 runs sampled)
+gen-mapping: addMapping x 13,013 ops/sec ±0.11% (101 runs sampled)
+source-map-js: addMapping x 4,564 ops/sec ±0.21% (98 runs sampled)
+source-map-0.6.1: addMapping x 4,562 ops/sec ±0.11% (99 runs sampled)
+source-map-0.8.0: addMapping x 4,593 ops/sec ±0.11% (100 runs sampled)
+Fastest is gen-mapping: addSegment
+
+Generate speed:
+gen-mapping: decoded output x 379,864,020 ops/sec ±0.23% (93 runs sampled)
+gen-mapping: encoded output x 14,368 ops/sec ±4.07% (82 runs sampled)
+source-map-js: encoded output x 5,261 ops/sec ±0.21% (99 runs sampled)
+source-map-0.6.1: encoded output x 5,124 ops/sec ±0.58% (99 runs sampled)
+source-map-0.8.0: encoded output x 5,434 ops/sec ±0.33% (96 runs sampled)
+Fastest is gen-mapping: decoded output
+
+
+***
+
+
+react.js.map
+Memory Usage:
+gen-mapping: addSegment 975096 bytes
+gen-mapping: addMapping 1102981 bytes
+source-map-js 2918836 bytes
+source-map-0.6.1 2885435 bytes
+source-map-0.8.0 2874336 bytes
+Smallest memory usage is gen-mapping: addSegment
+
+Adding speed:
+gen-mapping: addSegment x 4,772 ops/sec ±0.15% (100 runs sampled)
+gen-mapping: addMapping x 4,456 ops/sec ±0.13% (97 runs sampled)
+source-map-js: addMapping x 1,618 ops/sec ±0.24% (97 runs sampled)
+source-map-0.6.1: addMapping x 1,622 ops/sec ±0.12% (99 runs sampled)
+source-map-0.8.0: addMapping x 1,631 ops/sec ±0.12% (100 runs sampled)
+Fastest is gen-mapping: addSegment
+
+Generate speed:
+gen-mapping: decoded output x 379,107,695 ops/sec ±0.07% (99 runs sampled)
+gen-mapping: encoded output x 5,421 ops/sec ±1.60% (89 runs sampled)
+source-map-js: encoded output x 2,113 ops/sec ±1.81% (98 runs sampled)
+source-map-0.6.1: encoded output x 2,126 ops/sec ±0.10% (100 runs sampled)
+source-map-0.8.0: encoded output x 2,176 ops/sec ±0.39% (98 runs sampled)
+Fastest is gen-mapping: decoded output
+```
+
+[source-map]: https://www.npmjs.com/package/source-map
+[trace-mapping]: https://github.com/jridgewell/sourcemaps/tree/main/packages/trace-mapping
diff --git a/sdk/node_modules/@jridgewell/gen-mapping/dist/gen-mapping.mjs b/sdk/node_modules/@jridgewell/gen-mapping/dist/gen-mapping.mjs
new file mode 100644
index 00000000..bbb0cacc
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/gen-mapping/dist/gen-mapping.mjs
@@ -0,0 +1,292 @@
+// src/set-array.ts
+var SetArray = class {
+ constructor() {
+ this._indexes = { __proto__: null };
+ this.array = [];
+ }
+};
+function cast(set) {
+ return set;
+}
+function get(setarr, key) {
+ return cast(setarr)._indexes[key];
+}
+function put(setarr, key) {
+ const index = get(setarr, key);
+ if (index !== void 0) return index;
+ const { array, _indexes: indexes } = cast(setarr);
+ const length = array.push(key);
+ return indexes[key] = length - 1;
+}
+function remove(setarr, key) {
+ const index = get(setarr, key);
+ if (index === void 0) return;
+ const { array, _indexes: indexes } = cast(setarr);
+ for (let i = index + 1; i < array.length; i++) {
+ const k = array[i];
+ array[i - 1] = k;
+ indexes[k]--;
+ }
+ indexes[key] = void 0;
+ array.pop();
+}
+
+// src/gen-mapping.ts
+import {
+ encode
+} from "@jridgewell/sourcemap-codec";
+import { TraceMap, decodedMappings } from "@jridgewell/trace-mapping";
+
+// src/sourcemap-segment.ts
+var COLUMN = 0;
+var SOURCES_INDEX = 1;
+var SOURCE_LINE = 2;
+var SOURCE_COLUMN = 3;
+var NAMES_INDEX = 4;
+
+// src/gen-mapping.ts
+var NO_NAME = -1;
+var GenMapping = class {
+ constructor({ file, sourceRoot } = {}) {
+ this._names = new SetArray();
+ this._sources = new SetArray();
+ this._sourcesContent = [];
+ this._mappings = [];
+ this.file = file;
+ this.sourceRoot = sourceRoot;
+ this._ignoreList = new SetArray();
+ }
+};
+function cast2(map) {
+ return map;
+}
+function addSegment(map, genLine, genColumn, source, sourceLine, sourceColumn, name, content) {
+ return addSegmentInternal(
+ false,
+ map,
+ genLine,
+ genColumn,
+ source,
+ sourceLine,
+ sourceColumn,
+ name,
+ content
+ );
+}
+function addMapping(map, mapping) {
+ return addMappingInternal(false, map, mapping);
+}
+var maybeAddSegment = (map, genLine, genColumn, source, sourceLine, sourceColumn, name, content) => {
+ return addSegmentInternal(
+ true,
+ map,
+ genLine,
+ genColumn,
+ source,
+ sourceLine,
+ sourceColumn,
+ name,
+ content
+ );
+};
+var maybeAddMapping = (map, mapping) => {
+ return addMappingInternal(true, map, mapping);
+};
+function setSourceContent(map, source, content) {
+ const {
+ _sources: sources,
+ _sourcesContent: sourcesContent
+ // _originalScopes: originalScopes,
+ } = cast2(map);
+ const index = put(sources, source);
+ sourcesContent[index] = content;
+}
+function setIgnore(map, source, ignore = true) {
+ const {
+ _sources: sources,
+ _sourcesContent: sourcesContent,
+ _ignoreList: ignoreList
+ // _originalScopes: originalScopes,
+ } = cast2(map);
+ const index = put(sources, source);
+ if (index === sourcesContent.length) sourcesContent[index] = null;
+ if (ignore) put(ignoreList, index);
+ else remove(ignoreList, index);
+}
+function toDecodedMap(map) {
+ const {
+ _mappings: mappings,
+ _sources: sources,
+ _sourcesContent: sourcesContent,
+ _names: names,
+ _ignoreList: ignoreList
+ // _originalScopes: originalScopes,
+ // _generatedRanges: generatedRanges,
+ } = cast2(map);
+ removeEmptyFinalLines(mappings);
+ return {
+ version: 3,
+ file: map.file || void 0,
+ names: names.array,
+ sourceRoot: map.sourceRoot || void 0,
+ sources: sources.array,
+ sourcesContent,
+ mappings,
+ // originalScopes,
+ // generatedRanges,
+ ignoreList: ignoreList.array
+ };
+}
+function toEncodedMap(map) {
+ const decoded = toDecodedMap(map);
+ return Object.assign({}, decoded, {
+ // originalScopes: decoded.originalScopes.map((os) => encodeOriginalScopes(os)),
+ // generatedRanges: encodeGeneratedRanges(decoded.generatedRanges as GeneratedRange[]),
+ mappings: encode(decoded.mappings)
+ });
+}
+function fromMap(input) {
+ const map = new TraceMap(input);
+ const gen = new GenMapping({ file: map.file, sourceRoot: map.sourceRoot });
+ putAll(cast2(gen)._names, map.names);
+ putAll(cast2(gen)._sources, map.sources);
+ cast2(gen)._sourcesContent = map.sourcesContent || map.sources.map(() => null);
+ cast2(gen)._mappings = decodedMappings(map);
+ if (map.ignoreList) putAll(cast2(gen)._ignoreList, map.ignoreList);
+ return gen;
+}
+function allMappings(map) {
+ const out = [];
+ const { _mappings: mappings, _sources: sources, _names: names } = cast2(map);
+ for (let i = 0; i < mappings.length; i++) {
+ const line = mappings[i];
+ for (let j = 0; j < line.length; j++) {
+ const seg = line[j];
+ const generated = { line: i + 1, column: seg[COLUMN] };
+ let source = void 0;
+ let original = void 0;
+ let name = void 0;
+ if (seg.length !== 1) {
+ source = sources.array[seg[SOURCES_INDEX]];
+ original = { line: seg[SOURCE_LINE] + 1, column: seg[SOURCE_COLUMN] };
+ if (seg.length === 5) name = names.array[seg[NAMES_INDEX]];
+ }
+ out.push({ generated, source, original, name });
+ }
+ }
+ return out;
+}
+function addSegmentInternal(skipable, map, genLine, genColumn, source, sourceLine, sourceColumn, name, content) {
+ const {
+ _mappings: mappings,
+ _sources: sources,
+ _sourcesContent: sourcesContent,
+ _names: names
+ // _originalScopes: originalScopes,
+ } = cast2(map);
+ const line = getIndex(mappings, genLine);
+ const index = getColumnIndex(line, genColumn);
+ if (!source) {
+ if (skipable && skipSourceless(line, index)) return;
+ return insert(line, index, [genColumn]);
+ }
+ assert(sourceLine);
+ assert(sourceColumn);
+ const sourcesIndex = put(sources, source);
+ const namesIndex = name ? put(names, name) : NO_NAME;
+ if (sourcesIndex === sourcesContent.length) sourcesContent[sourcesIndex] = content != null ? content : null;
+ if (skipable && skipSource(line, index, sourcesIndex, sourceLine, sourceColumn, namesIndex)) {
+ return;
+ }
+ return insert(
+ line,
+ index,
+ name ? [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex] : [genColumn, sourcesIndex, sourceLine, sourceColumn]
+ );
+}
+function assert(_val) {
+}
+function getIndex(arr, index) {
+ for (let i = arr.length; i <= index; i++) {
+ arr[i] = [];
+ }
+ return arr[index];
+}
+function getColumnIndex(line, genColumn) {
+ let index = line.length;
+ for (let i = index - 1; i >= 0; index = i--) {
+ const current = line[i];
+ if (genColumn >= current[COLUMN]) break;
+ }
+ return index;
+}
+function insert(array, index, value) {
+ for (let i = array.length; i > index; i--) {
+ array[i] = array[i - 1];
+ }
+ array[index] = value;
+}
+function removeEmptyFinalLines(mappings) {
+ const { length } = mappings;
+ let len = length;
+ for (let i = len - 1; i >= 0; len = i, i--) {
+ if (mappings[i].length > 0) break;
+ }
+ if (len < length) mappings.length = len;
+}
+function putAll(setarr, array) {
+ for (let i = 0; i < array.length; i++) put(setarr, array[i]);
+}
+function skipSourceless(line, index) {
+ if (index === 0) return true;
+ const prev = line[index - 1];
+ return prev.length === 1;
+}
+function skipSource(line, index, sourcesIndex, sourceLine, sourceColumn, namesIndex) {
+ if (index === 0) return false;
+ const prev = line[index - 1];
+ if (prev.length === 1) return false;
+ return sourcesIndex === prev[SOURCES_INDEX] && sourceLine === prev[SOURCE_LINE] && sourceColumn === prev[SOURCE_COLUMN] && namesIndex === (prev.length === 5 ? prev[NAMES_INDEX] : NO_NAME);
+}
+function addMappingInternal(skipable, map, mapping) {
+ const { generated, source, original, name, content } = mapping;
+ if (!source) {
+ return addSegmentInternal(
+ skipable,
+ map,
+ generated.line - 1,
+ generated.column,
+ null,
+ null,
+ null,
+ null,
+ null
+ );
+ }
+ assert(original);
+ return addSegmentInternal(
+ skipable,
+ map,
+ generated.line - 1,
+ generated.column,
+ source,
+ original.line - 1,
+ original.column,
+ name,
+ content
+ );
+}
+export {
+ GenMapping,
+ addMapping,
+ addSegment,
+ allMappings,
+ fromMap,
+ maybeAddMapping,
+ maybeAddSegment,
+ setIgnore,
+ setSourceContent,
+ toDecodedMap,
+ toEncodedMap
+};
+//# sourceMappingURL=gen-mapping.mjs.map
diff --git a/sdk/node_modules/@jridgewell/gen-mapping/dist/gen-mapping.mjs.map b/sdk/node_modules/@jridgewell/gen-mapping/dist/gen-mapping.mjs.map
new file mode 100644
index 00000000..4e37e457
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/gen-mapping/dist/gen-mapping.mjs.map
@@ -0,0 +1,6 @@
+{
+ "version": 3,
+ "sources": ["../src/set-array.ts", "../src/gen-mapping.ts", "../src/sourcemap-segment.ts"],
+ "mappings": "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",
+ "names": ["cast"]
+}
diff --git a/sdk/node_modules/@jridgewell/gen-mapping/dist/gen-mapping.umd.js b/sdk/node_modules/@jridgewell/gen-mapping/dist/gen-mapping.umd.js
new file mode 100644
index 00000000..cb84af55
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/gen-mapping/dist/gen-mapping.umd.js
@@ -0,0 +1,358 @@
+(function (global, factory) {
+ if (typeof exports === 'object' && typeof module !== 'undefined') {
+ factory(module, require('@jridgewell/sourcemap-codec'), require('@jridgewell/trace-mapping'));
+ module.exports = def(module);
+ } else if (typeof define === 'function' && define.amd) {
+ define(['module', '@jridgewell/sourcemap-codec', '@jridgewell/trace-mapping'], function(mod) {
+ factory.apply(this, arguments);
+ mod.exports = def(mod);
+ });
+ } else {
+ const mod = { exports: {} };
+ factory(mod, global.sourcemapCodec, global.traceMapping);
+ global = typeof globalThis !== 'undefined' ? globalThis : global || self;
+ global.genMapping = def(mod);
+ }
+ function def(m) { return 'default' in m.exports ? m.exports.default : m.exports; }
+})(this, (function (module, require_sourcemapCodec, require_traceMapping) {
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+ return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+ for (var name in all)
+ __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+ if (from && typeof from === "object" || typeof from === "function") {
+ for (let key of __getOwnPropNames(from))
+ if (!__hasOwnProp.call(to, key) && key !== except)
+ __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+ }
+ return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+ // If the importer is in node compatibility mode or this is not an ESM
+ // file that has been converted to a CommonJS file using a Babel-
+ // compatible transform (i.e. "__esModule" has not been set), then set
+ // "default" to the CommonJS "module.exports" for node compatibility.
+ isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+ mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// umd:@jridgewell/sourcemap-codec
+var require_sourcemap_codec = __commonJS({
+ "umd:@jridgewell/sourcemap-codec"(exports, module2) {
+ module2.exports = require_sourcemapCodec;
+ }
+});
+
+// umd:@jridgewell/trace-mapping
+var require_trace_mapping = __commonJS({
+ "umd:@jridgewell/trace-mapping"(exports, module2) {
+ module2.exports = require_traceMapping;
+ }
+});
+
+// src/gen-mapping.ts
+var gen_mapping_exports = {};
+__export(gen_mapping_exports, {
+ GenMapping: () => GenMapping,
+ addMapping: () => addMapping,
+ addSegment: () => addSegment,
+ allMappings: () => allMappings,
+ fromMap: () => fromMap,
+ maybeAddMapping: () => maybeAddMapping,
+ maybeAddSegment: () => maybeAddSegment,
+ setIgnore: () => setIgnore,
+ setSourceContent: () => setSourceContent,
+ toDecodedMap: () => toDecodedMap,
+ toEncodedMap: () => toEncodedMap
+});
+module.exports = __toCommonJS(gen_mapping_exports);
+
+// src/set-array.ts
+var SetArray = class {
+ constructor() {
+ this._indexes = { __proto__: null };
+ this.array = [];
+ }
+};
+function cast(set) {
+ return set;
+}
+function get(setarr, key) {
+ return cast(setarr)._indexes[key];
+}
+function put(setarr, key) {
+ const index = get(setarr, key);
+ if (index !== void 0) return index;
+ const { array, _indexes: indexes } = cast(setarr);
+ const length = array.push(key);
+ return indexes[key] = length - 1;
+}
+function remove(setarr, key) {
+ const index = get(setarr, key);
+ if (index === void 0) return;
+ const { array, _indexes: indexes } = cast(setarr);
+ for (let i = index + 1; i < array.length; i++) {
+ const k = array[i];
+ array[i - 1] = k;
+ indexes[k]--;
+ }
+ indexes[key] = void 0;
+ array.pop();
+}
+
+// src/gen-mapping.ts
+var import_sourcemap_codec = __toESM(require_sourcemap_codec());
+var import_trace_mapping = __toESM(require_trace_mapping());
+
+// src/sourcemap-segment.ts
+var COLUMN = 0;
+var SOURCES_INDEX = 1;
+var SOURCE_LINE = 2;
+var SOURCE_COLUMN = 3;
+var NAMES_INDEX = 4;
+
+// src/gen-mapping.ts
+var NO_NAME = -1;
+var GenMapping = class {
+ constructor({ file, sourceRoot } = {}) {
+ this._names = new SetArray();
+ this._sources = new SetArray();
+ this._sourcesContent = [];
+ this._mappings = [];
+ this.file = file;
+ this.sourceRoot = sourceRoot;
+ this._ignoreList = new SetArray();
+ }
+};
+function cast2(map) {
+ return map;
+}
+function addSegment(map, genLine, genColumn, source, sourceLine, sourceColumn, name, content) {
+ return addSegmentInternal(
+ false,
+ map,
+ genLine,
+ genColumn,
+ source,
+ sourceLine,
+ sourceColumn,
+ name,
+ content
+ );
+}
+function addMapping(map, mapping) {
+ return addMappingInternal(false, map, mapping);
+}
+var maybeAddSegment = (map, genLine, genColumn, source, sourceLine, sourceColumn, name, content) => {
+ return addSegmentInternal(
+ true,
+ map,
+ genLine,
+ genColumn,
+ source,
+ sourceLine,
+ sourceColumn,
+ name,
+ content
+ );
+};
+var maybeAddMapping = (map, mapping) => {
+ return addMappingInternal(true, map, mapping);
+};
+function setSourceContent(map, source, content) {
+ const {
+ _sources: sources,
+ _sourcesContent: sourcesContent
+ // _originalScopes: originalScopes,
+ } = cast2(map);
+ const index = put(sources, source);
+ sourcesContent[index] = content;
+}
+function setIgnore(map, source, ignore = true) {
+ const {
+ _sources: sources,
+ _sourcesContent: sourcesContent,
+ _ignoreList: ignoreList
+ // _originalScopes: originalScopes,
+ } = cast2(map);
+ const index = put(sources, source);
+ if (index === sourcesContent.length) sourcesContent[index] = null;
+ if (ignore) put(ignoreList, index);
+ else remove(ignoreList, index);
+}
+function toDecodedMap(map) {
+ const {
+ _mappings: mappings,
+ _sources: sources,
+ _sourcesContent: sourcesContent,
+ _names: names,
+ _ignoreList: ignoreList
+ // _originalScopes: originalScopes,
+ // _generatedRanges: generatedRanges,
+ } = cast2(map);
+ removeEmptyFinalLines(mappings);
+ return {
+ version: 3,
+ file: map.file || void 0,
+ names: names.array,
+ sourceRoot: map.sourceRoot || void 0,
+ sources: sources.array,
+ sourcesContent,
+ mappings,
+ // originalScopes,
+ // generatedRanges,
+ ignoreList: ignoreList.array
+ };
+}
+function toEncodedMap(map) {
+ const decoded = toDecodedMap(map);
+ return Object.assign({}, decoded, {
+ // originalScopes: decoded.originalScopes.map((os) => encodeOriginalScopes(os)),
+ // generatedRanges: encodeGeneratedRanges(decoded.generatedRanges as GeneratedRange[]),
+ mappings: (0, import_sourcemap_codec.encode)(decoded.mappings)
+ });
+}
+function fromMap(input) {
+ const map = new import_trace_mapping.TraceMap(input);
+ const gen = new GenMapping({ file: map.file, sourceRoot: map.sourceRoot });
+ putAll(cast2(gen)._names, map.names);
+ putAll(cast2(gen)._sources, map.sources);
+ cast2(gen)._sourcesContent = map.sourcesContent || map.sources.map(() => null);
+ cast2(gen)._mappings = (0, import_trace_mapping.decodedMappings)(map);
+ if (map.ignoreList) putAll(cast2(gen)._ignoreList, map.ignoreList);
+ return gen;
+}
+function allMappings(map) {
+ const out = [];
+ const { _mappings: mappings, _sources: sources, _names: names } = cast2(map);
+ for (let i = 0; i < mappings.length; i++) {
+ const line = mappings[i];
+ for (let j = 0; j < line.length; j++) {
+ const seg = line[j];
+ const generated = { line: i + 1, column: seg[COLUMN] };
+ let source = void 0;
+ let original = void 0;
+ let name = void 0;
+ if (seg.length !== 1) {
+ source = sources.array[seg[SOURCES_INDEX]];
+ original = { line: seg[SOURCE_LINE] + 1, column: seg[SOURCE_COLUMN] };
+ if (seg.length === 5) name = names.array[seg[NAMES_INDEX]];
+ }
+ out.push({ generated, source, original, name });
+ }
+ }
+ return out;
+}
+function addSegmentInternal(skipable, map, genLine, genColumn, source, sourceLine, sourceColumn, name, content) {
+ const {
+ _mappings: mappings,
+ _sources: sources,
+ _sourcesContent: sourcesContent,
+ _names: names
+ // _originalScopes: originalScopes,
+ } = cast2(map);
+ const line = getIndex(mappings, genLine);
+ const index = getColumnIndex(line, genColumn);
+ if (!source) {
+ if (skipable && skipSourceless(line, index)) return;
+ return insert(line, index, [genColumn]);
+ }
+ assert(sourceLine);
+ assert(sourceColumn);
+ const sourcesIndex = put(sources, source);
+ const namesIndex = name ? put(names, name) : NO_NAME;
+ if (sourcesIndex === sourcesContent.length) sourcesContent[sourcesIndex] = content != null ? content : null;
+ if (skipable && skipSource(line, index, sourcesIndex, sourceLine, sourceColumn, namesIndex)) {
+ return;
+ }
+ return insert(
+ line,
+ index,
+ name ? [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex] : [genColumn, sourcesIndex, sourceLine, sourceColumn]
+ );
+}
+function assert(_val) {
+}
+function getIndex(arr, index) {
+ for (let i = arr.length; i <= index; i++) {
+ arr[i] = [];
+ }
+ return arr[index];
+}
+function getColumnIndex(line, genColumn) {
+ let index = line.length;
+ for (let i = index - 1; i >= 0; index = i--) {
+ const current = line[i];
+ if (genColumn >= current[COLUMN]) break;
+ }
+ return index;
+}
+function insert(array, index, value) {
+ for (let i = array.length; i > index; i--) {
+ array[i] = array[i - 1];
+ }
+ array[index] = value;
+}
+function removeEmptyFinalLines(mappings) {
+ const { length } = mappings;
+ let len = length;
+ for (let i = len - 1; i >= 0; len = i, i--) {
+ if (mappings[i].length > 0) break;
+ }
+ if (len < length) mappings.length = len;
+}
+function putAll(setarr, array) {
+ for (let i = 0; i < array.length; i++) put(setarr, array[i]);
+}
+function skipSourceless(line, index) {
+ if (index === 0) return true;
+ const prev = line[index - 1];
+ return prev.length === 1;
+}
+function skipSource(line, index, sourcesIndex, sourceLine, sourceColumn, namesIndex) {
+ if (index === 0) return false;
+ const prev = line[index - 1];
+ if (prev.length === 1) return false;
+ return sourcesIndex === prev[SOURCES_INDEX] && sourceLine === prev[SOURCE_LINE] && sourceColumn === prev[SOURCE_COLUMN] && namesIndex === (prev.length === 5 ? prev[NAMES_INDEX] : NO_NAME);
+}
+function addMappingInternal(skipable, map, mapping) {
+ const { generated, source, original, name, content } = mapping;
+ if (!source) {
+ return addSegmentInternal(
+ skipable,
+ map,
+ generated.line - 1,
+ generated.column,
+ null,
+ null,
+ null,
+ null,
+ null
+ );
+ }
+ assert(original);
+ return addSegmentInternal(
+ skipable,
+ map,
+ generated.line - 1,
+ generated.column,
+ source,
+ original.line - 1,
+ original.column,
+ name,
+ content
+ );
+}
+}));
+//# sourceMappingURL=gen-mapping.umd.js.map
diff --git a/sdk/node_modules/@jridgewell/gen-mapping/dist/gen-mapping.umd.js.map b/sdk/node_modules/@jridgewell/gen-mapping/dist/gen-mapping.umd.js.map
new file mode 100644
index 00000000..b13750bf
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/gen-mapping/dist/gen-mapping.umd.js.map
@@ -0,0 +1,6 @@
+{
+ "version": 3,
+ "sources": ["umd:@jridgewell/sourcemap-codec", "umd:@jridgewell/trace-mapping", "../src/gen-mapping.ts", "../src/set-array.ts", "../src/sourcemap-segment.ts"],
+ "mappings": "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",
+ "names": ["module", "module", "cast"]
+}
diff --git a/sdk/node_modules/@jridgewell/gen-mapping/dist/types/gen-mapping.d.ts b/sdk/node_modules/@jridgewell/gen-mapping/dist/types/gen-mapping.d.ts
new file mode 100644
index 00000000..9ba936e8
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/gen-mapping/dist/types/gen-mapping.d.ts
@@ -0,0 +1,88 @@
+import type { SourceMapInput } from '@jridgewell/trace-mapping';
+import type { DecodedSourceMap, EncodedSourceMap, Pos, Mapping } from './types';
+export type { DecodedSourceMap, EncodedSourceMap, Mapping };
+export type Options = {
+ file?: string | null;
+ sourceRoot?: string | null;
+};
+/**
+ * Provides the state to generate a sourcemap.
+ */
+export declare class GenMapping {
+ private _names;
+ private _sources;
+ private _sourcesContent;
+ private _mappings;
+ private _ignoreList;
+ file: string | null | undefined;
+ sourceRoot: string | null | undefined;
+ constructor({ file, sourceRoot }?: Options);
+}
+/**
+ * A low-level API to associate a generated position with an original source position. Line and
+ * column here are 0-based, unlike `addMapping`.
+ */
+export declare function addSegment(map: GenMapping, genLine: number, genColumn: number, source?: null, sourceLine?: null, sourceColumn?: null, name?: null, content?: null): void;
+export declare function addSegment(map: GenMapping, genLine: number, genColumn: number, source: string, sourceLine: number, sourceColumn: number, name?: null, content?: string | null): void;
+export declare function addSegment(map: GenMapping, genLine: number, genColumn: number, source: string, sourceLine: number, sourceColumn: number, name: string, content?: string | null): void;
+/**
+ * A high-level API to associate a generated position with an original source position. Line is
+ * 1-based, but column is 0-based, due to legacy behavior in `source-map` library.
+ */
+export declare function addMapping(map: GenMapping, mapping: {
+ generated: Pos;
+ source?: null;
+ original?: null;
+ name?: null;
+ content?: null;
+}): void;
+export declare function addMapping(map: GenMapping, mapping: {
+ generated: Pos;
+ source: string;
+ original: Pos;
+ name?: null;
+ content?: string | null;
+}): void;
+export declare function addMapping(map: GenMapping, mapping: {
+ generated: Pos;
+ source: string;
+ original: Pos;
+ name: string;
+ content?: string | null;
+}): void;
+/**
+ * Same as `addSegment`, but will only add the segment if it generates useful information in the
+ * resulting map. This only works correctly if segments are added **in order**, meaning you should
+ * not add a segment with a lower generated line/column than one that came before.
+ */
+export declare const maybeAddSegment: typeof addSegment;
+/**
+ * Same as `addMapping`, but will only add the mapping if it generates useful information in the
+ * resulting map. This only works correctly if mappings are added **in order**, meaning you should
+ * not add a mapping with a lower generated line/column than one that came before.
+ */
+export declare const maybeAddMapping: typeof addMapping;
+/**
+ * Adds/removes the content of the source file to the source map.
+ */
+export declare function setSourceContent(map: GenMapping, source: string, content: string | null): void;
+export declare function setIgnore(map: GenMapping, source: string, ignore?: boolean): void;
+/**
+ * Returns a sourcemap object (with decoded mappings) suitable for passing to a library that expects
+ * a sourcemap, or to JSON.stringify.
+ */
+export declare function toDecodedMap(map: GenMapping): DecodedSourceMap;
+/**
+ * Returns a sourcemap object (with encoded mappings) suitable for passing to a library that expects
+ * a sourcemap, or to JSON.stringify.
+ */
+export declare function toEncodedMap(map: GenMapping): EncodedSourceMap;
+/**
+ * Constructs a new GenMapping, using the already present mappings of the input.
+ */
+export declare function fromMap(input: SourceMapInput): GenMapping;
+/**
+ * Returns an array of high-level mapping objects for every recorded segment, which could then be
+ * passed to the `source-map` library.
+ */
+export declare function allMappings(map: GenMapping): Mapping[];
diff --git a/sdk/node_modules/@jridgewell/gen-mapping/dist/types/set-array.d.ts b/sdk/node_modules/@jridgewell/gen-mapping/dist/types/set-array.d.ts
new file mode 100644
index 00000000..6ed43543
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/gen-mapping/dist/types/set-array.d.ts
@@ -0,0 +1,32 @@
+type Key = string | number | symbol;
+/**
+ * SetArray acts like a `Set` (allowing only one occurrence of a string `key`), but provides the
+ * index of the `key` in the backing array.
+ *
+ * This is designed to allow synchronizing a second array with the contents of the backing array,
+ * like how in a sourcemap `sourcesContent[i]` is the source content associated with `source[i]`,
+ * and there are never duplicates.
+ */
+export declare class SetArray {
+ private _indexes;
+ array: readonly T[];
+ constructor();
+}
+/**
+ * Gets the index associated with `key` in the backing array, if it is already present.
+ */
+export declare function get(setarr: SetArray, key: T): number | undefined;
+/**
+ * Puts `key` into the backing array, if it is not already present. Returns
+ * the index of the `key` in the backing array.
+ */
+export declare function put(setarr: SetArray, key: T): number;
+/**
+ * Pops the last added item out of the SetArray.
+ */
+export declare function pop(setarr: SetArray): void;
+/**
+ * Removes the key, if it exists in the set.
+ */
+export declare function remove(setarr: SetArray, key: T): void;
+export {};
diff --git a/sdk/node_modules/@jridgewell/gen-mapping/dist/types/sourcemap-segment.d.ts b/sdk/node_modules/@jridgewell/gen-mapping/dist/types/sourcemap-segment.d.ts
new file mode 100644
index 00000000..aa19fb5e
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/gen-mapping/dist/types/sourcemap-segment.d.ts
@@ -0,0 +1,12 @@
+type GeneratedColumn = number;
+type SourcesIndex = number;
+type SourceLine = number;
+type SourceColumn = number;
+type NamesIndex = number;
+export type SourceMapSegment = [GeneratedColumn] | [GeneratedColumn, SourcesIndex, SourceLine, SourceColumn] | [GeneratedColumn, SourcesIndex, SourceLine, SourceColumn, NamesIndex];
+export declare const COLUMN = 0;
+export declare const SOURCES_INDEX = 1;
+export declare const SOURCE_LINE = 2;
+export declare const SOURCE_COLUMN = 3;
+export declare const NAMES_INDEX = 4;
+export {};
diff --git a/sdk/node_modules/@jridgewell/gen-mapping/dist/types/types.d.ts b/sdk/node_modules/@jridgewell/gen-mapping/dist/types/types.d.ts
new file mode 100644
index 00000000..8eb90fb4
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/gen-mapping/dist/types/types.d.ts
@@ -0,0 +1,43 @@
+import type { SourceMapSegment } from './sourcemap-segment';
+export interface SourceMapV3 {
+ file?: string | null;
+ names: readonly string[];
+ sourceRoot?: string;
+ sources: readonly (string | null)[];
+ sourcesContent?: readonly (string | null)[];
+ version: 3;
+ ignoreList?: readonly number[];
+}
+export interface EncodedSourceMap extends SourceMapV3 {
+ mappings: string;
+}
+export interface DecodedSourceMap extends SourceMapV3 {
+ mappings: readonly SourceMapSegment[][];
+}
+export interface Pos {
+ line: number;
+ column: number;
+}
+export interface OriginalPos extends Pos {
+ source: string;
+}
+export interface BindingExpressionRange {
+ start: Pos;
+ expression: string;
+}
+export type Mapping = {
+ generated: Pos;
+ source: undefined;
+ original: undefined;
+ name: undefined;
+} | {
+ generated: Pos;
+ source: string;
+ original: Pos;
+ name: string;
+} | {
+ generated: Pos;
+ source: string;
+ original: Pos;
+ name: undefined;
+};
diff --git a/sdk/node_modules/@jridgewell/gen-mapping/package.json b/sdk/node_modules/@jridgewell/gen-mapping/package.json
new file mode 100644
index 00000000..036f9b79
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/gen-mapping/package.json
@@ -0,0 +1,67 @@
+{
+ "name": "@jridgewell/gen-mapping",
+ "version": "0.3.13",
+ "description": "Generate source maps",
+ "keywords": [
+ "source",
+ "map"
+ ],
+ "main": "dist/gen-mapping.umd.js",
+ "module": "dist/gen-mapping.mjs",
+ "types": "types/gen-mapping.d.cts",
+ "files": [
+ "dist",
+ "src",
+ "types"
+ ],
+ "exports": {
+ ".": [
+ {
+ "import": {
+ "types": "./types/gen-mapping.d.mts",
+ "default": "./dist/gen-mapping.mjs"
+ },
+ "default": {
+ "types": "./types/gen-mapping.d.cts",
+ "default": "./dist/gen-mapping.umd.js"
+ }
+ },
+ "./dist/gen-mapping.umd.js"
+ ],
+ "./package.json": "./package.json"
+ },
+ "scripts": {
+ "benchmark": "run-s build:code benchmark:*",
+ "benchmark:install": "cd benchmark && npm install",
+ "benchmark:only": "node --expose-gc benchmark/index.js",
+ "build": "run-s -n build:code build:types",
+ "build:code": "node ../../esbuild.mjs gen-mapping.ts",
+ "build:types": "run-s build:types:force build:types:emit build:types:mts",
+ "build:types:force": "rimraf tsconfig.build.tsbuildinfo",
+ "build:types:emit": "tsc --project tsconfig.build.json",
+ "build:types:mts": "node ../../mts-types.mjs",
+ "clean": "run-s -n clean:code clean:types",
+ "clean:code": "tsc --build --clean tsconfig.build.json",
+ "clean:types": "rimraf dist types",
+ "test": "run-s -n test:types test:only test:format",
+ "test:format": "prettier --check '{src,test}/**/*.ts'",
+ "test:only": "mocha",
+ "test:types": "eslint '{src,test}/**/*.ts'",
+ "lint": "run-s -n lint:types lint:format",
+ "lint:format": "npm run test:format -- --write",
+ "lint:types": "npm run test:types -- --fix",
+ "prepublishOnly": "npm run-s -n build test"
+ },
+ "homepage": "https://github.com/jridgewell/sourcemaps/tree/main/packages/gen-mapping",
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/jridgewell/sourcemaps.git",
+ "directory": "packages/gen-mapping"
+ },
+ "author": "Justin Ridgewell ",
+ "license": "MIT",
+ "dependencies": {
+ "@jridgewell/sourcemap-codec": "^1.5.0",
+ "@jridgewell/trace-mapping": "^0.3.24"
+ }
+}
diff --git a/sdk/node_modules/@jridgewell/gen-mapping/src/gen-mapping.ts b/sdk/node_modules/@jridgewell/gen-mapping/src/gen-mapping.ts
new file mode 100644
index 00000000..ecc878c5
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/gen-mapping/src/gen-mapping.ts
@@ -0,0 +1,614 @@
+import { SetArray, put, remove } from './set-array';
+import {
+ encode,
+ // encodeGeneratedRanges,
+ // encodeOriginalScopes
+} from '@jridgewell/sourcemap-codec';
+import { TraceMap, decodedMappings } from '@jridgewell/trace-mapping';
+
+import {
+ COLUMN,
+ SOURCES_INDEX,
+ SOURCE_LINE,
+ SOURCE_COLUMN,
+ NAMES_INDEX,
+} from './sourcemap-segment';
+
+import type { SourceMapInput } from '@jridgewell/trace-mapping';
+// import type { OriginalScope, GeneratedRange } from '@jridgewell/sourcemap-codec';
+import type { SourceMapSegment } from './sourcemap-segment';
+import type {
+ DecodedSourceMap,
+ EncodedSourceMap,
+ Pos,
+ Mapping,
+ // BindingExpressionRange,
+ // OriginalPos,
+ // OriginalScopeInfo,
+ // GeneratedRangeInfo,
+} from './types';
+
+export type { DecodedSourceMap, EncodedSourceMap, Mapping };
+
+export type Options = {
+ file?: string | null;
+ sourceRoot?: string | null;
+};
+
+const NO_NAME = -1;
+
+/**
+ * Provides the state to generate a sourcemap.
+ */
+export class GenMapping {
+ declare private _names: SetArray;
+ declare private _sources: SetArray;
+ declare private _sourcesContent: (string | null)[];
+ declare private _mappings: SourceMapSegment[][];
+ // private declare _originalScopes: OriginalScope[][];
+ // private declare _generatedRanges: GeneratedRange[];
+ declare private _ignoreList: SetArray;
+ declare file: string | null | undefined;
+ declare sourceRoot: string | null | undefined;
+
+ constructor({ file, sourceRoot }: Options = {}) {
+ this._names = new SetArray();
+ this._sources = new SetArray();
+ this._sourcesContent = [];
+ this._mappings = [];
+ // this._originalScopes = [];
+ // this._generatedRanges = [];
+ this.file = file;
+ this.sourceRoot = sourceRoot;
+ this._ignoreList = new SetArray();
+ }
+}
+
+interface PublicMap {
+ _names: GenMapping['_names'];
+ _sources: GenMapping['_sources'];
+ _sourcesContent: GenMapping['_sourcesContent'];
+ _mappings: GenMapping['_mappings'];
+ // _originalScopes: GenMapping['_originalScopes'];
+ // _generatedRanges: GenMapping['_generatedRanges'];
+ _ignoreList: GenMapping['_ignoreList'];
+}
+
+/**
+ * Typescript doesn't allow friend access to private fields, so this just casts the map into a type
+ * with public access modifiers.
+ */
+function cast(map: unknown): PublicMap {
+ return map as any;
+}
+
+/**
+ * A low-level API to associate a generated position with an original source position. Line and
+ * column here are 0-based, unlike `addMapping`.
+ */
+export function addSegment(
+ map: GenMapping,
+ genLine: number,
+ genColumn: number,
+ source?: null,
+ sourceLine?: null,
+ sourceColumn?: null,
+ name?: null,
+ content?: null,
+): void;
+export function addSegment(
+ map: GenMapping,
+ genLine: number,
+ genColumn: number,
+ source: string,
+ sourceLine: number,
+ sourceColumn: number,
+ name?: null,
+ content?: string | null,
+): void;
+export function addSegment(
+ map: GenMapping,
+ genLine: number,
+ genColumn: number,
+ source: string,
+ sourceLine: number,
+ sourceColumn: number,
+ name: string,
+ content?: string | null,
+): void;
+export function addSegment(
+ map: GenMapping,
+ genLine: number,
+ genColumn: number,
+ source?: string | null,
+ sourceLine?: number | null,
+ sourceColumn?: number | null,
+ name?: string | null,
+ content?: string | null,
+): void {
+ return addSegmentInternal(
+ false,
+ map,
+ genLine,
+ genColumn,
+ source,
+ sourceLine,
+ sourceColumn,
+ name,
+ content,
+ );
+}
+
+/**
+ * A high-level API to associate a generated position with an original source position. Line is
+ * 1-based, but column is 0-based, due to legacy behavior in `source-map` library.
+ */
+export function addMapping(
+ map: GenMapping,
+ mapping: {
+ generated: Pos;
+ source?: null;
+ original?: null;
+ name?: null;
+ content?: null;
+ },
+): void;
+export function addMapping(
+ map: GenMapping,
+ mapping: {
+ generated: Pos;
+ source: string;
+ original: Pos;
+ name?: null;
+ content?: string | null;
+ },
+): void;
+export function addMapping(
+ map: GenMapping,
+ mapping: {
+ generated: Pos;
+ source: string;
+ original: Pos;
+ name: string;
+ content?: string | null;
+ },
+): void;
+export function addMapping(
+ map: GenMapping,
+ mapping: {
+ generated: Pos;
+ source?: string | null;
+ original?: Pos | null;
+ name?: string | null;
+ content?: string | null;
+ },
+): void {
+ return addMappingInternal(false, map, mapping as Parameters[2]);
+}
+
+/**
+ * Same as `addSegment`, but will only add the segment if it generates useful information in the
+ * resulting map. This only works correctly if segments are added **in order**, meaning you should
+ * not add a segment with a lower generated line/column than one that came before.
+ */
+export const maybeAddSegment: typeof addSegment = (
+ map,
+ genLine,
+ genColumn,
+ source,
+ sourceLine,
+ sourceColumn,
+ name,
+ content,
+) => {
+ return addSegmentInternal(
+ true,
+ map,
+ genLine,
+ genColumn,
+ source,
+ sourceLine,
+ sourceColumn,
+ name,
+ content,
+ );
+};
+
+/**
+ * Same as `addMapping`, but will only add the mapping if it generates useful information in the
+ * resulting map. This only works correctly if mappings are added **in order**, meaning you should
+ * not add a mapping with a lower generated line/column than one that came before.
+ */
+export const maybeAddMapping: typeof addMapping = (map, mapping) => {
+ return addMappingInternal(true, map, mapping as Parameters[2]);
+};
+
+/**
+ * Adds/removes the content of the source file to the source map.
+ */
+export function setSourceContent(map: GenMapping, source: string, content: string | null): void {
+ const {
+ _sources: sources,
+ _sourcesContent: sourcesContent,
+ // _originalScopes: originalScopes,
+ } = cast(map);
+ const index = put(sources, source);
+ sourcesContent[index] = content;
+ // if (index === originalScopes.length) originalScopes[index] = [];
+}
+
+export function setIgnore(map: GenMapping, source: string, ignore = true) {
+ const {
+ _sources: sources,
+ _sourcesContent: sourcesContent,
+ _ignoreList: ignoreList,
+ // _originalScopes: originalScopes,
+ } = cast(map);
+ const index = put(sources, source);
+ if (index === sourcesContent.length) sourcesContent[index] = null;
+ // if (index === originalScopes.length) originalScopes[index] = [];
+ if (ignore) put(ignoreList, index);
+ else remove(ignoreList, index);
+}
+
+/**
+ * Returns a sourcemap object (with decoded mappings) suitable for passing to a library that expects
+ * a sourcemap, or to JSON.stringify.
+ */
+export function toDecodedMap(map: GenMapping): DecodedSourceMap {
+ const {
+ _mappings: mappings,
+ _sources: sources,
+ _sourcesContent: sourcesContent,
+ _names: names,
+ _ignoreList: ignoreList,
+ // _originalScopes: originalScopes,
+ // _generatedRanges: generatedRanges,
+ } = cast(map);
+ removeEmptyFinalLines(mappings);
+
+ return {
+ version: 3,
+ file: map.file || undefined,
+ names: names.array,
+ sourceRoot: map.sourceRoot || undefined,
+ sources: sources.array,
+ sourcesContent,
+ mappings,
+ // originalScopes,
+ // generatedRanges,
+ ignoreList: ignoreList.array,
+ };
+}
+
+/**
+ * Returns a sourcemap object (with encoded mappings) suitable for passing to a library that expects
+ * a sourcemap, or to JSON.stringify.
+ */
+export function toEncodedMap(map: GenMapping): EncodedSourceMap {
+ const decoded = toDecodedMap(map);
+ return Object.assign({}, decoded, {
+ // originalScopes: decoded.originalScopes.map((os) => encodeOriginalScopes(os)),
+ // generatedRanges: encodeGeneratedRanges(decoded.generatedRanges as GeneratedRange[]),
+ mappings: encode(decoded.mappings as SourceMapSegment[][]),
+ });
+}
+
+/**
+ * Constructs a new GenMapping, using the already present mappings of the input.
+ */
+export function fromMap(input: SourceMapInput): GenMapping {
+ const map = new TraceMap(input);
+ const gen = new GenMapping({ file: map.file, sourceRoot: map.sourceRoot });
+
+ putAll(cast(gen)._names, map.names);
+ putAll(cast(gen)._sources, map.sources as string[]);
+ cast(gen)._sourcesContent = map.sourcesContent || map.sources.map(() => null);
+ cast(gen)._mappings = decodedMappings(map) as GenMapping['_mappings'];
+ // TODO: implement originalScopes/generatedRanges
+ if (map.ignoreList) putAll(cast(gen)._ignoreList, map.ignoreList);
+
+ return gen;
+}
+
+/**
+ * Returns an array of high-level mapping objects for every recorded segment, which could then be
+ * passed to the `source-map` library.
+ */
+export function allMappings(map: GenMapping): Mapping[] {
+ const out: Mapping[] = [];
+ const { _mappings: mappings, _sources: sources, _names: names } = cast(map);
+
+ for (let i = 0; i < mappings.length; i++) {
+ const line = mappings[i];
+ for (let j = 0; j < line.length; j++) {
+ const seg = line[j];
+
+ const generated = { line: i + 1, column: seg[COLUMN] };
+ let source: string | undefined = undefined;
+ let original: Pos | undefined = undefined;
+ let name: string | undefined = undefined;
+
+ if (seg.length !== 1) {
+ source = sources.array[seg[SOURCES_INDEX]];
+ original = { line: seg[SOURCE_LINE] + 1, column: seg[SOURCE_COLUMN] };
+
+ if (seg.length === 5) name = names.array[seg[NAMES_INDEX]];
+ }
+
+ out.push({ generated, source, original, name } as Mapping);
+ }
+ }
+
+ return out;
+}
+
+// This split declaration is only so that terser can elminiate the static initialization block.
+function addSegmentInternal(
+ skipable: boolean,
+ map: GenMapping,
+ genLine: number,
+ genColumn: number,
+ source: S,
+ sourceLine: S extends string ? number : null | undefined,
+ sourceColumn: S extends string ? number : null | undefined,
+ name: S extends string ? string | null | undefined : null | undefined,
+ content: S extends string ? string | null | undefined : null | undefined,
+): void {
+ const {
+ _mappings: mappings,
+ _sources: sources,
+ _sourcesContent: sourcesContent,
+ _names: names,
+ // _originalScopes: originalScopes,
+ } = cast(map);
+ const line = getIndex(mappings, genLine);
+ const index = getColumnIndex(line, genColumn);
+
+ if (!source) {
+ if (skipable && skipSourceless(line, index)) return;
+ return insert(line, index, [genColumn]);
+ }
+
+ // Sigh, TypeScript can't figure out sourceLine and sourceColumn aren't nullish if source
+ // isn't nullish.
+ assert(sourceLine);
+ assert(sourceColumn);
+
+ const sourcesIndex = put(sources, source);
+ const namesIndex = name ? put(names, name) : NO_NAME;
+ if (sourcesIndex === sourcesContent.length) sourcesContent[sourcesIndex] = content ?? null;
+ // if (sourcesIndex === originalScopes.length) originalScopes[sourcesIndex] = [];
+
+ if (skipable && skipSource(line, index, sourcesIndex, sourceLine, sourceColumn, namesIndex)) {
+ return;
+ }
+
+ return insert(
+ line,
+ index,
+ name
+ ? [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex]
+ : [genColumn, sourcesIndex, sourceLine, sourceColumn],
+ );
+}
+
+function assert(_val: unknown): asserts _val is T {
+ // noop.
+}
+
+function getIndex(arr: T[][], index: number): T[] {
+ for (let i = arr.length; i <= index; i++) {
+ arr[i] = [];
+ }
+ return arr[index];
+}
+
+function getColumnIndex(line: SourceMapSegment[], genColumn: number): number {
+ let index = line.length;
+ for (let i = index - 1; i >= 0; index = i--) {
+ const current = line[i];
+ if (genColumn >= current[COLUMN]) break;
+ }
+ return index;
+}
+
+function insert(array: T[], index: number, value: T) {
+ for (let i = array.length; i > index; i--) {
+ array[i] = array[i - 1];
+ }
+ array[index] = value;
+}
+
+function removeEmptyFinalLines(mappings: SourceMapSegment[][]) {
+ const { length } = mappings;
+ let len = length;
+ for (let i = len - 1; i >= 0; len = i, i--) {
+ if (mappings[i].length > 0) break;
+ }
+ if (len < length) mappings.length = len;
+}
+
+function putAll(setarr: SetArray, array: T[]) {
+ for (let i = 0; i < array.length; i++) put(setarr, array[i]);
+}
+
+function skipSourceless(line: SourceMapSegment[], index: number): boolean {
+ // The start of a line is already sourceless, so adding a sourceless segment to the beginning
+ // doesn't generate any useful information.
+ if (index === 0) return true;
+
+ const prev = line[index - 1];
+ // If the previous segment is also sourceless, then adding another sourceless segment doesn't
+ // genrate any new information. Else, this segment will end the source/named segment and point to
+ // a sourceless position, which is useful.
+ return prev.length === 1;
+}
+
+function skipSource(
+ line: SourceMapSegment[],
+ index: number,
+ sourcesIndex: number,
+ sourceLine: number,
+ sourceColumn: number,
+ namesIndex: number,
+): boolean {
+ // A source/named segment at the start of a line gives position at that genColumn
+ if (index === 0) return false;
+
+ const prev = line[index - 1];
+
+ // If the previous segment is sourceless, then we're transitioning to a source.
+ if (prev.length === 1) return false;
+
+ // If the previous segment maps to the exact same source position, then this segment doesn't
+ // provide any new position information.
+ return (
+ sourcesIndex === prev[SOURCES_INDEX] &&
+ sourceLine === prev[SOURCE_LINE] &&
+ sourceColumn === prev[SOURCE_COLUMN] &&
+ namesIndex === (prev.length === 5 ? prev[NAMES_INDEX] : NO_NAME)
+ );
+}
+
+function addMappingInternal(
+ skipable: boolean,
+ map: GenMapping,
+ mapping: {
+ generated: Pos;
+ source: S;
+ original: S extends string ? Pos : null | undefined;
+ name: S extends string ? string | null | undefined : null | undefined;
+ content: S extends string ? string | null | undefined : null | undefined;
+ },
+) {
+ const { generated, source, original, name, content } = mapping;
+ if (!source) {
+ return addSegmentInternal(
+ skipable,
+ map,
+ generated.line - 1,
+ generated.column,
+ null,
+ null,
+ null,
+ null,
+ null,
+ );
+ }
+ assert(original);
+ return addSegmentInternal(
+ skipable,
+ map,
+ generated.line - 1,
+ generated.column,
+ source as string,
+ original.line - 1,
+ original.column,
+ name,
+ content,
+ );
+}
+
+/*
+export function addOriginalScope(
+ map: GenMapping,
+ data: {
+ start: Pos;
+ end: Pos;
+ source: string;
+ kind: string;
+ name?: string;
+ variables?: string[];
+ },
+): OriginalScopeInfo {
+ const { start, end, source, kind, name, variables } = data;
+ const {
+ _sources: sources,
+ _sourcesContent: sourcesContent,
+ _originalScopes: originalScopes,
+ _names: names,
+ } = cast(map);
+ const index = put(sources, source);
+ if (index === sourcesContent.length) sourcesContent[index] = null;
+ if (index === originalScopes.length) originalScopes[index] = [];
+
+ const kindIndex = put(names, kind);
+ const scope: OriginalScope = name
+ ? [start.line - 1, start.column, end.line - 1, end.column, kindIndex, put(names, name)]
+ : [start.line - 1, start.column, end.line - 1, end.column, kindIndex];
+ if (variables) {
+ scope.vars = variables.map((v) => put(names, v));
+ }
+ const len = originalScopes[index].push(scope);
+ return [index, len - 1, variables];
+}
+*/
+
+// Generated Ranges
+/*
+export function addGeneratedRange(
+ map: GenMapping,
+ data: {
+ start: Pos;
+ isScope: boolean;
+ originalScope?: OriginalScopeInfo;
+ callsite?: OriginalPos;
+ },
+): GeneratedRangeInfo {
+ const { start, isScope, originalScope, callsite } = data;
+ const {
+ _originalScopes: originalScopes,
+ _sources: sources,
+ _sourcesContent: sourcesContent,
+ _generatedRanges: generatedRanges,
+ } = cast(map);
+
+ const range: GeneratedRange = [
+ start.line - 1,
+ start.column,
+ 0,
+ 0,
+ originalScope ? originalScope[0] : -1,
+ originalScope ? originalScope[1] : -1,
+ ];
+ if (originalScope?.[2]) {
+ range.bindings = originalScope[2].map(() => [[-1]]);
+ }
+ if (callsite) {
+ const index = put(sources, callsite.source);
+ if (index === sourcesContent.length) sourcesContent[index] = null;
+ if (index === originalScopes.length) originalScopes[index] = [];
+ range.callsite = [index, callsite.line - 1, callsite.column];
+ }
+ if (isScope) range.isScope = true;
+ generatedRanges.push(range);
+
+ return [range, originalScope?.[2]];
+}
+
+export function setEndPosition(range: GeneratedRangeInfo, pos: Pos) {
+ range[0][2] = pos.line - 1;
+ range[0][3] = pos.column;
+}
+
+export function addBinding(
+ map: GenMapping,
+ range: GeneratedRangeInfo,
+ variable: string,
+ expression: string | BindingExpressionRange,
+) {
+ const { _names: names } = cast(map);
+ const bindings = (range[0].bindings ||= []);
+ const vars = range[1];
+
+ const index = vars!.indexOf(variable);
+ const binding = getIndex(bindings, index);
+
+ if (typeof expression === 'string') binding[0] = [put(names, expression)];
+ else {
+ const { start } = expression;
+ binding.push([put(names, expression.expression), start.line - 1, start.column]);
+ }
+}
+*/
diff --git a/sdk/node_modules/@jridgewell/gen-mapping/src/set-array.ts b/sdk/node_modules/@jridgewell/gen-mapping/src/set-array.ts
new file mode 100644
index 00000000..a2a73a52
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/gen-mapping/src/set-array.ts
@@ -0,0 +1,82 @@
+type Key = string | number | symbol;
+
+/**
+ * SetArray acts like a `Set` (allowing only one occurrence of a string `key`), but provides the
+ * index of the `key` in the backing array.
+ *
+ * This is designed to allow synchronizing a second array with the contents of the backing array,
+ * like how in a sourcemap `sourcesContent[i]` is the source content associated with `source[i]`,
+ * and there are never duplicates.
+ */
+export class SetArray {
+ declare private _indexes: Record;
+ declare array: readonly T[];
+
+ constructor() {
+ this._indexes = { __proto__: null } as any;
+ this.array = [];
+ }
+}
+
+interface PublicSet {
+ array: T[];
+ _indexes: SetArray['_indexes'];
+}
+
+/**
+ * Typescript doesn't allow friend access to private fields, so this just casts the set into a type
+ * with public access modifiers.
+ */
+function cast(set: SetArray): PublicSet {
+ return set as any;
+}
+
+/**
+ * Gets the index associated with `key` in the backing array, if it is already present.
+ */
+export function get(setarr: SetArray, key: T): number | undefined {
+ return cast(setarr)._indexes[key];
+}
+
+/**
+ * Puts `key` into the backing array, if it is not already present. Returns
+ * the index of the `key` in the backing array.
+ */
+export function put(setarr: SetArray, key: T): number {
+ // The key may or may not be present. If it is present, it's a number.
+ const index = get(setarr, key);
+ if (index !== undefined) return index;
+
+ const { array, _indexes: indexes } = cast(setarr);
+
+ const length = array.push(key);
+ return (indexes[key] = length - 1);
+}
+
+/**
+ * Pops the last added item out of the SetArray.
+ */
+export function pop(setarr: SetArray): void {
+ const { array, _indexes: indexes } = cast(setarr);
+ if (array.length === 0) return;
+
+ const last = array.pop()!;
+ indexes[last] = undefined;
+}
+
+/**
+ * Removes the key, if it exists in the set.
+ */
+export function remove(setarr: SetArray, key: T): void {
+ const index = get(setarr, key);
+ if (index === undefined) return;
+
+ const { array, _indexes: indexes } = cast(setarr);
+ for (let i = index + 1; i < array.length; i++) {
+ const k = array[i];
+ array[i - 1] = k;
+ indexes[k]!--;
+ }
+ indexes[key] = undefined;
+ array.pop();
+}
diff --git a/sdk/node_modules/@jridgewell/gen-mapping/src/sourcemap-segment.ts b/sdk/node_modules/@jridgewell/gen-mapping/src/sourcemap-segment.ts
new file mode 100644
index 00000000..fb296dd3
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/gen-mapping/src/sourcemap-segment.ts
@@ -0,0 +1,16 @@
+type GeneratedColumn = number;
+type SourcesIndex = number;
+type SourceLine = number;
+type SourceColumn = number;
+type NamesIndex = number;
+
+export type SourceMapSegment =
+ | [GeneratedColumn]
+ | [GeneratedColumn, SourcesIndex, SourceLine, SourceColumn]
+ | [GeneratedColumn, SourcesIndex, SourceLine, SourceColumn, NamesIndex];
+
+export const COLUMN = 0;
+export const SOURCES_INDEX = 1;
+export const SOURCE_LINE = 2;
+export const SOURCE_COLUMN = 3;
+export const NAMES_INDEX = 4;
diff --git a/sdk/node_modules/@jridgewell/gen-mapping/src/types.ts b/sdk/node_modules/@jridgewell/gen-mapping/src/types.ts
new file mode 100644
index 00000000..b087f706
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/gen-mapping/src/types.ts
@@ -0,0 +1,61 @@
+// import type { GeneratedRange, OriginalScope } from '@jridgewell/sourcemap-codec';
+import type { SourceMapSegment } from './sourcemap-segment';
+
+export interface SourceMapV3 {
+ file?: string | null;
+ names: readonly string[];
+ sourceRoot?: string;
+ sources: readonly (string | null)[];
+ sourcesContent?: readonly (string | null)[];
+ version: 3;
+ ignoreList?: readonly number[];
+}
+
+export interface EncodedSourceMap extends SourceMapV3 {
+ mappings: string;
+ // originalScopes: string[];
+ // generatedRanges: string;
+}
+
+export interface DecodedSourceMap extends SourceMapV3 {
+ mappings: readonly SourceMapSegment[][];
+ // originalScopes: readonly OriginalScope[][];
+ // generatedRanges: readonly GeneratedRange[];
+}
+
+export interface Pos {
+ line: number; // 1-based
+ column: number; // 0-based
+}
+
+export interface OriginalPos extends Pos {
+ source: string;
+}
+
+export interface BindingExpressionRange {
+ start: Pos;
+ expression: string;
+}
+
+// export type OriginalScopeInfo = [number, number, string[] | undefined];
+// export type GeneratedRangeInfo = [GeneratedRange, string[] | undefined];
+
+export type Mapping =
+ | {
+ generated: Pos;
+ source: undefined;
+ original: undefined;
+ name: undefined;
+ }
+ | {
+ generated: Pos;
+ source: string;
+ original: Pos;
+ name: string;
+ }
+ | {
+ generated: Pos;
+ source: string;
+ original: Pos;
+ name: undefined;
+ };
diff --git a/sdk/node_modules/@jridgewell/gen-mapping/types/gen-mapping.d.cts b/sdk/node_modules/@jridgewell/gen-mapping/types/gen-mapping.d.cts
new file mode 100644
index 00000000..7618d857
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/gen-mapping/types/gen-mapping.d.cts
@@ -0,0 +1,89 @@
+import type { SourceMapInput } from '@jridgewell/trace-mapping';
+import type { DecodedSourceMap, EncodedSourceMap, Pos, Mapping } from './types.cts';
+export type { DecodedSourceMap, EncodedSourceMap, Mapping };
+export type Options = {
+ file?: string | null;
+ sourceRoot?: string | null;
+};
+/**
+ * Provides the state to generate a sourcemap.
+ */
+export declare class GenMapping {
+ private _names;
+ private _sources;
+ private _sourcesContent;
+ private _mappings;
+ private _ignoreList;
+ file: string | null | undefined;
+ sourceRoot: string | null | undefined;
+ constructor({ file, sourceRoot }?: Options);
+}
+/**
+ * A low-level API to associate a generated position with an original source position. Line and
+ * column here are 0-based, unlike `addMapping`.
+ */
+export declare function addSegment(map: GenMapping, genLine: number, genColumn: number, source?: null, sourceLine?: null, sourceColumn?: null, name?: null, content?: null): void;
+export declare function addSegment(map: GenMapping, genLine: number, genColumn: number, source: string, sourceLine: number, sourceColumn: number, name?: null, content?: string | null): void;
+export declare function addSegment(map: GenMapping, genLine: number, genColumn: number, source: string, sourceLine: number, sourceColumn: number, name: string, content?: string | null): void;
+/**
+ * A high-level API to associate a generated position with an original source position. Line is
+ * 1-based, but column is 0-based, due to legacy behavior in `source-map` library.
+ */
+export declare function addMapping(map: GenMapping, mapping: {
+ generated: Pos;
+ source?: null;
+ original?: null;
+ name?: null;
+ content?: null;
+}): void;
+export declare function addMapping(map: GenMapping, mapping: {
+ generated: Pos;
+ source: string;
+ original: Pos;
+ name?: null;
+ content?: string | null;
+}): void;
+export declare function addMapping(map: GenMapping, mapping: {
+ generated: Pos;
+ source: string;
+ original: Pos;
+ name: string;
+ content?: string | null;
+}): void;
+/**
+ * Same as `addSegment`, but will only add the segment if it generates useful information in the
+ * resulting map. This only works correctly if segments are added **in order**, meaning you should
+ * not add a segment with a lower generated line/column than one that came before.
+ */
+export declare const maybeAddSegment: typeof addSegment;
+/**
+ * Same as `addMapping`, but will only add the mapping if it generates useful information in the
+ * resulting map. This only works correctly if mappings are added **in order**, meaning you should
+ * not add a mapping with a lower generated line/column than one that came before.
+ */
+export declare const maybeAddMapping: typeof addMapping;
+/**
+ * Adds/removes the content of the source file to the source map.
+ */
+export declare function setSourceContent(map: GenMapping, source: string, content: string | null): void;
+export declare function setIgnore(map: GenMapping, source: string, ignore?: boolean): void;
+/**
+ * Returns a sourcemap object (with decoded mappings) suitable for passing to a library that expects
+ * a sourcemap, or to JSON.stringify.
+ */
+export declare function toDecodedMap(map: GenMapping): DecodedSourceMap;
+/**
+ * Returns a sourcemap object (with encoded mappings) suitable for passing to a library that expects
+ * a sourcemap, or to JSON.stringify.
+ */
+export declare function toEncodedMap(map: GenMapping): EncodedSourceMap;
+/**
+ * Constructs a new GenMapping, using the already present mappings of the input.
+ */
+export declare function fromMap(input: SourceMapInput): GenMapping;
+/**
+ * Returns an array of high-level mapping objects for every recorded segment, which could then be
+ * passed to the `source-map` library.
+ */
+export declare function allMappings(map: GenMapping): Mapping[];
+//# sourceMappingURL=gen-mapping.d.ts.map
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/gen-mapping/types/gen-mapping.d.cts.map b/sdk/node_modules/@jridgewell/gen-mapping/types/gen-mapping.d.cts.map
new file mode 100644
index 00000000..8a2b1835
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/gen-mapping/types/gen-mapping.d.cts.map
@@ -0,0 +1 @@
+{"version":3,"file":"gen-mapping.d.ts","sourceRoot":"","sources":["../src/gen-mapping.ts"],"names":[],"mappings":"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"}
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/gen-mapping/types/gen-mapping.d.mts b/sdk/node_modules/@jridgewell/gen-mapping/types/gen-mapping.d.mts
new file mode 100644
index 00000000..bbc0d89c
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/gen-mapping/types/gen-mapping.d.mts
@@ -0,0 +1,89 @@
+import type { SourceMapInput } from '@jridgewell/trace-mapping';
+import type { DecodedSourceMap, EncodedSourceMap, Pos, Mapping } from './types.mts';
+export type { DecodedSourceMap, EncodedSourceMap, Mapping };
+export type Options = {
+ file?: string | null;
+ sourceRoot?: string | null;
+};
+/**
+ * Provides the state to generate a sourcemap.
+ */
+export declare class GenMapping {
+ private _names;
+ private _sources;
+ private _sourcesContent;
+ private _mappings;
+ private _ignoreList;
+ file: string | null | undefined;
+ sourceRoot: string | null | undefined;
+ constructor({ file, sourceRoot }?: Options);
+}
+/**
+ * A low-level API to associate a generated position with an original source position. Line and
+ * column here are 0-based, unlike `addMapping`.
+ */
+export declare function addSegment(map: GenMapping, genLine: number, genColumn: number, source?: null, sourceLine?: null, sourceColumn?: null, name?: null, content?: null): void;
+export declare function addSegment(map: GenMapping, genLine: number, genColumn: number, source: string, sourceLine: number, sourceColumn: number, name?: null, content?: string | null): void;
+export declare function addSegment(map: GenMapping, genLine: number, genColumn: number, source: string, sourceLine: number, sourceColumn: number, name: string, content?: string | null): void;
+/**
+ * A high-level API to associate a generated position with an original source position. Line is
+ * 1-based, but column is 0-based, due to legacy behavior in `source-map` library.
+ */
+export declare function addMapping(map: GenMapping, mapping: {
+ generated: Pos;
+ source?: null;
+ original?: null;
+ name?: null;
+ content?: null;
+}): void;
+export declare function addMapping(map: GenMapping, mapping: {
+ generated: Pos;
+ source: string;
+ original: Pos;
+ name?: null;
+ content?: string | null;
+}): void;
+export declare function addMapping(map: GenMapping, mapping: {
+ generated: Pos;
+ source: string;
+ original: Pos;
+ name: string;
+ content?: string | null;
+}): void;
+/**
+ * Same as `addSegment`, but will only add the segment if it generates useful information in the
+ * resulting map. This only works correctly if segments are added **in order**, meaning you should
+ * not add a segment with a lower generated line/column than one that came before.
+ */
+export declare const maybeAddSegment: typeof addSegment;
+/**
+ * Same as `addMapping`, but will only add the mapping if it generates useful information in the
+ * resulting map. This only works correctly if mappings are added **in order**, meaning you should
+ * not add a mapping with a lower generated line/column than one that came before.
+ */
+export declare const maybeAddMapping: typeof addMapping;
+/**
+ * Adds/removes the content of the source file to the source map.
+ */
+export declare function setSourceContent(map: GenMapping, source: string, content: string | null): void;
+export declare function setIgnore(map: GenMapping, source: string, ignore?: boolean): void;
+/**
+ * Returns a sourcemap object (with decoded mappings) suitable for passing to a library that expects
+ * a sourcemap, or to JSON.stringify.
+ */
+export declare function toDecodedMap(map: GenMapping): DecodedSourceMap;
+/**
+ * Returns a sourcemap object (with encoded mappings) suitable for passing to a library that expects
+ * a sourcemap, or to JSON.stringify.
+ */
+export declare function toEncodedMap(map: GenMapping): EncodedSourceMap;
+/**
+ * Constructs a new GenMapping, using the already present mappings of the input.
+ */
+export declare function fromMap(input: SourceMapInput): GenMapping;
+/**
+ * Returns an array of high-level mapping objects for every recorded segment, which could then be
+ * passed to the `source-map` library.
+ */
+export declare function allMappings(map: GenMapping): Mapping[];
+//# sourceMappingURL=gen-mapping.d.ts.map
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/gen-mapping/types/gen-mapping.d.mts.map b/sdk/node_modules/@jridgewell/gen-mapping/types/gen-mapping.d.mts.map
new file mode 100644
index 00000000..8a2b1835
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/gen-mapping/types/gen-mapping.d.mts.map
@@ -0,0 +1 @@
+{"version":3,"file":"gen-mapping.d.ts","sourceRoot":"","sources":["../src/gen-mapping.ts"],"names":[],"mappings":"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"}
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/gen-mapping/types/set-array.d.cts b/sdk/node_modules/@jridgewell/gen-mapping/types/set-array.d.cts
new file mode 100644
index 00000000..5d8cda35
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/gen-mapping/types/set-array.d.cts
@@ -0,0 +1,33 @@
+type Key = string | number | symbol;
+/**
+ * SetArray acts like a `Set` (allowing only one occurrence of a string `key`), but provides the
+ * index of the `key` in the backing array.
+ *
+ * This is designed to allow synchronizing a second array with the contents of the backing array,
+ * like how in a sourcemap `sourcesContent[i]` is the source content associated with `source[i]`,
+ * and there are never duplicates.
+ */
+export declare class SetArray {
+ private _indexes;
+ array: readonly T[];
+ constructor();
+}
+/**
+ * Gets the index associated with `key` in the backing array, if it is already present.
+ */
+export declare function get(setarr: SetArray, key: T): number | undefined;
+/**
+ * Puts `key` into the backing array, if it is not already present. Returns
+ * the index of the `key` in the backing array.
+ */
+export declare function put(setarr: SetArray, key: T): number;
+/**
+ * Pops the last added item out of the SetArray.
+ */
+export declare function pop(setarr: SetArray): void;
+/**
+ * Removes the key, if it exists in the set.
+ */
+export declare function remove(setarr: SetArray, key: T): void;
+export {};
+//# sourceMappingURL=set-array.d.ts.map
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/gen-mapping/types/set-array.d.cts.map b/sdk/node_modules/@jridgewell/gen-mapping/types/set-array.d.cts.map
new file mode 100644
index 00000000..c52b8bce
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/gen-mapping/types/set-array.d.cts.map
@@ -0,0 +1 @@
+{"version":3,"file":"set-array.d.ts","sourceRoot":"","sources":["../src/set-array.ts"],"names":[],"mappings":"AAAA,KAAK,GAAG,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;AAEpC;;;;;;;GAOG;AACH,qBAAa,QAAQ,CAAC,CAAC,SAAS,GAAG,GAAG,GAAG;IACvC,QAAgB,QAAQ,CAAgC;IAChD,KAAK,EAAE,SAAS,CAAC,EAAE,CAAC;;CAM7B;AAeD;;GAEG;AACH,wBAAgB,GAAG,CAAC,CAAC,SAAS,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,MAAM,GAAG,SAAS,CAElF;AAED;;;GAGG;AACH,wBAAgB,GAAG,CAAC,CAAC,SAAS,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,MAAM,CAStE;AAED;;GAEG;AACH,wBAAgB,GAAG,CAAC,CAAC,SAAS,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,IAAI,CAM5D;AAED;;GAEG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,IAAI,CAYvE"}
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/gen-mapping/types/set-array.d.mts b/sdk/node_modules/@jridgewell/gen-mapping/types/set-array.d.mts
new file mode 100644
index 00000000..5d8cda35
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/gen-mapping/types/set-array.d.mts
@@ -0,0 +1,33 @@
+type Key = string | number | symbol;
+/**
+ * SetArray acts like a `Set` (allowing only one occurrence of a string `key`), but provides the
+ * index of the `key` in the backing array.
+ *
+ * This is designed to allow synchronizing a second array with the contents of the backing array,
+ * like how in a sourcemap `sourcesContent[i]` is the source content associated with `source[i]`,
+ * and there are never duplicates.
+ */
+export declare class SetArray {
+ private _indexes;
+ array: readonly T[];
+ constructor();
+}
+/**
+ * Gets the index associated with `key` in the backing array, if it is already present.
+ */
+export declare function get(setarr: SetArray, key: T): number | undefined;
+/**
+ * Puts `key` into the backing array, if it is not already present. Returns
+ * the index of the `key` in the backing array.
+ */
+export declare function put(setarr: SetArray, key: T): number;
+/**
+ * Pops the last added item out of the SetArray.
+ */
+export declare function pop(setarr: SetArray): void;
+/**
+ * Removes the key, if it exists in the set.
+ */
+export declare function remove(setarr: SetArray, key: T): void;
+export {};
+//# sourceMappingURL=set-array.d.ts.map
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/gen-mapping/types/set-array.d.mts.map b/sdk/node_modules/@jridgewell/gen-mapping/types/set-array.d.mts.map
new file mode 100644
index 00000000..c52b8bce
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/gen-mapping/types/set-array.d.mts.map
@@ -0,0 +1 @@
+{"version":3,"file":"set-array.d.ts","sourceRoot":"","sources":["../src/set-array.ts"],"names":[],"mappings":"AAAA,KAAK,GAAG,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;AAEpC;;;;;;;GAOG;AACH,qBAAa,QAAQ,CAAC,CAAC,SAAS,GAAG,GAAG,GAAG;IACvC,QAAgB,QAAQ,CAAgC;IAChD,KAAK,EAAE,SAAS,CAAC,EAAE,CAAC;;CAM7B;AAeD;;GAEG;AACH,wBAAgB,GAAG,CAAC,CAAC,SAAS,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,MAAM,GAAG,SAAS,CAElF;AAED;;;GAGG;AACH,wBAAgB,GAAG,CAAC,CAAC,SAAS,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,MAAM,CAStE;AAED;;GAEG;AACH,wBAAgB,GAAG,CAAC,CAAC,SAAS,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,IAAI,CAM5D;AAED;;GAEG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,IAAI,CAYvE"}
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/gen-mapping/types/sourcemap-segment.d.cts b/sdk/node_modules/@jridgewell/gen-mapping/types/sourcemap-segment.d.cts
new file mode 100644
index 00000000..68862952
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/gen-mapping/types/sourcemap-segment.d.cts
@@ -0,0 +1,13 @@
+type GeneratedColumn = number;
+type SourcesIndex = number;
+type SourceLine = number;
+type SourceColumn = number;
+type NamesIndex = number;
+export type SourceMapSegment = [GeneratedColumn] | [GeneratedColumn, SourcesIndex, SourceLine, SourceColumn] | [GeneratedColumn, SourcesIndex, SourceLine, SourceColumn, NamesIndex];
+export declare const COLUMN = 0;
+export declare const SOURCES_INDEX = 1;
+export declare const SOURCE_LINE = 2;
+export declare const SOURCE_COLUMN = 3;
+export declare const NAMES_INDEX = 4;
+export {};
+//# sourceMappingURL=sourcemap-segment.d.ts.map
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/gen-mapping/types/sourcemap-segment.d.cts.map b/sdk/node_modules/@jridgewell/gen-mapping/types/sourcemap-segment.d.cts.map
new file mode 100644
index 00000000..23cdc452
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/gen-mapping/types/sourcemap-segment.d.cts.map
@@ -0,0 +1 @@
+{"version":3,"file":"sourcemap-segment.d.ts","sourceRoot":"","sources":["../src/sourcemap-segment.ts"],"names":[],"mappings":"AAAA,KAAK,eAAe,GAAG,MAAM,CAAC;AAC9B,KAAK,YAAY,GAAG,MAAM,CAAC;AAC3B,KAAK,UAAU,GAAG,MAAM,CAAC;AACzB,KAAK,YAAY,GAAG,MAAM,CAAC;AAC3B,KAAK,UAAU,GAAG,MAAM,CAAC;AAEzB,MAAM,MAAM,gBAAgB,GACxB,CAAC,eAAe,CAAC,GACjB,CAAC,eAAe,EAAE,YAAY,EAAE,UAAU,EAAE,YAAY,CAAC,GACzD,CAAC,eAAe,EAAE,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,UAAU,CAAC,CAAC;AAE1E,eAAO,MAAM,MAAM,IAAI,CAAC;AACxB,eAAO,MAAM,aAAa,IAAI,CAAC;AAC/B,eAAO,MAAM,WAAW,IAAI,CAAC;AAC7B,eAAO,MAAM,aAAa,IAAI,CAAC;AAC/B,eAAO,MAAM,WAAW,IAAI,CAAC"}
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/gen-mapping/types/sourcemap-segment.d.mts b/sdk/node_modules/@jridgewell/gen-mapping/types/sourcemap-segment.d.mts
new file mode 100644
index 00000000..68862952
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/gen-mapping/types/sourcemap-segment.d.mts
@@ -0,0 +1,13 @@
+type GeneratedColumn = number;
+type SourcesIndex = number;
+type SourceLine = number;
+type SourceColumn = number;
+type NamesIndex = number;
+export type SourceMapSegment = [GeneratedColumn] | [GeneratedColumn, SourcesIndex, SourceLine, SourceColumn] | [GeneratedColumn, SourcesIndex, SourceLine, SourceColumn, NamesIndex];
+export declare const COLUMN = 0;
+export declare const SOURCES_INDEX = 1;
+export declare const SOURCE_LINE = 2;
+export declare const SOURCE_COLUMN = 3;
+export declare const NAMES_INDEX = 4;
+export {};
+//# sourceMappingURL=sourcemap-segment.d.ts.map
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/gen-mapping/types/sourcemap-segment.d.mts.map b/sdk/node_modules/@jridgewell/gen-mapping/types/sourcemap-segment.d.mts.map
new file mode 100644
index 00000000..23cdc452
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/gen-mapping/types/sourcemap-segment.d.mts.map
@@ -0,0 +1 @@
+{"version":3,"file":"sourcemap-segment.d.ts","sourceRoot":"","sources":["../src/sourcemap-segment.ts"],"names":[],"mappings":"AAAA,KAAK,eAAe,GAAG,MAAM,CAAC;AAC9B,KAAK,YAAY,GAAG,MAAM,CAAC;AAC3B,KAAK,UAAU,GAAG,MAAM,CAAC;AACzB,KAAK,YAAY,GAAG,MAAM,CAAC;AAC3B,KAAK,UAAU,GAAG,MAAM,CAAC;AAEzB,MAAM,MAAM,gBAAgB,GACxB,CAAC,eAAe,CAAC,GACjB,CAAC,eAAe,EAAE,YAAY,EAAE,UAAU,EAAE,YAAY,CAAC,GACzD,CAAC,eAAe,EAAE,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,UAAU,CAAC,CAAC;AAE1E,eAAO,MAAM,MAAM,IAAI,CAAC;AACxB,eAAO,MAAM,aAAa,IAAI,CAAC;AAC/B,eAAO,MAAM,WAAW,IAAI,CAAC;AAC7B,eAAO,MAAM,aAAa,IAAI,CAAC;AAC/B,eAAO,MAAM,WAAW,IAAI,CAAC"}
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/gen-mapping/types/types.d.cts b/sdk/node_modules/@jridgewell/gen-mapping/types/types.d.cts
new file mode 100644
index 00000000..58da00a9
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/gen-mapping/types/types.d.cts
@@ -0,0 +1,44 @@
+import type { SourceMapSegment } from './sourcemap-segment.cts';
+export interface SourceMapV3 {
+ file?: string | null;
+ names: readonly string[];
+ sourceRoot?: string;
+ sources: readonly (string | null)[];
+ sourcesContent?: readonly (string | null)[];
+ version: 3;
+ ignoreList?: readonly number[];
+}
+export interface EncodedSourceMap extends SourceMapV3 {
+ mappings: string;
+}
+export interface DecodedSourceMap extends SourceMapV3 {
+ mappings: readonly SourceMapSegment[][];
+}
+export interface Pos {
+ line: number;
+ column: number;
+}
+export interface OriginalPos extends Pos {
+ source: string;
+}
+export interface BindingExpressionRange {
+ start: Pos;
+ expression: string;
+}
+export type Mapping = {
+ generated: Pos;
+ source: undefined;
+ original: undefined;
+ name: undefined;
+} | {
+ generated: Pos;
+ source: string;
+ original: Pos;
+ name: string;
+} | {
+ generated: Pos;
+ source: string;
+ original: Pos;
+ name: undefined;
+};
+//# sourceMappingURL=types.d.ts.map
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/gen-mapping/types/types.d.cts.map b/sdk/node_modules/@jridgewell/gen-mapping/types/types.d.cts.map
new file mode 100644
index 00000000..159e734d
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/gen-mapping/types/types.d.cts.map
@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAE5D,MAAM,WAAW,WAAW;IAC1B,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IACzB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,SAAS,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC;IACpC,cAAc,CAAC,EAAE,SAAS,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC;IAC5C,OAAO,EAAE,CAAC,CAAC;IACX,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAChC;AAED,MAAM,WAAW,gBAAiB,SAAQ,WAAW;IACnD,QAAQ,EAAE,MAAM,CAAC;CAGlB;AAED,MAAM,WAAW,gBAAiB,SAAQ,WAAW;IACnD,QAAQ,EAAE,SAAS,gBAAgB,EAAE,EAAE,CAAC;CAGzC;AAED,MAAM,WAAW,GAAG;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,WAAY,SAAQ,GAAG;IACtC,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,sBAAsB;IACrC,KAAK,EAAE,GAAG,CAAC;IACX,UAAU,EAAE,MAAM,CAAC;CACpB;AAKD,MAAM,MAAM,OAAO,GACf;IACE,SAAS,EAAE,GAAG,CAAC;IACf,MAAM,EAAE,SAAS,CAAC;IAClB,QAAQ,EAAE,SAAS,CAAC;IACpB,IAAI,EAAE,SAAS,CAAC;CACjB,GACD;IACE,SAAS,EAAE,GAAG,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,GAAG,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;CACd,GACD;IACE,SAAS,EAAE,GAAG,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,GAAG,CAAC;IACd,IAAI,EAAE,SAAS,CAAC;CACjB,CAAC"}
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/gen-mapping/types/types.d.mts b/sdk/node_modules/@jridgewell/gen-mapping/types/types.d.mts
new file mode 100644
index 00000000..e9837ebe
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/gen-mapping/types/types.d.mts
@@ -0,0 +1,44 @@
+import type { SourceMapSegment } from './sourcemap-segment.mts';
+export interface SourceMapV3 {
+ file?: string | null;
+ names: readonly string[];
+ sourceRoot?: string;
+ sources: readonly (string | null)[];
+ sourcesContent?: readonly (string | null)[];
+ version: 3;
+ ignoreList?: readonly number[];
+}
+export interface EncodedSourceMap extends SourceMapV3 {
+ mappings: string;
+}
+export interface DecodedSourceMap extends SourceMapV3 {
+ mappings: readonly SourceMapSegment[][];
+}
+export interface Pos {
+ line: number;
+ column: number;
+}
+export interface OriginalPos extends Pos {
+ source: string;
+}
+export interface BindingExpressionRange {
+ start: Pos;
+ expression: string;
+}
+export type Mapping = {
+ generated: Pos;
+ source: undefined;
+ original: undefined;
+ name: undefined;
+} | {
+ generated: Pos;
+ source: string;
+ original: Pos;
+ name: string;
+} | {
+ generated: Pos;
+ source: string;
+ original: Pos;
+ name: undefined;
+};
+//# sourceMappingURL=types.d.ts.map
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/gen-mapping/types/types.d.mts.map b/sdk/node_modules/@jridgewell/gen-mapping/types/types.d.mts.map
new file mode 100644
index 00000000..159e734d
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/gen-mapping/types/types.d.mts.map
@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAE5D,MAAM,WAAW,WAAW;IAC1B,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IACzB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,SAAS,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC;IACpC,cAAc,CAAC,EAAE,SAAS,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC;IAC5C,OAAO,EAAE,CAAC,CAAC;IACX,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAChC;AAED,MAAM,WAAW,gBAAiB,SAAQ,WAAW;IACnD,QAAQ,EAAE,MAAM,CAAC;CAGlB;AAED,MAAM,WAAW,gBAAiB,SAAQ,WAAW;IACnD,QAAQ,EAAE,SAAS,gBAAgB,EAAE,EAAE,CAAC;CAGzC;AAED,MAAM,WAAW,GAAG;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,WAAY,SAAQ,GAAG;IACtC,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,sBAAsB;IACrC,KAAK,EAAE,GAAG,CAAC;IACX,UAAU,EAAE,MAAM,CAAC;CACpB;AAKD,MAAM,MAAM,OAAO,GACf;IACE,SAAS,EAAE,GAAG,CAAC;IACf,MAAM,EAAE,SAAS,CAAC;IAClB,QAAQ,EAAE,SAAS,CAAC;IACpB,IAAI,EAAE,SAAS,CAAC;CACjB,GACD;IACE,SAAS,EAAE,GAAG,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,GAAG,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;CACd,GACD;IACE,SAAS,EAAE,GAAG,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,GAAG,CAAC;IACd,IAAI,EAAE,SAAS,CAAC;CACjB,CAAC"}
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/resolve-uri/LICENSE b/sdk/node_modules/@jridgewell/resolve-uri/LICENSE
new file mode 100644
index 00000000..0a81b2ad
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/resolve-uri/LICENSE
@@ -0,0 +1,19 @@
+Copyright 2019 Justin Ridgewell
+
+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.
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/resolve-uri/README.md b/sdk/node_modules/@jridgewell/resolve-uri/README.md
new file mode 100644
index 00000000..2fe70df7
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/resolve-uri/README.md
@@ -0,0 +1,40 @@
+# @jridgewell/resolve-uri
+
+> Resolve a URI relative to an optional base URI
+
+Resolve any combination of absolute URIs, protocol-realtive URIs, absolute paths, or relative paths.
+
+## Installation
+
+```sh
+npm install @jridgewell/resolve-uri
+```
+
+## Usage
+
+```typescript
+function resolve(input: string, base?: string): string;
+```
+
+```js
+import resolve from '@jridgewell/resolve-uri';
+
+resolve('foo', 'https://example.com'); // => 'https://example.com/foo'
+```
+
+| Input | Base | Resolution | Explanation |
+|-----------------------|-------------------------|--------------------------------|--------------------------------------------------------------|
+| `https://example.com` | _any_ | `https://example.com/` | Input is normalized only |
+| `//example.com` | `https://base.com/` | `https://example.com/` | Input inherits the base's protocol |
+| `//example.com` | _rest_ | `//example.com/` | Input is normalized only |
+| `/example` | `https://base.com/` | `https://base.com/example` | Input inherits the base's origin |
+| `/example` | `//base.com/` | `//base.com/example` | Input inherits the base's host and remains protocol relative |
+| `/example` | _rest_ | `/example` | Input is normalized only |
+| `example` | `https://base.com/dir/` | `https://base.com/dir/example` | Input is joined with the base |
+| `example` | `https://base.com/file` | `https://base.com/example` | Input is joined with the base without its file |
+| `example` | `//base.com/dir/` | `//base.com/dir/example` | Input is joined with the base's last directory |
+| `example` | `//base.com/file` | `//base.com/example` | Input is joined with the base without its file |
+| `example` | `/base/dir/` | `/base/dir/example` | Input is joined with the base's last directory |
+| `example` | `/base/file` | `/base/example` | Input is joined with the base without its file |
+| `example` | `base/dir/` | `base/dir/example` | Input is joined with the base's last directory |
+| `example` | `base/file` | `base/example` | Input is joined with the base without its file |
diff --git a/sdk/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.mjs b/sdk/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.mjs
new file mode 100644
index 00000000..e958e881
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.mjs
@@ -0,0 +1,232 @@
+// Matches the scheme of a URL, eg "http://"
+const schemeRegex = /^[\w+.-]+:\/\//;
+/**
+ * Matches the parts of a URL:
+ * 1. Scheme, including ":", guaranteed.
+ * 2. User/password, including "@", optional.
+ * 3. Host, guaranteed.
+ * 4. Port, including ":", optional.
+ * 5. Path, including "/", optional.
+ * 6. Query, including "?", optional.
+ * 7. Hash, including "#", optional.
+ */
+const urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/;
+/**
+ * File URLs are weird. They dont' need the regular `//` in the scheme, they may or may not start
+ * with a leading `/`, they can have a domain (but only if they don't start with a Windows drive).
+ *
+ * 1. Host, optional.
+ * 2. Path, which may include "/", guaranteed.
+ * 3. Query, including "?", optional.
+ * 4. Hash, including "#", optional.
+ */
+const fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i;
+function isAbsoluteUrl(input) {
+ return schemeRegex.test(input);
+}
+function isSchemeRelativeUrl(input) {
+ return input.startsWith('//');
+}
+function isAbsolutePath(input) {
+ return input.startsWith('/');
+}
+function isFileUrl(input) {
+ return input.startsWith('file:');
+}
+function isRelative(input) {
+ return /^[.?#]/.test(input);
+}
+function parseAbsoluteUrl(input) {
+ const match = urlRegex.exec(input);
+ return makeUrl(match[1], match[2] || '', match[3], match[4] || '', match[5] || '/', match[6] || '', match[7] || '');
+}
+function parseFileUrl(input) {
+ const match = fileRegex.exec(input);
+ const path = match[2];
+ return makeUrl('file:', '', match[1] || '', '', isAbsolutePath(path) ? path : '/' + path, match[3] || '', match[4] || '');
+}
+function makeUrl(scheme, user, host, port, path, query, hash) {
+ return {
+ scheme,
+ user,
+ host,
+ port,
+ path,
+ query,
+ hash,
+ type: 7 /* Absolute */,
+ };
+}
+function parseUrl(input) {
+ if (isSchemeRelativeUrl(input)) {
+ const url = parseAbsoluteUrl('http:' + input);
+ url.scheme = '';
+ url.type = 6 /* SchemeRelative */;
+ return url;
+ }
+ if (isAbsolutePath(input)) {
+ const url = parseAbsoluteUrl('http://foo.com' + input);
+ url.scheme = '';
+ url.host = '';
+ url.type = 5 /* AbsolutePath */;
+ return url;
+ }
+ if (isFileUrl(input))
+ return parseFileUrl(input);
+ if (isAbsoluteUrl(input))
+ return parseAbsoluteUrl(input);
+ const url = parseAbsoluteUrl('http://foo.com/' + input);
+ url.scheme = '';
+ url.host = '';
+ url.type = input
+ ? input.startsWith('?')
+ ? 3 /* Query */
+ : input.startsWith('#')
+ ? 2 /* Hash */
+ : 4 /* RelativePath */
+ : 1 /* Empty */;
+ return url;
+}
+function stripPathFilename(path) {
+ // If a path ends with a parent directory "..", then it's a relative path with excess parent
+ // paths. It's not a file, so we can't strip it.
+ if (path.endsWith('/..'))
+ return path;
+ const index = path.lastIndexOf('/');
+ return path.slice(0, index + 1);
+}
+function mergePaths(url, base) {
+ normalizePath(base, base.type);
+ // If the path is just a "/", then it was an empty path to begin with (remember, we're a relative
+ // path).
+ if (url.path === '/') {
+ url.path = base.path;
+ }
+ else {
+ // Resolution happens relative to the base path's directory, not the file.
+ url.path = stripPathFilename(base.path) + url.path;
+ }
+}
+/**
+ * The path can have empty directories "//", unneeded parents "foo/..", or current directory
+ * "foo/.". We need to normalize to a standard representation.
+ */
+function normalizePath(url, type) {
+ const rel = type <= 4 /* RelativePath */;
+ const pieces = url.path.split('/');
+ // We need to preserve the first piece always, so that we output a leading slash. The item at
+ // pieces[0] is an empty string.
+ let pointer = 1;
+ // Positive is the number of real directories we've output, used for popping a parent directory.
+ // Eg, "foo/bar/.." will have a positive 2, and we can decrement to be left with just "foo".
+ let positive = 0;
+ // We need to keep a trailing slash if we encounter an empty directory (eg, splitting "foo/" will
+ // generate `["foo", ""]` pieces). And, if we pop a parent directory. But once we encounter a
+ // real directory, we won't need to append, unless the other conditions happen again.
+ let addTrailingSlash = false;
+ for (let i = 1; i < pieces.length; i++) {
+ const piece = pieces[i];
+ // An empty directory, could be a trailing slash, or just a double "//" in the path.
+ if (!piece) {
+ addTrailingSlash = true;
+ continue;
+ }
+ // If we encounter a real directory, then we don't need to append anymore.
+ addTrailingSlash = false;
+ // A current directory, which we can always drop.
+ if (piece === '.')
+ continue;
+ // A parent directory, we need to see if there are any real directories we can pop. Else, we
+ // have an excess of parents, and we'll need to keep the "..".
+ if (piece === '..') {
+ if (positive) {
+ addTrailingSlash = true;
+ positive--;
+ pointer--;
+ }
+ else if (rel) {
+ // If we're in a relativePath, then we need to keep the excess parents. Else, in an absolute
+ // URL, protocol relative URL, or an absolute path, we don't need to keep excess.
+ pieces[pointer++] = piece;
+ }
+ continue;
+ }
+ // We've encountered a real directory. Move it to the next insertion pointer, which accounts for
+ // any popped or dropped directories.
+ pieces[pointer++] = piece;
+ positive++;
+ }
+ let path = '';
+ for (let i = 1; i < pointer; i++) {
+ path += '/' + pieces[i];
+ }
+ if (!path || (addTrailingSlash && !path.endsWith('/..'))) {
+ path += '/';
+ }
+ url.path = path;
+}
+/**
+ * Attempts to resolve `input` URL/path relative to `base`.
+ */
+function resolve(input, base) {
+ if (!input && !base)
+ return '';
+ const url = parseUrl(input);
+ let inputType = url.type;
+ if (base && inputType !== 7 /* Absolute */) {
+ const baseUrl = parseUrl(base);
+ const baseType = baseUrl.type;
+ switch (inputType) {
+ case 1 /* Empty */:
+ url.hash = baseUrl.hash;
+ // fall through
+ case 2 /* Hash */:
+ url.query = baseUrl.query;
+ // fall through
+ case 3 /* Query */:
+ case 4 /* RelativePath */:
+ mergePaths(url, baseUrl);
+ // fall through
+ case 5 /* AbsolutePath */:
+ // The host, user, and port are joined, you can't copy one without the others.
+ url.user = baseUrl.user;
+ url.host = baseUrl.host;
+ url.port = baseUrl.port;
+ // fall through
+ case 6 /* SchemeRelative */:
+ // The input doesn't have a schema at least, so we need to copy at least that over.
+ url.scheme = baseUrl.scheme;
+ }
+ if (baseType > inputType)
+ inputType = baseType;
+ }
+ normalizePath(url, inputType);
+ const queryHash = url.query + url.hash;
+ switch (inputType) {
+ // This is impossible, because of the empty checks at the start of the function.
+ // case UrlType.Empty:
+ case 2 /* Hash */:
+ case 3 /* Query */:
+ return queryHash;
+ case 4 /* RelativePath */: {
+ // The first char is always a "/", and we need it to be relative.
+ const path = url.path.slice(1);
+ if (!path)
+ return queryHash || '.';
+ if (isRelative(base || input) && !isRelative(path)) {
+ // If base started with a leading ".", or there is no base and input started with a ".",
+ // then we need to ensure that the relative path starts with a ".". We don't know if
+ // relative starts with a "..", though, so check before prepending.
+ return './' + path + queryHash;
+ }
+ return path + queryHash;
+ }
+ case 5 /* AbsolutePath */:
+ return url.path + queryHash;
+ default:
+ return url.scheme + '//' + url.user + url.host + url.port + url.path + queryHash;
+ }
+}
+
+export { resolve as default };
+//# sourceMappingURL=resolve-uri.mjs.map
diff --git a/sdk/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.mjs.map b/sdk/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.mjs.map
new file mode 100644
index 00000000..1de97d01
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.mjs.map
@@ -0,0 +1 @@
+{"version":3,"file":"resolve-uri.mjs","sources":["../src/resolve-uri.ts"],"sourcesContent":["// Matches the scheme of a URL, eg \"http://\"\nconst schemeRegex = /^[\\w+.-]+:\\/\\//;\n\n/**\n * Matches the parts of a URL:\n * 1. Scheme, including \":\", guaranteed.\n * 2. User/password, including \"@\", optional.\n * 3. Host, guaranteed.\n * 4. Port, including \":\", optional.\n * 5. Path, including \"/\", optional.\n * 6. Query, including \"?\", optional.\n * 7. Hash, including \"#\", optional.\n */\nconst urlRegex = /^([\\w+.-]+:)\\/\\/([^@/#?]*@)?([^:/#?]*)(:\\d+)?(\\/[^#?]*)?(\\?[^#]*)?(#.*)?/;\n\n/**\n * File URLs are weird. They dont' need the regular `//` in the scheme, they may or may not start\n * with a leading `/`, they can have a domain (but only if they don't start with a Windows drive).\n *\n * 1. Host, optional.\n * 2. Path, which may include \"/\", guaranteed.\n * 3. Query, including \"?\", optional.\n * 4. Hash, including \"#\", optional.\n */\nconst fileRegex = /^file:(?:\\/\\/((?![a-z]:)[^/#?]*)?)?(\\/?[^#?]*)(\\?[^#]*)?(#.*)?/i;\n\ntype Url = {\n scheme: string;\n user: string;\n host: string;\n port: string;\n path: string;\n query: string;\n hash: string;\n type: UrlType;\n};\n\nconst enum UrlType {\n Empty = 1,\n Hash = 2,\n Query = 3,\n RelativePath = 4,\n AbsolutePath = 5,\n SchemeRelative = 6,\n Absolute = 7,\n}\n\nfunction isAbsoluteUrl(input: string): boolean {\n return schemeRegex.test(input);\n}\n\nfunction isSchemeRelativeUrl(input: string): boolean {\n return input.startsWith('//');\n}\n\nfunction isAbsolutePath(input: string): boolean {\n return input.startsWith('/');\n}\n\nfunction isFileUrl(input: string): boolean {\n return input.startsWith('file:');\n}\n\nfunction isRelative(input: string): boolean {\n return /^[.?#]/.test(input);\n}\n\nfunction parseAbsoluteUrl(input: string): Url {\n const match = urlRegex.exec(input)!;\n return makeUrl(\n match[1],\n match[2] || '',\n match[3],\n match[4] || '',\n match[5] || '/',\n match[6] || '',\n match[7] || '',\n );\n}\n\nfunction parseFileUrl(input: string): Url {\n const match = fileRegex.exec(input)!;\n const path = match[2];\n return makeUrl(\n 'file:',\n '',\n match[1] || '',\n '',\n isAbsolutePath(path) ? path : '/' + path,\n match[3] || '',\n match[4] || '',\n );\n}\n\nfunction makeUrl(\n scheme: string,\n user: string,\n host: string,\n port: string,\n path: string,\n query: string,\n hash: string,\n): Url {\n return {\n scheme,\n user,\n host,\n port,\n path,\n query,\n hash,\n type: UrlType.Absolute,\n };\n}\n\nfunction parseUrl(input: string): Url {\n if (isSchemeRelativeUrl(input)) {\n const url = parseAbsoluteUrl('http:' + input);\n url.scheme = '';\n url.type = UrlType.SchemeRelative;\n return url;\n }\n\n if (isAbsolutePath(input)) {\n const url = parseAbsoluteUrl('http://foo.com' + input);\n url.scheme = '';\n url.host = '';\n url.type = UrlType.AbsolutePath;\n return url;\n }\n\n if (isFileUrl(input)) return parseFileUrl(input);\n\n if (isAbsoluteUrl(input)) return parseAbsoluteUrl(input);\n\n const url = parseAbsoluteUrl('http://foo.com/' + input);\n url.scheme = '';\n url.host = '';\n url.type = input\n ? input.startsWith('?')\n ? UrlType.Query\n : input.startsWith('#')\n ? UrlType.Hash\n : UrlType.RelativePath\n : UrlType.Empty;\n return url;\n}\n\nfunction stripPathFilename(path: string): string {\n // If a path ends with a parent directory \"..\", then it's a relative path with excess parent\n // paths. It's not a file, so we can't strip it.\n if (path.endsWith('/..')) return path;\n const index = path.lastIndexOf('/');\n return path.slice(0, index + 1);\n}\n\nfunction mergePaths(url: Url, base: Url) {\n normalizePath(base, base.type);\n\n // If the path is just a \"/\", then it was an empty path to begin with (remember, we're a relative\n // path).\n if (url.path === '/') {\n url.path = base.path;\n } else {\n // Resolution happens relative to the base path's directory, not the file.\n url.path = stripPathFilename(base.path) + url.path;\n }\n}\n\n/**\n * The path can have empty directories \"//\", unneeded parents \"foo/..\", or current directory\n * \"foo/.\". We need to normalize to a standard representation.\n */\nfunction normalizePath(url: Url, type: UrlType) {\n const rel = type <= UrlType.RelativePath;\n const pieces = url.path.split('/');\n\n // We need to preserve the first piece always, so that we output a leading slash. The item at\n // pieces[0] is an empty string.\n let pointer = 1;\n\n // Positive is the number of real directories we've output, used for popping a parent directory.\n // Eg, \"foo/bar/..\" will have a positive 2, and we can decrement to be left with just \"foo\".\n let positive = 0;\n\n // We need to keep a trailing slash if we encounter an empty directory (eg, splitting \"foo/\" will\n // generate `[\"foo\", \"\"]` pieces). And, if we pop a parent directory. But once we encounter a\n // real directory, we won't need to append, unless the other conditions happen again.\n let addTrailingSlash = false;\n\n for (let i = 1; i < pieces.length; i++) {\n const piece = pieces[i];\n\n // An empty directory, could be a trailing slash, or just a double \"//\" in the path.\n if (!piece) {\n addTrailingSlash = true;\n continue;\n }\n\n // If we encounter a real directory, then we don't need to append anymore.\n addTrailingSlash = false;\n\n // A current directory, which we can always drop.\n if (piece === '.') continue;\n\n // A parent directory, we need to see if there are any real directories we can pop. Else, we\n // have an excess of parents, and we'll need to keep the \"..\".\n if (piece === '..') {\n if (positive) {\n addTrailingSlash = true;\n positive--;\n pointer--;\n } else if (rel) {\n // If we're in a relativePath, then we need to keep the excess parents. Else, in an absolute\n // URL, protocol relative URL, or an absolute path, we don't need to keep excess.\n pieces[pointer++] = piece;\n }\n continue;\n }\n\n // We've encountered a real directory. Move it to the next insertion pointer, which accounts for\n // any popped or dropped directories.\n pieces[pointer++] = piece;\n positive++;\n }\n\n let path = '';\n for (let i = 1; i < pointer; i++) {\n path += '/' + pieces[i];\n }\n if (!path || (addTrailingSlash && !path.endsWith('/..'))) {\n path += '/';\n }\n url.path = path;\n}\n\n/**\n * Attempts to resolve `input` URL/path relative to `base`.\n */\nexport default function resolve(input: string, base: string | undefined): string {\n if (!input && !base) return '';\n\n const url = parseUrl(input);\n let inputType = url.type;\n\n if (base && inputType !== UrlType.Absolute) {\n const baseUrl = parseUrl(base);\n const baseType = baseUrl.type;\n\n switch (inputType) {\n case UrlType.Empty:\n url.hash = baseUrl.hash;\n // fall through\n\n case UrlType.Hash:\n url.query = baseUrl.query;\n // fall through\n\n case UrlType.Query:\n case UrlType.RelativePath:\n mergePaths(url, baseUrl);\n // fall through\n\n case UrlType.AbsolutePath:\n // The host, user, and port are joined, you can't copy one without the others.\n url.user = baseUrl.user;\n url.host = baseUrl.host;\n url.port = baseUrl.port;\n // fall through\n\n case UrlType.SchemeRelative:\n // The input doesn't have a schema at least, so we need to copy at least that over.\n url.scheme = baseUrl.scheme;\n }\n if (baseType > inputType) inputType = baseType;\n }\n\n normalizePath(url, inputType);\n\n const queryHash = url.query + url.hash;\n switch (inputType) {\n // This is impossible, because of the empty checks at the start of the function.\n // case UrlType.Empty:\n\n case UrlType.Hash:\n case UrlType.Query:\n return queryHash;\n\n case UrlType.RelativePath: {\n // The first char is always a \"/\", and we need it to be relative.\n const path = url.path.slice(1);\n\n if (!path) return queryHash || '.';\n\n if (isRelative(base || input) && !isRelative(path)) {\n // If base started with a leading \".\", or there is no base and input started with a \".\",\n // then we need to ensure that the relative path starts with a \".\". We don't know if\n // relative starts with a \"..\", though, so check before prepending.\n return './' + path + queryHash;\n }\n\n return path + queryHash;\n }\n\n case UrlType.AbsolutePath:\n return url.path + queryHash;\n\n default:\n return url.scheme + '//' + url.user + url.host + url.port + url.path + queryHash;\n }\n}\n"],"names":[],"mappings":"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"}
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.umd.js b/sdk/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.umd.js
new file mode 100644
index 00000000..a783049b
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.umd.js
@@ -0,0 +1,240 @@
+(function (global, factory) {
+ typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+ typeof define === 'function' && define.amd ? define(factory) :
+ (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.resolveURI = factory());
+})(this, (function () { 'use strict';
+
+ // Matches the scheme of a URL, eg "http://"
+ const schemeRegex = /^[\w+.-]+:\/\//;
+ /**
+ * Matches the parts of a URL:
+ * 1. Scheme, including ":", guaranteed.
+ * 2. User/password, including "@", optional.
+ * 3. Host, guaranteed.
+ * 4. Port, including ":", optional.
+ * 5. Path, including "/", optional.
+ * 6. Query, including "?", optional.
+ * 7. Hash, including "#", optional.
+ */
+ const urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/;
+ /**
+ * File URLs are weird. They dont' need the regular `//` in the scheme, they may or may not start
+ * with a leading `/`, they can have a domain (but only if they don't start with a Windows drive).
+ *
+ * 1. Host, optional.
+ * 2. Path, which may include "/", guaranteed.
+ * 3. Query, including "?", optional.
+ * 4. Hash, including "#", optional.
+ */
+ const fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i;
+ function isAbsoluteUrl(input) {
+ return schemeRegex.test(input);
+ }
+ function isSchemeRelativeUrl(input) {
+ return input.startsWith('//');
+ }
+ function isAbsolutePath(input) {
+ return input.startsWith('/');
+ }
+ function isFileUrl(input) {
+ return input.startsWith('file:');
+ }
+ function isRelative(input) {
+ return /^[.?#]/.test(input);
+ }
+ function parseAbsoluteUrl(input) {
+ const match = urlRegex.exec(input);
+ return makeUrl(match[1], match[2] || '', match[3], match[4] || '', match[5] || '/', match[6] || '', match[7] || '');
+ }
+ function parseFileUrl(input) {
+ const match = fileRegex.exec(input);
+ const path = match[2];
+ return makeUrl('file:', '', match[1] || '', '', isAbsolutePath(path) ? path : '/' + path, match[3] || '', match[4] || '');
+ }
+ function makeUrl(scheme, user, host, port, path, query, hash) {
+ return {
+ scheme,
+ user,
+ host,
+ port,
+ path,
+ query,
+ hash,
+ type: 7 /* Absolute */,
+ };
+ }
+ function parseUrl(input) {
+ if (isSchemeRelativeUrl(input)) {
+ const url = parseAbsoluteUrl('http:' + input);
+ url.scheme = '';
+ url.type = 6 /* SchemeRelative */;
+ return url;
+ }
+ if (isAbsolutePath(input)) {
+ const url = parseAbsoluteUrl('http://foo.com' + input);
+ url.scheme = '';
+ url.host = '';
+ url.type = 5 /* AbsolutePath */;
+ return url;
+ }
+ if (isFileUrl(input))
+ return parseFileUrl(input);
+ if (isAbsoluteUrl(input))
+ return parseAbsoluteUrl(input);
+ const url = parseAbsoluteUrl('http://foo.com/' + input);
+ url.scheme = '';
+ url.host = '';
+ url.type = input
+ ? input.startsWith('?')
+ ? 3 /* Query */
+ : input.startsWith('#')
+ ? 2 /* Hash */
+ : 4 /* RelativePath */
+ : 1 /* Empty */;
+ return url;
+ }
+ function stripPathFilename(path) {
+ // If a path ends with a parent directory "..", then it's a relative path with excess parent
+ // paths. It's not a file, so we can't strip it.
+ if (path.endsWith('/..'))
+ return path;
+ const index = path.lastIndexOf('/');
+ return path.slice(0, index + 1);
+ }
+ function mergePaths(url, base) {
+ normalizePath(base, base.type);
+ // If the path is just a "/", then it was an empty path to begin with (remember, we're a relative
+ // path).
+ if (url.path === '/') {
+ url.path = base.path;
+ }
+ else {
+ // Resolution happens relative to the base path's directory, not the file.
+ url.path = stripPathFilename(base.path) + url.path;
+ }
+ }
+ /**
+ * The path can have empty directories "//", unneeded parents "foo/..", or current directory
+ * "foo/.". We need to normalize to a standard representation.
+ */
+ function normalizePath(url, type) {
+ const rel = type <= 4 /* RelativePath */;
+ const pieces = url.path.split('/');
+ // We need to preserve the first piece always, so that we output a leading slash. The item at
+ // pieces[0] is an empty string.
+ let pointer = 1;
+ // Positive is the number of real directories we've output, used for popping a parent directory.
+ // Eg, "foo/bar/.." will have a positive 2, and we can decrement to be left with just "foo".
+ let positive = 0;
+ // We need to keep a trailing slash if we encounter an empty directory (eg, splitting "foo/" will
+ // generate `["foo", ""]` pieces). And, if we pop a parent directory. But once we encounter a
+ // real directory, we won't need to append, unless the other conditions happen again.
+ let addTrailingSlash = false;
+ for (let i = 1; i < pieces.length; i++) {
+ const piece = pieces[i];
+ // An empty directory, could be a trailing slash, or just a double "//" in the path.
+ if (!piece) {
+ addTrailingSlash = true;
+ continue;
+ }
+ // If we encounter a real directory, then we don't need to append anymore.
+ addTrailingSlash = false;
+ // A current directory, which we can always drop.
+ if (piece === '.')
+ continue;
+ // A parent directory, we need to see if there are any real directories we can pop. Else, we
+ // have an excess of parents, and we'll need to keep the "..".
+ if (piece === '..') {
+ if (positive) {
+ addTrailingSlash = true;
+ positive--;
+ pointer--;
+ }
+ else if (rel) {
+ // If we're in a relativePath, then we need to keep the excess parents. Else, in an absolute
+ // URL, protocol relative URL, or an absolute path, we don't need to keep excess.
+ pieces[pointer++] = piece;
+ }
+ continue;
+ }
+ // We've encountered a real directory. Move it to the next insertion pointer, which accounts for
+ // any popped or dropped directories.
+ pieces[pointer++] = piece;
+ positive++;
+ }
+ let path = '';
+ for (let i = 1; i < pointer; i++) {
+ path += '/' + pieces[i];
+ }
+ if (!path || (addTrailingSlash && !path.endsWith('/..'))) {
+ path += '/';
+ }
+ url.path = path;
+ }
+ /**
+ * Attempts to resolve `input` URL/path relative to `base`.
+ */
+ function resolve(input, base) {
+ if (!input && !base)
+ return '';
+ const url = parseUrl(input);
+ let inputType = url.type;
+ if (base && inputType !== 7 /* Absolute */) {
+ const baseUrl = parseUrl(base);
+ const baseType = baseUrl.type;
+ switch (inputType) {
+ case 1 /* Empty */:
+ url.hash = baseUrl.hash;
+ // fall through
+ case 2 /* Hash */:
+ url.query = baseUrl.query;
+ // fall through
+ case 3 /* Query */:
+ case 4 /* RelativePath */:
+ mergePaths(url, baseUrl);
+ // fall through
+ case 5 /* AbsolutePath */:
+ // The host, user, and port are joined, you can't copy one without the others.
+ url.user = baseUrl.user;
+ url.host = baseUrl.host;
+ url.port = baseUrl.port;
+ // fall through
+ case 6 /* SchemeRelative */:
+ // The input doesn't have a schema at least, so we need to copy at least that over.
+ url.scheme = baseUrl.scheme;
+ }
+ if (baseType > inputType)
+ inputType = baseType;
+ }
+ normalizePath(url, inputType);
+ const queryHash = url.query + url.hash;
+ switch (inputType) {
+ // This is impossible, because of the empty checks at the start of the function.
+ // case UrlType.Empty:
+ case 2 /* Hash */:
+ case 3 /* Query */:
+ return queryHash;
+ case 4 /* RelativePath */: {
+ // The first char is always a "/", and we need it to be relative.
+ const path = url.path.slice(1);
+ if (!path)
+ return queryHash || '.';
+ if (isRelative(base || input) && !isRelative(path)) {
+ // If base started with a leading ".", or there is no base and input started with a ".",
+ // then we need to ensure that the relative path starts with a ".". We don't know if
+ // relative starts with a "..", though, so check before prepending.
+ return './' + path + queryHash;
+ }
+ return path + queryHash;
+ }
+ case 5 /* AbsolutePath */:
+ return url.path + queryHash;
+ default:
+ return url.scheme + '//' + url.user + url.host + url.port + url.path + queryHash;
+ }
+ }
+
+ return resolve;
+
+}));
+//# sourceMappingURL=resolve-uri.umd.js.map
diff --git a/sdk/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.umd.js.map b/sdk/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.umd.js.map
new file mode 100644
index 00000000..70a37f21
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.umd.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"resolve-uri.umd.js","sources":["../src/resolve-uri.ts"],"sourcesContent":["// Matches the scheme of a URL, eg \"http://\"\nconst schemeRegex = /^[\\w+.-]+:\\/\\//;\n\n/**\n * Matches the parts of a URL:\n * 1. Scheme, including \":\", guaranteed.\n * 2. User/password, including \"@\", optional.\n * 3. Host, guaranteed.\n * 4. Port, including \":\", optional.\n * 5. Path, including \"/\", optional.\n * 6. Query, including \"?\", optional.\n * 7. Hash, including \"#\", optional.\n */\nconst urlRegex = /^([\\w+.-]+:)\\/\\/([^@/#?]*@)?([^:/#?]*)(:\\d+)?(\\/[^#?]*)?(\\?[^#]*)?(#.*)?/;\n\n/**\n * File URLs are weird. They dont' need the regular `//` in the scheme, they may or may not start\n * with a leading `/`, they can have a domain (but only if they don't start with a Windows drive).\n *\n * 1. Host, optional.\n * 2. Path, which may include \"/\", guaranteed.\n * 3. Query, including \"?\", optional.\n * 4. Hash, including \"#\", optional.\n */\nconst fileRegex = /^file:(?:\\/\\/((?![a-z]:)[^/#?]*)?)?(\\/?[^#?]*)(\\?[^#]*)?(#.*)?/i;\n\ntype Url = {\n scheme: string;\n user: string;\n host: string;\n port: string;\n path: string;\n query: string;\n hash: string;\n type: UrlType;\n};\n\nconst enum UrlType {\n Empty = 1,\n Hash = 2,\n Query = 3,\n RelativePath = 4,\n AbsolutePath = 5,\n SchemeRelative = 6,\n Absolute = 7,\n}\n\nfunction isAbsoluteUrl(input: string): boolean {\n return schemeRegex.test(input);\n}\n\nfunction isSchemeRelativeUrl(input: string): boolean {\n return input.startsWith('//');\n}\n\nfunction isAbsolutePath(input: string): boolean {\n return input.startsWith('/');\n}\n\nfunction isFileUrl(input: string): boolean {\n return input.startsWith('file:');\n}\n\nfunction isRelative(input: string): boolean {\n return /^[.?#]/.test(input);\n}\n\nfunction parseAbsoluteUrl(input: string): Url {\n const match = urlRegex.exec(input)!;\n return makeUrl(\n match[1],\n match[2] || '',\n match[3],\n match[4] || '',\n match[5] || '/',\n match[6] || '',\n match[7] || '',\n );\n}\n\nfunction parseFileUrl(input: string): Url {\n const match = fileRegex.exec(input)!;\n const path = match[2];\n return makeUrl(\n 'file:',\n '',\n match[1] || '',\n '',\n isAbsolutePath(path) ? path : '/' + path,\n match[3] || '',\n match[4] || '',\n );\n}\n\nfunction makeUrl(\n scheme: string,\n user: string,\n host: string,\n port: string,\n path: string,\n query: string,\n hash: string,\n): Url {\n return {\n scheme,\n user,\n host,\n port,\n path,\n query,\n hash,\n type: UrlType.Absolute,\n };\n}\n\nfunction parseUrl(input: string): Url {\n if (isSchemeRelativeUrl(input)) {\n const url = parseAbsoluteUrl('http:' + input);\n url.scheme = '';\n url.type = UrlType.SchemeRelative;\n return url;\n }\n\n if (isAbsolutePath(input)) {\n const url = parseAbsoluteUrl('http://foo.com' + input);\n url.scheme = '';\n url.host = '';\n url.type = UrlType.AbsolutePath;\n return url;\n }\n\n if (isFileUrl(input)) return parseFileUrl(input);\n\n if (isAbsoluteUrl(input)) return parseAbsoluteUrl(input);\n\n const url = parseAbsoluteUrl('http://foo.com/' + input);\n url.scheme = '';\n url.host = '';\n url.type = input\n ? input.startsWith('?')\n ? UrlType.Query\n : input.startsWith('#')\n ? UrlType.Hash\n : UrlType.RelativePath\n : UrlType.Empty;\n return url;\n}\n\nfunction stripPathFilename(path: string): string {\n // If a path ends with a parent directory \"..\", then it's a relative path with excess parent\n // paths. It's not a file, so we can't strip it.\n if (path.endsWith('/..')) return path;\n const index = path.lastIndexOf('/');\n return path.slice(0, index + 1);\n}\n\nfunction mergePaths(url: Url, base: Url) {\n normalizePath(base, base.type);\n\n // If the path is just a \"/\", then it was an empty path to begin with (remember, we're a relative\n // path).\n if (url.path === '/') {\n url.path = base.path;\n } else {\n // Resolution happens relative to the base path's directory, not the file.\n url.path = stripPathFilename(base.path) + url.path;\n }\n}\n\n/**\n * The path can have empty directories \"//\", unneeded parents \"foo/..\", or current directory\n * \"foo/.\". We need to normalize to a standard representation.\n */\nfunction normalizePath(url: Url, type: UrlType) {\n const rel = type <= UrlType.RelativePath;\n const pieces = url.path.split('/');\n\n // We need to preserve the first piece always, so that we output a leading slash. The item at\n // pieces[0] is an empty string.\n let pointer = 1;\n\n // Positive is the number of real directories we've output, used for popping a parent directory.\n // Eg, \"foo/bar/..\" will have a positive 2, and we can decrement to be left with just \"foo\".\n let positive = 0;\n\n // We need to keep a trailing slash if we encounter an empty directory (eg, splitting \"foo/\" will\n // generate `[\"foo\", \"\"]` pieces). And, if we pop a parent directory. But once we encounter a\n // real directory, we won't need to append, unless the other conditions happen again.\n let addTrailingSlash = false;\n\n for (let i = 1; i < pieces.length; i++) {\n const piece = pieces[i];\n\n // An empty directory, could be a trailing slash, or just a double \"//\" in the path.\n if (!piece) {\n addTrailingSlash = true;\n continue;\n }\n\n // If we encounter a real directory, then we don't need to append anymore.\n addTrailingSlash = false;\n\n // A current directory, which we can always drop.\n if (piece === '.') continue;\n\n // A parent directory, we need to see if there are any real directories we can pop. Else, we\n // have an excess of parents, and we'll need to keep the \"..\".\n if (piece === '..') {\n if (positive) {\n addTrailingSlash = true;\n positive--;\n pointer--;\n } else if (rel) {\n // If we're in a relativePath, then we need to keep the excess parents. Else, in an absolute\n // URL, protocol relative URL, or an absolute path, we don't need to keep excess.\n pieces[pointer++] = piece;\n }\n continue;\n }\n\n // We've encountered a real directory. Move it to the next insertion pointer, which accounts for\n // any popped or dropped directories.\n pieces[pointer++] = piece;\n positive++;\n }\n\n let path = '';\n for (let i = 1; i < pointer; i++) {\n path += '/' + pieces[i];\n }\n if (!path || (addTrailingSlash && !path.endsWith('/..'))) {\n path += '/';\n }\n url.path = path;\n}\n\n/**\n * Attempts to resolve `input` URL/path relative to `base`.\n */\nexport default function resolve(input: string, base: string | undefined): string {\n if (!input && !base) return '';\n\n const url = parseUrl(input);\n let inputType = url.type;\n\n if (base && inputType !== UrlType.Absolute) {\n const baseUrl = parseUrl(base);\n const baseType = baseUrl.type;\n\n switch (inputType) {\n case UrlType.Empty:\n url.hash = baseUrl.hash;\n // fall through\n\n case UrlType.Hash:\n url.query = baseUrl.query;\n // fall through\n\n case UrlType.Query:\n case UrlType.RelativePath:\n mergePaths(url, baseUrl);\n // fall through\n\n case UrlType.AbsolutePath:\n // The host, user, and port are joined, you can't copy one without the others.\n url.user = baseUrl.user;\n url.host = baseUrl.host;\n url.port = baseUrl.port;\n // fall through\n\n case UrlType.SchemeRelative:\n // The input doesn't have a schema at least, so we need to copy at least that over.\n url.scheme = baseUrl.scheme;\n }\n if (baseType > inputType) inputType = baseType;\n }\n\n normalizePath(url, inputType);\n\n const queryHash = url.query + url.hash;\n switch (inputType) {\n // This is impossible, because of the empty checks at the start of the function.\n // case UrlType.Empty:\n\n case UrlType.Hash:\n case UrlType.Query:\n return queryHash;\n\n case UrlType.RelativePath: {\n // The first char is always a \"/\", and we need it to be relative.\n const path = url.path.slice(1);\n\n if (!path) return queryHash || '.';\n\n if (isRelative(base || input) && !isRelative(path)) {\n // If base started with a leading \".\", or there is no base and input started with a \".\",\n // then we need to ensure that the relative path starts with a \".\". We don't know if\n // relative starts with a \"..\", though, so check before prepending.\n return './' + path + queryHash;\n }\n\n return path + queryHash;\n }\n\n case UrlType.AbsolutePath:\n return url.path + queryHash;\n\n default:\n return url.scheme + '//' + url.user + url.host + url.port + url.path + queryHash;\n }\n}\n"],"names":[],"mappings":"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"}
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/resolve-uri/dist/types/resolve-uri.d.ts b/sdk/node_modules/@jridgewell/resolve-uri/dist/types/resolve-uri.d.ts
new file mode 100644
index 00000000..b7f0b3b2
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/resolve-uri/dist/types/resolve-uri.d.ts
@@ -0,0 +1,4 @@
+/**
+ * Attempts to resolve `input` URL/path relative to `base`.
+ */
+export default function resolve(input: string, base: string | undefined): string;
diff --git a/sdk/node_modules/@jridgewell/resolve-uri/package.json b/sdk/node_modules/@jridgewell/resolve-uri/package.json
new file mode 100644
index 00000000..02a4c518
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/resolve-uri/package.json
@@ -0,0 +1,69 @@
+{
+ "name": "@jridgewell/resolve-uri",
+ "version": "3.1.2",
+ "description": "Resolve a URI relative to an optional base URI",
+ "keywords": [
+ "resolve",
+ "uri",
+ "url",
+ "path"
+ ],
+ "author": "Justin Ridgewell ",
+ "license": "MIT",
+ "repository": "https://github.com/jridgewell/resolve-uri",
+ "main": "dist/resolve-uri.umd.js",
+ "module": "dist/resolve-uri.mjs",
+ "types": "dist/types/resolve-uri.d.ts",
+ "exports": {
+ ".": [
+ {
+ "types": "./dist/types/resolve-uri.d.ts",
+ "browser": "./dist/resolve-uri.umd.js",
+ "require": "./dist/resolve-uri.umd.js",
+ "import": "./dist/resolve-uri.mjs"
+ },
+ "./dist/resolve-uri.umd.js"
+ ],
+ "./package.json": "./package.json"
+ },
+ "files": [
+ "dist"
+ ],
+ "engines": {
+ "node": ">=6.0.0"
+ },
+ "scripts": {
+ "prebuild": "rm -rf dist",
+ "build": "run-s -n build:*",
+ "build:rollup": "rollup -c rollup.config.js",
+ "build:ts": "tsc --project tsconfig.build.json",
+ "lint": "run-s -n lint:*",
+ "lint:prettier": "npm run test:lint:prettier -- --write",
+ "lint:ts": "npm run test:lint:ts -- --fix",
+ "pretest": "run-s build:rollup",
+ "test": "run-s -n test:lint test:only",
+ "test:debug": "mocha --inspect-brk",
+ "test:lint": "run-s -n test:lint:*",
+ "test:lint:prettier": "prettier --check '{src,test}/**/*.ts'",
+ "test:lint:ts": "eslint '{src,test}/**/*.ts'",
+ "test:only": "mocha",
+ "test:coverage": "c8 mocha",
+ "test:watch": "mocha --watch",
+ "prepublishOnly": "npm run preversion",
+ "preversion": "run-s test build"
+ },
+ "devDependencies": {
+ "@jridgewell/resolve-uri-latest": "npm:@jridgewell/resolve-uri@*",
+ "@rollup/plugin-typescript": "8.3.0",
+ "@typescript-eslint/eslint-plugin": "5.10.0",
+ "@typescript-eslint/parser": "5.10.0",
+ "c8": "7.11.0",
+ "eslint": "8.7.0",
+ "eslint-config-prettier": "8.3.0",
+ "mocha": "9.2.0",
+ "npm-run-all": "4.1.5",
+ "prettier": "2.5.1",
+ "rollup": "2.66.0",
+ "typescript": "4.5.5"
+ }
+}
diff --git a/sdk/node_modules/@jridgewell/sourcemap-codec/LICENSE b/sdk/node_modules/@jridgewell/sourcemap-codec/LICENSE
new file mode 100644
index 00000000..1f6ce94c
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/sourcemap-codec/LICENSE
@@ -0,0 +1,19 @@
+Copyright 2024 Justin Ridgewell
+
+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.
diff --git a/sdk/node_modules/@jridgewell/sourcemap-codec/README.md b/sdk/node_modules/@jridgewell/sourcemap-codec/README.md
new file mode 100644
index 00000000..b3e0708b
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/sourcemap-codec/README.md
@@ -0,0 +1,264 @@
+# @jridgewell/sourcemap-codec
+
+Encode/decode the `mappings` property of a [sourcemap](https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit).
+
+
+## Why?
+
+Sourcemaps are difficult to generate and manipulate, because the `mappings` property – the part that actually links the generated code back to the original source – is encoded using an obscure method called [Variable-length quantity](https://en.wikipedia.org/wiki/Variable-length_quantity). On top of that, each segment in the mapping contains offsets rather than absolute indices, which means that you can't look at a segment in isolation – you have to understand the whole sourcemap.
+
+This package makes the process slightly easier.
+
+
+## Installation
+
+```bash
+npm install @jridgewell/sourcemap-codec
+```
+
+
+## Usage
+
+```js
+import { encode, decode } from '@jridgewell/sourcemap-codec';
+
+var decoded = decode( ';EAEEA,EAAE,EAAC,CAAE;ECQY,UACC' );
+
+assert.deepEqual( decoded, [
+ // the first line (of the generated code) has no mappings,
+ // as shown by the starting semi-colon (which separates lines)
+ [],
+
+ // the second line contains four (comma-separated) segments
+ [
+ // segments are encoded as you'd expect:
+ // [ generatedCodeColumn, sourceIndex, sourceCodeLine, sourceCodeColumn, nameIndex ]
+
+ // i.e. the first segment begins at column 2, and maps back to the second column
+ // of the second line (both zero-based) of the 0th source, and uses the 0th
+ // name in the `map.names` array
+ [ 2, 0, 2, 2, 0 ],
+
+ // the remaining segments are 4-length rather than 5-length,
+ // because they don't map a name
+ [ 4, 0, 2, 4 ],
+ [ 6, 0, 2, 5 ],
+ [ 7, 0, 2, 7 ]
+ ],
+
+ // the final line contains two segments
+ [
+ [ 2, 1, 10, 19 ],
+ [ 12, 1, 11, 20 ]
+ ]
+]);
+
+var encoded = encode( decoded );
+assert.equal( encoded, ';EAEEA,EAAE,EAAC,CAAE;ECQY,UACC' );
+```
+
+## Benchmarks
+
+```
+node v20.10.0
+
+amp.js.map - 45120 segments
+
+Decode Memory Usage:
+local code 5815135 bytes
+@jridgewell/sourcemap-codec 1.4.15 5868160 bytes
+sourcemap-codec 5492584 bytes
+source-map-0.6.1 13569984 bytes
+source-map-0.8.0 6390584 bytes
+chrome dev tools 8011136 bytes
+Smallest memory usage is sourcemap-codec
+
+Decode speed:
+decode: local code x 492 ops/sec ±1.22% (90 runs sampled)
+decode: @jridgewell/sourcemap-codec 1.4.15 x 499 ops/sec ±1.16% (89 runs sampled)
+decode: sourcemap-codec x 376 ops/sec ±1.66% (89 runs sampled)
+decode: source-map-0.6.1 x 34.99 ops/sec ±0.94% (48 runs sampled)
+decode: source-map-0.8.0 x 351 ops/sec ±0.07% (95 runs sampled)
+chrome dev tools x 165 ops/sec ±0.91% (86 runs sampled)
+Fastest is decode: @jridgewell/sourcemap-codec 1.4.15
+
+Encode Memory Usage:
+local code 444248 bytes
+@jridgewell/sourcemap-codec 1.4.15 623024 bytes
+sourcemap-codec 8696280 bytes
+source-map-0.6.1 8745176 bytes
+source-map-0.8.0 8736624 bytes
+Smallest memory usage is local code
+
+Encode speed:
+encode: local code x 796 ops/sec ±0.11% (97 runs sampled)
+encode: @jridgewell/sourcemap-codec 1.4.15 x 795 ops/sec ±0.25% (98 runs sampled)
+encode: sourcemap-codec x 231 ops/sec ±0.83% (86 runs sampled)
+encode: source-map-0.6.1 x 166 ops/sec ±0.57% (86 runs sampled)
+encode: source-map-0.8.0 x 203 ops/sec ±0.45% (88 runs sampled)
+Fastest is encode: local code,encode: @jridgewell/sourcemap-codec 1.4.15
+
+
+***
+
+
+babel.min.js.map - 347793 segments
+
+Decode Memory Usage:
+local code 35424960 bytes
+@jridgewell/sourcemap-codec 1.4.15 35424696 bytes
+sourcemap-codec 36033464 bytes
+source-map-0.6.1 62253704 bytes
+source-map-0.8.0 43843920 bytes
+chrome dev tools 45111400 bytes
+Smallest memory usage is @jridgewell/sourcemap-codec 1.4.15
+
+Decode speed:
+decode: local code x 38.18 ops/sec ±5.44% (52 runs sampled)
+decode: @jridgewell/sourcemap-codec 1.4.15 x 38.36 ops/sec ±5.02% (52 runs sampled)
+decode: sourcemap-codec x 34.05 ops/sec ±4.45% (47 runs sampled)
+decode: source-map-0.6.1 x 4.31 ops/sec ±2.76% (15 runs sampled)
+decode: source-map-0.8.0 x 55.60 ops/sec ±0.13% (73 runs sampled)
+chrome dev tools x 16.94 ops/sec ±3.78% (46 runs sampled)
+Fastest is decode: source-map-0.8.0
+
+Encode Memory Usage:
+local code 2606016 bytes
+@jridgewell/sourcemap-codec 1.4.15 2626440 bytes
+sourcemap-codec 21152576 bytes
+source-map-0.6.1 25023928 bytes
+source-map-0.8.0 25256448 bytes
+Smallest memory usage is local code
+
+Encode speed:
+encode: local code x 127 ops/sec ±0.18% (83 runs sampled)
+encode: @jridgewell/sourcemap-codec 1.4.15 x 128 ops/sec ±0.26% (83 runs sampled)
+encode: sourcemap-codec x 29.31 ops/sec ±2.55% (53 runs sampled)
+encode: source-map-0.6.1 x 18.85 ops/sec ±3.19% (36 runs sampled)
+encode: source-map-0.8.0 x 19.34 ops/sec ±1.97% (36 runs sampled)
+Fastest is encode: @jridgewell/sourcemap-codec 1.4.15
+
+
+***
+
+
+preact.js.map - 1992 segments
+
+Decode Memory Usage:
+local code 261696 bytes
+@jridgewell/sourcemap-codec 1.4.15 244296 bytes
+sourcemap-codec 302816 bytes
+source-map-0.6.1 939176 bytes
+source-map-0.8.0 336 bytes
+chrome dev tools 587368 bytes
+Smallest memory usage is source-map-0.8.0
+
+Decode speed:
+decode: local code x 17,782 ops/sec ±0.32% (97 runs sampled)
+decode: @jridgewell/sourcemap-codec 1.4.15 x 17,863 ops/sec ±0.40% (100 runs sampled)
+decode: sourcemap-codec x 12,453 ops/sec ±0.27% (101 runs sampled)
+decode: source-map-0.6.1 x 1,288 ops/sec ±1.05% (96 runs sampled)
+decode: source-map-0.8.0 x 9,289 ops/sec ±0.27% (101 runs sampled)
+chrome dev tools x 4,769 ops/sec ±0.18% (100 runs sampled)
+Fastest is decode: @jridgewell/sourcemap-codec 1.4.15
+
+Encode Memory Usage:
+local code 262944 bytes
+@jridgewell/sourcemap-codec 1.4.15 25544 bytes
+sourcemap-codec 323048 bytes
+source-map-0.6.1 507808 bytes
+source-map-0.8.0 507480 bytes
+Smallest memory usage is @jridgewell/sourcemap-codec 1.4.15
+
+Encode speed:
+encode: local code x 24,207 ops/sec ±0.79% (95 runs sampled)
+encode: @jridgewell/sourcemap-codec 1.4.15 x 24,288 ops/sec ±0.48% (96 runs sampled)
+encode: sourcemap-codec x 6,761 ops/sec ±0.21% (100 runs sampled)
+encode: source-map-0.6.1 x 5,374 ops/sec ±0.17% (99 runs sampled)
+encode: source-map-0.8.0 x 5,633 ops/sec ±0.32% (99 runs sampled)
+Fastest is encode: @jridgewell/sourcemap-codec 1.4.15,encode: local code
+
+
+***
+
+
+react.js.map - 5726 segments
+
+Decode Memory Usage:
+local code 678816 bytes
+@jridgewell/sourcemap-codec 1.4.15 678816 bytes
+sourcemap-codec 816400 bytes
+source-map-0.6.1 2288864 bytes
+source-map-0.8.0 721360 bytes
+chrome dev tools 1012512 bytes
+Smallest memory usage is local code
+
+Decode speed:
+decode: local code x 6,178 ops/sec ±0.19% (98 runs sampled)
+decode: @jridgewell/sourcemap-codec 1.4.15 x 6,261 ops/sec ±0.22% (100 runs sampled)
+decode: sourcemap-codec x 4,472 ops/sec ±0.90% (99 runs sampled)
+decode: source-map-0.6.1 x 449 ops/sec ±0.31% (95 runs sampled)
+decode: source-map-0.8.0 x 3,219 ops/sec ±0.13% (100 runs sampled)
+chrome dev tools x 1,743 ops/sec ±0.20% (99 runs sampled)
+Fastest is decode: @jridgewell/sourcemap-codec 1.4.15
+
+Encode Memory Usage:
+local code 140960 bytes
+@jridgewell/sourcemap-codec 1.4.15 159808 bytes
+sourcemap-codec 969304 bytes
+source-map-0.6.1 930520 bytes
+source-map-0.8.0 930248 bytes
+Smallest memory usage is local code
+
+Encode speed:
+encode: local code x 8,013 ops/sec ±0.19% (100 runs sampled)
+encode: @jridgewell/sourcemap-codec 1.4.15 x 7,989 ops/sec ±0.20% (101 runs sampled)
+encode: sourcemap-codec x 2,472 ops/sec ±0.21% (99 runs sampled)
+encode: source-map-0.6.1 x 2,200 ops/sec ±0.17% (99 runs sampled)
+encode: source-map-0.8.0 x 2,220 ops/sec ±0.37% (99 runs sampled)
+Fastest is encode: local code
+
+
+***
+
+
+vscode.map - 2141001 segments
+
+Decode Memory Usage:
+local code 198955264 bytes
+@jridgewell/sourcemap-codec 1.4.15 199175352 bytes
+sourcemap-codec 199102688 bytes
+source-map-0.6.1 386323432 bytes
+source-map-0.8.0 244116432 bytes
+chrome dev tools 293734280 bytes
+Smallest memory usage is local code
+
+Decode speed:
+decode: local code x 3.90 ops/sec ±22.21% (15 runs sampled)
+decode: @jridgewell/sourcemap-codec 1.4.15 x 3.95 ops/sec ±23.53% (15 runs sampled)
+decode: sourcemap-codec x 3.82 ops/sec ±17.94% (14 runs sampled)
+decode: source-map-0.6.1 x 0.61 ops/sec ±7.81% (6 runs sampled)
+decode: source-map-0.8.0 x 9.54 ops/sec ±0.28% (28 runs sampled)
+chrome dev tools x 2.18 ops/sec ±10.58% (10 runs sampled)
+Fastest is decode: source-map-0.8.0
+
+Encode Memory Usage:
+local code 13509880 bytes
+@jridgewell/sourcemap-codec 1.4.15 13537648 bytes
+sourcemap-codec 32540104 bytes
+source-map-0.6.1 127531040 bytes
+source-map-0.8.0 127535312 bytes
+Smallest memory usage is local code
+
+Encode speed:
+encode: local code x 20.10 ops/sec ±0.19% (38 runs sampled)
+encode: @jridgewell/sourcemap-codec 1.4.15 x 20.26 ops/sec ±0.32% (38 runs sampled)
+encode: sourcemap-codec x 5.44 ops/sec ±1.64% (18 runs sampled)
+encode: source-map-0.6.1 x 2.30 ops/sec ±4.79% (10 runs sampled)
+encode: source-map-0.8.0 x 2.46 ops/sec ±6.53% (10 runs sampled)
+Fastest is encode: @jridgewell/sourcemap-codec 1.4.15
+```
+
+# License
+
+MIT
diff --git a/sdk/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs b/sdk/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
new file mode 100644
index 00000000..532bab39
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
@@ -0,0 +1,423 @@
+// src/vlq.ts
+var comma = ",".charCodeAt(0);
+var semicolon = ";".charCodeAt(0);
+var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var intToChar = new Uint8Array(64);
+var charToInt = new Uint8Array(128);
+for (let i = 0; i < chars.length; i++) {
+ const c = chars.charCodeAt(i);
+ intToChar[i] = c;
+ charToInt[c] = i;
+}
+function decodeInteger(reader, relative) {
+ let value = 0;
+ let shift = 0;
+ let integer = 0;
+ do {
+ const c = reader.next();
+ integer = charToInt[c];
+ value |= (integer & 31) << shift;
+ shift += 5;
+ } while (integer & 32);
+ const shouldNegate = value & 1;
+ value >>>= 1;
+ if (shouldNegate) {
+ value = -2147483648 | -value;
+ }
+ return relative + value;
+}
+function encodeInteger(builder, num, relative) {
+ let delta = num - relative;
+ delta = delta < 0 ? -delta << 1 | 1 : delta << 1;
+ do {
+ let clamped = delta & 31;
+ delta >>>= 5;
+ if (delta > 0) clamped |= 32;
+ builder.write(intToChar[clamped]);
+ } while (delta > 0);
+ return num;
+}
+function hasMoreVlq(reader, max) {
+ if (reader.pos >= max) return false;
+ return reader.peek() !== comma;
+}
+
+// src/strings.ts
+var bufLength = 1024 * 16;
+var td = typeof TextDecoder !== "undefined" ? /* @__PURE__ */ new TextDecoder() : typeof Buffer !== "undefined" ? {
+ decode(buf) {
+ const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
+ return out.toString();
+ }
+} : {
+ decode(buf) {
+ let out = "";
+ for (let i = 0; i < buf.length; i++) {
+ out += String.fromCharCode(buf[i]);
+ }
+ return out;
+ }
+};
+var StringWriter = class {
+ constructor() {
+ this.pos = 0;
+ this.out = "";
+ this.buffer = new Uint8Array(bufLength);
+ }
+ write(v) {
+ const { buffer } = this;
+ buffer[this.pos++] = v;
+ if (this.pos === bufLength) {
+ this.out += td.decode(buffer);
+ this.pos = 0;
+ }
+ }
+ flush() {
+ const { buffer, out, pos } = this;
+ return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out;
+ }
+};
+var StringReader = class {
+ constructor(buffer) {
+ this.pos = 0;
+ this.buffer = buffer;
+ }
+ next() {
+ return this.buffer.charCodeAt(this.pos++);
+ }
+ peek() {
+ return this.buffer.charCodeAt(this.pos);
+ }
+ indexOf(char) {
+ const { buffer, pos } = this;
+ const idx = buffer.indexOf(char, pos);
+ return idx === -1 ? buffer.length : idx;
+ }
+};
+
+// src/scopes.ts
+var EMPTY = [];
+function decodeOriginalScopes(input) {
+ const { length } = input;
+ const reader = new StringReader(input);
+ const scopes = [];
+ const stack = [];
+ let line = 0;
+ for (; reader.pos < length; reader.pos++) {
+ line = decodeInteger(reader, line);
+ const column = decodeInteger(reader, 0);
+ if (!hasMoreVlq(reader, length)) {
+ const last = stack.pop();
+ last[2] = line;
+ last[3] = column;
+ continue;
+ }
+ const kind = decodeInteger(reader, 0);
+ const fields = decodeInteger(reader, 0);
+ const hasName = fields & 1;
+ const scope = hasName ? [line, column, 0, 0, kind, decodeInteger(reader, 0)] : [line, column, 0, 0, kind];
+ let vars = EMPTY;
+ if (hasMoreVlq(reader, length)) {
+ vars = [];
+ do {
+ const varsIndex = decodeInteger(reader, 0);
+ vars.push(varsIndex);
+ } while (hasMoreVlq(reader, length));
+ }
+ scope.vars = vars;
+ scopes.push(scope);
+ stack.push(scope);
+ }
+ return scopes;
+}
+function encodeOriginalScopes(scopes) {
+ const writer = new StringWriter();
+ for (let i = 0; i < scopes.length; ) {
+ i = _encodeOriginalScopes(scopes, i, writer, [0]);
+ }
+ return writer.flush();
+}
+function _encodeOriginalScopes(scopes, index, writer, state) {
+ const scope = scopes[index];
+ const { 0: startLine, 1: startColumn, 2: endLine, 3: endColumn, 4: kind, vars } = scope;
+ if (index > 0) writer.write(comma);
+ state[0] = encodeInteger(writer, startLine, state[0]);
+ encodeInteger(writer, startColumn, 0);
+ encodeInteger(writer, kind, 0);
+ const fields = scope.length === 6 ? 1 : 0;
+ encodeInteger(writer, fields, 0);
+ if (scope.length === 6) encodeInteger(writer, scope[5], 0);
+ for (const v of vars) {
+ encodeInteger(writer, v, 0);
+ }
+ for (index++; index < scopes.length; ) {
+ const next = scopes[index];
+ const { 0: l, 1: c } = next;
+ if (l > endLine || l === endLine && c >= endColumn) {
+ break;
+ }
+ index = _encodeOriginalScopes(scopes, index, writer, state);
+ }
+ writer.write(comma);
+ state[0] = encodeInteger(writer, endLine, state[0]);
+ encodeInteger(writer, endColumn, 0);
+ return index;
+}
+function decodeGeneratedRanges(input) {
+ const { length } = input;
+ const reader = new StringReader(input);
+ const ranges = [];
+ const stack = [];
+ let genLine = 0;
+ let definitionSourcesIndex = 0;
+ let definitionScopeIndex = 0;
+ let callsiteSourcesIndex = 0;
+ let callsiteLine = 0;
+ let callsiteColumn = 0;
+ let bindingLine = 0;
+ let bindingColumn = 0;
+ do {
+ const semi = reader.indexOf(";");
+ let genColumn = 0;
+ for (; reader.pos < semi; reader.pos++) {
+ genColumn = decodeInteger(reader, genColumn);
+ if (!hasMoreVlq(reader, semi)) {
+ const last = stack.pop();
+ last[2] = genLine;
+ last[3] = genColumn;
+ continue;
+ }
+ const fields = decodeInteger(reader, 0);
+ const hasDefinition = fields & 1;
+ const hasCallsite = fields & 2;
+ const hasScope = fields & 4;
+ let callsite = null;
+ let bindings = EMPTY;
+ let range;
+ if (hasDefinition) {
+ const defSourcesIndex = decodeInteger(reader, definitionSourcesIndex);
+ definitionScopeIndex = decodeInteger(
+ reader,
+ definitionSourcesIndex === defSourcesIndex ? definitionScopeIndex : 0
+ );
+ definitionSourcesIndex = defSourcesIndex;
+ range = [genLine, genColumn, 0, 0, defSourcesIndex, definitionScopeIndex];
+ } else {
+ range = [genLine, genColumn, 0, 0];
+ }
+ range.isScope = !!hasScope;
+ if (hasCallsite) {
+ const prevCsi = callsiteSourcesIndex;
+ const prevLine = callsiteLine;
+ callsiteSourcesIndex = decodeInteger(reader, callsiteSourcesIndex);
+ const sameSource = prevCsi === callsiteSourcesIndex;
+ callsiteLine = decodeInteger(reader, sameSource ? callsiteLine : 0);
+ callsiteColumn = decodeInteger(
+ reader,
+ sameSource && prevLine === callsiteLine ? callsiteColumn : 0
+ );
+ callsite = [callsiteSourcesIndex, callsiteLine, callsiteColumn];
+ }
+ range.callsite = callsite;
+ if (hasMoreVlq(reader, semi)) {
+ bindings = [];
+ do {
+ bindingLine = genLine;
+ bindingColumn = genColumn;
+ const expressionsCount = decodeInteger(reader, 0);
+ let expressionRanges;
+ if (expressionsCount < -1) {
+ expressionRanges = [[decodeInteger(reader, 0)]];
+ for (let i = -1; i > expressionsCount; i--) {
+ const prevBl = bindingLine;
+ bindingLine = decodeInteger(reader, bindingLine);
+ bindingColumn = decodeInteger(reader, bindingLine === prevBl ? bindingColumn : 0);
+ const expression = decodeInteger(reader, 0);
+ expressionRanges.push([expression, bindingLine, bindingColumn]);
+ }
+ } else {
+ expressionRanges = [[expressionsCount]];
+ }
+ bindings.push(expressionRanges);
+ } while (hasMoreVlq(reader, semi));
+ }
+ range.bindings = bindings;
+ ranges.push(range);
+ stack.push(range);
+ }
+ genLine++;
+ reader.pos = semi + 1;
+ } while (reader.pos < length);
+ return ranges;
+}
+function encodeGeneratedRanges(ranges) {
+ if (ranges.length === 0) return "";
+ const writer = new StringWriter();
+ for (let i = 0; i < ranges.length; ) {
+ i = _encodeGeneratedRanges(ranges, i, writer, [0, 0, 0, 0, 0, 0, 0]);
+ }
+ return writer.flush();
+}
+function _encodeGeneratedRanges(ranges, index, writer, state) {
+ const range = ranges[index];
+ const {
+ 0: startLine,
+ 1: startColumn,
+ 2: endLine,
+ 3: endColumn,
+ isScope,
+ callsite,
+ bindings
+ } = range;
+ if (state[0] < startLine) {
+ catchupLine(writer, state[0], startLine);
+ state[0] = startLine;
+ state[1] = 0;
+ } else if (index > 0) {
+ writer.write(comma);
+ }
+ state[1] = encodeInteger(writer, range[1], state[1]);
+ const fields = (range.length === 6 ? 1 : 0) | (callsite ? 2 : 0) | (isScope ? 4 : 0);
+ encodeInteger(writer, fields, 0);
+ if (range.length === 6) {
+ const { 4: sourcesIndex, 5: scopesIndex } = range;
+ if (sourcesIndex !== state[2]) {
+ state[3] = 0;
+ }
+ state[2] = encodeInteger(writer, sourcesIndex, state[2]);
+ state[3] = encodeInteger(writer, scopesIndex, state[3]);
+ }
+ if (callsite) {
+ const { 0: sourcesIndex, 1: callLine, 2: callColumn } = range.callsite;
+ if (sourcesIndex !== state[4]) {
+ state[5] = 0;
+ state[6] = 0;
+ } else if (callLine !== state[5]) {
+ state[6] = 0;
+ }
+ state[4] = encodeInteger(writer, sourcesIndex, state[4]);
+ state[5] = encodeInteger(writer, callLine, state[5]);
+ state[6] = encodeInteger(writer, callColumn, state[6]);
+ }
+ if (bindings) {
+ for (const binding of bindings) {
+ if (binding.length > 1) encodeInteger(writer, -binding.length, 0);
+ const expression = binding[0][0];
+ encodeInteger(writer, expression, 0);
+ let bindingStartLine = startLine;
+ let bindingStartColumn = startColumn;
+ for (let i = 1; i < binding.length; i++) {
+ const expRange = binding[i];
+ bindingStartLine = encodeInteger(writer, expRange[1], bindingStartLine);
+ bindingStartColumn = encodeInteger(writer, expRange[2], bindingStartColumn);
+ encodeInteger(writer, expRange[0], 0);
+ }
+ }
+ }
+ for (index++; index < ranges.length; ) {
+ const next = ranges[index];
+ const { 0: l, 1: c } = next;
+ if (l > endLine || l === endLine && c >= endColumn) {
+ break;
+ }
+ index = _encodeGeneratedRanges(ranges, index, writer, state);
+ }
+ if (state[0] < endLine) {
+ catchupLine(writer, state[0], endLine);
+ state[0] = endLine;
+ state[1] = 0;
+ } else {
+ writer.write(comma);
+ }
+ state[1] = encodeInteger(writer, endColumn, state[1]);
+ return index;
+}
+function catchupLine(writer, lastLine, line) {
+ do {
+ writer.write(semicolon);
+ } while (++lastLine < line);
+}
+
+// src/sourcemap-codec.ts
+function decode(mappings) {
+ const { length } = mappings;
+ const reader = new StringReader(mappings);
+ const decoded = [];
+ let genColumn = 0;
+ let sourcesIndex = 0;
+ let sourceLine = 0;
+ let sourceColumn = 0;
+ let namesIndex = 0;
+ do {
+ const semi = reader.indexOf(";");
+ const line = [];
+ let sorted = true;
+ let lastCol = 0;
+ genColumn = 0;
+ while (reader.pos < semi) {
+ let seg;
+ genColumn = decodeInteger(reader, genColumn);
+ if (genColumn < lastCol) sorted = false;
+ lastCol = genColumn;
+ if (hasMoreVlq(reader, semi)) {
+ sourcesIndex = decodeInteger(reader, sourcesIndex);
+ sourceLine = decodeInteger(reader, sourceLine);
+ sourceColumn = decodeInteger(reader, sourceColumn);
+ if (hasMoreVlq(reader, semi)) {
+ namesIndex = decodeInteger(reader, namesIndex);
+ seg = [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex];
+ } else {
+ seg = [genColumn, sourcesIndex, sourceLine, sourceColumn];
+ }
+ } else {
+ seg = [genColumn];
+ }
+ line.push(seg);
+ reader.pos++;
+ }
+ if (!sorted) sort(line);
+ decoded.push(line);
+ reader.pos = semi + 1;
+ } while (reader.pos <= length);
+ return decoded;
+}
+function sort(line) {
+ line.sort(sortComparator);
+}
+function sortComparator(a, b) {
+ return a[0] - b[0];
+}
+function encode(decoded) {
+ const writer = new StringWriter();
+ let sourcesIndex = 0;
+ let sourceLine = 0;
+ let sourceColumn = 0;
+ let namesIndex = 0;
+ for (let i = 0; i < decoded.length; i++) {
+ const line = decoded[i];
+ if (i > 0) writer.write(semicolon);
+ if (line.length === 0) continue;
+ let genColumn = 0;
+ for (let j = 0; j < line.length; j++) {
+ const segment = line[j];
+ if (j > 0) writer.write(comma);
+ genColumn = encodeInteger(writer, segment[0], genColumn);
+ if (segment.length === 1) continue;
+ sourcesIndex = encodeInteger(writer, segment[1], sourcesIndex);
+ sourceLine = encodeInteger(writer, segment[2], sourceLine);
+ sourceColumn = encodeInteger(writer, segment[3], sourceColumn);
+ if (segment.length === 4) continue;
+ namesIndex = encodeInteger(writer, segment[4], namesIndex);
+ }
+ }
+ return writer.flush();
+}
+export {
+ decode,
+ decodeGeneratedRanges,
+ decodeOriginalScopes,
+ encode,
+ encodeGeneratedRanges,
+ encodeOriginalScopes
+};
+//# sourceMappingURL=sourcemap-codec.mjs.map
diff --git a/sdk/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs.map b/sdk/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs.map
new file mode 100644
index 00000000..c276844b
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs.map
@@ -0,0 +1,6 @@
+{
+ "version": 3,
+ "sources": ["../src/vlq.ts", "../src/strings.ts", "../src/scopes.ts", "../src/sourcemap-codec.ts"],
+ "mappings": "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",
+ "names": []
+}
diff --git a/sdk/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.umd.js b/sdk/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.umd.js
new file mode 100644
index 00000000..2d8e459f
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.umd.js
@@ -0,0 +1,464 @@
+(function (global, factory) {
+ if (typeof exports === 'object' && typeof module !== 'undefined') {
+ factory(module);
+ module.exports = def(module);
+ } else if (typeof define === 'function' && define.amd) {
+ define(['module'], function(mod) {
+ factory.apply(this, arguments);
+ mod.exports = def(mod);
+ });
+ } else {
+ const mod = { exports: {} };
+ factory(mod);
+ global = typeof globalThis !== 'undefined' ? globalThis : global || self;
+ global.sourcemapCodec = def(mod);
+ }
+ function def(m) { return 'default' in m.exports ? m.exports.default : m.exports; }
+})(this, (function (module) {
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+ for (var name in all)
+ __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+ if (from && typeof from === "object" || typeof from === "function") {
+ for (let key of __getOwnPropNames(from))
+ if (!__hasOwnProp.call(to, key) && key !== except)
+ __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+ }
+ return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/sourcemap-codec.ts
+var sourcemap_codec_exports = {};
+__export(sourcemap_codec_exports, {
+ decode: () => decode,
+ decodeGeneratedRanges: () => decodeGeneratedRanges,
+ decodeOriginalScopes: () => decodeOriginalScopes,
+ encode: () => encode,
+ encodeGeneratedRanges: () => encodeGeneratedRanges,
+ encodeOriginalScopes: () => encodeOriginalScopes
+});
+module.exports = __toCommonJS(sourcemap_codec_exports);
+
+// src/vlq.ts
+var comma = ",".charCodeAt(0);
+var semicolon = ";".charCodeAt(0);
+var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var intToChar = new Uint8Array(64);
+var charToInt = new Uint8Array(128);
+for (let i = 0; i < chars.length; i++) {
+ const c = chars.charCodeAt(i);
+ intToChar[i] = c;
+ charToInt[c] = i;
+}
+function decodeInteger(reader, relative) {
+ let value = 0;
+ let shift = 0;
+ let integer = 0;
+ do {
+ const c = reader.next();
+ integer = charToInt[c];
+ value |= (integer & 31) << shift;
+ shift += 5;
+ } while (integer & 32);
+ const shouldNegate = value & 1;
+ value >>>= 1;
+ if (shouldNegate) {
+ value = -2147483648 | -value;
+ }
+ return relative + value;
+}
+function encodeInteger(builder, num, relative) {
+ let delta = num - relative;
+ delta = delta < 0 ? -delta << 1 | 1 : delta << 1;
+ do {
+ let clamped = delta & 31;
+ delta >>>= 5;
+ if (delta > 0) clamped |= 32;
+ builder.write(intToChar[clamped]);
+ } while (delta > 0);
+ return num;
+}
+function hasMoreVlq(reader, max) {
+ if (reader.pos >= max) return false;
+ return reader.peek() !== comma;
+}
+
+// src/strings.ts
+var bufLength = 1024 * 16;
+var td = typeof TextDecoder !== "undefined" ? /* @__PURE__ */ new TextDecoder() : typeof Buffer !== "undefined" ? {
+ decode(buf) {
+ const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
+ return out.toString();
+ }
+} : {
+ decode(buf) {
+ let out = "";
+ for (let i = 0; i < buf.length; i++) {
+ out += String.fromCharCode(buf[i]);
+ }
+ return out;
+ }
+};
+var StringWriter = class {
+ constructor() {
+ this.pos = 0;
+ this.out = "";
+ this.buffer = new Uint8Array(bufLength);
+ }
+ write(v) {
+ const { buffer } = this;
+ buffer[this.pos++] = v;
+ if (this.pos === bufLength) {
+ this.out += td.decode(buffer);
+ this.pos = 0;
+ }
+ }
+ flush() {
+ const { buffer, out, pos } = this;
+ return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out;
+ }
+};
+var StringReader = class {
+ constructor(buffer) {
+ this.pos = 0;
+ this.buffer = buffer;
+ }
+ next() {
+ return this.buffer.charCodeAt(this.pos++);
+ }
+ peek() {
+ return this.buffer.charCodeAt(this.pos);
+ }
+ indexOf(char) {
+ const { buffer, pos } = this;
+ const idx = buffer.indexOf(char, pos);
+ return idx === -1 ? buffer.length : idx;
+ }
+};
+
+// src/scopes.ts
+var EMPTY = [];
+function decodeOriginalScopes(input) {
+ const { length } = input;
+ const reader = new StringReader(input);
+ const scopes = [];
+ const stack = [];
+ let line = 0;
+ for (; reader.pos < length; reader.pos++) {
+ line = decodeInteger(reader, line);
+ const column = decodeInteger(reader, 0);
+ if (!hasMoreVlq(reader, length)) {
+ const last = stack.pop();
+ last[2] = line;
+ last[3] = column;
+ continue;
+ }
+ const kind = decodeInteger(reader, 0);
+ const fields = decodeInteger(reader, 0);
+ const hasName = fields & 1;
+ const scope = hasName ? [line, column, 0, 0, kind, decodeInteger(reader, 0)] : [line, column, 0, 0, kind];
+ let vars = EMPTY;
+ if (hasMoreVlq(reader, length)) {
+ vars = [];
+ do {
+ const varsIndex = decodeInteger(reader, 0);
+ vars.push(varsIndex);
+ } while (hasMoreVlq(reader, length));
+ }
+ scope.vars = vars;
+ scopes.push(scope);
+ stack.push(scope);
+ }
+ return scopes;
+}
+function encodeOriginalScopes(scopes) {
+ const writer = new StringWriter();
+ for (let i = 0; i < scopes.length; ) {
+ i = _encodeOriginalScopes(scopes, i, writer, [0]);
+ }
+ return writer.flush();
+}
+function _encodeOriginalScopes(scopes, index, writer, state) {
+ const scope = scopes[index];
+ const { 0: startLine, 1: startColumn, 2: endLine, 3: endColumn, 4: kind, vars } = scope;
+ if (index > 0) writer.write(comma);
+ state[0] = encodeInteger(writer, startLine, state[0]);
+ encodeInteger(writer, startColumn, 0);
+ encodeInteger(writer, kind, 0);
+ const fields = scope.length === 6 ? 1 : 0;
+ encodeInteger(writer, fields, 0);
+ if (scope.length === 6) encodeInteger(writer, scope[5], 0);
+ for (const v of vars) {
+ encodeInteger(writer, v, 0);
+ }
+ for (index++; index < scopes.length; ) {
+ const next = scopes[index];
+ const { 0: l, 1: c } = next;
+ if (l > endLine || l === endLine && c >= endColumn) {
+ break;
+ }
+ index = _encodeOriginalScopes(scopes, index, writer, state);
+ }
+ writer.write(comma);
+ state[0] = encodeInteger(writer, endLine, state[0]);
+ encodeInteger(writer, endColumn, 0);
+ return index;
+}
+function decodeGeneratedRanges(input) {
+ const { length } = input;
+ const reader = new StringReader(input);
+ const ranges = [];
+ const stack = [];
+ let genLine = 0;
+ let definitionSourcesIndex = 0;
+ let definitionScopeIndex = 0;
+ let callsiteSourcesIndex = 0;
+ let callsiteLine = 0;
+ let callsiteColumn = 0;
+ let bindingLine = 0;
+ let bindingColumn = 0;
+ do {
+ const semi = reader.indexOf(";");
+ let genColumn = 0;
+ for (; reader.pos < semi; reader.pos++) {
+ genColumn = decodeInteger(reader, genColumn);
+ if (!hasMoreVlq(reader, semi)) {
+ const last = stack.pop();
+ last[2] = genLine;
+ last[3] = genColumn;
+ continue;
+ }
+ const fields = decodeInteger(reader, 0);
+ const hasDefinition = fields & 1;
+ const hasCallsite = fields & 2;
+ const hasScope = fields & 4;
+ let callsite = null;
+ let bindings = EMPTY;
+ let range;
+ if (hasDefinition) {
+ const defSourcesIndex = decodeInteger(reader, definitionSourcesIndex);
+ definitionScopeIndex = decodeInteger(
+ reader,
+ definitionSourcesIndex === defSourcesIndex ? definitionScopeIndex : 0
+ );
+ definitionSourcesIndex = defSourcesIndex;
+ range = [genLine, genColumn, 0, 0, defSourcesIndex, definitionScopeIndex];
+ } else {
+ range = [genLine, genColumn, 0, 0];
+ }
+ range.isScope = !!hasScope;
+ if (hasCallsite) {
+ const prevCsi = callsiteSourcesIndex;
+ const prevLine = callsiteLine;
+ callsiteSourcesIndex = decodeInteger(reader, callsiteSourcesIndex);
+ const sameSource = prevCsi === callsiteSourcesIndex;
+ callsiteLine = decodeInteger(reader, sameSource ? callsiteLine : 0);
+ callsiteColumn = decodeInteger(
+ reader,
+ sameSource && prevLine === callsiteLine ? callsiteColumn : 0
+ );
+ callsite = [callsiteSourcesIndex, callsiteLine, callsiteColumn];
+ }
+ range.callsite = callsite;
+ if (hasMoreVlq(reader, semi)) {
+ bindings = [];
+ do {
+ bindingLine = genLine;
+ bindingColumn = genColumn;
+ const expressionsCount = decodeInteger(reader, 0);
+ let expressionRanges;
+ if (expressionsCount < -1) {
+ expressionRanges = [[decodeInteger(reader, 0)]];
+ for (let i = -1; i > expressionsCount; i--) {
+ const prevBl = bindingLine;
+ bindingLine = decodeInteger(reader, bindingLine);
+ bindingColumn = decodeInteger(reader, bindingLine === prevBl ? bindingColumn : 0);
+ const expression = decodeInteger(reader, 0);
+ expressionRanges.push([expression, bindingLine, bindingColumn]);
+ }
+ } else {
+ expressionRanges = [[expressionsCount]];
+ }
+ bindings.push(expressionRanges);
+ } while (hasMoreVlq(reader, semi));
+ }
+ range.bindings = bindings;
+ ranges.push(range);
+ stack.push(range);
+ }
+ genLine++;
+ reader.pos = semi + 1;
+ } while (reader.pos < length);
+ return ranges;
+}
+function encodeGeneratedRanges(ranges) {
+ if (ranges.length === 0) return "";
+ const writer = new StringWriter();
+ for (let i = 0; i < ranges.length; ) {
+ i = _encodeGeneratedRanges(ranges, i, writer, [0, 0, 0, 0, 0, 0, 0]);
+ }
+ return writer.flush();
+}
+function _encodeGeneratedRanges(ranges, index, writer, state) {
+ const range = ranges[index];
+ const {
+ 0: startLine,
+ 1: startColumn,
+ 2: endLine,
+ 3: endColumn,
+ isScope,
+ callsite,
+ bindings
+ } = range;
+ if (state[0] < startLine) {
+ catchupLine(writer, state[0], startLine);
+ state[0] = startLine;
+ state[1] = 0;
+ } else if (index > 0) {
+ writer.write(comma);
+ }
+ state[1] = encodeInteger(writer, range[1], state[1]);
+ const fields = (range.length === 6 ? 1 : 0) | (callsite ? 2 : 0) | (isScope ? 4 : 0);
+ encodeInteger(writer, fields, 0);
+ if (range.length === 6) {
+ const { 4: sourcesIndex, 5: scopesIndex } = range;
+ if (sourcesIndex !== state[2]) {
+ state[3] = 0;
+ }
+ state[2] = encodeInteger(writer, sourcesIndex, state[2]);
+ state[3] = encodeInteger(writer, scopesIndex, state[3]);
+ }
+ if (callsite) {
+ const { 0: sourcesIndex, 1: callLine, 2: callColumn } = range.callsite;
+ if (sourcesIndex !== state[4]) {
+ state[5] = 0;
+ state[6] = 0;
+ } else if (callLine !== state[5]) {
+ state[6] = 0;
+ }
+ state[4] = encodeInteger(writer, sourcesIndex, state[4]);
+ state[5] = encodeInteger(writer, callLine, state[5]);
+ state[6] = encodeInteger(writer, callColumn, state[6]);
+ }
+ if (bindings) {
+ for (const binding of bindings) {
+ if (binding.length > 1) encodeInteger(writer, -binding.length, 0);
+ const expression = binding[0][0];
+ encodeInteger(writer, expression, 0);
+ let bindingStartLine = startLine;
+ let bindingStartColumn = startColumn;
+ for (let i = 1; i < binding.length; i++) {
+ const expRange = binding[i];
+ bindingStartLine = encodeInteger(writer, expRange[1], bindingStartLine);
+ bindingStartColumn = encodeInteger(writer, expRange[2], bindingStartColumn);
+ encodeInteger(writer, expRange[0], 0);
+ }
+ }
+ }
+ for (index++; index < ranges.length; ) {
+ const next = ranges[index];
+ const { 0: l, 1: c } = next;
+ if (l > endLine || l === endLine && c >= endColumn) {
+ break;
+ }
+ index = _encodeGeneratedRanges(ranges, index, writer, state);
+ }
+ if (state[0] < endLine) {
+ catchupLine(writer, state[0], endLine);
+ state[0] = endLine;
+ state[1] = 0;
+ } else {
+ writer.write(comma);
+ }
+ state[1] = encodeInteger(writer, endColumn, state[1]);
+ return index;
+}
+function catchupLine(writer, lastLine, line) {
+ do {
+ writer.write(semicolon);
+ } while (++lastLine < line);
+}
+
+// src/sourcemap-codec.ts
+function decode(mappings) {
+ const { length } = mappings;
+ const reader = new StringReader(mappings);
+ const decoded = [];
+ let genColumn = 0;
+ let sourcesIndex = 0;
+ let sourceLine = 0;
+ let sourceColumn = 0;
+ let namesIndex = 0;
+ do {
+ const semi = reader.indexOf(";");
+ const line = [];
+ let sorted = true;
+ let lastCol = 0;
+ genColumn = 0;
+ while (reader.pos < semi) {
+ let seg;
+ genColumn = decodeInteger(reader, genColumn);
+ if (genColumn < lastCol) sorted = false;
+ lastCol = genColumn;
+ if (hasMoreVlq(reader, semi)) {
+ sourcesIndex = decodeInteger(reader, sourcesIndex);
+ sourceLine = decodeInteger(reader, sourceLine);
+ sourceColumn = decodeInteger(reader, sourceColumn);
+ if (hasMoreVlq(reader, semi)) {
+ namesIndex = decodeInteger(reader, namesIndex);
+ seg = [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex];
+ } else {
+ seg = [genColumn, sourcesIndex, sourceLine, sourceColumn];
+ }
+ } else {
+ seg = [genColumn];
+ }
+ line.push(seg);
+ reader.pos++;
+ }
+ if (!sorted) sort(line);
+ decoded.push(line);
+ reader.pos = semi + 1;
+ } while (reader.pos <= length);
+ return decoded;
+}
+function sort(line) {
+ line.sort(sortComparator);
+}
+function sortComparator(a, b) {
+ return a[0] - b[0];
+}
+function encode(decoded) {
+ const writer = new StringWriter();
+ let sourcesIndex = 0;
+ let sourceLine = 0;
+ let sourceColumn = 0;
+ let namesIndex = 0;
+ for (let i = 0; i < decoded.length; i++) {
+ const line = decoded[i];
+ if (i > 0) writer.write(semicolon);
+ if (line.length === 0) continue;
+ let genColumn = 0;
+ for (let j = 0; j < line.length; j++) {
+ const segment = line[j];
+ if (j > 0) writer.write(comma);
+ genColumn = encodeInteger(writer, segment[0], genColumn);
+ if (segment.length === 1) continue;
+ sourcesIndex = encodeInteger(writer, segment[1], sourcesIndex);
+ sourceLine = encodeInteger(writer, segment[2], sourceLine);
+ sourceColumn = encodeInteger(writer, segment[3], sourceColumn);
+ if (segment.length === 4) continue;
+ namesIndex = encodeInteger(writer, segment[4], namesIndex);
+ }
+ }
+ return writer.flush();
+}
+}));
+//# sourceMappingURL=sourcemap-codec.umd.js.map
diff --git a/sdk/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.umd.js.map b/sdk/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.umd.js.map
new file mode 100644
index 00000000..abc18d28
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.umd.js.map
@@ -0,0 +1,6 @@
+{
+ "version": 3,
+ "sources": ["../src/sourcemap-codec.ts", "../src/vlq.ts", "../src/strings.ts", "../src/scopes.ts"],
+ "mappings": "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",
+ "names": []
+}
diff --git a/sdk/node_modules/@jridgewell/sourcemap-codec/package.json b/sdk/node_modules/@jridgewell/sourcemap-codec/package.json
new file mode 100644
index 00000000..da551376
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/sourcemap-codec/package.json
@@ -0,0 +1,63 @@
+{
+ "name": "@jridgewell/sourcemap-codec",
+ "version": "1.5.5",
+ "description": "Encode/decode sourcemap mappings",
+ "keywords": [
+ "sourcemap",
+ "vlq"
+ ],
+ "main": "dist/sourcemap-codec.umd.js",
+ "module": "dist/sourcemap-codec.mjs",
+ "types": "types/sourcemap-codec.d.cts",
+ "files": [
+ "dist",
+ "src",
+ "types"
+ ],
+ "exports": {
+ ".": [
+ {
+ "import": {
+ "types": "./types/sourcemap-codec.d.mts",
+ "default": "./dist/sourcemap-codec.mjs"
+ },
+ "default": {
+ "types": "./types/sourcemap-codec.d.cts",
+ "default": "./dist/sourcemap-codec.umd.js"
+ }
+ },
+ "./dist/sourcemap-codec.umd.js"
+ ],
+ "./package.json": "./package.json"
+ },
+ "scripts": {
+ "benchmark": "run-s build:code benchmark:*",
+ "benchmark:install": "cd benchmark && npm install",
+ "benchmark:only": "node --expose-gc benchmark/index.js",
+ "build": "run-s -n build:code build:types",
+ "build:code": "node ../../esbuild.mjs sourcemap-codec.ts",
+ "build:types": "run-s build:types:force build:types:emit build:types:mts",
+ "build:types:force": "rimraf tsconfig.build.tsbuildinfo",
+ "build:types:emit": "tsc --project tsconfig.build.json",
+ "build:types:mts": "node ../../mts-types.mjs",
+ "clean": "run-s -n clean:code clean:types",
+ "clean:code": "tsc --build --clean tsconfig.build.json",
+ "clean:types": "rimraf dist types",
+ "test": "run-s -n test:types test:only test:format",
+ "test:format": "prettier --check '{src,test}/**/*.ts'",
+ "test:only": "mocha",
+ "test:types": "eslint '{src,test}/**/*.ts'",
+ "lint": "run-s -n lint:types lint:format",
+ "lint:format": "npm run test:format -- --write",
+ "lint:types": "npm run test:types -- --fix",
+ "prepublishOnly": "npm run-s -n build test"
+ },
+ "homepage": "https://github.com/jridgewell/sourcemaps/tree/main/packages/sourcemap-codec",
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/jridgewell/sourcemaps.git",
+ "directory": "packages/sourcemap-codec"
+ },
+ "author": "Justin Ridgewell ",
+ "license": "MIT"
+}
diff --git a/sdk/node_modules/@jridgewell/sourcemap-codec/src/scopes.ts b/sdk/node_modules/@jridgewell/sourcemap-codec/src/scopes.ts
new file mode 100644
index 00000000..d194c2f0
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/sourcemap-codec/src/scopes.ts
@@ -0,0 +1,345 @@
+import { StringReader, StringWriter } from './strings';
+import { comma, decodeInteger, encodeInteger, hasMoreVlq, semicolon } from './vlq';
+
+const EMPTY: any[] = [];
+
+type Line = number;
+type Column = number;
+type Kind = number;
+type Name = number;
+type Var = number;
+type SourcesIndex = number;
+type ScopesIndex = number;
+
+type Mix = (A & O) | (B & O);
+
+export type OriginalScope = Mix<
+ [Line, Column, Line, Column, Kind],
+ [Line, Column, Line, Column, Kind, Name],
+ { vars: Var[] }
+>;
+
+export type GeneratedRange = Mix<
+ [Line, Column, Line, Column],
+ [Line, Column, Line, Column, SourcesIndex, ScopesIndex],
+ {
+ callsite: CallSite | null;
+ bindings: Binding[];
+ isScope: boolean;
+ }
+>;
+export type CallSite = [SourcesIndex, Line, Column];
+type Binding = BindingExpressionRange[];
+export type BindingExpressionRange = [Name] | [Name, Line, Column];
+
+export function decodeOriginalScopes(input: string): OriginalScope[] {
+ const { length } = input;
+ const reader = new StringReader(input);
+ const scopes: OriginalScope[] = [];
+ const stack: OriginalScope[] = [];
+ let line = 0;
+
+ for (; reader.pos < length; reader.pos++) {
+ line = decodeInteger(reader, line);
+ const column = decodeInteger(reader, 0);
+
+ if (!hasMoreVlq(reader, length)) {
+ const last = stack.pop()!;
+ last[2] = line;
+ last[3] = column;
+ continue;
+ }
+
+ const kind = decodeInteger(reader, 0);
+ const fields = decodeInteger(reader, 0);
+ const hasName = fields & 0b0001;
+
+ const scope: OriginalScope = (
+ hasName ? [line, column, 0, 0, kind, decodeInteger(reader, 0)] : [line, column, 0, 0, kind]
+ ) as OriginalScope;
+
+ let vars: Var[] = EMPTY;
+ if (hasMoreVlq(reader, length)) {
+ vars = [];
+ do {
+ const varsIndex = decodeInteger(reader, 0);
+ vars.push(varsIndex);
+ } while (hasMoreVlq(reader, length));
+ }
+ scope.vars = vars;
+
+ scopes.push(scope);
+ stack.push(scope);
+ }
+
+ return scopes;
+}
+
+export function encodeOriginalScopes(scopes: OriginalScope[]): string {
+ const writer = new StringWriter();
+
+ for (let i = 0; i < scopes.length; ) {
+ i = _encodeOriginalScopes(scopes, i, writer, [0]);
+ }
+
+ return writer.flush();
+}
+
+function _encodeOriginalScopes(
+ scopes: OriginalScope[],
+ index: number,
+ writer: StringWriter,
+ state: [
+ number, // GenColumn
+ ],
+): number {
+ const scope = scopes[index];
+ const { 0: startLine, 1: startColumn, 2: endLine, 3: endColumn, 4: kind, vars } = scope;
+
+ if (index > 0) writer.write(comma);
+
+ state[0] = encodeInteger(writer, startLine, state[0]);
+ encodeInteger(writer, startColumn, 0);
+ encodeInteger(writer, kind, 0);
+
+ const fields = scope.length === 6 ? 0b0001 : 0;
+ encodeInteger(writer, fields, 0);
+ if (scope.length === 6) encodeInteger(writer, scope[5], 0);
+
+ for (const v of vars) {
+ encodeInteger(writer, v, 0);
+ }
+
+ for (index++; index < scopes.length; ) {
+ const next = scopes[index];
+ const { 0: l, 1: c } = next;
+ if (l > endLine || (l === endLine && c >= endColumn)) {
+ break;
+ }
+ index = _encodeOriginalScopes(scopes, index, writer, state);
+ }
+
+ writer.write(comma);
+ state[0] = encodeInteger(writer, endLine, state[0]);
+ encodeInteger(writer, endColumn, 0);
+
+ return index;
+}
+
+export function decodeGeneratedRanges(input: string): GeneratedRange[] {
+ const { length } = input;
+ const reader = new StringReader(input);
+ const ranges: GeneratedRange[] = [];
+ const stack: GeneratedRange[] = [];
+
+ let genLine = 0;
+ let definitionSourcesIndex = 0;
+ let definitionScopeIndex = 0;
+ let callsiteSourcesIndex = 0;
+ let callsiteLine = 0;
+ let callsiteColumn = 0;
+ let bindingLine = 0;
+ let bindingColumn = 0;
+
+ do {
+ const semi = reader.indexOf(';');
+ let genColumn = 0;
+
+ for (; reader.pos < semi; reader.pos++) {
+ genColumn = decodeInteger(reader, genColumn);
+
+ if (!hasMoreVlq(reader, semi)) {
+ const last = stack.pop()!;
+ last[2] = genLine;
+ last[3] = genColumn;
+ continue;
+ }
+
+ const fields = decodeInteger(reader, 0);
+ const hasDefinition = fields & 0b0001;
+ const hasCallsite = fields & 0b0010;
+ const hasScope = fields & 0b0100;
+
+ let callsite: CallSite | null = null;
+ let bindings: Binding[] = EMPTY;
+ let range: GeneratedRange;
+ if (hasDefinition) {
+ const defSourcesIndex = decodeInteger(reader, definitionSourcesIndex);
+ definitionScopeIndex = decodeInteger(
+ reader,
+ definitionSourcesIndex === defSourcesIndex ? definitionScopeIndex : 0,
+ );
+
+ definitionSourcesIndex = defSourcesIndex;
+ range = [genLine, genColumn, 0, 0, defSourcesIndex, definitionScopeIndex] as GeneratedRange;
+ } else {
+ range = [genLine, genColumn, 0, 0] as GeneratedRange;
+ }
+
+ range.isScope = !!hasScope;
+
+ if (hasCallsite) {
+ const prevCsi = callsiteSourcesIndex;
+ const prevLine = callsiteLine;
+ callsiteSourcesIndex = decodeInteger(reader, callsiteSourcesIndex);
+ const sameSource = prevCsi === callsiteSourcesIndex;
+ callsiteLine = decodeInteger(reader, sameSource ? callsiteLine : 0);
+ callsiteColumn = decodeInteger(
+ reader,
+ sameSource && prevLine === callsiteLine ? callsiteColumn : 0,
+ );
+
+ callsite = [callsiteSourcesIndex, callsiteLine, callsiteColumn];
+ }
+ range.callsite = callsite;
+
+ if (hasMoreVlq(reader, semi)) {
+ bindings = [];
+ do {
+ bindingLine = genLine;
+ bindingColumn = genColumn;
+ const expressionsCount = decodeInteger(reader, 0);
+ let expressionRanges: BindingExpressionRange[];
+ if (expressionsCount < -1) {
+ expressionRanges = [[decodeInteger(reader, 0)]];
+ for (let i = -1; i > expressionsCount; i--) {
+ const prevBl = bindingLine;
+ bindingLine = decodeInteger(reader, bindingLine);
+ bindingColumn = decodeInteger(reader, bindingLine === prevBl ? bindingColumn : 0);
+ const expression = decodeInteger(reader, 0);
+ expressionRanges.push([expression, bindingLine, bindingColumn]);
+ }
+ } else {
+ expressionRanges = [[expressionsCount]];
+ }
+ bindings.push(expressionRanges);
+ } while (hasMoreVlq(reader, semi));
+ }
+ range.bindings = bindings;
+
+ ranges.push(range);
+ stack.push(range);
+ }
+
+ genLine++;
+ reader.pos = semi + 1;
+ } while (reader.pos < length);
+
+ return ranges;
+}
+
+export function encodeGeneratedRanges(ranges: GeneratedRange[]): string {
+ if (ranges.length === 0) return '';
+
+ const writer = new StringWriter();
+
+ for (let i = 0; i < ranges.length; ) {
+ i = _encodeGeneratedRanges(ranges, i, writer, [0, 0, 0, 0, 0, 0, 0]);
+ }
+
+ return writer.flush();
+}
+
+function _encodeGeneratedRanges(
+ ranges: GeneratedRange[],
+ index: number,
+ writer: StringWriter,
+ state: [
+ number, // GenLine
+ number, // GenColumn
+ number, // DefSourcesIndex
+ number, // DefScopesIndex
+ number, // CallSourcesIndex
+ number, // CallLine
+ number, // CallColumn
+ ],
+): number {
+ const range = ranges[index];
+ const {
+ 0: startLine,
+ 1: startColumn,
+ 2: endLine,
+ 3: endColumn,
+ isScope,
+ callsite,
+ bindings,
+ } = range;
+
+ if (state[0] < startLine) {
+ catchupLine(writer, state[0], startLine);
+ state[0] = startLine;
+ state[1] = 0;
+ } else if (index > 0) {
+ writer.write(comma);
+ }
+
+ state[1] = encodeInteger(writer, range[1], state[1]);
+
+ const fields =
+ (range.length === 6 ? 0b0001 : 0) | (callsite ? 0b0010 : 0) | (isScope ? 0b0100 : 0);
+ encodeInteger(writer, fields, 0);
+
+ if (range.length === 6) {
+ const { 4: sourcesIndex, 5: scopesIndex } = range;
+ if (sourcesIndex !== state[2]) {
+ state[3] = 0;
+ }
+ state[2] = encodeInteger(writer, sourcesIndex, state[2]);
+ state[3] = encodeInteger(writer, scopesIndex, state[3]);
+ }
+
+ if (callsite) {
+ const { 0: sourcesIndex, 1: callLine, 2: callColumn } = range.callsite!;
+ if (sourcesIndex !== state[4]) {
+ state[5] = 0;
+ state[6] = 0;
+ } else if (callLine !== state[5]) {
+ state[6] = 0;
+ }
+ state[4] = encodeInteger(writer, sourcesIndex, state[4]);
+ state[5] = encodeInteger(writer, callLine, state[5]);
+ state[6] = encodeInteger(writer, callColumn, state[6]);
+ }
+
+ if (bindings) {
+ for (const binding of bindings) {
+ if (binding.length > 1) encodeInteger(writer, -binding.length, 0);
+ const expression = binding[0][0];
+ encodeInteger(writer, expression, 0);
+ let bindingStartLine = startLine;
+ let bindingStartColumn = startColumn;
+ for (let i = 1; i < binding.length; i++) {
+ const expRange = binding[i];
+ bindingStartLine = encodeInteger(writer, expRange[1]!, bindingStartLine);
+ bindingStartColumn = encodeInteger(writer, expRange[2]!, bindingStartColumn);
+ encodeInteger(writer, expRange[0]!, 0);
+ }
+ }
+ }
+
+ for (index++; index < ranges.length; ) {
+ const next = ranges[index];
+ const { 0: l, 1: c } = next;
+ if (l > endLine || (l === endLine && c >= endColumn)) {
+ break;
+ }
+ index = _encodeGeneratedRanges(ranges, index, writer, state);
+ }
+
+ if (state[0] < endLine) {
+ catchupLine(writer, state[0], endLine);
+ state[0] = endLine;
+ state[1] = 0;
+ } else {
+ writer.write(comma);
+ }
+ state[1] = encodeInteger(writer, endColumn, state[1]);
+
+ return index;
+}
+
+function catchupLine(writer: StringWriter, lastLine: number, line: number) {
+ do {
+ writer.write(semicolon);
+ } while (++lastLine < line);
+}
diff --git a/sdk/node_modules/@jridgewell/sourcemap-codec/src/sourcemap-codec.ts b/sdk/node_modules/@jridgewell/sourcemap-codec/src/sourcemap-codec.ts
new file mode 100644
index 00000000..a81f894d
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/sourcemap-codec/src/sourcemap-codec.ts
@@ -0,0 +1,111 @@
+import { comma, decodeInteger, encodeInteger, hasMoreVlq, semicolon } from './vlq';
+import { StringWriter, StringReader } from './strings';
+
+export {
+ decodeOriginalScopes,
+ encodeOriginalScopes,
+ decodeGeneratedRanges,
+ encodeGeneratedRanges,
+} from './scopes';
+export type { OriginalScope, GeneratedRange, CallSite, BindingExpressionRange } from './scopes';
+
+export type SourceMapSegment =
+ | [number]
+ | [number, number, number, number]
+ | [number, number, number, number, number];
+export type SourceMapLine = SourceMapSegment[];
+export type SourceMapMappings = SourceMapLine[];
+
+export function decode(mappings: string): SourceMapMappings {
+ const { length } = mappings;
+ const reader = new StringReader(mappings);
+ const decoded: SourceMapMappings = [];
+ let genColumn = 0;
+ let sourcesIndex = 0;
+ let sourceLine = 0;
+ let sourceColumn = 0;
+ let namesIndex = 0;
+
+ do {
+ const semi = reader.indexOf(';');
+ const line: SourceMapLine = [];
+ let sorted = true;
+ let lastCol = 0;
+ genColumn = 0;
+
+ while (reader.pos < semi) {
+ let seg: SourceMapSegment;
+
+ genColumn = decodeInteger(reader, genColumn);
+ if (genColumn < lastCol) sorted = false;
+ lastCol = genColumn;
+
+ if (hasMoreVlq(reader, semi)) {
+ sourcesIndex = decodeInteger(reader, sourcesIndex);
+ sourceLine = decodeInteger(reader, sourceLine);
+ sourceColumn = decodeInteger(reader, sourceColumn);
+
+ if (hasMoreVlq(reader, semi)) {
+ namesIndex = decodeInteger(reader, namesIndex);
+ seg = [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex];
+ } else {
+ seg = [genColumn, sourcesIndex, sourceLine, sourceColumn];
+ }
+ } else {
+ seg = [genColumn];
+ }
+
+ line.push(seg);
+ reader.pos++;
+ }
+
+ if (!sorted) sort(line);
+ decoded.push(line);
+ reader.pos = semi + 1;
+ } while (reader.pos <= length);
+
+ return decoded;
+}
+
+function sort(line: SourceMapSegment[]) {
+ line.sort(sortComparator);
+}
+
+function sortComparator(a: SourceMapSegment, b: SourceMapSegment): number {
+ return a[0] - b[0];
+}
+
+export function encode(decoded: SourceMapMappings): string;
+export function encode(decoded: Readonly): string;
+export function encode(decoded: Readonly): string {
+ const writer = new StringWriter();
+ let sourcesIndex = 0;
+ let sourceLine = 0;
+ let sourceColumn = 0;
+ let namesIndex = 0;
+
+ for (let i = 0; i < decoded.length; i++) {
+ const line = decoded[i];
+ if (i > 0) writer.write(semicolon);
+ if (line.length === 0) continue;
+
+ let genColumn = 0;
+
+ for (let j = 0; j < line.length; j++) {
+ const segment = line[j];
+ if (j > 0) writer.write(comma);
+
+ genColumn = encodeInteger(writer, segment[0], genColumn);
+
+ if (segment.length === 1) continue;
+ sourcesIndex = encodeInteger(writer, segment[1], sourcesIndex);
+ sourceLine = encodeInteger(writer, segment[2], sourceLine);
+ sourceColumn = encodeInteger(writer, segment[3], sourceColumn);
+
+ if (segment.length === 4) continue;
+ namesIndex = encodeInteger(writer, segment[4], namesIndex);
+ }
+ }
+
+ return writer.flush();
+}
diff --git a/sdk/node_modules/@jridgewell/sourcemap-codec/src/strings.ts b/sdk/node_modules/@jridgewell/sourcemap-codec/src/strings.ts
new file mode 100644
index 00000000..d1619650
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/sourcemap-codec/src/strings.ts
@@ -0,0 +1,65 @@
+const bufLength = 1024 * 16;
+
+// Provide a fallback for older environments.
+const td =
+ typeof TextDecoder !== 'undefined'
+ ? /* #__PURE__ */ new TextDecoder()
+ : typeof Buffer !== 'undefined'
+ ? {
+ decode(buf: Uint8Array): string {
+ const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
+ return out.toString();
+ },
+ }
+ : {
+ decode(buf: Uint8Array): string {
+ let out = '';
+ for (let i = 0; i < buf.length; i++) {
+ out += String.fromCharCode(buf[i]);
+ }
+ return out;
+ },
+ };
+
+export class StringWriter {
+ pos = 0;
+ private out = '';
+ private buffer = new Uint8Array(bufLength);
+
+ write(v: number): void {
+ const { buffer } = this;
+ buffer[this.pos++] = v;
+ if (this.pos === bufLength) {
+ this.out += td.decode(buffer);
+ this.pos = 0;
+ }
+ }
+
+ flush(): string {
+ const { buffer, out, pos } = this;
+ return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out;
+ }
+}
+
+export class StringReader {
+ pos = 0;
+ declare private buffer: string;
+
+ constructor(buffer: string) {
+ this.buffer = buffer;
+ }
+
+ next(): number {
+ return this.buffer.charCodeAt(this.pos++);
+ }
+
+ peek(): number {
+ return this.buffer.charCodeAt(this.pos);
+ }
+
+ indexOf(char: string): number {
+ const { buffer, pos } = this;
+ const idx = buffer.indexOf(char, pos);
+ return idx === -1 ? buffer.length : idx;
+ }
+}
diff --git a/sdk/node_modules/@jridgewell/sourcemap-codec/src/vlq.ts b/sdk/node_modules/@jridgewell/sourcemap-codec/src/vlq.ts
new file mode 100644
index 00000000..a42c6815
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/sourcemap-codec/src/vlq.ts
@@ -0,0 +1,55 @@
+import type { StringReader, StringWriter } from './strings';
+
+export const comma = ','.charCodeAt(0);
+export const semicolon = ';'.charCodeAt(0);
+
+const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+const intToChar = new Uint8Array(64); // 64 possible chars.
+const charToInt = new Uint8Array(128); // z is 122 in ASCII
+
+for (let i = 0; i < chars.length; i++) {
+ const c = chars.charCodeAt(i);
+ intToChar[i] = c;
+ charToInt[c] = i;
+}
+
+export function decodeInteger(reader: StringReader, relative: number): number {
+ let value = 0;
+ let shift = 0;
+ let integer = 0;
+
+ do {
+ const c = reader.next();
+ integer = charToInt[c];
+ value |= (integer & 31) << shift;
+ shift += 5;
+ } while (integer & 32);
+
+ const shouldNegate = value & 1;
+ value >>>= 1;
+
+ if (shouldNegate) {
+ value = -0x80000000 | -value;
+ }
+
+ return relative + value;
+}
+
+export function encodeInteger(builder: StringWriter, num: number, relative: number): number {
+ let delta = num - relative;
+
+ delta = delta < 0 ? (-delta << 1) | 1 : delta << 1;
+ do {
+ let clamped = delta & 0b011111;
+ delta >>>= 5;
+ if (delta > 0) clamped |= 0b100000;
+ builder.write(intToChar[clamped]);
+ } while (delta > 0);
+
+ return num;
+}
+
+export function hasMoreVlq(reader: StringReader, max: number) {
+ if (reader.pos >= max) return false;
+ return reader.peek() !== comma;
+}
diff --git a/sdk/node_modules/@jridgewell/sourcemap-codec/types/scopes.d.cts b/sdk/node_modules/@jridgewell/sourcemap-codec/types/scopes.d.cts
new file mode 100644
index 00000000..c583c756
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/sourcemap-codec/types/scopes.d.cts
@@ -0,0 +1,50 @@
+type Line = number;
+type Column = number;
+type Kind = number;
+type Name = number;
+type Var = number;
+type SourcesIndex = number;
+type ScopesIndex = number;
+type Mix = (A & O) | (B & O);
+export type OriginalScope = Mix<[
+ Line,
+ Column,
+ Line,
+ Column,
+ Kind
+], [
+ Line,
+ Column,
+ Line,
+ Column,
+ Kind,
+ Name
+], {
+ vars: Var[];
+}>;
+export type GeneratedRange = Mix<[
+ Line,
+ Column,
+ Line,
+ Column
+], [
+ Line,
+ Column,
+ Line,
+ Column,
+ SourcesIndex,
+ ScopesIndex
+], {
+ callsite: CallSite | null;
+ bindings: Binding[];
+ isScope: boolean;
+}>;
+export type CallSite = [SourcesIndex, Line, Column];
+type Binding = BindingExpressionRange[];
+export type BindingExpressionRange = [Name] | [Name, Line, Column];
+export declare function decodeOriginalScopes(input: string): OriginalScope[];
+export declare function encodeOriginalScopes(scopes: OriginalScope[]): string;
+export declare function decodeGeneratedRanges(input: string): GeneratedRange[];
+export declare function encodeGeneratedRanges(ranges: GeneratedRange[]): string;
+export {};
+//# sourceMappingURL=scopes.d.ts.map
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/sourcemap-codec/types/scopes.d.cts.map b/sdk/node_modules/@jridgewell/sourcemap-codec/types/scopes.d.cts.map
new file mode 100644
index 00000000..630e6477
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/sourcemap-codec/types/scopes.d.cts.map
@@ -0,0 +1 @@
+{"version":3,"file":"scopes.d.ts","sourceRoot":"","sources":["../src/scopes.ts"],"names":[],"mappings":"AAKA,KAAK,IAAI,GAAG,MAAM,CAAC;AACnB,KAAK,MAAM,GAAG,MAAM,CAAC;AACrB,KAAK,IAAI,GAAG,MAAM,CAAC;AACnB,KAAK,IAAI,GAAG,MAAM,CAAC;AACnB,KAAK,GAAG,GAAG,MAAM,CAAC;AAClB,KAAK,YAAY,GAAG,MAAM,CAAC;AAC3B,KAAK,WAAW,GAAG,MAAM,CAAC;AAE1B,KAAK,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;AAEtC,MAAM,MAAM,aAAa,GAAG,GAAG,CAC7B;IAAC,IAAI;IAAE,MAAM;IAAE,IAAI;IAAE,MAAM;IAAE,IAAI;CAAC,EAClC;IAAC,IAAI;IAAE,MAAM;IAAE,IAAI;IAAE,MAAM;IAAE,IAAI;IAAE,IAAI;CAAC,EACxC;IAAE,IAAI,EAAE,GAAG,EAAE,CAAA;CAAE,CAChB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,GAAG,CAC9B;IAAC,IAAI;IAAE,MAAM;IAAE,IAAI;IAAE,MAAM;CAAC,EAC5B;IAAC,IAAI;IAAE,MAAM;IAAE,IAAI;IAAE,MAAM;IAAE,YAAY;IAAE,WAAW;CAAC,EACvD;IACE,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAAC;IAC1B,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,OAAO,EAAE,OAAO,CAAC;CAClB,CACF,CAAC;AACF,MAAM,MAAM,QAAQ,GAAG,CAAC,YAAY,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;AACpD,KAAK,OAAO,GAAG,sBAAsB,EAAE,CAAC;AACxC,MAAM,MAAM,sBAAsB,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;AAEnE,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,aAAa,EAAE,CAyCnE;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,MAAM,CAQpE;AA2CD,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,EAAE,CAoGrE;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,cAAc,EAAE,GAAG,MAAM,CAUtE"}
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/sourcemap-codec/types/scopes.d.mts b/sdk/node_modules/@jridgewell/sourcemap-codec/types/scopes.d.mts
new file mode 100644
index 00000000..c583c756
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/sourcemap-codec/types/scopes.d.mts
@@ -0,0 +1,50 @@
+type Line = number;
+type Column = number;
+type Kind = number;
+type Name = number;
+type Var = number;
+type SourcesIndex = number;
+type ScopesIndex = number;
+type Mix = (A & O) | (B & O);
+export type OriginalScope = Mix<[
+ Line,
+ Column,
+ Line,
+ Column,
+ Kind
+], [
+ Line,
+ Column,
+ Line,
+ Column,
+ Kind,
+ Name
+], {
+ vars: Var[];
+}>;
+export type GeneratedRange = Mix<[
+ Line,
+ Column,
+ Line,
+ Column
+], [
+ Line,
+ Column,
+ Line,
+ Column,
+ SourcesIndex,
+ ScopesIndex
+], {
+ callsite: CallSite | null;
+ bindings: Binding[];
+ isScope: boolean;
+}>;
+export type CallSite = [SourcesIndex, Line, Column];
+type Binding = BindingExpressionRange[];
+export type BindingExpressionRange = [Name] | [Name, Line, Column];
+export declare function decodeOriginalScopes(input: string): OriginalScope[];
+export declare function encodeOriginalScopes(scopes: OriginalScope[]): string;
+export declare function decodeGeneratedRanges(input: string): GeneratedRange[];
+export declare function encodeGeneratedRanges(ranges: GeneratedRange[]): string;
+export {};
+//# sourceMappingURL=scopes.d.ts.map
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/sourcemap-codec/types/scopes.d.mts.map b/sdk/node_modules/@jridgewell/sourcemap-codec/types/scopes.d.mts.map
new file mode 100644
index 00000000..630e6477
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/sourcemap-codec/types/scopes.d.mts.map
@@ -0,0 +1 @@
+{"version":3,"file":"scopes.d.ts","sourceRoot":"","sources":["../src/scopes.ts"],"names":[],"mappings":"AAKA,KAAK,IAAI,GAAG,MAAM,CAAC;AACnB,KAAK,MAAM,GAAG,MAAM,CAAC;AACrB,KAAK,IAAI,GAAG,MAAM,CAAC;AACnB,KAAK,IAAI,GAAG,MAAM,CAAC;AACnB,KAAK,GAAG,GAAG,MAAM,CAAC;AAClB,KAAK,YAAY,GAAG,MAAM,CAAC;AAC3B,KAAK,WAAW,GAAG,MAAM,CAAC;AAE1B,KAAK,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;AAEtC,MAAM,MAAM,aAAa,GAAG,GAAG,CAC7B;IAAC,IAAI;IAAE,MAAM;IAAE,IAAI;IAAE,MAAM;IAAE,IAAI;CAAC,EAClC;IAAC,IAAI;IAAE,MAAM;IAAE,IAAI;IAAE,MAAM;IAAE,IAAI;IAAE,IAAI;CAAC,EACxC;IAAE,IAAI,EAAE,GAAG,EAAE,CAAA;CAAE,CAChB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,GAAG,CAC9B;IAAC,IAAI;IAAE,MAAM;IAAE,IAAI;IAAE,MAAM;CAAC,EAC5B;IAAC,IAAI;IAAE,MAAM;IAAE,IAAI;IAAE,MAAM;IAAE,YAAY;IAAE,WAAW;CAAC,EACvD;IACE,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAAC;IAC1B,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,OAAO,EAAE,OAAO,CAAC;CAClB,CACF,CAAC;AACF,MAAM,MAAM,QAAQ,GAAG,CAAC,YAAY,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;AACpD,KAAK,OAAO,GAAG,sBAAsB,EAAE,CAAC;AACxC,MAAM,MAAM,sBAAsB,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;AAEnE,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,aAAa,EAAE,CAyCnE;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,MAAM,CAQpE;AA2CD,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,EAAE,CAoGrE;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,cAAc,EAAE,GAAG,MAAM,CAUtE"}
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/sourcemap-codec/types/sourcemap-codec.d.cts b/sdk/node_modules/@jridgewell/sourcemap-codec/types/sourcemap-codec.d.cts
new file mode 100644
index 00000000..5f35e22f
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/sourcemap-codec/types/sourcemap-codec.d.cts
@@ -0,0 +1,9 @@
+export { decodeOriginalScopes, encodeOriginalScopes, decodeGeneratedRanges, encodeGeneratedRanges, } from './scopes.cts';
+export type { OriginalScope, GeneratedRange, CallSite, BindingExpressionRange } from './scopes.cts';
+export type SourceMapSegment = [number] | [number, number, number, number] | [number, number, number, number, number];
+export type SourceMapLine = SourceMapSegment[];
+export type SourceMapMappings = SourceMapLine[];
+export declare function decode(mappings: string): SourceMapMappings;
+export declare function encode(decoded: SourceMapMappings): string;
+export declare function encode(decoded: Readonly): string;
+//# sourceMappingURL=sourcemap-codec.d.ts.map
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/sourcemap-codec/types/sourcemap-codec.d.cts.map b/sdk/node_modules/@jridgewell/sourcemap-codec/types/sourcemap-codec.d.cts.map
new file mode 100644
index 00000000..7123d520
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/sourcemap-codec/types/sourcemap-codec.d.cts.map
@@ -0,0 +1 @@
+{"version":3,"file":"sourcemap-codec.d.ts","sourceRoot":"","sources":["../src/sourcemap-codec.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,oBAAoB,EACpB,oBAAoB,EACpB,qBAAqB,EACrB,qBAAqB,GACtB,MAAM,UAAU,CAAC;AAClB,YAAY,EAAE,aAAa,EAAE,cAAc,EAAE,QAAQ,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAC;AAEhG,MAAM,MAAM,gBAAgB,GACxB,CAAC,MAAM,CAAC,GACR,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAChC,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAC7C,MAAM,MAAM,aAAa,GAAG,gBAAgB,EAAE,CAAC;AAC/C,MAAM,MAAM,iBAAiB,GAAG,aAAa,EAAE,CAAC;AAEhD,wBAAgB,MAAM,CAAC,QAAQ,EAAE,MAAM,GAAG,iBAAiB,CAiD1D;AAUD,wBAAgB,MAAM,CAAC,OAAO,EAAE,iBAAiB,GAAG,MAAM,CAAC;AAC3D,wBAAgB,MAAM,CAAC,OAAO,EAAE,QAAQ,CAAC,iBAAiB,CAAC,GAAG,MAAM,CAAC"}
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/sourcemap-codec/types/sourcemap-codec.d.mts b/sdk/node_modules/@jridgewell/sourcemap-codec/types/sourcemap-codec.d.mts
new file mode 100644
index 00000000..199fb9f5
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/sourcemap-codec/types/sourcemap-codec.d.mts
@@ -0,0 +1,9 @@
+export { decodeOriginalScopes, encodeOriginalScopes, decodeGeneratedRanges, encodeGeneratedRanges, } from './scopes.mts';
+export type { OriginalScope, GeneratedRange, CallSite, BindingExpressionRange } from './scopes.mts';
+export type SourceMapSegment = [number] | [number, number, number, number] | [number, number, number, number, number];
+export type SourceMapLine = SourceMapSegment[];
+export type SourceMapMappings = SourceMapLine[];
+export declare function decode(mappings: string): SourceMapMappings;
+export declare function encode(decoded: SourceMapMappings): string;
+export declare function encode(decoded: Readonly): string;
+//# sourceMappingURL=sourcemap-codec.d.ts.map
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/sourcemap-codec/types/sourcemap-codec.d.mts.map b/sdk/node_modules/@jridgewell/sourcemap-codec/types/sourcemap-codec.d.mts.map
new file mode 100644
index 00000000..7123d520
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/sourcemap-codec/types/sourcemap-codec.d.mts.map
@@ -0,0 +1 @@
+{"version":3,"file":"sourcemap-codec.d.ts","sourceRoot":"","sources":["../src/sourcemap-codec.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,oBAAoB,EACpB,oBAAoB,EACpB,qBAAqB,EACrB,qBAAqB,GACtB,MAAM,UAAU,CAAC;AAClB,YAAY,EAAE,aAAa,EAAE,cAAc,EAAE,QAAQ,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAC;AAEhG,MAAM,MAAM,gBAAgB,GACxB,CAAC,MAAM,CAAC,GACR,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAChC,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAC7C,MAAM,MAAM,aAAa,GAAG,gBAAgB,EAAE,CAAC;AAC/C,MAAM,MAAM,iBAAiB,GAAG,aAAa,EAAE,CAAC;AAEhD,wBAAgB,MAAM,CAAC,QAAQ,EAAE,MAAM,GAAG,iBAAiB,CAiD1D;AAUD,wBAAgB,MAAM,CAAC,OAAO,EAAE,iBAAiB,GAAG,MAAM,CAAC;AAC3D,wBAAgB,MAAM,CAAC,OAAO,EAAE,QAAQ,CAAC,iBAAiB,CAAC,GAAG,MAAM,CAAC"}
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/sourcemap-codec/types/strings.d.cts b/sdk/node_modules/@jridgewell/sourcemap-codec/types/strings.d.cts
new file mode 100644
index 00000000..62faceb3
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/sourcemap-codec/types/strings.d.cts
@@ -0,0 +1,16 @@
+export declare class StringWriter {
+ pos: number;
+ private out;
+ private buffer;
+ write(v: number): void;
+ flush(): string;
+}
+export declare class StringReader {
+ pos: number;
+ private buffer;
+ constructor(buffer: string);
+ next(): number;
+ peek(): number;
+ indexOf(char: string): number;
+}
+//# sourceMappingURL=strings.d.ts.map
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/sourcemap-codec/types/strings.d.cts.map b/sdk/node_modules/@jridgewell/sourcemap-codec/types/strings.d.cts.map
new file mode 100644
index 00000000..d3602da4
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/sourcemap-codec/types/strings.d.cts.map
@@ -0,0 +1 @@
+{"version":3,"file":"strings.d.ts","sourceRoot":"","sources":["../src/strings.ts"],"names":[],"mappings":"AAuBA,qBAAa,YAAY;IACvB,GAAG,SAAK;IACR,OAAO,CAAC,GAAG,CAAM;IACjB,OAAO,CAAC,MAAM,CAA6B;IAE3C,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI;IAStB,KAAK,IAAI,MAAM;CAIhB;AAED,qBAAa,YAAY;IACvB,GAAG,SAAK;IACR,QAAgB,MAAM,CAAS;gBAEnB,MAAM,EAAE,MAAM;IAI1B,IAAI,IAAI,MAAM;IAId,IAAI,IAAI,MAAM;IAId,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;CAK9B"}
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/sourcemap-codec/types/strings.d.mts b/sdk/node_modules/@jridgewell/sourcemap-codec/types/strings.d.mts
new file mode 100644
index 00000000..62faceb3
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/sourcemap-codec/types/strings.d.mts
@@ -0,0 +1,16 @@
+export declare class StringWriter {
+ pos: number;
+ private out;
+ private buffer;
+ write(v: number): void;
+ flush(): string;
+}
+export declare class StringReader {
+ pos: number;
+ private buffer;
+ constructor(buffer: string);
+ next(): number;
+ peek(): number;
+ indexOf(char: string): number;
+}
+//# sourceMappingURL=strings.d.ts.map
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/sourcemap-codec/types/strings.d.mts.map b/sdk/node_modules/@jridgewell/sourcemap-codec/types/strings.d.mts.map
new file mode 100644
index 00000000..d3602da4
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/sourcemap-codec/types/strings.d.mts.map
@@ -0,0 +1 @@
+{"version":3,"file":"strings.d.ts","sourceRoot":"","sources":["../src/strings.ts"],"names":[],"mappings":"AAuBA,qBAAa,YAAY;IACvB,GAAG,SAAK;IACR,OAAO,CAAC,GAAG,CAAM;IACjB,OAAO,CAAC,MAAM,CAA6B;IAE3C,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI;IAStB,KAAK,IAAI,MAAM;CAIhB;AAED,qBAAa,YAAY;IACvB,GAAG,SAAK;IACR,QAAgB,MAAM,CAAS;gBAEnB,MAAM,EAAE,MAAM;IAI1B,IAAI,IAAI,MAAM;IAId,IAAI,IAAI,MAAM;IAId,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;CAK9B"}
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/sourcemap-codec/types/vlq.d.cts b/sdk/node_modules/@jridgewell/sourcemap-codec/types/vlq.d.cts
new file mode 100644
index 00000000..dbd6602d
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/sourcemap-codec/types/vlq.d.cts
@@ -0,0 +1,7 @@
+import type { StringReader, StringWriter } from './strings.cts';
+export declare const comma: number;
+export declare const semicolon: number;
+export declare function decodeInteger(reader: StringReader, relative: number): number;
+export declare function encodeInteger(builder: StringWriter, num: number, relative: number): number;
+export declare function hasMoreVlq(reader: StringReader, max: number): boolean;
+//# sourceMappingURL=vlq.d.ts.map
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/sourcemap-codec/types/vlq.d.cts.map b/sdk/node_modules/@jridgewell/sourcemap-codec/types/vlq.d.cts.map
new file mode 100644
index 00000000..6fdc3569
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/sourcemap-codec/types/vlq.d.cts.map
@@ -0,0 +1 @@
+{"version":3,"file":"vlq.d.ts","sourceRoot":"","sources":["../src/vlq.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAE5D,eAAO,MAAM,KAAK,QAAoB,CAAC;AACvC,eAAO,MAAM,SAAS,QAAoB,CAAC;AAY3C,wBAAgB,aAAa,CAAC,MAAM,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAoB5E;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,YAAY,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAY1F;AAED,wBAAgB,UAAU,CAAC,MAAM,EAAE,YAAY,EAAE,GAAG,EAAE,MAAM,WAG3D"}
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/sourcemap-codec/types/vlq.d.mts b/sdk/node_modules/@jridgewell/sourcemap-codec/types/vlq.d.mts
new file mode 100644
index 00000000..2c739bc9
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/sourcemap-codec/types/vlq.d.mts
@@ -0,0 +1,7 @@
+import type { StringReader, StringWriter } from './strings.mts';
+export declare const comma: number;
+export declare const semicolon: number;
+export declare function decodeInteger(reader: StringReader, relative: number): number;
+export declare function encodeInteger(builder: StringWriter, num: number, relative: number): number;
+export declare function hasMoreVlq(reader: StringReader, max: number): boolean;
+//# sourceMappingURL=vlq.d.ts.map
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/sourcemap-codec/types/vlq.d.mts.map b/sdk/node_modules/@jridgewell/sourcemap-codec/types/vlq.d.mts.map
new file mode 100644
index 00000000..6fdc3569
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/sourcemap-codec/types/vlq.d.mts.map
@@ -0,0 +1 @@
+{"version":3,"file":"vlq.d.ts","sourceRoot":"","sources":["../src/vlq.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAE5D,eAAO,MAAM,KAAK,QAAoB,CAAC;AACvC,eAAO,MAAM,SAAS,QAAoB,CAAC;AAY3C,wBAAgB,aAAa,CAAC,MAAM,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAoB5E;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,YAAY,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAY1F;AAED,wBAAgB,UAAU,CAAC,MAAM,EAAE,YAAY,EAAE,GAAG,EAAE,MAAM,WAG3D"}
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/trace-mapping/LICENSE b/sdk/node_modules/@jridgewell/trace-mapping/LICENSE
new file mode 100644
index 00000000..1f6ce94c
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/trace-mapping/LICENSE
@@ -0,0 +1,19 @@
+Copyright 2024 Justin Ridgewell
+
+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.
diff --git a/sdk/node_modules/@jridgewell/trace-mapping/README.md b/sdk/node_modules/@jridgewell/trace-mapping/README.md
new file mode 100644
index 00000000..9fc0ed09
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/trace-mapping/README.md
@@ -0,0 +1,348 @@
+# @jridgewell/trace-mapping
+
+> Trace the original position through a source map
+
+`trace-mapping` allows you to take the line and column of an output file and trace it to the
+original location in the source file through a source map.
+
+You may already be familiar with the [`source-map`][source-map] package's `SourceMapConsumer`. This
+provides the same `originalPositionFor` and `generatedPositionFor` API, without requiring WASM.
+
+## Installation
+
+```sh
+npm install @jridgewell/trace-mapping
+```
+
+## Usage
+
+```typescript
+import {
+ TraceMap,
+ originalPositionFor,
+ generatedPositionFor,
+ sourceContentFor,
+ isIgnored,
+} from '@jridgewell/trace-mapping';
+
+const tracer = new TraceMap({
+ version: 3,
+ sources: ['input.js'],
+ sourcesContent: ['content of input.js'],
+ names: ['foo'],
+ mappings: 'KAyCIA',
+ ignoreList: [],
+});
+
+// Lines start at line 1, columns at column 0.
+const traced = originalPositionFor(tracer, { line: 1, column: 5 });
+assert.deepEqual(traced, {
+ source: 'input.js',
+ line: 42,
+ column: 4,
+ name: 'foo',
+});
+
+const content = sourceContentFor(tracer, traced.source);
+assert.strictEqual(content, 'content for input.js');
+
+const generated = generatedPositionFor(tracer, {
+ source: 'input.js',
+ line: 42,
+ column: 4,
+});
+assert.deepEqual(generated, {
+ line: 1,
+ column: 5,
+});
+
+const ignored = isIgnored(tracer, 'input.js');
+assert.equal(ignored, false);
+```
+
+We also provide a lower level API to get the actual segment that matches our line and column. Unlike
+`originalPositionFor`, `traceSegment` uses a 0-base for `line`:
+
+```typescript
+import { traceSegment } from '@jridgewell/trace-mapping';
+
+// line is 0-base.
+const traced = traceSegment(tracer, /* line */ 0, /* column */ 5);
+
+// Segments are [outputColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex]
+// Again, line is 0-base and so is sourceLine
+assert.deepEqual(traced, [5, 0, 41, 4, 0]);
+```
+
+### SectionedSourceMaps
+
+The sourcemap spec defines a special `sections` field that's designed to handle concatenation of
+output code with associated sourcemaps. This type of sourcemap is rarely used (no major build tool
+produces it), but if you are hand coding a concatenation you may need it. We provide an `AnyMap`
+helper that can receive either a regular sourcemap or a `SectionedSourceMap` and returns a
+`TraceMap` instance:
+
+```typescript
+import { AnyMap } from '@jridgewell/trace-mapping';
+const fooOutput = 'foo';
+const barOutput = 'bar';
+const output = [fooOutput, barOutput].join('\n');
+
+const sectioned = new AnyMap({
+ version: 3,
+ sections: [
+ {
+ // 0-base line and column
+ offset: { line: 0, column: 0 },
+ // fooOutput's sourcemap
+ map: {
+ version: 3,
+ sources: ['foo.js'],
+ names: ['foo'],
+ mappings: 'AAAAA',
+ },
+ },
+ {
+ // barOutput's sourcemap will not affect the first line, only the second
+ offset: { line: 1, column: 0 },
+ map: {
+ version: 3,
+ sources: ['bar.js'],
+ names: ['bar'],
+ mappings: 'AAAAA',
+ },
+ },
+ ],
+});
+
+const traced = originalPositionFor(sectioned, {
+ line: 2,
+ column: 0,
+});
+
+assert.deepEqual(traced, {
+ source: 'bar.js',
+ line: 1,
+ column: 0,
+ name: 'bar',
+});
+```
+
+## Benchmarks
+
+```
+node v20.10.0
+
+amp.js.map - 45120 segments
+
+Memory Usage:
+trace-mapping decoded 414164 bytes
+trace-mapping encoded 6274352 bytes
+source-map-js 10968904 bytes
+source-map-0.6.1 17587160 bytes
+source-map-0.8.0 8812155 bytes
+Chrome dev tools 8672912 bytes
+Smallest memory usage is trace-mapping decoded
+
+Init speed:
+trace-mapping: decoded JSON input x 205 ops/sec ±0.19% (88 runs sampled)
+trace-mapping: encoded JSON input x 405 ops/sec ±1.47% (88 runs sampled)
+trace-mapping: decoded Object input x 4,645 ops/sec ±0.15% (98 runs sampled)
+trace-mapping: encoded Object input x 458 ops/sec ±1.63% (91 runs sampled)
+source-map-js: encoded Object input x 75.48 ops/sec ±1.64% (67 runs sampled)
+source-map-0.6.1: encoded Object input x 39.37 ops/sec ±1.44% (53 runs sampled)
+Chrome dev tools: encoded Object input x 150 ops/sec ±1.76% (79 runs sampled)
+Fastest is trace-mapping: decoded Object input
+
+Trace speed (random):
+trace-mapping: decoded originalPositionFor x 44,946 ops/sec ±0.16% (99 runs sampled)
+trace-mapping: encoded originalPositionFor x 37,995 ops/sec ±1.81% (89 runs sampled)
+source-map-js: encoded originalPositionFor x 9,230 ops/sec ±1.36% (93 runs sampled)
+source-map-0.6.1: encoded originalPositionFor x 8,057 ops/sec ±0.84% (96 runs sampled)
+source-map-0.8.0: encoded originalPositionFor x 28,198 ops/sec ±1.12% (91 runs sampled)
+Chrome dev tools: encoded originalPositionFor x 46,276 ops/sec ±1.35% (95 runs sampled)
+Fastest is Chrome dev tools: encoded originalPositionFor
+
+Trace speed (ascending):
+trace-mapping: decoded originalPositionFor x 204,406 ops/sec ±0.19% (97 runs sampled)
+trace-mapping: encoded originalPositionFor x 196,695 ops/sec ±0.24% (99 runs sampled)
+source-map-js: encoded originalPositionFor x 11,948 ops/sec ±0.94% (99 runs sampled)
+source-map-0.6.1: encoded originalPositionFor x 10,730 ops/sec ±0.36% (100 runs sampled)
+source-map-0.8.0: encoded originalPositionFor x 51,427 ops/sec ±0.21% (98 runs sampled)
+Chrome dev tools: encoded originalPositionFor x 162,615 ops/sec ±0.18% (98 runs sampled)
+Fastest is trace-mapping: decoded originalPositionFor
+
+
+***
+
+
+babel.min.js.map - 347793 segments
+
+Memory Usage:
+trace-mapping decoded 18504 bytes
+trace-mapping encoded 35428008 bytes
+source-map-js 51676808 bytes
+source-map-0.6.1 63367136 bytes
+source-map-0.8.0 43158400 bytes
+Chrome dev tools 50721552 bytes
+Smallest memory usage is trace-mapping decoded
+
+Init speed:
+trace-mapping: decoded JSON input x 17.82 ops/sec ±6.35% (35 runs sampled)
+trace-mapping: encoded JSON input x 31.57 ops/sec ±7.50% (43 runs sampled)
+trace-mapping: decoded Object input x 867 ops/sec ±0.74% (94 runs sampled)
+trace-mapping: encoded Object input x 33.83 ops/sec ±7.66% (46 runs sampled)
+source-map-js: encoded Object input x 6.58 ops/sec ±3.31% (20 runs sampled)
+source-map-0.6.1: encoded Object input x 4.23 ops/sec ±3.43% (15 runs sampled)
+Chrome dev tools: encoded Object input x 22.14 ops/sec ±3.79% (41 runs sampled)
+Fastest is trace-mapping: decoded Object input
+
+Trace speed (random):
+trace-mapping: decoded originalPositionFor x 78,234 ops/sec ±1.48% (29 runs sampled)
+trace-mapping: encoded originalPositionFor x 60,761 ops/sec ±1.35% (21 runs sampled)
+source-map-js: encoded originalPositionFor x 51,448 ops/sec ±2.17% (89 runs sampled)
+source-map-0.6.1: encoded originalPositionFor x 47,221 ops/sec ±1.99% (15 runs sampled)
+source-map-0.8.0: encoded originalPositionFor x 84,002 ops/sec ±1.45% (27 runs sampled)
+Chrome dev tools: encoded originalPositionFor x 106,457 ops/sec ±1.38% (37 runs sampled)
+Fastest is Chrome dev tools: encoded originalPositionFor
+
+Trace speed (ascending):
+trace-mapping: decoded originalPositionFor x 930,943 ops/sec ±0.25% (99 runs sampled)
+trace-mapping: encoded originalPositionFor x 843,545 ops/sec ±0.34% (97 runs sampled)
+source-map-js: encoded originalPositionFor x 114,510 ops/sec ±1.37% (36 runs sampled)
+source-map-0.6.1: encoded originalPositionFor x 87,412 ops/sec ±0.72% (92 runs sampled)
+source-map-0.8.0: encoded originalPositionFor x 197,709 ops/sec ±0.89% (59 runs sampled)
+Chrome dev tools: encoded originalPositionFor x 688,983 ops/sec ±0.33% (98 runs sampled)
+Fastest is trace-mapping: decoded originalPositionFor
+
+
+***
+
+
+preact.js.map - 1992 segments
+
+Memory Usage:
+trace-mapping decoded 33136 bytes
+trace-mapping encoded 254240 bytes
+source-map-js 837488 bytes
+source-map-0.6.1 961928 bytes
+source-map-0.8.0 54384 bytes
+Chrome dev tools 709680 bytes
+Smallest memory usage is trace-mapping decoded
+
+Init speed:
+trace-mapping: decoded JSON input x 3,709 ops/sec ±0.13% (99 runs sampled)
+trace-mapping: encoded JSON input x 6,447 ops/sec ±0.22% (101 runs sampled)
+trace-mapping: decoded Object input x 83,062 ops/sec ±0.23% (100 runs sampled)
+trace-mapping: encoded Object input x 14,980 ops/sec ±0.28% (100 runs sampled)
+source-map-js: encoded Object input x 2,544 ops/sec ±0.16% (99 runs sampled)
+source-map-0.6.1: encoded Object input x 1,221 ops/sec ±0.37% (97 runs sampled)
+Chrome dev tools: encoded Object input x 4,241 ops/sec ±0.39% (93 runs sampled)
+Fastest is trace-mapping: decoded Object input
+
+Trace speed (random):
+trace-mapping: decoded originalPositionFor x 91,028 ops/sec ±0.14% (94 runs sampled)
+trace-mapping: encoded originalPositionFor x 84,348 ops/sec ±0.26% (98 runs sampled)
+source-map-js: encoded originalPositionFor x 26,998 ops/sec ±0.23% (98 runs sampled)
+source-map-0.6.1: encoded originalPositionFor x 18,049 ops/sec ±0.26% (100 runs sampled)
+source-map-0.8.0: encoded originalPositionFor x 41,916 ops/sec ±0.28% (98 runs sampled)
+Chrome dev tools: encoded originalPositionFor x 88,616 ops/sec ±0.14% (98 runs sampled)
+Fastest is trace-mapping: decoded originalPositionFor
+
+Trace speed (ascending):
+trace-mapping: decoded originalPositionFor x 319,960 ops/sec ±0.16% (100 runs sampled)
+trace-mapping: encoded originalPositionFor x 302,153 ops/sec ±0.18% (100 runs sampled)
+source-map-js: encoded originalPositionFor x 35,574 ops/sec ±0.19% (100 runs sampled)
+source-map-0.6.1: encoded originalPositionFor x 19,943 ops/sec ±0.12% (101 runs sampled)
+source-map-0.8.0: encoded originalPositionFor x 54,648 ops/sec ±0.20% (99 runs sampled)
+Chrome dev tools: encoded originalPositionFor x 278,319 ops/sec ±0.17% (102 runs sampled)
+Fastest is trace-mapping: decoded originalPositionFor
+
+
+***
+
+
+react.js.map - 5726 segments
+
+Memory Usage:
+trace-mapping decoded 10872 bytes
+trace-mapping encoded 681512 bytes
+source-map-js 2563944 bytes
+source-map-0.6.1 2150864 bytes
+source-map-0.8.0 88680 bytes
+Chrome dev tools 1149576 bytes
+Smallest memory usage is trace-mapping decoded
+
+Init speed:
+trace-mapping: decoded JSON input x 1,887 ops/sec ±0.28% (99 runs sampled)
+trace-mapping: encoded JSON input x 4,749 ops/sec ±0.48% (97 runs sampled)
+trace-mapping: decoded Object input x 74,236 ops/sec ±0.11% (99 runs sampled)
+trace-mapping: encoded Object input x 5,752 ops/sec ±0.38% (100 runs sampled)
+source-map-js: encoded Object input x 806 ops/sec ±0.19% (97 runs sampled)
+source-map-0.6.1: encoded Object input x 418 ops/sec ±0.33% (94 runs sampled)
+Chrome dev tools: encoded Object input x 1,524 ops/sec ±0.57% (92 runs sampled)
+Fastest is trace-mapping: decoded Object input
+
+Trace speed (random):
+trace-mapping: decoded originalPositionFor x 620,201 ops/sec ±0.33% (96 runs sampled)
+trace-mapping: encoded originalPositionFor x 579,548 ops/sec ±0.35% (97 runs sampled)
+source-map-js: encoded originalPositionFor x 230,983 ops/sec ±0.62% (54 runs sampled)
+source-map-0.6.1: encoded originalPositionFor x 158,145 ops/sec ±0.80% (46 runs sampled)
+source-map-0.8.0: encoded originalPositionFor x 343,801 ops/sec ±0.55% (96 runs sampled)
+Chrome dev tools: encoded originalPositionFor x 659,649 ops/sec ±0.49% (98 runs sampled)
+Fastest is Chrome dev tools: encoded originalPositionFor
+
+Trace speed (ascending):
+trace-mapping: decoded originalPositionFor x 2,368,079 ops/sec ±0.32% (98 runs sampled)
+trace-mapping: encoded originalPositionFor x 2,134,039 ops/sec ±2.72% (87 runs sampled)
+source-map-js: encoded originalPositionFor x 290,120 ops/sec ±2.49% (82 runs sampled)
+source-map-0.6.1: encoded originalPositionFor x 187,613 ops/sec ±0.86% (49 runs sampled)
+source-map-0.8.0: encoded originalPositionFor x 479,569 ops/sec ±0.65% (96 runs sampled)
+Chrome dev tools: encoded originalPositionFor x 2,048,414 ops/sec ±0.24% (98 runs sampled)
+Fastest is trace-mapping: decoded originalPositionFor
+
+
+***
+
+
+vscode.map - 2141001 segments
+
+Memory Usage:
+trace-mapping decoded 5206584 bytes
+trace-mapping encoded 208370336 bytes
+source-map-js 278493008 bytes
+source-map-0.6.1 391564048 bytes
+source-map-0.8.0 257508787 bytes
+Chrome dev tools 291053000 bytes
+Smallest memory usage is trace-mapping decoded
+
+Init speed:
+trace-mapping: decoded JSON input x 1.63 ops/sec ±33.88% (9 runs sampled)
+trace-mapping: encoded JSON input x 3.29 ops/sec ±36.13% (13 runs sampled)
+trace-mapping: decoded Object input x 103 ops/sec ±0.93% (77 runs sampled)
+trace-mapping: encoded Object input x 5.42 ops/sec ±28.54% (19 runs sampled)
+source-map-js: encoded Object input x 1.07 ops/sec ±13.84% (7 runs sampled)
+source-map-0.6.1: encoded Object input x 0.60 ops/sec ±2.43% (6 runs sampled)
+Chrome dev tools: encoded Object input x 2.61 ops/sec ±22.00% (11 runs sampled)
+Fastest is trace-mapping: decoded Object input
+
+Trace speed (random):
+trace-mapping: decoded originalPositionFor x 257,019 ops/sec ±0.97% (93 runs sampled)
+trace-mapping: encoded originalPositionFor x 179,163 ops/sec ±0.83% (92 runs sampled)
+source-map-js: encoded originalPositionFor x 73,337 ops/sec ±1.35% (87 runs sampled)
+source-map-0.6.1: encoded originalPositionFor x 38,797 ops/sec ±1.66% (88 runs sampled)
+source-map-0.8.0: encoded originalPositionFor x 107,758 ops/sec ±1.94% (45 runs sampled)
+Chrome dev tools: encoded originalPositionFor x 188,550 ops/sec ±1.85% (79 runs sampled)
+Fastest is trace-mapping: decoded originalPositionFor
+
+Trace speed (ascending):
+trace-mapping: decoded originalPositionFor x 447,621 ops/sec ±3.64% (94 runs sampled)
+trace-mapping: encoded originalPositionFor x 323,698 ops/sec ±5.20% (88 runs sampled)
+source-map-js: encoded originalPositionFor x 78,387 ops/sec ±1.69% (89 runs sampled)
+source-map-0.6.1: encoded originalPositionFor x 41,016 ops/sec ±3.01% (25 runs sampled)
+source-map-0.8.0: encoded originalPositionFor x 124,204 ops/sec ±0.90% (92 runs sampled)
+Chrome dev tools: encoded originalPositionFor x 230,087 ops/sec ±2.61% (93 runs sampled)
+Fastest is trace-mapping: decoded originalPositionFor
+```
+
+[source-map]: https://www.npmjs.com/package/source-map
diff --git a/sdk/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs b/sdk/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs
new file mode 100644
index 00000000..73a95c77
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs
@@ -0,0 +1,493 @@
+// src/trace-mapping.ts
+import { encode, decode } from "@jridgewell/sourcemap-codec";
+
+// src/resolve.ts
+import resolveUri from "@jridgewell/resolve-uri";
+
+// src/strip-filename.ts
+function stripFilename(path) {
+ if (!path) return "";
+ const index = path.lastIndexOf("/");
+ return path.slice(0, index + 1);
+}
+
+// src/resolve.ts
+function resolver(mapUrl, sourceRoot) {
+ const from = stripFilename(mapUrl);
+ const prefix = sourceRoot ? sourceRoot + "/" : "";
+ return (source) => resolveUri(prefix + (source || ""), from);
+}
+
+// src/sourcemap-segment.ts
+var COLUMN = 0;
+var SOURCES_INDEX = 1;
+var SOURCE_LINE = 2;
+var SOURCE_COLUMN = 3;
+var NAMES_INDEX = 4;
+var REV_GENERATED_LINE = 1;
+var REV_GENERATED_COLUMN = 2;
+
+// src/sort.ts
+function maybeSort(mappings, owned) {
+ const unsortedIndex = nextUnsortedSegmentLine(mappings, 0);
+ if (unsortedIndex === mappings.length) return mappings;
+ if (!owned) mappings = mappings.slice();
+ for (let i = unsortedIndex; i < mappings.length; i = nextUnsortedSegmentLine(mappings, i + 1)) {
+ mappings[i] = sortSegments(mappings[i], owned);
+ }
+ return mappings;
+}
+function nextUnsortedSegmentLine(mappings, start) {
+ for (let i = start; i < mappings.length; i++) {
+ if (!isSorted(mappings[i])) return i;
+ }
+ return mappings.length;
+}
+function isSorted(line) {
+ for (let j = 1; j < line.length; j++) {
+ if (line[j][COLUMN] < line[j - 1][COLUMN]) {
+ return false;
+ }
+ }
+ return true;
+}
+function sortSegments(line, owned) {
+ if (!owned) line = line.slice();
+ return line.sort(sortComparator);
+}
+function sortComparator(a, b) {
+ return a[COLUMN] - b[COLUMN];
+}
+
+// src/by-source.ts
+function buildBySources(decoded, memos) {
+ const sources = memos.map(() => []);
+ for (let i = 0; i < decoded.length; i++) {
+ const line = decoded[i];
+ for (let j = 0; j < line.length; j++) {
+ const seg = line[j];
+ if (seg.length === 1) continue;
+ const sourceIndex2 = seg[SOURCES_INDEX];
+ const sourceLine = seg[SOURCE_LINE];
+ const sourceColumn = seg[SOURCE_COLUMN];
+ const source = sources[sourceIndex2];
+ const segs = source[sourceLine] || (source[sourceLine] = []);
+ segs.push([sourceColumn, i, seg[COLUMN]]);
+ }
+ }
+ for (let i = 0; i < sources.length; i++) {
+ const source = sources[i];
+ for (let j = 0; j < source.length; j++) {
+ const line = source[j];
+ if (line) line.sort(sortComparator);
+ }
+ }
+ return sources;
+}
+
+// src/binary-search.ts
+var found = false;
+function binarySearch(haystack, needle, low, high) {
+ while (low <= high) {
+ const mid = low + (high - low >> 1);
+ const cmp = haystack[mid][COLUMN] - needle;
+ if (cmp === 0) {
+ found = true;
+ return mid;
+ }
+ if (cmp < 0) {
+ low = mid + 1;
+ } else {
+ high = mid - 1;
+ }
+ }
+ found = false;
+ return low - 1;
+}
+function upperBound(haystack, needle, index) {
+ for (let i = index + 1; i < haystack.length; index = i++) {
+ if (haystack[i][COLUMN] !== needle) break;
+ }
+ return index;
+}
+function lowerBound(haystack, needle, index) {
+ for (let i = index - 1; i >= 0; index = i--) {
+ if (haystack[i][COLUMN] !== needle) break;
+ }
+ return index;
+}
+function memoizedState() {
+ return {
+ lastKey: -1,
+ lastNeedle: -1,
+ lastIndex: -1
+ };
+}
+function memoizedBinarySearch(haystack, needle, state, key) {
+ const { lastKey, lastNeedle, lastIndex } = state;
+ let low = 0;
+ let high = haystack.length - 1;
+ if (key === lastKey) {
+ if (needle === lastNeedle) {
+ found = lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle;
+ return lastIndex;
+ }
+ if (needle >= lastNeedle) {
+ low = lastIndex === -1 ? 0 : lastIndex;
+ } else {
+ high = lastIndex;
+ }
+ }
+ state.lastKey = key;
+ state.lastNeedle = needle;
+ return state.lastIndex = binarySearch(haystack, needle, low, high);
+}
+
+// src/types.ts
+function parse(map) {
+ return typeof map === "string" ? JSON.parse(map) : map;
+}
+
+// src/flatten-map.ts
+var FlattenMap = function(map, mapUrl) {
+ const parsed = parse(map);
+ if (!("sections" in parsed)) {
+ return new TraceMap(parsed, mapUrl);
+ }
+ const mappings = [];
+ const sources = [];
+ const sourcesContent = [];
+ const names = [];
+ const ignoreList = [];
+ recurse(
+ parsed,
+ mapUrl,
+ mappings,
+ sources,
+ sourcesContent,
+ names,
+ ignoreList,
+ 0,
+ 0,
+ Infinity,
+ Infinity
+ );
+ const joined = {
+ version: 3,
+ file: parsed.file,
+ names,
+ sources,
+ sourcesContent,
+ mappings,
+ ignoreList
+ };
+ return presortedDecodedMap(joined);
+};
+function recurse(input, mapUrl, mappings, sources, sourcesContent, names, ignoreList, lineOffset, columnOffset, stopLine, stopColumn) {
+ const { sections } = input;
+ for (let i = 0; i < sections.length; i++) {
+ const { map, offset } = sections[i];
+ let sl = stopLine;
+ let sc = stopColumn;
+ if (i + 1 < sections.length) {
+ const nextOffset = sections[i + 1].offset;
+ sl = Math.min(stopLine, lineOffset + nextOffset.line);
+ if (sl === stopLine) {
+ sc = Math.min(stopColumn, columnOffset + nextOffset.column);
+ } else if (sl < stopLine) {
+ sc = columnOffset + nextOffset.column;
+ }
+ }
+ addSection(
+ map,
+ mapUrl,
+ mappings,
+ sources,
+ sourcesContent,
+ names,
+ ignoreList,
+ lineOffset + offset.line,
+ columnOffset + offset.column,
+ sl,
+ sc
+ );
+ }
+}
+function addSection(input, mapUrl, mappings, sources, sourcesContent, names, ignoreList, lineOffset, columnOffset, stopLine, stopColumn) {
+ const parsed = parse(input);
+ if ("sections" in parsed) return recurse(...arguments);
+ const map = new TraceMap(parsed, mapUrl);
+ const sourcesOffset = sources.length;
+ const namesOffset = names.length;
+ const decoded = decodedMappings(map);
+ const { resolvedSources, sourcesContent: contents, ignoreList: ignores } = map;
+ append(sources, resolvedSources);
+ append(names, map.names);
+ if (contents) append(sourcesContent, contents);
+ else for (let i = 0; i < resolvedSources.length; i++) sourcesContent.push(null);
+ if (ignores) for (let i = 0; i < ignores.length; i++) ignoreList.push(ignores[i] + sourcesOffset);
+ for (let i = 0; i < decoded.length; i++) {
+ const lineI = lineOffset + i;
+ if (lineI > stopLine) return;
+ const out = getLine(mappings, lineI);
+ const cOffset = i === 0 ? columnOffset : 0;
+ const line = decoded[i];
+ for (let j = 0; j < line.length; j++) {
+ const seg = line[j];
+ const column = cOffset + seg[COLUMN];
+ if (lineI === stopLine && column >= stopColumn) return;
+ if (seg.length === 1) {
+ out.push([column]);
+ continue;
+ }
+ const sourcesIndex = sourcesOffset + seg[SOURCES_INDEX];
+ const sourceLine = seg[SOURCE_LINE];
+ const sourceColumn = seg[SOURCE_COLUMN];
+ out.push(
+ seg.length === 4 ? [column, sourcesIndex, sourceLine, sourceColumn] : [column, sourcesIndex, sourceLine, sourceColumn, namesOffset + seg[NAMES_INDEX]]
+ );
+ }
+ }
+}
+function append(arr, other) {
+ for (let i = 0; i < other.length; i++) arr.push(other[i]);
+}
+function getLine(arr, index) {
+ for (let i = arr.length; i <= index; i++) arr[i] = [];
+ return arr[index];
+}
+
+// src/trace-mapping.ts
+var LINE_GTR_ZERO = "`line` must be greater than 0 (lines start at line 1)";
+var COL_GTR_EQ_ZERO = "`column` must be greater than or equal to 0 (columns start at column 0)";
+var LEAST_UPPER_BOUND = -1;
+var GREATEST_LOWER_BOUND = 1;
+var TraceMap = class {
+ constructor(map, mapUrl) {
+ const isString = typeof map === "string";
+ if (!isString && map._decodedMemo) return map;
+ const parsed = parse(map);
+ const { version, file, names, sourceRoot, sources, sourcesContent } = parsed;
+ this.version = version;
+ this.file = file;
+ this.names = names || [];
+ this.sourceRoot = sourceRoot;
+ this.sources = sources;
+ this.sourcesContent = sourcesContent;
+ this.ignoreList = parsed.ignoreList || parsed.x_google_ignoreList || void 0;
+ const resolve = resolver(mapUrl, sourceRoot);
+ this.resolvedSources = sources.map(resolve);
+ const { mappings } = parsed;
+ if (typeof mappings === "string") {
+ this._encoded = mappings;
+ this._decoded = void 0;
+ } else if (Array.isArray(mappings)) {
+ this._encoded = void 0;
+ this._decoded = maybeSort(mappings, isString);
+ } else if (parsed.sections) {
+ throw new Error(`TraceMap passed sectioned source map, please use FlattenMap export instead`);
+ } else {
+ throw new Error(`invalid source map: ${JSON.stringify(parsed)}`);
+ }
+ this._decodedMemo = memoizedState();
+ this._bySources = void 0;
+ this._bySourceMemos = void 0;
+ }
+};
+function cast(map) {
+ return map;
+}
+function encodedMappings(map) {
+ var _a, _b;
+ return (_b = (_a = cast(map))._encoded) != null ? _b : _a._encoded = encode(cast(map)._decoded);
+}
+function decodedMappings(map) {
+ var _a;
+ return (_a = cast(map))._decoded || (_a._decoded = decode(cast(map)._encoded));
+}
+function traceSegment(map, line, column) {
+ const decoded = decodedMappings(map);
+ if (line >= decoded.length) return null;
+ const segments = decoded[line];
+ const index = traceSegmentInternal(
+ segments,
+ cast(map)._decodedMemo,
+ line,
+ column,
+ GREATEST_LOWER_BOUND
+ );
+ return index === -1 ? null : segments[index];
+}
+function originalPositionFor(map, needle) {
+ let { line, column, bias } = needle;
+ line--;
+ if (line < 0) throw new Error(LINE_GTR_ZERO);
+ if (column < 0) throw new Error(COL_GTR_EQ_ZERO);
+ const decoded = decodedMappings(map);
+ if (line >= decoded.length) return OMapping(null, null, null, null);
+ const segments = decoded[line];
+ const index = traceSegmentInternal(
+ segments,
+ cast(map)._decodedMemo,
+ line,
+ column,
+ bias || GREATEST_LOWER_BOUND
+ );
+ if (index === -1) return OMapping(null, null, null, null);
+ const segment = segments[index];
+ if (segment.length === 1) return OMapping(null, null, null, null);
+ const { names, resolvedSources } = map;
+ return OMapping(
+ resolvedSources[segment[SOURCES_INDEX]],
+ segment[SOURCE_LINE] + 1,
+ segment[SOURCE_COLUMN],
+ segment.length === 5 ? names[segment[NAMES_INDEX]] : null
+ );
+}
+function generatedPositionFor(map, needle) {
+ const { source, line, column, bias } = needle;
+ return generatedPosition(map, source, line, column, bias || GREATEST_LOWER_BOUND, false);
+}
+function allGeneratedPositionsFor(map, needle) {
+ const { source, line, column, bias } = needle;
+ return generatedPosition(map, source, line, column, bias || LEAST_UPPER_BOUND, true);
+}
+function eachMapping(map, cb) {
+ const decoded = decodedMappings(map);
+ const { names, resolvedSources } = map;
+ for (let i = 0; i < decoded.length; i++) {
+ const line = decoded[i];
+ for (let j = 0; j < line.length; j++) {
+ const seg = line[j];
+ const generatedLine = i + 1;
+ const generatedColumn = seg[0];
+ let source = null;
+ let originalLine = null;
+ let originalColumn = null;
+ let name = null;
+ if (seg.length !== 1) {
+ source = resolvedSources[seg[1]];
+ originalLine = seg[2] + 1;
+ originalColumn = seg[3];
+ }
+ if (seg.length === 5) name = names[seg[4]];
+ cb({
+ generatedLine,
+ generatedColumn,
+ source,
+ originalLine,
+ originalColumn,
+ name
+ });
+ }
+ }
+}
+function sourceIndex(map, source) {
+ const { sources, resolvedSources } = map;
+ let index = sources.indexOf(source);
+ if (index === -1) index = resolvedSources.indexOf(source);
+ return index;
+}
+function sourceContentFor(map, source) {
+ const { sourcesContent } = map;
+ if (sourcesContent == null) return null;
+ const index = sourceIndex(map, source);
+ return index === -1 ? null : sourcesContent[index];
+}
+function isIgnored(map, source) {
+ const { ignoreList } = map;
+ if (ignoreList == null) return false;
+ const index = sourceIndex(map, source);
+ return index === -1 ? false : ignoreList.includes(index);
+}
+function presortedDecodedMap(map, mapUrl) {
+ const tracer = new TraceMap(clone(map, []), mapUrl);
+ cast(tracer)._decoded = map.mappings;
+ return tracer;
+}
+function decodedMap(map) {
+ return clone(map, decodedMappings(map));
+}
+function encodedMap(map) {
+ return clone(map, encodedMappings(map));
+}
+function clone(map, mappings) {
+ return {
+ version: map.version,
+ file: map.file,
+ names: map.names,
+ sourceRoot: map.sourceRoot,
+ sources: map.sources,
+ sourcesContent: map.sourcesContent,
+ mappings,
+ ignoreList: map.ignoreList || map.x_google_ignoreList
+ };
+}
+function OMapping(source, line, column, name) {
+ return { source, line, column, name };
+}
+function GMapping(line, column) {
+ return { line, column };
+}
+function traceSegmentInternal(segments, memo, line, column, bias) {
+ let index = memoizedBinarySearch(segments, column, memo, line);
+ if (found) {
+ index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index);
+ } else if (bias === LEAST_UPPER_BOUND) index++;
+ if (index === -1 || index === segments.length) return -1;
+ return index;
+}
+function sliceGeneratedPositions(segments, memo, line, column, bias) {
+ let min = traceSegmentInternal(segments, memo, line, column, GREATEST_LOWER_BOUND);
+ if (!found && bias === LEAST_UPPER_BOUND) min++;
+ if (min === -1 || min === segments.length) return [];
+ const matchedColumn = found ? column : segments[min][COLUMN];
+ if (!found) min = lowerBound(segments, matchedColumn, min);
+ const max = upperBound(segments, matchedColumn, min);
+ const result = [];
+ for (; min <= max; min++) {
+ const segment = segments[min];
+ result.push(GMapping(segment[REV_GENERATED_LINE] + 1, segment[REV_GENERATED_COLUMN]));
+ }
+ return result;
+}
+function generatedPosition(map, source, line, column, bias, all) {
+ var _a, _b;
+ line--;
+ if (line < 0) throw new Error(LINE_GTR_ZERO);
+ if (column < 0) throw new Error(COL_GTR_EQ_ZERO);
+ const { sources, resolvedSources } = map;
+ let sourceIndex2 = sources.indexOf(source);
+ if (sourceIndex2 === -1) sourceIndex2 = resolvedSources.indexOf(source);
+ if (sourceIndex2 === -1) return all ? [] : GMapping(null, null);
+ const bySourceMemos = (_a = cast(map))._bySourceMemos || (_a._bySourceMemos = sources.map(memoizedState));
+ const generated = (_b = cast(map))._bySources || (_b._bySources = buildBySources(decodedMappings(map), bySourceMemos));
+ const segments = generated[sourceIndex2][line];
+ if (segments == null) return all ? [] : GMapping(null, null);
+ const memo = bySourceMemos[sourceIndex2];
+ if (all) return sliceGeneratedPositions(segments, memo, line, column, bias);
+ const index = traceSegmentInternal(segments, memo, line, column, bias);
+ if (index === -1) return GMapping(null, null);
+ const segment = segments[index];
+ return GMapping(segment[REV_GENERATED_LINE] + 1, segment[REV_GENERATED_COLUMN]);
+}
+export {
+ FlattenMap as AnyMap,
+ FlattenMap,
+ GREATEST_LOWER_BOUND,
+ LEAST_UPPER_BOUND,
+ TraceMap,
+ allGeneratedPositionsFor,
+ decodedMap,
+ decodedMappings,
+ eachMapping,
+ encodedMap,
+ encodedMappings,
+ generatedPositionFor,
+ isIgnored,
+ originalPositionFor,
+ presortedDecodedMap,
+ sourceContentFor,
+ traceSegment
+};
+//# sourceMappingURL=trace-mapping.mjs.map
diff --git a/sdk/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs.map b/sdk/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs.map
new file mode 100644
index 00000000..a7895814
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs.map
@@ -0,0 +1,6 @@
+{
+ "version": 3,
+ "sources": ["../src/trace-mapping.ts", "../src/resolve.ts", "../src/strip-filename.ts", "../src/sourcemap-segment.ts", "../src/sort.ts", "../src/by-source.ts", "../src/binary-search.ts", "../src/types.ts", "../src/flatten-map.ts"],
+ "mappings": "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",
+ "names": ["sourceIndex", "sourceIndex"]
+}
diff --git a/sdk/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.umd.js b/sdk/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.umd.js
new file mode 100644
index 00000000..0387ae38
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.umd.js
@@ -0,0 +1,559 @@
+(function (global, factory) {
+ if (typeof exports === 'object' && typeof module !== 'undefined') {
+ factory(module, require('@jridgewell/resolve-uri'), require('@jridgewell/sourcemap-codec'));
+ module.exports = def(module);
+ } else if (typeof define === 'function' && define.amd) {
+ define(['module', '@jridgewell/resolve-uri', '@jridgewell/sourcemap-codec'], function(mod) {
+ factory.apply(this, arguments);
+ mod.exports = def(mod);
+ });
+ } else {
+ const mod = { exports: {} };
+ factory(mod, global.resolveURI, global.sourcemapCodec);
+ global = typeof globalThis !== 'undefined' ? globalThis : global || self;
+ global.traceMapping = def(mod);
+ }
+ function def(m) { return 'default' in m.exports ? m.exports.default : m.exports; }
+})(this, (function (module, require_resolveURI, require_sourcemapCodec) {
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+ return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+ for (var name in all)
+ __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+ if (from && typeof from === "object" || typeof from === "function") {
+ for (let key of __getOwnPropNames(from))
+ if (!__hasOwnProp.call(to, key) && key !== except)
+ __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+ }
+ return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+ // If the importer is in node compatibility mode or this is not an ESM
+ // file that has been converted to a CommonJS file using a Babel-
+ // compatible transform (i.e. "__esModule" has not been set), then set
+ // "default" to the CommonJS "module.exports" for node compatibility.
+ isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+ mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// umd:@jridgewell/sourcemap-codec
+var require_sourcemap_codec = __commonJS({
+ "umd:@jridgewell/sourcemap-codec"(exports, module2) {
+ module2.exports = require_sourcemapCodec;
+ }
+});
+
+// umd:@jridgewell/resolve-uri
+var require_resolve_uri = __commonJS({
+ "umd:@jridgewell/resolve-uri"(exports, module2) {
+ module2.exports = require_resolveURI;
+ }
+});
+
+// src/trace-mapping.ts
+var trace_mapping_exports = {};
+__export(trace_mapping_exports, {
+ AnyMap: () => FlattenMap,
+ FlattenMap: () => FlattenMap,
+ GREATEST_LOWER_BOUND: () => GREATEST_LOWER_BOUND,
+ LEAST_UPPER_BOUND: () => LEAST_UPPER_BOUND,
+ TraceMap: () => TraceMap,
+ allGeneratedPositionsFor: () => allGeneratedPositionsFor,
+ decodedMap: () => decodedMap,
+ decodedMappings: () => decodedMappings,
+ eachMapping: () => eachMapping,
+ encodedMap: () => encodedMap,
+ encodedMappings: () => encodedMappings,
+ generatedPositionFor: () => generatedPositionFor,
+ isIgnored: () => isIgnored,
+ originalPositionFor: () => originalPositionFor,
+ presortedDecodedMap: () => presortedDecodedMap,
+ sourceContentFor: () => sourceContentFor,
+ traceSegment: () => traceSegment
+});
+module.exports = __toCommonJS(trace_mapping_exports);
+var import_sourcemap_codec = __toESM(require_sourcemap_codec());
+
+// src/resolve.ts
+var import_resolve_uri = __toESM(require_resolve_uri());
+
+// src/strip-filename.ts
+function stripFilename(path) {
+ if (!path) return "";
+ const index = path.lastIndexOf("/");
+ return path.slice(0, index + 1);
+}
+
+// src/resolve.ts
+function resolver(mapUrl, sourceRoot) {
+ const from = stripFilename(mapUrl);
+ const prefix = sourceRoot ? sourceRoot + "/" : "";
+ return (source) => (0, import_resolve_uri.default)(prefix + (source || ""), from);
+}
+
+// src/sourcemap-segment.ts
+var COLUMN = 0;
+var SOURCES_INDEX = 1;
+var SOURCE_LINE = 2;
+var SOURCE_COLUMN = 3;
+var NAMES_INDEX = 4;
+var REV_GENERATED_LINE = 1;
+var REV_GENERATED_COLUMN = 2;
+
+// src/sort.ts
+function maybeSort(mappings, owned) {
+ const unsortedIndex = nextUnsortedSegmentLine(mappings, 0);
+ if (unsortedIndex === mappings.length) return mappings;
+ if (!owned) mappings = mappings.slice();
+ for (let i = unsortedIndex; i < mappings.length; i = nextUnsortedSegmentLine(mappings, i + 1)) {
+ mappings[i] = sortSegments(mappings[i], owned);
+ }
+ return mappings;
+}
+function nextUnsortedSegmentLine(mappings, start) {
+ for (let i = start; i < mappings.length; i++) {
+ if (!isSorted(mappings[i])) return i;
+ }
+ return mappings.length;
+}
+function isSorted(line) {
+ for (let j = 1; j < line.length; j++) {
+ if (line[j][COLUMN] < line[j - 1][COLUMN]) {
+ return false;
+ }
+ }
+ return true;
+}
+function sortSegments(line, owned) {
+ if (!owned) line = line.slice();
+ return line.sort(sortComparator);
+}
+function sortComparator(a, b) {
+ return a[COLUMN] - b[COLUMN];
+}
+
+// src/by-source.ts
+function buildBySources(decoded, memos) {
+ const sources = memos.map(() => []);
+ for (let i = 0; i < decoded.length; i++) {
+ const line = decoded[i];
+ for (let j = 0; j < line.length; j++) {
+ const seg = line[j];
+ if (seg.length === 1) continue;
+ const sourceIndex2 = seg[SOURCES_INDEX];
+ const sourceLine = seg[SOURCE_LINE];
+ const sourceColumn = seg[SOURCE_COLUMN];
+ const source = sources[sourceIndex2];
+ const segs = source[sourceLine] || (source[sourceLine] = []);
+ segs.push([sourceColumn, i, seg[COLUMN]]);
+ }
+ }
+ for (let i = 0; i < sources.length; i++) {
+ const source = sources[i];
+ for (let j = 0; j < source.length; j++) {
+ const line = source[j];
+ if (line) line.sort(sortComparator);
+ }
+ }
+ return sources;
+}
+
+// src/binary-search.ts
+var found = false;
+function binarySearch(haystack, needle, low, high) {
+ while (low <= high) {
+ const mid = low + (high - low >> 1);
+ const cmp = haystack[mid][COLUMN] - needle;
+ if (cmp === 0) {
+ found = true;
+ return mid;
+ }
+ if (cmp < 0) {
+ low = mid + 1;
+ } else {
+ high = mid - 1;
+ }
+ }
+ found = false;
+ return low - 1;
+}
+function upperBound(haystack, needle, index) {
+ for (let i = index + 1; i < haystack.length; index = i++) {
+ if (haystack[i][COLUMN] !== needle) break;
+ }
+ return index;
+}
+function lowerBound(haystack, needle, index) {
+ for (let i = index - 1; i >= 0; index = i--) {
+ if (haystack[i][COLUMN] !== needle) break;
+ }
+ return index;
+}
+function memoizedState() {
+ return {
+ lastKey: -1,
+ lastNeedle: -1,
+ lastIndex: -1
+ };
+}
+function memoizedBinarySearch(haystack, needle, state, key) {
+ const { lastKey, lastNeedle, lastIndex } = state;
+ let low = 0;
+ let high = haystack.length - 1;
+ if (key === lastKey) {
+ if (needle === lastNeedle) {
+ found = lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle;
+ return lastIndex;
+ }
+ if (needle >= lastNeedle) {
+ low = lastIndex === -1 ? 0 : lastIndex;
+ } else {
+ high = lastIndex;
+ }
+ }
+ state.lastKey = key;
+ state.lastNeedle = needle;
+ return state.lastIndex = binarySearch(haystack, needle, low, high);
+}
+
+// src/types.ts
+function parse(map) {
+ return typeof map === "string" ? JSON.parse(map) : map;
+}
+
+// src/flatten-map.ts
+var FlattenMap = function(map, mapUrl) {
+ const parsed = parse(map);
+ if (!("sections" in parsed)) {
+ return new TraceMap(parsed, mapUrl);
+ }
+ const mappings = [];
+ const sources = [];
+ const sourcesContent = [];
+ const names = [];
+ const ignoreList = [];
+ recurse(
+ parsed,
+ mapUrl,
+ mappings,
+ sources,
+ sourcesContent,
+ names,
+ ignoreList,
+ 0,
+ 0,
+ Infinity,
+ Infinity
+ );
+ const joined = {
+ version: 3,
+ file: parsed.file,
+ names,
+ sources,
+ sourcesContent,
+ mappings,
+ ignoreList
+ };
+ return presortedDecodedMap(joined);
+};
+function recurse(input, mapUrl, mappings, sources, sourcesContent, names, ignoreList, lineOffset, columnOffset, stopLine, stopColumn) {
+ const { sections } = input;
+ for (let i = 0; i < sections.length; i++) {
+ const { map, offset } = sections[i];
+ let sl = stopLine;
+ let sc = stopColumn;
+ if (i + 1 < sections.length) {
+ const nextOffset = sections[i + 1].offset;
+ sl = Math.min(stopLine, lineOffset + nextOffset.line);
+ if (sl === stopLine) {
+ sc = Math.min(stopColumn, columnOffset + nextOffset.column);
+ } else if (sl < stopLine) {
+ sc = columnOffset + nextOffset.column;
+ }
+ }
+ addSection(
+ map,
+ mapUrl,
+ mappings,
+ sources,
+ sourcesContent,
+ names,
+ ignoreList,
+ lineOffset + offset.line,
+ columnOffset + offset.column,
+ sl,
+ sc
+ );
+ }
+}
+function addSection(input, mapUrl, mappings, sources, sourcesContent, names, ignoreList, lineOffset, columnOffset, stopLine, stopColumn) {
+ const parsed = parse(input);
+ if ("sections" in parsed) return recurse(...arguments);
+ const map = new TraceMap(parsed, mapUrl);
+ const sourcesOffset = sources.length;
+ const namesOffset = names.length;
+ const decoded = decodedMappings(map);
+ const { resolvedSources, sourcesContent: contents, ignoreList: ignores } = map;
+ append(sources, resolvedSources);
+ append(names, map.names);
+ if (contents) append(sourcesContent, contents);
+ else for (let i = 0; i < resolvedSources.length; i++) sourcesContent.push(null);
+ if (ignores) for (let i = 0; i < ignores.length; i++) ignoreList.push(ignores[i] + sourcesOffset);
+ for (let i = 0; i < decoded.length; i++) {
+ const lineI = lineOffset + i;
+ if (lineI > stopLine) return;
+ const out = getLine(mappings, lineI);
+ const cOffset = i === 0 ? columnOffset : 0;
+ const line = decoded[i];
+ for (let j = 0; j < line.length; j++) {
+ const seg = line[j];
+ const column = cOffset + seg[COLUMN];
+ if (lineI === stopLine && column >= stopColumn) return;
+ if (seg.length === 1) {
+ out.push([column]);
+ continue;
+ }
+ const sourcesIndex = sourcesOffset + seg[SOURCES_INDEX];
+ const sourceLine = seg[SOURCE_LINE];
+ const sourceColumn = seg[SOURCE_COLUMN];
+ out.push(
+ seg.length === 4 ? [column, sourcesIndex, sourceLine, sourceColumn] : [column, sourcesIndex, sourceLine, sourceColumn, namesOffset + seg[NAMES_INDEX]]
+ );
+ }
+ }
+}
+function append(arr, other) {
+ for (let i = 0; i < other.length; i++) arr.push(other[i]);
+}
+function getLine(arr, index) {
+ for (let i = arr.length; i <= index; i++) arr[i] = [];
+ return arr[index];
+}
+
+// src/trace-mapping.ts
+var LINE_GTR_ZERO = "`line` must be greater than 0 (lines start at line 1)";
+var COL_GTR_EQ_ZERO = "`column` must be greater than or equal to 0 (columns start at column 0)";
+var LEAST_UPPER_BOUND = -1;
+var GREATEST_LOWER_BOUND = 1;
+var TraceMap = class {
+ constructor(map, mapUrl) {
+ const isString = typeof map === "string";
+ if (!isString && map._decodedMemo) return map;
+ const parsed = parse(map);
+ const { version, file, names, sourceRoot, sources, sourcesContent } = parsed;
+ this.version = version;
+ this.file = file;
+ this.names = names || [];
+ this.sourceRoot = sourceRoot;
+ this.sources = sources;
+ this.sourcesContent = sourcesContent;
+ this.ignoreList = parsed.ignoreList || parsed.x_google_ignoreList || void 0;
+ const resolve = resolver(mapUrl, sourceRoot);
+ this.resolvedSources = sources.map(resolve);
+ const { mappings } = parsed;
+ if (typeof mappings === "string") {
+ this._encoded = mappings;
+ this._decoded = void 0;
+ } else if (Array.isArray(mappings)) {
+ this._encoded = void 0;
+ this._decoded = maybeSort(mappings, isString);
+ } else if (parsed.sections) {
+ throw new Error(`TraceMap passed sectioned source map, please use FlattenMap export instead`);
+ } else {
+ throw new Error(`invalid source map: ${JSON.stringify(parsed)}`);
+ }
+ this._decodedMemo = memoizedState();
+ this._bySources = void 0;
+ this._bySourceMemos = void 0;
+ }
+};
+function cast(map) {
+ return map;
+}
+function encodedMappings(map) {
+ var _a, _b;
+ return (_b = (_a = cast(map))._encoded) != null ? _b : _a._encoded = (0, import_sourcemap_codec.encode)(cast(map)._decoded);
+}
+function decodedMappings(map) {
+ var _a;
+ return (_a = cast(map))._decoded || (_a._decoded = (0, import_sourcemap_codec.decode)(cast(map)._encoded));
+}
+function traceSegment(map, line, column) {
+ const decoded = decodedMappings(map);
+ if (line >= decoded.length) return null;
+ const segments = decoded[line];
+ const index = traceSegmentInternal(
+ segments,
+ cast(map)._decodedMemo,
+ line,
+ column,
+ GREATEST_LOWER_BOUND
+ );
+ return index === -1 ? null : segments[index];
+}
+function originalPositionFor(map, needle) {
+ let { line, column, bias } = needle;
+ line--;
+ if (line < 0) throw new Error(LINE_GTR_ZERO);
+ if (column < 0) throw new Error(COL_GTR_EQ_ZERO);
+ const decoded = decodedMappings(map);
+ if (line >= decoded.length) return OMapping(null, null, null, null);
+ const segments = decoded[line];
+ const index = traceSegmentInternal(
+ segments,
+ cast(map)._decodedMemo,
+ line,
+ column,
+ bias || GREATEST_LOWER_BOUND
+ );
+ if (index === -1) return OMapping(null, null, null, null);
+ const segment = segments[index];
+ if (segment.length === 1) return OMapping(null, null, null, null);
+ const { names, resolvedSources } = map;
+ return OMapping(
+ resolvedSources[segment[SOURCES_INDEX]],
+ segment[SOURCE_LINE] + 1,
+ segment[SOURCE_COLUMN],
+ segment.length === 5 ? names[segment[NAMES_INDEX]] : null
+ );
+}
+function generatedPositionFor(map, needle) {
+ const { source, line, column, bias } = needle;
+ return generatedPosition(map, source, line, column, bias || GREATEST_LOWER_BOUND, false);
+}
+function allGeneratedPositionsFor(map, needle) {
+ const { source, line, column, bias } = needle;
+ return generatedPosition(map, source, line, column, bias || LEAST_UPPER_BOUND, true);
+}
+function eachMapping(map, cb) {
+ const decoded = decodedMappings(map);
+ const { names, resolvedSources } = map;
+ for (let i = 0; i < decoded.length; i++) {
+ const line = decoded[i];
+ for (let j = 0; j < line.length; j++) {
+ const seg = line[j];
+ const generatedLine = i + 1;
+ const generatedColumn = seg[0];
+ let source = null;
+ let originalLine = null;
+ let originalColumn = null;
+ let name = null;
+ if (seg.length !== 1) {
+ source = resolvedSources[seg[1]];
+ originalLine = seg[2] + 1;
+ originalColumn = seg[3];
+ }
+ if (seg.length === 5) name = names[seg[4]];
+ cb({
+ generatedLine,
+ generatedColumn,
+ source,
+ originalLine,
+ originalColumn,
+ name
+ });
+ }
+ }
+}
+function sourceIndex(map, source) {
+ const { sources, resolvedSources } = map;
+ let index = sources.indexOf(source);
+ if (index === -1) index = resolvedSources.indexOf(source);
+ return index;
+}
+function sourceContentFor(map, source) {
+ const { sourcesContent } = map;
+ if (sourcesContent == null) return null;
+ const index = sourceIndex(map, source);
+ return index === -1 ? null : sourcesContent[index];
+}
+function isIgnored(map, source) {
+ const { ignoreList } = map;
+ if (ignoreList == null) return false;
+ const index = sourceIndex(map, source);
+ return index === -1 ? false : ignoreList.includes(index);
+}
+function presortedDecodedMap(map, mapUrl) {
+ const tracer = new TraceMap(clone(map, []), mapUrl);
+ cast(tracer)._decoded = map.mappings;
+ return tracer;
+}
+function decodedMap(map) {
+ return clone(map, decodedMappings(map));
+}
+function encodedMap(map) {
+ return clone(map, encodedMappings(map));
+}
+function clone(map, mappings) {
+ return {
+ version: map.version,
+ file: map.file,
+ names: map.names,
+ sourceRoot: map.sourceRoot,
+ sources: map.sources,
+ sourcesContent: map.sourcesContent,
+ mappings,
+ ignoreList: map.ignoreList || map.x_google_ignoreList
+ };
+}
+function OMapping(source, line, column, name) {
+ return { source, line, column, name };
+}
+function GMapping(line, column) {
+ return { line, column };
+}
+function traceSegmentInternal(segments, memo, line, column, bias) {
+ let index = memoizedBinarySearch(segments, column, memo, line);
+ if (found) {
+ index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index);
+ } else if (bias === LEAST_UPPER_BOUND) index++;
+ if (index === -1 || index === segments.length) return -1;
+ return index;
+}
+function sliceGeneratedPositions(segments, memo, line, column, bias) {
+ let min = traceSegmentInternal(segments, memo, line, column, GREATEST_LOWER_BOUND);
+ if (!found && bias === LEAST_UPPER_BOUND) min++;
+ if (min === -1 || min === segments.length) return [];
+ const matchedColumn = found ? column : segments[min][COLUMN];
+ if (!found) min = lowerBound(segments, matchedColumn, min);
+ const max = upperBound(segments, matchedColumn, min);
+ const result = [];
+ for (; min <= max; min++) {
+ const segment = segments[min];
+ result.push(GMapping(segment[REV_GENERATED_LINE] + 1, segment[REV_GENERATED_COLUMN]));
+ }
+ return result;
+}
+function generatedPosition(map, source, line, column, bias, all) {
+ var _a, _b;
+ line--;
+ if (line < 0) throw new Error(LINE_GTR_ZERO);
+ if (column < 0) throw new Error(COL_GTR_EQ_ZERO);
+ const { sources, resolvedSources } = map;
+ let sourceIndex2 = sources.indexOf(source);
+ if (sourceIndex2 === -1) sourceIndex2 = resolvedSources.indexOf(source);
+ if (sourceIndex2 === -1) return all ? [] : GMapping(null, null);
+ const bySourceMemos = (_a = cast(map))._bySourceMemos || (_a._bySourceMemos = sources.map(memoizedState));
+ const generated = (_b = cast(map))._bySources || (_b._bySources = buildBySources(decodedMappings(map), bySourceMemos));
+ const segments = generated[sourceIndex2][line];
+ if (segments == null) return all ? [] : GMapping(null, null);
+ const memo = bySourceMemos[sourceIndex2];
+ if (all) return sliceGeneratedPositions(segments, memo, line, column, bias);
+ const index = traceSegmentInternal(segments, memo, line, column, bias);
+ if (index === -1) return GMapping(null, null);
+ const segment = segments[index];
+ return GMapping(segment[REV_GENERATED_LINE] + 1, segment[REV_GENERATED_COLUMN]);
+}
+}));
+//# sourceMappingURL=trace-mapping.umd.js.map
diff --git a/sdk/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.umd.js.map b/sdk/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.umd.js.map
new file mode 100644
index 00000000..68b0c775
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.umd.js.map
@@ -0,0 +1,6 @@
+{
+ "version": 3,
+ "sources": ["umd:@jridgewell/sourcemap-codec", "umd:@jridgewell/resolve-uri", "../src/trace-mapping.ts", "../src/resolve.ts", "../src/strip-filename.ts", "../src/sourcemap-segment.ts", "../src/sort.ts", "../src/by-source.ts", "../src/binary-search.ts", "../src/types.ts", "../src/flatten-map.ts"],
+ "mappings": "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",
+ "names": ["module", "module", "resolveUri", "sourceIndex", "sourceIndex"]
+}
diff --git a/sdk/node_modules/@jridgewell/trace-mapping/package.json b/sdk/node_modules/@jridgewell/trace-mapping/package.json
new file mode 100644
index 00000000..9d3a1c08
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/trace-mapping/package.json
@@ -0,0 +1,67 @@
+{
+ "name": "@jridgewell/trace-mapping",
+ "version": "0.3.31",
+ "description": "Trace the original position through a source map",
+ "keywords": [
+ "source",
+ "map"
+ ],
+ "main": "dist/trace-mapping.umd.js",
+ "module": "dist/trace-mapping.mjs",
+ "types": "types/trace-mapping.d.cts",
+ "files": [
+ "dist",
+ "src",
+ "types"
+ ],
+ "exports": {
+ ".": [
+ {
+ "import": {
+ "types": "./types/trace-mapping.d.mts",
+ "default": "./dist/trace-mapping.mjs"
+ },
+ "default": {
+ "types": "./types/trace-mapping.d.cts",
+ "default": "./dist/trace-mapping.umd.js"
+ }
+ },
+ "./dist/trace-mapping.umd.js"
+ ],
+ "./package.json": "./package.json"
+ },
+ "scripts": {
+ "benchmark": "run-s build:code benchmark:*",
+ "benchmark:install": "cd benchmark && npm install",
+ "benchmark:only": "node --expose-gc benchmark/index.mjs",
+ "build": "run-s -n build:code build:types",
+ "build:code": "node ../../esbuild.mjs trace-mapping.ts",
+ "build:types": "run-s build:types:force build:types:emit build:types:mts",
+ "build:types:force": "rimraf tsconfig.build.tsbuildinfo",
+ "build:types:emit": "tsc --project tsconfig.build.json",
+ "build:types:mts": "node ../../mts-types.mjs",
+ "clean": "run-s -n clean:code clean:types",
+ "clean:code": "tsc --build --clean tsconfig.build.json",
+ "clean:types": "rimraf dist types",
+ "test": "run-s -n test:types test:only test:format",
+ "test:format": "prettier --check '{src,test}/**/*.ts'",
+ "test:only": "mocha",
+ "test:types": "eslint '{src,test}/**/*.ts'",
+ "lint": "run-s -n lint:types lint:format",
+ "lint:format": "npm run test:format -- --write",
+ "lint:types": "npm run test:types -- --fix",
+ "prepublishOnly": "npm run-s -n build test"
+ },
+ "homepage": "https://github.com/jridgewell/sourcemaps/tree/main/packages/trace-mapping",
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/jridgewell/sourcemaps.git",
+ "directory": "packages/trace-mapping"
+ },
+ "author": "Justin Ridgewell ",
+ "license": "MIT",
+ "dependencies": {
+ "@jridgewell/resolve-uri": "^3.1.0",
+ "@jridgewell/sourcemap-codec": "^1.4.14"
+ }
+}
diff --git a/sdk/node_modules/@jridgewell/trace-mapping/src/binary-search.ts b/sdk/node_modules/@jridgewell/trace-mapping/src/binary-search.ts
new file mode 100644
index 00000000..c1144ad1
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/trace-mapping/src/binary-search.ts
@@ -0,0 +1,115 @@
+import type { SourceMapSegment, ReverseSegment } from './sourcemap-segment';
+import { COLUMN } from './sourcemap-segment';
+
+export type MemoState = {
+ lastKey: number;
+ lastNeedle: number;
+ lastIndex: number;
+};
+
+export let found = false;
+
+/**
+ * A binary search implementation that returns the index if a match is found.
+ * If no match is found, then the left-index (the index associated with the item that comes just
+ * before the desired index) is returned. To maintain proper sort order, a splice would happen at
+ * the next index:
+ *
+ * ```js
+ * const array = [1, 3];
+ * const needle = 2;
+ * const index = binarySearch(array, needle, (item, needle) => item - needle);
+ *
+ * assert.equal(index, 0);
+ * array.splice(index + 1, 0, needle);
+ * assert.deepEqual(array, [1, 2, 3]);
+ * ```
+ */
+export function binarySearch(
+ haystack: SourceMapSegment[] | ReverseSegment[],
+ needle: number,
+ low: number,
+ high: number,
+): number {
+ while (low <= high) {
+ const mid = low + ((high - low) >> 1);
+ const cmp = haystack[mid][COLUMN] - needle;
+
+ if (cmp === 0) {
+ found = true;
+ return mid;
+ }
+
+ if (cmp < 0) {
+ low = mid + 1;
+ } else {
+ high = mid - 1;
+ }
+ }
+
+ found = false;
+ return low - 1;
+}
+
+export function upperBound(
+ haystack: SourceMapSegment[] | ReverseSegment[],
+ needle: number,
+ index: number,
+): number {
+ for (let i = index + 1; i < haystack.length; index = i++) {
+ if (haystack[i][COLUMN] !== needle) break;
+ }
+ return index;
+}
+
+export function lowerBound(
+ haystack: SourceMapSegment[] | ReverseSegment[],
+ needle: number,
+ index: number,
+): number {
+ for (let i = index - 1; i >= 0; index = i--) {
+ if (haystack[i][COLUMN] !== needle) break;
+ }
+ return index;
+}
+
+export function memoizedState(): MemoState {
+ return {
+ lastKey: -1,
+ lastNeedle: -1,
+ lastIndex: -1,
+ };
+}
+
+/**
+ * This overly complicated beast is just to record the last tested line/column and the resulting
+ * index, allowing us to skip a few tests if mappings are monotonically increasing.
+ */
+export function memoizedBinarySearch(
+ haystack: SourceMapSegment[] | ReverseSegment[],
+ needle: number,
+ state: MemoState,
+ key: number,
+): number {
+ const { lastKey, lastNeedle, lastIndex } = state;
+
+ let low = 0;
+ let high = haystack.length - 1;
+ if (key === lastKey) {
+ if (needle === lastNeedle) {
+ found = lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle;
+ return lastIndex;
+ }
+
+ if (needle >= lastNeedle) {
+ // lastIndex may be -1 if the previous needle was not found.
+ low = lastIndex === -1 ? 0 : lastIndex;
+ } else {
+ high = lastIndex;
+ }
+ }
+ state.lastKey = key;
+ state.lastNeedle = needle;
+
+ return (state.lastIndex = binarySearch(haystack, needle, low, high));
+}
diff --git a/sdk/node_modules/@jridgewell/trace-mapping/src/by-source.ts b/sdk/node_modules/@jridgewell/trace-mapping/src/by-source.ts
new file mode 100644
index 00000000..1da6af05
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/trace-mapping/src/by-source.ts
@@ -0,0 +1,41 @@
+import { COLUMN, SOURCES_INDEX, SOURCE_LINE, SOURCE_COLUMN } from './sourcemap-segment';
+import { sortComparator } from './sort';
+
+import type { ReverseSegment, SourceMapSegment } from './sourcemap-segment';
+
+export type Source = ReverseSegment[][];
+
+// Rebuilds the original source files, with mappings that are ordered by source line/column instead
+// of generated line/column.
+export default function buildBySources(
+ decoded: readonly SourceMapSegment[][],
+ memos: unknown[],
+): Source[] {
+ const sources: Source[] = memos.map(() => []);
+
+ for (let i = 0; i < decoded.length; i++) {
+ const line = decoded[i];
+ for (let j = 0; j < line.length; j++) {
+ const seg = line[j];
+ if (seg.length === 1) continue;
+
+ const sourceIndex = seg[SOURCES_INDEX];
+ const sourceLine = seg[SOURCE_LINE];
+ const sourceColumn = seg[SOURCE_COLUMN];
+
+ const source = sources[sourceIndex];
+ const segs = (source[sourceLine] ||= []);
+ segs.push([sourceColumn, i, seg[COLUMN]]);
+ }
+ }
+
+ for (let i = 0; i < sources.length; i++) {
+ const source = sources[i];
+ for (let j = 0; j < source.length; j++) {
+ const line = source[j];
+ if (line) line.sort(sortComparator);
+ }
+ }
+
+ return sources;
+}
diff --git a/sdk/node_modules/@jridgewell/trace-mapping/src/flatten-map.ts b/sdk/node_modules/@jridgewell/trace-mapping/src/flatten-map.ts
new file mode 100644
index 00000000..61ac40ca
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/trace-mapping/src/flatten-map.ts
@@ -0,0 +1,192 @@
+import { TraceMap, presortedDecodedMap, decodedMappings } from './trace-mapping';
+import {
+ COLUMN,
+ SOURCES_INDEX,
+ SOURCE_LINE,
+ SOURCE_COLUMN,
+ NAMES_INDEX,
+} from './sourcemap-segment';
+import { parse } from './types';
+
+import type {
+ DecodedSourceMap,
+ DecodedSourceMapXInput,
+ EncodedSourceMapXInput,
+ SectionedSourceMapXInput,
+ SectionedSourceMapInput,
+ SectionXInput,
+ Ro,
+} from './types';
+import type { SourceMapSegment } from './sourcemap-segment';
+
+type FlattenMap = {
+ new (map: Ro, mapUrl?: string | null): TraceMap;
+ (map: Ro, mapUrl?: string | null): TraceMap;
+};
+
+export const FlattenMap: FlattenMap = function (map, mapUrl) {
+ const parsed = parse(map as SectionedSourceMapInput);
+
+ if (!('sections' in parsed)) {
+ return new TraceMap(parsed as DecodedSourceMapXInput | EncodedSourceMapXInput, mapUrl);
+ }
+
+ const mappings: SourceMapSegment[][] = [];
+ const sources: string[] = [];
+ const sourcesContent: (string | null)[] = [];
+ const names: string[] = [];
+ const ignoreList: number[] = [];
+
+ recurse(
+ parsed,
+ mapUrl,
+ mappings,
+ sources,
+ sourcesContent,
+ names,
+ ignoreList,
+ 0,
+ 0,
+ Infinity,
+ Infinity,
+ );
+
+ const joined: DecodedSourceMap = {
+ version: 3,
+ file: parsed.file,
+ names,
+ sources,
+ sourcesContent,
+ mappings,
+ ignoreList,
+ };
+
+ return presortedDecodedMap(joined);
+} as FlattenMap;
+
+function recurse(
+ input: SectionedSourceMapXInput,
+ mapUrl: string | null | undefined,
+ mappings: SourceMapSegment[][],
+ sources: string[],
+ sourcesContent: (string | null)[],
+ names: string[],
+ ignoreList: number[],
+ lineOffset: number,
+ columnOffset: number,
+ stopLine: number,
+ stopColumn: number,
+) {
+ const { sections } = input;
+ for (let i = 0; i < sections.length; i++) {
+ const { map, offset } = sections[i];
+
+ let sl = stopLine;
+ let sc = stopColumn;
+ if (i + 1 < sections.length) {
+ const nextOffset = sections[i + 1].offset;
+ sl = Math.min(stopLine, lineOffset + nextOffset.line);
+
+ if (sl === stopLine) {
+ sc = Math.min(stopColumn, columnOffset + nextOffset.column);
+ } else if (sl < stopLine) {
+ sc = columnOffset + nextOffset.column;
+ }
+ }
+
+ addSection(
+ map,
+ mapUrl,
+ mappings,
+ sources,
+ sourcesContent,
+ names,
+ ignoreList,
+ lineOffset + offset.line,
+ columnOffset + offset.column,
+ sl,
+ sc,
+ );
+ }
+}
+
+function addSection(
+ input: SectionXInput['map'],
+ mapUrl: string | null | undefined,
+ mappings: SourceMapSegment[][],
+ sources: string[],
+ sourcesContent: (string | null)[],
+ names: string[],
+ ignoreList: number[],
+ lineOffset: number,
+ columnOffset: number,
+ stopLine: number,
+ stopColumn: number,
+) {
+ const parsed = parse(input);
+ if ('sections' in parsed) return recurse(...(arguments as unknown as Parameters));
+
+ const map = new TraceMap(parsed, mapUrl);
+ const sourcesOffset = sources.length;
+ const namesOffset = names.length;
+ const decoded = decodedMappings(map);
+ const { resolvedSources, sourcesContent: contents, ignoreList: ignores } = map;
+
+ append(sources, resolvedSources);
+ append(names, map.names);
+
+ if (contents) append(sourcesContent, contents);
+ else for (let i = 0; i < resolvedSources.length; i++) sourcesContent.push(null);
+
+ if (ignores) for (let i = 0; i < ignores.length; i++) ignoreList.push(ignores[i] + sourcesOffset);
+
+ for (let i = 0; i < decoded.length; i++) {
+ const lineI = lineOffset + i;
+
+ // We can only add so many lines before we step into the range that the next section's map
+ // controls. When we get to the last line, then we'll start checking the segments to see if
+ // they've crossed into the column range. But it may not have any columns that overstep, so we
+ // still need to check that we don't overstep lines, too.
+ if (lineI > stopLine) return;
+
+ // The out line may already exist in mappings (if we're continuing the line started by a
+ // previous section). Or, we may have jumped ahead several lines to start this section.
+ const out = getLine(mappings, lineI);
+ // On the 0th loop, the section's column offset shifts us forward. On all other lines (since the
+ // map can be multiple lines), it doesn't.
+ const cOffset = i === 0 ? columnOffset : 0;
+
+ const line = decoded[i];
+ for (let j = 0; j < line.length; j++) {
+ const seg = line[j];
+ const column = cOffset + seg[COLUMN];
+
+ // If this segment steps into the column range that the next section's map controls, we need
+ // to stop early.
+ if (lineI === stopLine && column >= stopColumn) return;
+
+ if (seg.length === 1) {
+ out.push([column]);
+ continue;
+ }
+
+ const sourcesIndex = sourcesOffset + seg[SOURCES_INDEX];
+ const sourceLine = seg[SOURCE_LINE];
+ const sourceColumn = seg[SOURCE_COLUMN];
+ out.push(
+ seg.length === 4
+ ? [column, sourcesIndex, sourceLine, sourceColumn]
+ : [column, sourcesIndex, sourceLine, sourceColumn, namesOffset + seg[NAMES_INDEX]],
+ );
+ }
+ }
+}
+
+function append(arr: T[], other: T[]) {
+ for (let i = 0; i < other.length; i++) arr.push(other[i]);
+}
+
+function getLine(arr: T[][], index: number): T[] {
+ for (let i = arr.length; i <= index; i++) arr[i] = [];
+ return arr[index];
+}
diff --git a/sdk/node_modules/@jridgewell/trace-mapping/src/resolve.ts b/sdk/node_modules/@jridgewell/trace-mapping/src/resolve.ts
new file mode 100644
index 00000000..30bfa3b2
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/trace-mapping/src/resolve.ts
@@ -0,0 +1,16 @@
+import resolveUri from '@jridgewell/resolve-uri';
+import stripFilename from './strip-filename';
+
+type Resolve = (source: string | null) => string;
+export default function resolver(
+ mapUrl: string | null | undefined,
+ sourceRoot: string | undefined,
+): Resolve {
+ const from = stripFilename(mapUrl);
+ // The sourceRoot is always treated as a directory, if it's not empty.
+ // https://github.com/mozilla/source-map/blob/8cb3ee57/lib/util.js#L327
+ // https://github.com/chromium/chromium/blob/da4adbb3/third_party/blink/renderer/devtools/front_end/sdk/SourceMap.js#L400-L401
+ const prefix = sourceRoot ? sourceRoot + '/' : '';
+
+ return (source) => resolveUri(prefix + (source || ''), from);
+}
diff --git a/sdk/node_modules/@jridgewell/trace-mapping/src/sort.ts b/sdk/node_modules/@jridgewell/trace-mapping/src/sort.ts
new file mode 100644
index 00000000..5d016cb7
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/trace-mapping/src/sort.ts
@@ -0,0 +1,45 @@
+import { COLUMN } from './sourcemap-segment';
+
+import type { ReverseSegment, SourceMapSegment } from './sourcemap-segment';
+
+export default function maybeSort(
+ mappings: SourceMapSegment[][],
+ owned: boolean,
+): SourceMapSegment[][] {
+ const unsortedIndex = nextUnsortedSegmentLine(mappings, 0);
+ if (unsortedIndex === mappings.length) return mappings;
+
+ // If we own the array (meaning we parsed it from JSON), then we're free to directly mutate it. If
+ // not, we do not want to modify the consumer's input array.
+ if (!owned) mappings = mappings.slice();
+
+ for (let i = unsortedIndex; i < mappings.length; i = nextUnsortedSegmentLine(mappings, i + 1)) {
+ mappings[i] = sortSegments(mappings[i], owned);
+ }
+ return mappings;
+}
+
+function nextUnsortedSegmentLine(mappings: SourceMapSegment[][], start: number): number {
+ for (let i = start; i < mappings.length; i++) {
+ if (!isSorted(mappings[i])) return i;
+ }
+ return mappings.length;
+}
+
+function isSorted(line: SourceMapSegment[]): boolean {
+ for (let j = 1; j < line.length; j++) {
+ if (line[j][COLUMN] < line[j - 1][COLUMN]) {
+ return false;
+ }
+ }
+ return true;
+}
+
+function sortSegments(line: SourceMapSegment[], owned: boolean): SourceMapSegment[] {
+ if (!owned) line = line.slice();
+ return line.sort(sortComparator);
+}
+
+export function sortComparator(a: T, b: T): number {
+ return a[COLUMN] - b[COLUMN];
+}
diff --git a/sdk/node_modules/@jridgewell/trace-mapping/src/sourcemap-segment.ts b/sdk/node_modules/@jridgewell/trace-mapping/src/sourcemap-segment.ts
new file mode 100644
index 00000000..94f1b6ab
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/trace-mapping/src/sourcemap-segment.ts
@@ -0,0 +1,23 @@
+type GeneratedColumn = number;
+type SourcesIndex = number;
+type SourceLine = number;
+type SourceColumn = number;
+type NamesIndex = number;
+
+type GeneratedLine = number;
+
+export type SourceMapSegment =
+ | [GeneratedColumn]
+ | [GeneratedColumn, SourcesIndex, SourceLine, SourceColumn]
+ | [GeneratedColumn, SourcesIndex, SourceLine, SourceColumn, NamesIndex];
+
+export type ReverseSegment = [SourceColumn, GeneratedLine, GeneratedColumn];
+
+export const COLUMN = 0;
+export const SOURCES_INDEX = 1;
+export const SOURCE_LINE = 2;
+export const SOURCE_COLUMN = 3;
+export const NAMES_INDEX = 4;
+
+export const REV_GENERATED_LINE = 1;
+export const REV_GENERATED_COLUMN = 2;
diff --git a/sdk/node_modules/@jridgewell/trace-mapping/src/strip-filename.ts b/sdk/node_modules/@jridgewell/trace-mapping/src/strip-filename.ts
new file mode 100644
index 00000000..2c889800
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/trace-mapping/src/strip-filename.ts
@@ -0,0 +1,8 @@
+/**
+ * Removes everything after the last "/", but leaves the slash.
+ */
+export default function stripFilename(path: string | undefined | null): string {
+ if (!path) return '';
+ const index = path.lastIndexOf('/');
+ return path.slice(0, index + 1);
+}
diff --git a/sdk/node_modules/@jridgewell/trace-mapping/src/trace-mapping.ts b/sdk/node_modules/@jridgewell/trace-mapping/src/trace-mapping.ts
new file mode 100644
index 00000000..0b793d5b
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/trace-mapping/src/trace-mapping.ts
@@ -0,0 +1,502 @@
+import { encode, decode } from '@jridgewell/sourcemap-codec';
+
+import resolver from './resolve';
+import maybeSort from './sort';
+import buildBySources from './by-source';
+import {
+ memoizedState,
+ memoizedBinarySearch,
+ upperBound,
+ lowerBound,
+ found as bsFound,
+} from './binary-search';
+import {
+ COLUMN,
+ SOURCES_INDEX,
+ SOURCE_LINE,
+ SOURCE_COLUMN,
+ NAMES_INDEX,
+ REV_GENERATED_LINE,
+ REV_GENERATED_COLUMN,
+} from './sourcemap-segment';
+import { parse } from './types';
+
+import type { SourceMapSegment, ReverseSegment } from './sourcemap-segment';
+import type {
+ SourceMapV3,
+ DecodedSourceMap,
+ EncodedSourceMap,
+ InvalidOriginalMapping,
+ OriginalMapping,
+ InvalidGeneratedMapping,
+ GeneratedMapping,
+ SourceMapInput,
+ Needle,
+ SourceNeedle,
+ SourceMap,
+ EachMapping,
+ Bias,
+ XInput,
+ SectionedSourceMap,
+ Ro,
+} from './types';
+import type { Source } from './by-source';
+import type { MemoState } from './binary-search';
+
+export type { SourceMapSegment } from './sourcemap-segment';
+export type {
+ SourceMap,
+ DecodedSourceMap,
+ EncodedSourceMap,
+ Section,
+ SectionedSourceMap,
+ SourceMapV3,
+ Bias,
+ EachMapping,
+ GeneratedMapping,
+ InvalidGeneratedMapping,
+ InvalidOriginalMapping,
+ Needle,
+ OriginalMapping,
+ OriginalMapping as Mapping,
+ SectionedSourceMapInput,
+ SourceMapInput,
+ SourceNeedle,
+ XInput,
+ EncodedSourceMapXInput,
+ DecodedSourceMapXInput,
+ SectionedSourceMapXInput,
+ SectionXInput,
+} from './types';
+
+interface PublicMap {
+ _encoded: TraceMap['_encoded'];
+ _decoded: TraceMap['_decoded'];
+ _decodedMemo: TraceMap['_decodedMemo'];
+ _bySources: TraceMap['_bySources'];
+ _bySourceMemos: TraceMap['_bySourceMemos'];
+}
+
+const LINE_GTR_ZERO = '`line` must be greater than 0 (lines start at line 1)';
+const COL_GTR_EQ_ZERO = '`column` must be greater than or equal to 0 (columns start at column 0)';
+
+export const LEAST_UPPER_BOUND = -1;
+export const GREATEST_LOWER_BOUND = 1;
+
+export { FlattenMap, FlattenMap as AnyMap } from './flatten-map';
+
+export class TraceMap implements SourceMap {
+ declare version: SourceMapV3['version'];
+ declare file: SourceMapV3['file'];
+ declare names: SourceMapV3['names'];
+ declare sourceRoot: SourceMapV3['sourceRoot'];
+ declare sources: SourceMapV3['sources'];
+ declare sourcesContent: SourceMapV3['sourcesContent'];
+ declare ignoreList: SourceMapV3['ignoreList'];
+
+ declare resolvedSources: string[];
+ declare private _encoded: string | undefined;
+
+ declare private _decoded: SourceMapSegment[][] | undefined;
+ declare private _decodedMemo: MemoState;
+
+ declare private _bySources: Source[] | undefined;
+ declare private _bySourceMemos: MemoState[] | undefined;
+
+ constructor(map: Ro, mapUrl?: string | null) {
+ const isString = typeof map === 'string';
+ if (!isString && (map as unknown as { _decodedMemo: any })._decodedMemo) return map as TraceMap;
+
+ const parsed = parse(map as Exclude);
+
+ const { version, file, names, sourceRoot, sources, sourcesContent } = parsed;
+ this.version = version;
+ this.file = file;
+ this.names = names || [];
+ this.sourceRoot = sourceRoot;
+ this.sources = sources;
+ this.sourcesContent = sourcesContent;
+ this.ignoreList = parsed.ignoreList || (parsed as XInput).x_google_ignoreList || undefined;
+
+ const resolve = resolver(mapUrl, sourceRoot);
+ this.resolvedSources = sources.map(resolve);
+
+ const { mappings } = parsed;
+ if (typeof mappings === 'string') {
+ this._encoded = mappings;
+ this._decoded = undefined;
+ } else if (Array.isArray(mappings)) {
+ this._encoded = undefined;
+ this._decoded = maybeSort(mappings, isString);
+ } else if ((parsed as unknown as SectionedSourceMap).sections) {
+ throw new Error(`TraceMap passed sectioned source map, please use FlattenMap export instead`);
+ } else {
+ throw new Error(`invalid source map: ${JSON.stringify(parsed)}`);
+ }
+
+ this._decodedMemo = memoizedState();
+ this._bySources = undefined;
+ this._bySourceMemos = undefined;
+ }
+}
+
+/**
+ * Typescript doesn't allow friend access to private fields, so this just casts the map into a type
+ * with public access modifiers.
+ */
+function cast(map: unknown): PublicMap {
+ return map as any;
+}
+
+/**
+ * Returns the encoded (VLQ string) form of the SourceMap's mappings field.
+ */
+export function encodedMappings(map: TraceMap): EncodedSourceMap['mappings'] {
+ return (cast(map)._encoded ??= encode(cast(map)._decoded!));
+}
+
+/**
+ * Returns the decoded (array of lines of segments) form of the SourceMap's mappings field.
+ */
+export function decodedMappings(map: TraceMap): Readonly {
+ return (cast(map)._decoded ||= decode(cast(map)._encoded!));
+}
+
+/**
+ * A low-level API to find the segment associated with a generated line/column (think, from a
+ * stack trace). Line and column here are 0-based, unlike `originalPositionFor`.
+ */
+export function traceSegment(
+ map: TraceMap,
+ line: number,
+ column: number,
+): Readonly | null {
+ const decoded = decodedMappings(map);
+
+ // It's common for parent source maps to have pointers to lines that have no
+ // mapping (like a "//# sourceMappingURL=") at the end of the child file.
+ if (line >= decoded.length) return null;
+
+ const segments = decoded[line];
+ const index = traceSegmentInternal(
+ segments,
+ cast(map)._decodedMemo,
+ line,
+ column,
+ GREATEST_LOWER_BOUND,
+ );
+
+ return index === -1 ? null : segments[index];
+}
+
+/**
+ * A higher-level API to find the source/line/column associated with a generated line/column
+ * (think, from a stack trace). Line is 1-based, but column is 0-based, due to legacy behavior in
+ * `source-map` library.
+ */
+export function originalPositionFor(
+ map: TraceMap,
+ needle: Needle,
+): OriginalMapping | InvalidOriginalMapping {
+ let { line, column, bias } = needle;
+ line--;
+ if (line < 0) throw new Error(LINE_GTR_ZERO);
+ if (column < 0) throw new Error(COL_GTR_EQ_ZERO);
+
+ const decoded = decodedMappings(map);
+
+ // It's common for parent source maps to have pointers to lines that have no
+ // mapping (like a "//# sourceMappingURL=") at the end of the child file.
+ if (line >= decoded.length) return OMapping(null, null, null, null);
+
+ const segments = decoded[line];
+ const index = traceSegmentInternal(
+ segments,
+ cast(map)._decodedMemo,
+ line,
+ column,
+ bias || GREATEST_LOWER_BOUND,
+ );
+
+ if (index === -1) return OMapping(null, null, null, null);
+
+ const segment = segments[index];
+ if (segment.length === 1) return OMapping(null, null, null, null);
+
+ const { names, resolvedSources } = map;
+ return OMapping(
+ resolvedSources[segment[SOURCES_INDEX]],
+ segment[SOURCE_LINE] + 1,
+ segment[SOURCE_COLUMN],
+ segment.length === 5 ? names[segment[NAMES_INDEX]] : null,
+ );
+}
+
+/**
+ * Finds the generated line/column position of the provided source/line/column source position.
+ */
+export function generatedPositionFor(
+ map: TraceMap,
+ needle: SourceNeedle,
+): GeneratedMapping | InvalidGeneratedMapping {
+ const { source, line, column, bias } = needle;
+ return generatedPosition(map, source, line, column, bias || GREATEST_LOWER_BOUND, false);
+}
+
+/**
+ * Finds all generated line/column positions of the provided source/line/column source position.
+ */
+export function allGeneratedPositionsFor(map: TraceMap, needle: SourceNeedle): GeneratedMapping[] {
+ const { source, line, column, bias } = needle;
+ // SourceMapConsumer uses LEAST_UPPER_BOUND for some reason, so we follow suit.
+ return generatedPosition(map, source, line, column, bias || LEAST_UPPER_BOUND, true);
+}
+
+/**
+ * Iterates each mapping in generated position order.
+ */
+export function eachMapping(map: TraceMap, cb: (mapping: EachMapping) => void): void {
+ const decoded = decodedMappings(map);
+ const { names, resolvedSources } = map;
+
+ for (let i = 0; i < decoded.length; i++) {
+ const line = decoded[i];
+ for (let j = 0; j < line.length; j++) {
+ const seg = line[j];
+
+ const generatedLine = i + 1;
+ const generatedColumn = seg[0];
+ let source = null;
+ let originalLine = null;
+ let originalColumn = null;
+ let name = null;
+ if (seg.length !== 1) {
+ source = resolvedSources[seg[1]];
+ originalLine = seg[2] + 1;
+ originalColumn = seg[3];
+ }
+ if (seg.length === 5) name = names[seg[4]];
+
+ cb({
+ generatedLine,
+ generatedColumn,
+ source,
+ originalLine,
+ originalColumn,
+ name,
+ } as EachMapping);
+ }
+ }
+}
+
+function sourceIndex(map: TraceMap, source: string): number {
+ const { sources, resolvedSources } = map;
+ let index = sources.indexOf(source);
+ if (index === -1) index = resolvedSources.indexOf(source);
+ return index;
+}
+
+/**
+ * Retrieves the source content for a particular source, if its found. Returns null if not.
+ */
+export function sourceContentFor(map: TraceMap, source: string): string | null {
+ const { sourcesContent } = map;
+ if (sourcesContent == null) return null;
+ const index = sourceIndex(map, source);
+ return index === -1 ? null : sourcesContent[index];
+}
+
+/**
+ * Determines if the source is marked to ignore by the source map.
+ */
+export function isIgnored(map: TraceMap, source: string): boolean {
+ const { ignoreList } = map;
+ if (ignoreList == null) return false;
+ const index = sourceIndex(map, source);
+ return index === -1 ? false : ignoreList.includes(index);
+}
+
+/**
+ * A helper that skips sorting of the input map's mappings array, which can be expensive for larger
+ * maps.
+ */
+export function presortedDecodedMap(map: DecodedSourceMap, mapUrl?: string): TraceMap {
+ const tracer = new TraceMap(clone(map, []), mapUrl);
+ cast(tracer)._decoded = map.mappings;
+ return tracer;
+}
+
+/**
+ * Returns a sourcemap object (with decoded mappings) suitable for passing to a library that expects
+ * a sourcemap, or to JSON.stringify.
+ */
+export function decodedMap(
+ map: TraceMap,
+): Omit & { mappings: readonly SourceMapSegment[][] } {
+ return clone(map, decodedMappings(map));
+}
+
+/**
+ * Returns a sourcemap object (with encoded mappings) suitable for passing to a library that expects
+ * a sourcemap, or to JSON.stringify.
+ */
+export function encodedMap(map: TraceMap): EncodedSourceMap {
+ return clone(map, encodedMappings(map));
+}
+
+function clone(
+ map: TraceMap | DecodedSourceMap,
+ mappings: T,
+): T extends string ? EncodedSourceMap : DecodedSourceMap {
+ return {
+ version: map.version,
+ file: map.file,
+ names: map.names,
+ sourceRoot: map.sourceRoot,
+ sources: map.sources,
+ sourcesContent: map.sourcesContent,
+ mappings,
+ ignoreList: map.ignoreList || (map as XInput).x_google_ignoreList,
+ } as any;
+}
+
+function OMapping(source: null, line: null, column: null, name: null): InvalidOriginalMapping;
+function OMapping(
+ source: string,
+ line: number,
+ column: number,
+ name: string | null,
+): OriginalMapping;
+function OMapping(
+ source: string | null,
+ line: number | null,
+ column: number | null,
+ name: string | null,
+): OriginalMapping | InvalidOriginalMapping {
+ return { source, line, column, name } as any;
+}
+
+function GMapping(line: null, column: null): InvalidGeneratedMapping;
+function GMapping(line: number, column: number): GeneratedMapping;
+function GMapping(
+ line: number | null,
+ column: number | null,
+): GeneratedMapping | InvalidGeneratedMapping {
+ return { line, column } as any;
+}
+
+function traceSegmentInternal(
+ segments: SourceMapSegment[],
+ memo: MemoState,
+ line: number,
+ column: number,
+ bias: Bias,
+): number;
+function traceSegmentInternal(
+ segments: ReverseSegment[],
+ memo: MemoState,
+ line: number,
+ column: number,
+ bias: Bias,
+): number;
+function traceSegmentInternal(
+ segments: SourceMapSegment[] | ReverseSegment[],
+ memo: MemoState,
+ line: number,
+ column: number,
+ bias: Bias,
+): number {
+ let index = memoizedBinarySearch(segments, column, memo, line);
+ if (bsFound) {
+ index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index);
+ } else if (bias === LEAST_UPPER_BOUND) index++;
+
+ if (index === -1 || index === segments.length) return -1;
+ return index;
+}
+
+function sliceGeneratedPositions(
+ segments: ReverseSegment[],
+ memo: MemoState,
+ line: number,
+ column: number,
+ bias: Bias,
+): GeneratedMapping[] {
+ let min = traceSegmentInternal(segments, memo, line, column, GREATEST_LOWER_BOUND);
+
+ // We ignored the bias when tracing the segment so that we're guarnateed to find the first (in
+ // insertion order) segment that matched. Even if we did respect the bias when tracing, we would
+ // still need to call `lowerBound()` to find the first segment, which is slower than just looking
+ // for the GREATEST_LOWER_BOUND to begin with. The only difference that matters for us is when the
+ // binary search didn't match, in which case GREATEST_LOWER_BOUND just needs to increment to
+ // match LEAST_UPPER_BOUND.
+ if (!bsFound && bias === LEAST_UPPER_BOUND) min++;
+
+ if (min === -1 || min === segments.length) return [];
+
+ // We may have found the segment that started at an earlier column. If this is the case, then we
+ // need to slice all generated segments that match _that_ column, because all such segments span
+ // to our desired column.
+ const matchedColumn = bsFound ? column : segments[min][COLUMN];
+
+ // The binary search is not guaranteed to find the lower bound when a match wasn't found.
+ if (!bsFound) min = lowerBound(segments, matchedColumn, min);
+ const max = upperBound(segments, matchedColumn, min);
+
+ const result = [];
+ for (; min <= max; min++) {
+ const segment = segments[min];
+ result.push(GMapping(segment[REV_GENERATED_LINE] + 1, segment[REV_GENERATED_COLUMN]));
+ }
+ return result;
+}
+
+function generatedPosition(
+ map: TraceMap,
+ source: string,
+ line: number,
+ column: number,
+ bias: Bias,
+ all: false,
+): GeneratedMapping | InvalidGeneratedMapping;
+function generatedPosition(
+ map: TraceMap,
+ source: string,
+ line: number,
+ column: number,
+ bias: Bias,
+ all: true,
+): GeneratedMapping[];
+function generatedPosition(
+ map: TraceMap,
+ source: string,
+ line: number,
+ column: number,
+ bias: Bias,
+ all: boolean,
+): GeneratedMapping | InvalidGeneratedMapping | GeneratedMapping[] {
+ line--;
+ if (line < 0) throw new Error(LINE_GTR_ZERO);
+ if (column < 0) throw new Error(COL_GTR_EQ_ZERO);
+
+ const { sources, resolvedSources } = map;
+ let sourceIndex = sources.indexOf(source);
+ if (sourceIndex === -1) sourceIndex = resolvedSources.indexOf(source);
+ if (sourceIndex === -1) return all ? [] : GMapping(null, null);
+
+ const bySourceMemos = (cast(map)._bySourceMemos ||= sources.map(memoizedState));
+ const generated = (cast(map)._bySources ||= buildBySources(decodedMappings(map), bySourceMemos));
+
+ const segments = generated[sourceIndex][line];
+ if (segments == null) return all ? [] : GMapping(null, null);
+
+ const memo = bySourceMemos[sourceIndex];
+
+ if (all) return sliceGeneratedPositions(segments, memo, line, column, bias);
+
+ const index = traceSegmentInternal(segments, memo, line, column, bias);
+ if (index === -1) return GMapping(null, null);
+
+ const segment = segments[index];
+ return GMapping(segment[REV_GENERATED_LINE] + 1, segment[REV_GENERATED_COLUMN]);
+}
diff --git a/sdk/node_modules/@jridgewell/trace-mapping/src/types.ts b/sdk/node_modules/@jridgewell/trace-mapping/src/types.ts
new file mode 100644
index 00000000..730a61fb
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/trace-mapping/src/types.ts
@@ -0,0 +1,114 @@
+import type { SourceMapSegment } from './sourcemap-segment';
+import type { GREATEST_LOWER_BOUND, LEAST_UPPER_BOUND, TraceMap } from './trace-mapping';
+
+export interface SourceMapV3 {
+ file?: string | null;
+ names: string[];
+ sourceRoot?: string;
+ sources: (string | null)[];
+ sourcesContent?: (string | null)[];
+ version: 3;
+ ignoreList?: number[];
+}
+
+export interface EncodedSourceMap extends SourceMapV3 {
+ mappings: string;
+}
+
+export interface DecodedSourceMap extends SourceMapV3 {
+ mappings: SourceMapSegment[][];
+}
+
+export interface Section {
+ offset: { line: number; column: number };
+ map: EncodedSourceMap | DecodedSourceMap | SectionedSourceMap;
+}
+
+export interface SectionedSourceMap {
+ file?: string | null;
+ sections: Section[];
+ version: 3;
+}
+
+export type OriginalMapping = {
+ source: string | null;
+ line: number;
+ column: number;
+ name: string | null;
+};
+
+export type InvalidOriginalMapping = {
+ source: null;
+ line: null;
+ column: null;
+ name: null;
+};
+
+export type GeneratedMapping = {
+ line: number;
+ column: number;
+};
+export type InvalidGeneratedMapping = {
+ line: null;
+ column: null;
+};
+
+export type Bias = typeof GREATEST_LOWER_BOUND | typeof LEAST_UPPER_BOUND;
+
+export type XInput = { x_google_ignoreList?: SourceMapV3['ignoreList'] };
+export type EncodedSourceMapXInput = EncodedSourceMap & XInput;
+export type DecodedSourceMapXInput = DecodedSourceMap & XInput;
+export type SectionedSourceMapXInput = Omit & {
+ sections: SectionXInput[];
+};
+export type SectionXInput = Omit & {
+ map: SectionedSourceMapInput;
+};
+
+export type SourceMapInput = string | EncodedSourceMapXInput | DecodedSourceMapXInput | TraceMap;
+export type SectionedSourceMapInput = SourceMapInput | SectionedSourceMapXInput;
+
+export type Needle = { line: number; column: number; bias?: Bias };
+export type SourceNeedle = { source: string; line: number; column: number; bias?: Bias };
+
+export type EachMapping =
+ | {
+ generatedLine: number;
+ generatedColumn: number;
+ source: null;
+ originalLine: null;
+ originalColumn: null;
+ name: null;
+ }
+ | {
+ generatedLine: number;
+ generatedColumn: number;
+ source: string | null;
+ originalLine: number;
+ originalColumn: number;
+ name: string | null;
+ };
+
+export abstract class SourceMap {
+ declare version: SourceMapV3['version'];
+ declare file: SourceMapV3['file'];
+ declare names: SourceMapV3['names'];
+ declare sourceRoot: SourceMapV3['sourceRoot'];
+ declare sources: SourceMapV3['sources'];
+ declare sourcesContent: SourceMapV3['sourcesContent'];
+ declare resolvedSources: SourceMapV3['sources'];
+ declare ignoreList: SourceMapV3['ignoreList'];
+}
+
+export type Ro =
+ T extends Array
+ ? V[] | Readonly | RoArray | Readonly>
+ : T extends object
+ ? T | Readonly | RoObject | Readonly>
+ : T;
+type RoArray = Ro[];
+type RoObject = { [K in keyof T]: T[K] | Ro };
+
+export function parse(map: T): Exclude {
+ return typeof map === 'string' ? JSON.parse(map) : (map as Exclude);
+}
diff --git a/sdk/node_modules/@jridgewell/trace-mapping/types/binary-search.d.cts b/sdk/node_modules/@jridgewell/trace-mapping/types/binary-search.d.cts
new file mode 100644
index 00000000..b7bb85c9
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/trace-mapping/types/binary-search.d.cts
@@ -0,0 +1,33 @@
+import type { SourceMapSegment, ReverseSegment } from './sourcemap-segment.cts';
+export type MemoState = {
+ lastKey: number;
+ lastNeedle: number;
+ lastIndex: number;
+};
+export declare let found: boolean;
+/**
+ * A binary search implementation that returns the index if a match is found.
+ * If no match is found, then the left-index (the index associated with the item that comes just
+ * before the desired index) is returned. To maintain proper sort order, a splice would happen at
+ * the next index:
+ *
+ * ```js
+ * const array = [1, 3];
+ * const needle = 2;
+ * const index = binarySearch(array, needle, (item, needle) => item - needle);
+ *
+ * assert.equal(index, 0);
+ * array.splice(index + 1, 0, needle);
+ * assert.deepEqual(array, [1, 2, 3]);
+ * ```
+ */
+export declare function binarySearch(haystack: SourceMapSegment[] | ReverseSegment[], needle: number, low: number, high: number): number;
+export declare function upperBound(haystack: SourceMapSegment[] | ReverseSegment[], needle: number, index: number): number;
+export declare function lowerBound(haystack: SourceMapSegment[] | ReverseSegment[], needle: number, index: number): number;
+export declare function memoizedState(): MemoState;
+/**
+ * This overly complicated beast is just to record the last tested line/column and the resulting
+ * index, allowing us to skip a few tests if mappings are monotonically increasing.
+ */
+export declare function memoizedBinarySearch(haystack: SourceMapSegment[] | ReverseSegment[], needle: number, state: MemoState, key: number): number;
+//# sourceMappingURL=binary-search.d.ts.map
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/trace-mapping/types/binary-search.d.cts.map b/sdk/node_modules/@jridgewell/trace-mapping/types/binary-search.d.cts.map
new file mode 100644
index 00000000..648e84c1
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/trace-mapping/types/binary-search.d.cts.map
@@ -0,0 +1 @@
+{"version":3,"file":"binary-search.d.ts","sourceRoot":"","sources":["../src/binary-search.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAG5E,MAAM,MAAM,SAAS,GAAG;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,eAAO,IAAI,KAAK,SAAQ,CAAC;AAEzB;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,gBAAgB,EAAE,GAAG,cAAc,EAAE,EAC/C,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,GACX,MAAM,CAmBR;AAED,wBAAgB,UAAU,CACxB,QAAQ,EAAE,gBAAgB,EAAE,GAAG,cAAc,EAAE,EAC/C,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,GACZ,MAAM,CAKR;AAED,wBAAgB,UAAU,CACxB,QAAQ,EAAE,gBAAgB,EAAE,GAAG,cAAc,EAAE,EAC/C,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,GACZ,MAAM,CAKR;AAED,wBAAgB,aAAa,IAAI,SAAS,CAMzC;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,gBAAgB,EAAE,GAAG,cAAc,EAAE,EAC/C,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,SAAS,EAChB,GAAG,EAAE,MAAM,GACV,MAAM,CAsBR"}
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/trace-mapping/types/binary-search.d.mts b/sdk/node_modules/@jridgewell/trace-mapping/types/binary-search.d.mts
new file mode 100644
index 00000000..19e1e6b9
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/trace-mapping/types/binary-search.d.mts
@@ -0,0 +1,33 @@
+import type { SourceMapSegment, ReverseSegment } from './sourcemap-segment.mts';
+export type MemoState = {
+ lastKey: number;
+ lastNeedle: number;
+ lastIndex: number;
+};
+export declare let found: boolean;
+/**
+ * A binary search implementation that returns the index if a match is found.
+ * If no match is found, then the left-index (the index associated with the item that comes just
+ * before the desired index) is returned. To maintain proper sort order, a splice would happen at
+ * the next index:
+ *
+ * ```js
+ * const array = [1, 3];
+ * const needle = 2;
+ * const index = binarySearch(array, needle, (item, needle) => item - needle);
+ *
+ * assert.equal(index, 0);
+ * array.splice(index + 1, 0, needle);
+ * assert.deepEqual(array, [1, 2, 3]);
+ * ```
+ */
+export declare function binarySearch(haystack: SourceMapSegment[] | ReverseSegment[], needle: number, low: number, high: number): number;
+export declare function upperBound(haystack: SourceMapSegment[] | ReverseSegment[], needle: number, index: number): number;
+export declare function lowerBound(haystack: SourceMapSegment[] | ReverseSegment[], needle: number, index: number): number;
+export declare function memoizedState(): MemoState;
+/**
+ * This overly complicated beast is just to record the last tested line/column and the resulting
+ * index, allowing us to skip a few tests if mappings are monotonically increasing.
+ */
+export declare function memoizedBinarySearch(haystack: SourceMapSegment[] | ReverseSegment[], needle: number, state: MemoState, key: number): number;
+//# sourceMappingURL=binary-search.d.ts.map
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/trace-mapping/types/binary-search.d.mts.map b/sdk/node_modules/@jridgewell/trace-mapping/types/binary-search.d.mts.map
new file mode 100644
index 00000000..648e84c1
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/trace-mapping/types/binary-search.d.mts.map
@@ -0,0 +1 @@
+{"version":3,"file":"binary-search.d.ts","sourceRoot":"","sources":["../src/binary-search.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAG5E,MAAM,MAAM,SAAS,GAAG;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,eAAO,IAAI,KAAK,SAAQ,CAAC;AAEzB;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,gBAAgB,EAAE,GAAG,cAAc,EAAE,EAC/C,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,GACX,MAAM,CAmBR;AAED,wBAAgB,UAAU,CACxB,QAAQ,EAAE,gBAAgB,EAAE,GAAG,cAAc,EAAE,EAC/C,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,GACZ,MAAM,CAKR;AAED,wBAAgB,UAAU,CACxB,QAAQ,EAAE,gBAAgB,EAAE,GAAG,cAAc,EAAE,EAC/C,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,GACZ,MAAM,CAKR;AAED,wBAAgB,aAAa,IAAI,SAAS,CAMzC;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,gBAAgB,EAAE,GAAG,cAAc,EAAE,EAC/C,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,SAAS,EAChB,GAAG,EAAE,MAAM,GACV,MAAM,CAsBR"}
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/trace-mapping/types/by-source.d.cts b/sdk/node_modules/@jridgewell/trace-mapping/types/by-source.d.cts
new file mode 100644
index 00000000..da496939
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/trace-mapping/types/by-source.d.cts
@@ -0,0 +1,4 @@
+import type { ReverseSegment, SourceMapSegment } from './sourcemap-segment.cts';
+export type Source = ReverseSegment[][];
+export = function buildBySources(decoded: readonly SourceMapSegment[][], memos: unknown[]): Source[];
+//# sourceMappingURL=by-source.d.ts.map
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/trace-mapping/types/by-source.d.cts.map b/sdk/node_modules/@jridgewell/trace-mapping/types/by-source.d.cts.map
new file mode 100644
index 00000000..32d2a7a1
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/trace-mapping/types/by-source.d.cts.map
@@ -0,0 +1 @@
+{"version":3,"file":"by-source.d.ts","sourceRoot":"","sources":["../src/by-source.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAE5E,MAAM,MAAM,MAAM,GAAG,cAAc,EAAE,EAAE,CAAC;AAIxC,MAAM,CAAC,OAAO,UAAU,cAAc,CACpC,OAAO,EAAE,SAAS,gBAAgB,EAAE,EAAE,EACtC,KAAK,EAAE,OAAO,EAAE,GACf,MAAM,EAAE,CA4BV"}
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/trace-mapping/types/by-source.d.mts b/sdk/node_modules/@jridgewell/trace-mapping/types/by-source.d.mts
new file mode 100644
index 00000000..f3610495
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/trace-mapping/types/by-source.d.mts
@@ -0,0 +1,4 @@
+import type { ReverseSegment, SourceMapSegment } from './sourcemap-segment.mts';
+export type Source = ReverseSegment[][];
+export default function buildBySources(decoded: readonly SourceMapSegment[][], memos: unknown[]): Source[];
+//# sourceMappingURL=by-source.d.ts.map
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/trace-mapping/types/by-source.d.mts.map b/sdk/node_modules/@jridgewell/trace-mapping/types/by-source.d.mts.map
new file mode 100644
index 00000000..32d2a7a1
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/trace-mapping/types/by-source.d.mts.map
@@ -0,0 +1 @@
+{"version":3,"file":"by-source.d.ts","sourceRoot":"","sources":["../src/by-source.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAE5E,MAAM,MAAM,MAAM,GAAG,cAAc,EAAE,EAAE,CAAC;AAIxC,MAAM,CAAC,OAAO,UAAU,cAAc,CACpC,OAAO,EAAE,SAAS,gBAAgB,EAAE,EAAE,EACtC,KAAK,EAAE,OAAO,EAAE,GACf,MAAM,EAAE,CA4BV"}
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/trace-mapping/types/flatten-map.d.cts b/sdk/node_modules/@jridgewell/trace-mapping/types/flatten-map.d.cts
new file mode 100644
index 00000000..433d849b
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/trace-mapping/types/flatten-map.d.cts
@@ -0,0 +1,9 @@
+import { TraceMap } from './trace-mapping.cts';
+import type { SectionedSourceMapInput, Ro } from './types.cts';
+type FlattenMap = {
+ new (map: Ro, mapUrl?: string | null): TraceMap;
+ (map: Ro, mapUrl?: string | null): TraceMap;
+};
+export declare const FlattenMap: FlattenMap;
+export {};
+//# sourceMappingURL=flatten-map.d.ts.map
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/trace-mapping/types/flatten-map.d.cts.map b/sdk/node_modules/@jridgewell/trace-mapping/types/flatten-map.d.cts.map
new file mode 100644
index 00000000..994b208a
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/trace-mapping/types/flatten-map.d.cts.map
@@ -0,0 +1 @@
+{"version":3,"file":"flatten-map.d.ts","sourceRoot":"","sources":["../src/flatten-map.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAwC,MAAM,iBAAiB,CAAC;AAUjF,OAAO,KAAK,EAKV,uBAAuB,EAEvB,EAAE,EACH,MAAM,SAAS,CAAC;AAGjB,KAAK,UAAU,GAAG;IAChB,KAAK,GAAG,EAAE,EAAE,CAAC,uBAAuB,CAAC,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,QAAQ,CAAC;IACzE,CAAC,GAAG,EAAE,EAAE,CAAC,uBAAuB,CAAC,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,QAAQ,CAAC;CACtE,CAAC;AAEF,eAAO,MAAM,UAAU,EAAE,UAsCV,CAAC"}
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/trace-mapping/types/flatten-map.d.mts b/sdk/node_modules/@jridgewell/trace-mapping/types/flatten-map.d.mts
new file mode 100644
index 00000000..444a1bed
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/trace-mapping/types/flatten-map.d.mts
@@ -0,0 +1,9 @@
+import { TraceMap } from './trace-mapping.mts';
+import type { SectionedSourceMapInput, Ro } from './types.mts';
+type FlattenMap = {
+ new (map: Ro, mapUrl?: string | null): TraceMap;
+ (map: Ro, mapUrl?: string | null): TraceMap;
+};
+export declare const FlattenMap: FlattenMap;
+export {};
+//# sourceMappingURL=flatten-map.d.ts.map
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/trace-mapping/types/flatten-map.d.mts.map b/sdk/node_modules/@jridgewell/trace-mapping/types/flatten-map.d.mts.map
new file mode 100644
index 00000000..994b208a
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/trace-mapping/types/flatten-map.d.mts.map
@@ -0,0 +1 @@
+{"version":3,"file":"flatten-map.d.ts","sourceRoot":"","sources":["../src/flatten-map.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAwC,MAAM,iBAAiB,CAAC;AAUjF,OAAO,KAAK,EAKV,uBAAuB,EAEvB,EAAE,EACH,MAAM,SAAS,CAAC;AAGjB,KAAK,UAAU,GAAG;IAChB,KAAK,GAAG,EAAE,EAAE,CAAC,uBAAuB,CAAC,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,QAAQ,CAAC;IACzE,CAAC,GAAG,EAAE,EAAE,CAAC,uBAAuB,CAAC,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,QAAQ,CAAC;CACtE,CAAC;AAEF,eAAO,MAAM,UAAU,EAAE,UAsCV,CAAC"}
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/trace-mapping/types/resolve.d.cts b/sdk/node_modules/@jridgewell/trace-mapping/types/resolve.d.cts
new file mode 100644
index 00000000..62aeedb5
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/trace-mapping/types/resolve.d.cts
@@ -0,0 +1,4 @@
+type Resolve = (source: string | null) => string;
+export = function resolver(mapUrl: string | null | undefined, sourceRoot: string | undefined): Resolve;
+export {};
+//# sourceMappingURL=resolve.d.ts.map
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/trace-mapping/types/resolve.d.cts.map b/sdk/node_modules/@jridgewell/trace-mapping/types/resolve.d.cts.map
new file mode 100644
index 00000000..9f155ace
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/trace-mapping/types/resolve.d.cts.map
@@ -0,0 +1 @@
+{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../src/resolve.ts"],"names":[],"mappings":"AAGA,KAAK,OAAO,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,KAAK,MAAM,CAAC;AACjD,MAAM,CAAC,OAAO,UAAU,QAAQ,CAC9B,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACjC,UAAU,EAAE,MAAM,GAAG,SAAS,GAC7B,OAAO,CAQT"}
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/trace-mapping/types/resolve.d.mts b/sdk/node_modules/@jridgewell/trace-mapping/types/resolve.d.mts
new file mode 100644
index 00000000..e2798a19
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/trace-mapping/types/resolve.d.mts
@@ -0,0 +1,4 @@
+type Resolve = (source: string | null) => string;
+export default function resolver(mapUrl: string | null | undefined, sourceRoot: string | undefined): Resolve;
+export {};
+//# sourceMappingURL=resolve.d.ts.map
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/trace-mapping/types/resolve.d.mts.map b/sdk/node_modules/@jridgewell/trace-mapping/types/resolve.d.mts.map
new file mode 100644
index 00000000..9f155ace
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/trace-mapping/types/resolve.d.mts.map
@@ -0,0 +1 @@
+{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../src/resolve.ts"],"names":[],"mappings":"AAGA,KAAK,OAAO,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,KAAK,MAAM,CAAC;AACjD,MAAM,CAAC,OAAO,UAAU,QAAQ,CAC9B,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACjC,UAAU,EAAE,MAAM,GAAG,SAAS,GAC7B,OAAO,CAQT"}
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/trace-mapping/types/sort.d.cts b/sdk/node_modules/@jridgewell/trace-mapping/types/sort.d.cts
new file mode 100644
index 00000000..aa14c129
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/trace-mapping/types/sort.d.cts
@@ -0,0 +1,4 @@
+import type { ReverseSegment, SourceMapSegment } from './sourcemap-segment.cts';
+export = function maybeSort(mappings: SourceMapSegment[][], owned: boolean): SourceMapSegment[][];
+export declare function sortComparator(a: T, b: T): number;
+//# sourceMappingURL=sort.d.ts.map
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/trace-mapping/types/sort.d.cts.map b/sdk/node_modules/@jridgewell/trace-mapping/types/sort.d.cts.map
new file mode 100644
index 00000000..48b8e674
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/trace-mapping/types/sort.d.cts.map
@@ -0,0 +1 @@
+{"version":3,"file":"sort.d.ts","sourceRoot":"","sources":["../src/sort.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAE5E,MAAM,CAAC,OAAO,UAAU,SAAS,CAC/B,QAAQ,EAAE,gBAAgB,EAAE,EAAE,EAC9B,KAAK,EAAE,OAAO,GACb,gBAAgB,EAAE,EAAE,CAYtB;AAuBD,wBAAgB,cAAc,CAAC,CAAC,SAAS,gBAAgB,GAAG,cAAc,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,MAAM,CAE9F"}
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/trace-mapping/types/sort.d.mts b/sdk/node_modules/@jridgewell/trace-mapping/types/sort.d.mts
new file mode 100644
index 00000000..c5b94e64
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/trace-mapping/types/sort.d.mts
@@ -0,0 +1,4 @@
+import type { ReverseSegment, SourceMapSegment } from './sourcemap-segment.mts';
+export default function maybeSort(mappings: SourceMapSegment[][], owned: boolean): SourceMapSegment[][];
+export declare function sortComparator(a: T, b: T): number;
+//# sourceMappingURL=sort.d.ts.map
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/trace-mapping/types/sort.d.mts.map b/sdk/node_modules/@jridgewell/trace-mapping/types/sort.d.mts.map
new file mode 100644
index 00000000..48b8e674
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/trace-mapping/types/sort.d.mts.map
@@ -0,0 +1 @@
+{"version":3,"file":"sort.d.ts","sourceRoot":"","sources":["../src/sort.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAE5E,MAAM,CAAC,OAAO,UAAU,SAAS,CAC/B,QAAQ,EAAE,gBAAgB,EAAE,EAAE,EAC9B,KAAK,EAAE,OAAO,GACb,gBAAgB,EAAE,EAAE,CAYtB;AAuBD,wBAAgB,cAAc,CAAC,CAAC,SAAS,gBAAgB,GAAG,cAAc,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,MAAM,CAE9F"}
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/trace-mapping/types/sourcemap-segment.d.cts b/sdk/node_modules/@jridgewell/trace-mapping/types/sourcemap-segment.d.cts
new file mode 100644
index 00000000..8d3cabc1
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/trace-mapping/types/sourcemap-segment.d.cts
@@ -0,0 +1,17 @@
+type GeneratedColumn = number;
+type SourcesIndex = number;
+type SourceLine = number;
+type SourceColumn = number;
+type NamesIndex = number;
+type GeneratedLine = number;
+export type SourceMapSegment = [GeneratedColumn] | [GeneratedColumn, SourcesIndex, SourceLine, SourceColumn] | [GeneratedColumn, SourcesIndex, SourceLine, SourceColumn, NamesIndex];
+export type ReverseSegment = [SourceColumn, GeneratedLine, GeneratedColumn];
+export declare const COLUMN = 0;
+export declare const SOURCES_INDEX = 1;
+export declare const SOURCE_LINE = 2;
+export declare const SOURCE_COLUMN = 3;
+export declare const NAMES_INDEX = 4;
+export declare const REV_GENERATED_LINE = 1;
+export declare const REV_GENERATED_COLUMN = 2;
+export {};
+//# sourceMappingURL=sourcemap-segment.d.ts.map
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/trace-mapping/types/sourcemap-segment.d.cts.map b/sdk/node_modules/@jridgewell/trace-mapping/types/sourcemap-segment.d.cts.map
new file mode 100644
index 00000000..0c94a461
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/trace-mapping/types/sourcemap-segment.d.cts.map
@@ -0,0 +1 @@
+{"version":3,"file":"sourcemap-segment.d.ts","sourceRoot":"","sources":["../src/sourcemap-segment.ts"],"names":[],"mappings":"AAAA,KAAK,eAAe,GAAG,MAAM,CAAC;AAC9B,KAAK,YAAY,GAAG,MAAM,CAAC;AAC3B,KAAK,UAAU,GAAG,MAAM,CAAC;AACzB,KAAK,YAAY,GAAG,MAAM,CAAC;AAC3B,KAAK,UAAU,GAAG,MAAM,CAAC;AAEzB,KAAK,aAAa,GAAG,MAAM,CAAC;AAE5B,MAAM,MAAM,gBAAgB,GACxB,CAAC,eAAe,CAAC,GACjB,CAAC,eAAe,EAAE,YAAY,EAAE,UAAU,EAAE,YAAY,CAAC,GACzD,CAAC,eAAe,EAAE,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,UAAU,CAAC,CAAC;AAE1E,MAAM,MAAM,cAAc,GAAG,CAAC,YAAY,EAAE,aAAa,EAAE,eAAe,CAAC,CAAC;AAE5E,eAAO,MAAM,MAAM,IAAI,CAAC;AACxB,eAAO,MAAM,aAAa,IAAI,CAAC;AAC/B,eAAO,MAAM,WAAW,IAAI,CAAC;AAC7B,eAAO,MAAM,aAAa,IAAI,CAAC;AAC/B,eAAO,MAAM,WAAW,IAAI,CAAC;AAE7B,eAAO,MAAM,kBAAkB,IAAI,CAAC;AACpC,eAAO,MAAM,oBAAoB,IAAI,CAAC"}
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/trace-mapping/types/sourcemap-segment.d.mts b/sdk/node_modules/@jridgewell/trace-mapping/types/sourcemap-segment.d.mts
new file mode 100644
index 00000000..8d3cabc1
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/trace-mapping/types/sourcemap-segment.d.mts
@@ -0,0 +1,17 @@
+type GeneratedColumn = number;
+type SourcesIndex = number;
+type SourceLine = number;
+type SourceColumn = number;
+type NamesIndex = number;
+type GeneratedLine = number;
+export type SourceMapSegment = [GeneratedColumn] | [GeneratedColumn, SourcesIndex, SourceLine, SourceColumn] | [GeneratedColumn, SourcesIndex, SourceLine, SourceColumn, NamesIndex];
+export type ReverseSegment = [SourceColumn, GeneratedLine, GeneratedColumn];
+export declare const COLUMN = 0;
+export declare const SOURCES_INDEX = 1;
+export declare const SOURCE_LINE = 2;
+export declare const SOURCE_COLUMN = 3;
+export declare const NAMES_INDEX = 4;
+export declare const REV_GENERATED_LINE = 1;
+export declare const REV_GENERATED_COLUMN = 2;
+export {};
+//# sourceMappingURL=sourcemap-segment.d.ts.map
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/trace-mapping/types/sourcemap-segment.d.mts.map b/sdk/node_modules/@jridgewell/trace-mapping/types/sourcemap-segment.d.mts.map
new file mode 100644
index 00000000..0c94a461
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/trace-mapping/types/sourcemap-segment.d.mts.map
@@ -0,0 +1 @@
+{"version":3,"file":"sourcemap-segment.d.ts","sourceRoot":"","sources":["../src/sourcemap-segment.ts"],"names":[],"mappings":"AAAA,KAAK,eAAe,GAAG,MAAM,CAAC;AAC9B,KAAK,YAAY,GAAG,MAAM,CAAC;AAC3B,KAAK,UAAU,GAAG,MAAM,CAAC;AACzB,KAAK,YAAY,GAAG,MAAM,CAAC;AAC3B,KAAK,UAAU,GAAG,MAAM,CAAC;AAEzB,KAAK,aAAa,GAAG,MAAM,CAAC;AAE5B,MAAM,MAAM,gBAAgB,GACxB,CAAC,eAAe,CAAC,GACjB,CAAC,eAAe,EAAE,YAAY,EAAE,UAAU,EAAE,YAAY,CAAC,GACzD,CAAC,eAAe,EAAE,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,UAAU,CAAC,CAAC;AAE1E,MAAM,MAAM,cAAc,GAAG,CAAC,YAAY,EAAE,aAAa,EAAE,eAAe,CAAC,CAAC;AAE5E,eAAO,MAAM,MAAM,IAAI,CAAC;AACxB,eAAO,MAAM,aAAa,IAAI,CAAC;AAC/B,eAAO,MAAM,WAAW,IAAI,CAAC;AAC7B,eAAO,MAAM,aAAa,IAAI,CAAC;AAC/B,eAAO,MAAM,WAAW,IAAI,CAAC;AAE7B,eAAO,MAAM,kBAAkB,IAAI,CAAC;AACpC,eAAO,MAAM,oBAAoB,IAAI,CAAC"}
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/trace-mapping/types/strip-filename.d.cts b/sdk/node_modules/@jridgewell/trace-mapping/types/strip-filename.d.cts
new file mode 100644
index 00000000..8b3c0e9b
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/trace-mapping/types/strip-filename.d.cts
@@ -0,0 +1,5 @@
+/**
+ * Removes everything after the last "/", but leaves the slash.
+ */
+export = function stripFilename(path: string | undefined | null): string;
+//# sourceMappingURL=strip-filename.d.ts.map
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/trace-mapping/types/strip-filename.d.cts.map b/sdk/node_modules/@jridgewell/trace-mapping/types/strip-filename.d.cts.map
new file mode 100644
index 00000000..17a25da0
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/trace-mapping/types/strip-filename.d.cts.map
@@ -0,0 +1 @@
+{"version":3,"file":"strip-filename.d.ts","sourceRoot":"","sources":["../src/strip-filename.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,CAAC,OAAO,UAAU,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,GAAG,MAAM,CAI7E"}
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/trace-mapping/types/strip-filename.d.mts b/sdk/node_modules/@jridgewell/trace-mapping/types/strip-filename.d.mts
new file mode 100644
index 00000000..cbbaee0d
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/trace-mapping/types/strip-filename.d.mts
@@ -0,0 +1,5 @@
+/**
+ * Removes everything after the last "/", but leaves the slash.
+ */
+export default function stripFilename(path: string | undefined | null): string;
+//# sourceMappingURL=strip-filename.d.ts.map
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/trace-mapping/types/strip-filename.d.mts.map b/sdk/node_modules/@jridgewell/trace-mapping/types/strip-filename.d.mts.map
new file mode 100644
index 00000000..17a25da0
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/trace-mapping/types/strip-filename.d.mts.map
@@ -0,0 +1 @@
+{"version":3,"file":"strip-filename.d.ts","sourceRoot":"","sources":["../src/strip-filename.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,CAAC,OAAO,UAAU,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,GAAG,MAAM,CAI7E"}
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/trace-mapping/types/trace-mapping.d.cts b/sdk/node_modules/@jridgewell/trace-mapping/types/trace-mapping.d.cts
new file mode 100644
index 00000000..a40f3054
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/trace-mapping/types/trace-mapping.d.cts
@@ -0,0 +1,80 @@
+import type { SourceMapSegment } from './sourcemap-segment.cts';
+import type { SourceMapV3, DecodedSourceMap, EncodedSourceMap, InvalidOriginalMapping, OriginalMapping, InvalidGeneratedMapping, GeneratedMapping, SourceMapInput, Needle, SourceNeedle, SourceMap, EachMapping, Ro } from './types.cts';
+export type { SourceMapSegment } from './sourcemap-segment.cts';
+export type { SourceMap, DecodedSourceMap, EncodedSourceMap, Section, SectionedSourceMap, SourceMapV3, Bias, EachMapping, GeneratedMapping, InvalidGeneratedMapping, InvalidOriginalMapping, Needle, OriginalMapping, OriginalMapping as Mapping, SectionedSourceMapInput, SourceMapInput, SourceNeedle, XInput, EncodedSourceMapXInput, DecodedSourceMapXInput, SectionedSourceMapXInput, SectionXInput, } from './types.cts';
+export declare const LEAST_UPPER_BOUND = -1;
+export declare const GREATEST_LOWER_BOUND = 1;
+export { FlattenMap, FlattenMap as AnyMap } from './flatten-map.cts';
+export declare class TraceMap implements SourceMap {
+ version: SourceMapV3['version'];
+ file: SourceMapV3['file'];
+ names: SourceMapV3['names'];
+ sourceRoot: SourceMapV3['sourceRoot'];
+ sources: SourceMapV3['sources'];
+ sourcesContent: SourceMapV3['sourcesContent'];
+ ignoreList: SourceMapV3['ignoreList'];
+ resolvedSources: string[];
+ private _encoded;
+ private _decoded;
+ private _decodedMemo;
+ private _bySources;
+ private _bySourceMemos;
+ constructor(map: Ro, mapUrl?: string | null);
+}
+/**
+ * Returns the encoded (VLQ string) form of the SourceMap's mappings field.
+ */
+export declare function encodedMappings(map: TraceMap): EncodedSourceMap['mappings'];
+/**
+ * Returns the decoded (array of lines of segments) form of the SourceMap's mappings field.
+ */
+export declare function decodedMappings(map: TraceMap): Readonly;
+/**
+ * A low-level API to find the segment associated with a generated line/column (think, from a
+ * stack trace). Line and column here are 0-based, unlike `originalPositionFor`.
+ */
+export declare function traceSegment(map: TraceMap, line: number, column: number): Readonly | null;
+/**
+ * A higher-level API to find the source/line/column associated with a generated line/column
+ * (think, from a stack trace). Line is 1-based, but column is 0-based, due to legacy behavior in
+ * `source-map` library.
+ */
+export declare function originalPositionFor(map: TraceMap, needle: Needle): OriginalMapping | InvalidOriginalMapping;
+/**
+ * Finds the generated line/column position of the provided source/line/column source position.
+ */
+export declare function generatedPositionFor(map: TraceMap, needle: SourceNeedle): GeneratedMapping | InvalidGeneratedMapping;
+/**
+ * Finds all generated line/column positions of the provided source/line/column source position.
+ */
+export declare function allGeneratedPositionsFor(map: TraceMap, needle: SourceNeedle): GeneratedMapping[];
+/**
+ * Iterates each mapping in generated position order.
+ */
+export declare function eachMapping(map: TraceMap, cb: (mapping: EachMapping) => void): void;
+/**
+ * Retrieves the source content for a particular source, if its found. Returns null if not.
+ */
+export declare function sourceContentFor(map: TraceMap, source: string): string | null;
+/**
+ * Determines if the source is marked to ignore by the source map.
+ */
+export declare function isIgnored(map: TraceMap, source: string): boolean;
+/**
+ * A helper that skips sorting of the input map's mappings array, which can be expensive for larger
+ * maps.
+ */
+export declare function presortedDecodedMap(map: DecodedSourceMap, mapUrl?: string): TraceMap;
+/**
+ * Returns a sourcemap object (with decoded mappings) suitable for passing to a library that expects
+ * a sourcemap, or to JSON.stringify.
+ */
+export declare function decodedMap(map: TraceMap): Omit & {
+ mappings: readonly SourceMapSegment[][];
+};
+/**
+ * Returns a sourcemap object (with encoded mappings) suitable for passing to a library that expects
+ * a sourcemap, or to JSON.stringify.
+ */
+export declare function encodedMap(map: TraceMap): EncodedSourceMap;
+//# sourceMappingURL=trace-mapping.d.ts.map
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/trace-mapping/types/trace-mapping.d.cts.map b/sdk/node_modules/@jridgewell/trace-mapping/types/trace-mapping.d.cts.map
new file mode 100644
index 00000000..b5a874c0
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/trace-mapping/types/trace-mapping.d.cts.map
@@ -0,0 +1 @@
+{"version":3,"file":"trace-mapping.d.ts","sourceRoot":"","sources":["../src/trace-mapping.ts"],"names":[],"mappings":"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"}
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/trace-mapping/types/trace-mapping.d.mts b/sdk/node_modules/@jridgewell/trace-mapping/types/trace-mapping.d.mts
new file mode 100644
index 00000000..bc2ff0f1
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/trace-mapping/types/trace-mapping.d.mts
@@ -0,0 +1,80 @@
+import type { SourceMapSegment } from './sourcemap-segment.mts';
+import type { SourceMapV3, DecodedSourceMap, EncodedSourceMap, InvalidOriginalMapping, OriginalMapping, InvalidGeneratedMapping, GeneratedMapping, SourceMapInput, Needle, SourceNeedle, SourceMap, EachMapping, Ro } from './types.mts';
+export type { SourceMapSegment } from './sourcemap-segment.mts';
+export type { SourceMap, DecodedSourceMap, EncodedSourceMap, Section, SectionedSourceMap, SourceMapV3, Bias, EachMapping, GeneratedMapping, InvalidGeneratedMapping, InvalidOriginalMapping, Needle, OriginalMapping, OriginalMapping as Mapping, SectionedSourceMapInput, SourceMapInput, SourceNeedle, XInput, EncodedSourceMapXInput, DecodedSourceMapXInput, SectionedSourceMapXInput, SectionXInput, } from './types.mts';
+export declare const LEAST_UPPER_BOUND = -1;
+export declare const GREATEST_LOWER_BOUND = 1;
+export { FlattenMap, FlattenMap as AnyMap } from './flatten-map.mts';
+export declare class TraceMap implements SourceMap {
+ version: SourceMapV3['version'];
+ file: SourceMapV3['file'];
+ names: SourceMapV3['names'];
+ sourceRoot: SourceMapV3['sourceRoot'];
+ sources: SourceMapV3['sources'];
+ sourcesContent: SourceMapV3['sourcesContent'];
+ ignoreList: SourceMapV3['ignoreList'];
+ resolvedSources: string[];
+ private _encoded;
+ private _decoded;
+ private _decodedMemo;
+ private _bySources;
+ private _bySourceMemos;
+ constructor(map: Ro, mapUrl?: string | null);
+}
+/**
+ * Returns the encoded (VLQ string) form of the SourceMap's mappings field.
+ */
+export declare function encodedMappings(map: TraceMap): EncodedSourceMap['mappings'];
+/**
+ * Returns the decoded (array of lines of segments) form of the SourceMap's mappings field.
+ */
+export declare function decodedMappings(map: TraceMap): Readonly;
+/**
+ * A low-level API to find the segment associated with a generated line/column (think, from a
+ * stack trace). Line and column here are 0-based, unlike `originalPositionFor`.
+ */
+export declare function traceSegment(map: TraceMap, line: number, column: number): Readonly | null;
+/**
+ * A higher-level API to find the source/line/column associated with a generated line/column
+ * (think, from a stack trace). Line is 1-based, but column is 0-based, due to legacy behavior in
+ * `source-map` library.
+ */
+export declare function originalPositionFor(map: TraceMap, needle: Needle): OriginalMapping | InvalidOriginalMapping;
+/**
+ * Finds the generated line/column position of the provided source/line/column source position.
+ */
+export declare function generatedPositionFor(map: TraceMap, needle: SourceNeedle): GeneratedMapping | InvalidGeneratedMapping;
+/**
+ * Finds all generated line/column positions of the provided source/line/column source position.
+ */
+export declare function allGeneratedPositionsFor(map: TraceMap, needle: SourceNeedle): GeneratedMapping[];
+/**
+ * Iterates each mapping in generated position order.
+ */
+export declare function eachMapping(map: TraceMap, cb: (mapping: EachMapping) => void): void;
+/**
+ * Retrieves the source content for a particular source, if its found. Returns null if not.
+ */
+export declare function sourceContentFor(map: TraceMap, source: string): string | null;
+/**
+ * Determines if the source is marked to ignore by the source map.
+ */
+export declare function isIgnored(map: TraceMap, source: string): boolean;
+/**
+ * A helper that skips sorting of the input map's mappings array, which can be expensive for larger
+ * maps.
+ */
+export declare function presortedDecodedMap(map: DecodedSourceMap, mapUrl?: string): TraceMap;
+/**
+ * Returns a sourcemap object (with decoded mappings) suitable for passing to a library that expects
+ * a sourcemap, or to JSON.stringify.
+ */
+export declare function decodedMap(map: TraceMap): Omit & {
+ mappings: readonly SourceMapSegment[][];
+};
+/**
+ * Returns a sourcemap object (with encoded mappings) suitable for passing to a library that expects
+ * a sourcemap, or to JSON.stringify.
+ */
+export declare function encodedMap(map: TraceMap): EncodedSourceMap;
+//# sourceMappingURL=trace-mapping.d.ts.map
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/trace-mapping/types/trace-mapping.d.mts.map b/sdk/node_modules/@jridgewell/trace-mapping/types/trace-mapping.d.mts.map
new file mode 100644
index 00000000..b5a874c0
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/trace-mapping/types/trace-mapping.d.mts.map
@@ -0,0 +1 @@
+{"version":3,"file":"trace-mapping.d.ts","sourceRoot":"","sources":["../src/trace-mapping.ts"],"names":[],"mappings":"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"}
\ No newline at end of file
diff --git a/sdk/node_modules/@jridgewell/trace-mapping/types/types.d.cts b/sdk/node_modules/@jridgewell/trace-mapping/types/types.d.cts
new file mode 100644
index 00000000..729c2c32
--- /dev/null
+++ b/sdk/node_modules/@jridgewell/trace-mapping/types/types.d.cts
@@ -0,0 +1,107 @@
+import type { SourceMapSegment } from './sourcemap-segment.cts';
+import type { GREATEST_LOWER_BOUND, LEAST_UPPER_BOUND, TraceMap } from './trace-mapping.cts';
+export interface SourceMapV3 {
+ file?: string | null;
+ names: string[];
+ sourceRoot?: string;
+ sources: (string | null)[];
+ sourcesContent?: (string | null)[];
+ version: 3;
+ ignoreList?: number[];
+}
+export interface EncodedSourceMap extends SourceMapV3 {
+ mappings: string;
+}
+export interface DecodedSourceMap extends SourceMapV3 {
+ mappings: SourceMapSegment[][];
+}
+export interface Section {
+ offset: {
+ line: number;
+ column: number;
+ };
+ map: EncodedSourceMap | DecodedSourceMap | SectionedSourceMap;
+}
+export interface SectionedSourceMap {
+ file?: string | null;
+ sections: Section[];
+ version: 3;
+}
+export type OriginalMapping = {
+ source: string | null;
+ line: number;
+ column: number;
+ name: string | null;
+};
+export type InvalidOriginalMapping = {
+ source: null;
+ line: null;
+ column: null;
+ name: null;
+};
+export type GeneratedMapping = {
+ line: number;
+ column: number;
+};
+export type InvalidGeneratedMapping = {
+ line: null;
+ column: null;
+};
+export type Bias = typeof GREATEST_LOWER_BOUND | typeof LEAST_UPPER_BOUND;
+export type XInput = {
+ x_google_ignoreList?: SourceMapV3['ignoreList'];
+};
+export type EncodedSourceMapXInput = EncodedSourceMap & XInput;
+export type DecodedSourceMapXInput = DecodedSourceMap & XInput;
+export type SectionedSourceMapXInput = Omit & {
+ sections: SectionXInput[];
+};
+export type SectionXInput = Omit & {
+ map: SectionedSourceMapInput;
+};
+export type SourceMapInput = string | EncodedSourceMapXInput | DecodedSourceMapXInput | TraceMap;
+export type SectionedSourceMapInput = SourceMapInput | SectionedSourceMapXInput;
+export type Needle = {
+ line: number;
+ column: number;
+ bias?: Bias;
+};
+export type SourceNeedle = {
+ source: string;
+ line: number;
+ column: number;
+ bias?: Bias;
+};
+export type EachMapping = {
+ generatedLine: number;
+ generatedColumn: number;
+ source: null;
+ originalLine: null;
+ originalColumn: null;
+ name: null;
+} | {
+ generatedLine: number;
+ generatedColumn: number;
+ source: string | null;
+ originalLine: number;
+ originalColumn: number;
+ name: string | null;
+};
+export declare abstract class SourceMap {
+ version: SourceMapV3['version'];
+ file: SourceMapV3['file'];
+ names: SourceMapV3['names'];
+ sourceRoot: SourceMapV3['sourceRoot'];
+ sources: SourceMapV3['sources'];
+ sourcesContent: SourceMapV3['sourcesContent'];
+ resolvedSources: SourceMapV3['sources'];
+ ignoreList: SourceMapV3['ignoreList'];
+}
+export type Ro = T extends Array ? V[] | Readonly | RoArray | Readonly> : T extends object ? T | Readonly | RoObject | Readonly> : T;
+type RoArray = Ro[];
+type RoObject